TellmeRevitPluging/Controllers/ShellController.cs

using System;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using RevitHttpControl.Models;
using RevitHttpControl.Services;
using RevitHttpControl.Common;

namespace RevitHttpControl.Controllers
{
    /// <summary>
    /// 薄壳优化控制器
    /// </summary>
    [RoutePrefix("api/shell")]
    public class ShellController : ApiController
    {
        private readonly ShellAnalyzer _analyzer;
        private readonly ShellOptimizer _optimizer;

        public ShellController()
        {
            _analyzer = new ShellAnalyzer();
            _optimizer = new ShellOptimizer();
        }

        /// <summary>
        /// 分析模型薄壳优化方案
        /// </summary>
        /// <param name="request">分析请求</param>
        /// <returns>分析结果</returns>
        [HttpPost]
        [Route("analyze")]
        public HttpResponseMessage AnalyzeShell([FromBody] ShellAnalyzeRequest request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    return this.CreateErrorResponse(
                        ErrorCodes.INVALID_REQUEST_PARAMETERS,
                        "请求参数不能为空",
                        HttpStatusCode.BadRequest
                    );
                }

                // 验证优化模式
                if (!Enum.IsDefined(typeof(ShellOptimizeMode), request.Mode))
                {
                    return this.CreateErrorResponse(
                        ErrorCodes.INVALID_REQUEST_PARAMETERS,
                        "无效的优化模式",
                        HttpStatusCode.BadRequest
                    );
                }

                // 执行分析
                var result = RevitService.AnalyzeShellOptimization(request.Mode);

                return this.CreateSuccessResponse(result, "薄壳分析完成");
            }
            catch (InvalidOperationException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.NO_DOCUMENT_OPEN,
                    ex.Message,
                    HttpStatusCode.BadRequest
                );
            }
            catch (ArgumentException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.INVALID_REQUEST_PARAMETERS,
                    ex.Message,
                    HttpStatusCode.BadRequest
                );
            }
            catch (TimeoutException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.OPERATION_TIMEOUT,
                    ex.Message,
                    HttpStatusCode.RequestTimeout
                );
            }
            catch (Exception ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.REVIT_API_ERROR,
                    "薄壳分析失败",
                    HttpStatusCode.InternalServerError,
                    ex.Message
                );
            }
        }

        /// <summary>
        /// 执行薄壳优化（异步）
        /// </summary>
        /// <param name="request">执行请求</param>
        /// <returns>异步任务响应</returns>
        [HttpPost]
        [Route("execute")]
        public HttpResponseMessage ExecuteShell([FromBody] ShellExecuteRequest request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    return this.CreateErrorResponse(
                        ErrorCodes.INVALID_REQUEST_PARAMETERS,
                        "请求参数不能为空",
                        HttpStatusCode.BadRequest
                    );
                }

                // 验证优化模式
                if (!Enum.IsDefined(typeof(ShellOptimizeMode), request.Mode))
                {
                    return this.CreateErrorResponse(
                        ErrorCodes.INVALID_REQUEST_PARAMETERS,
                        "无效的优化模式",
                        HttpStatusCode.BadRequest
                    );
                }

                // 创建异步任务
                var taskId = TaskManager.Instance.CreateTask(request.ExecutionId);
                TaskManager.Instance.SetTaskRunning(taskId);

                // 异步执行薄壳优化
                RevitService.ExecuteShellOptimizationAsync(request.Mode, request.BackupOriginal, taskId, TaskManager.Instance);

                var asyncResponse = new AsyncOperationResponse
                {
                    TaskId = taskId,
                    StatusUrl = $"/api/task/{taskId}"
                };

                return this.CreateSuccessResponse(asyncResponse, "薄壳优化任务已创建", HttpStatusCode.Accepted);
            }
            catch (InvalidOperationException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.NO_DOCUMENT_OPEN,
                    ex.Message,
                    HttpStatusCode.BadRequest
                );
            }
            catch (ArgumentException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.INVALID_REQUEST_PARAMETERS,
                    ex.Message,
                    HttpStatusCode.BadRequest
                );
            }
            catch (Exception ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.REVIT_API_ERROR,
                    "创建薄壳优化任务失败",
                    HttpStatusCode.InternalServerError,
                    ex.Message
                );
            }
        }

        /// <summary>
        /// 执行薄壳优化（同步）- 用于小型模型或测试
        /// </summary>
        /// <param name="request">执行请求</param>
        /// <returns>执行结果</returns>
        [HttpPost]
        [Route("execute/sync")]
        public HttpResponseMessage ExecuteShellSync([FromBody] ShellExecuteRequest request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    return this.CreateErrorResponse(
                        ErrorCodes.INVALID_REQUEST_PARAMETERS,
                        "请求参数不能为空",
                        HttpStatusCode.BadRequest
                    );
                }

                // 验证优化模式
                if (!Enum.IsDefined(typeof(ShellOptimizeMode), request.Mode))
                {
                    return this.CreateErrorResponse(
                        ErrorCodes.INVALID_REQUEST_PARAMETERS,
                        "无效的优化模式",
                        HttpStatusCode.BadRequest
                    );
                }

                // 同步执行薄壳优化
                var result = RevitService.ExecuteShellOptimization(request.Mode, request.BackupOriginal);

                return this.CreateSuccessResponse(result, "薄壳优化执行完成");
            }
            catch (InvalidOperationException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.NO_DOCUMENT_OPEN,
                    ex.Message,
                    HttpStatusCode.BadRequest
                );
            }
            catch (ArgumentException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.INVALID_REQUEST_PARAMETERS,
                    ex.Message,
                    HttpStatusCode.BadRequest
                );
            }
            catch (TimeoutException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.OPERATION_TIMEOUT,
                    ex.Message,
                    HttpStatusCode.RequestTimeout
                );
            }
            catch (UnauthorizedAccessException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.FILE_WRITE_PERMISSION_DENIED,
                    "文件写入权限不足：" + ex.Message,
                    HttpStatusCode.Forbidden
                );
            }
            catch (System.IO.IOException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.FILE_IO_ERROR,
                    "文件操作失败：" + ex.Message,
                    HttpStatusCode.InternalServerError
                );
            }
            catch (Exception ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.REVIT_API_ERROR,
                    "薄壳优化执行失败",
                    HttpStatusCode.InternalServerError,
                    ex.Message
                );
            }
        }

        /// <summary>
        /// 按类别自定义执行删除（同步）
        /// </summary>
        /// <param name="request">自定义删除请求</param>
        /// <returns>执行结果</returns>
        [HttpPost]
        [Route("execute/custom")]
        public HttpResponseMessage ExecuteShellCustom([FromBody] ShellCustomExecuteRequest request)
        {
            try
            {
                if (request == null)
                {
                    return this.CreateErrorResponse(
                        ErrorCodes.INVALID_REQUEST_PARAMETERS,
                        "请求参数不能为空",
                        HttpStatusCode.BadRequest
                    );
                }

                if (request.CategoryIds == null || request.CategoryIds.Count == 0)
                {
                    return this.CreateErrorResponse(
                        ErrorCodes.INVALID_REQUEST_PARAMETERS,
                        "CategoryIds 不能为空，且至少包含一个类别ID",
                        HttpStatusCode.BadRequest
                    );
                }

                var result = RevitService.ExecuteShellOptimizationByCategories(request.CategoryIds, request.BackupOriginal);
                return this.CreateSuccessResponse(result, "自定义类别删除执行完成");
            }
            catch (InvalidOperationException ex)
            {
                if (ex.Message.Contains(ErrorMessages.NO_DOCUMENT_OPEN_MSG))
                {
                    return this.CreateErrorResponse(
                        ErrorCodes.NO_DOCUMENT_OPEN,
                        ex.Message,
                        HttpStatusCode.BadRequest
                    );
                }

                if (ex.Message.Contains("创建备份失败"))
                {
                    return this.CreateErrorResponse(
                        ErrorCodes.FILE_WRITE_PERMISSION_DENIED,
                        ex.Message,
                        HttpStatusCode.Forbidden
                    );
                }

                return this.CreateErrorResponse(
                    ErrorCodes.REVIT_COMMAND_FAILED,
                    ex.Message,
                    HttpStatusCode.BadRequest
                );
            }
            catch (ArgumentException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.INVALID_REQUEST_PARAMETERS,
                    ex.Message,
                    HttpStatusCode.BadRequest
                );
            }
            catch (TimeoutException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.OPERATION_TIMEOUT,
                    ex.Message,
                    HttpStatusCode.RequestTimeout
                );
            }
            catch (UnauthorizedAccessException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.FILE_WRITE_PERMISSION_DENIED,
                    "文件写入权限不足：" + ex.Message,
                    HttpStatusCode.Forbidden
                );
            }
            catch (System.IO.IOException ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.FILE_IO_ERROR,
                    "文件操作失败：" + ex.Message,
                    HttpStatusCode.InternalServerError
                );
            }
            catch (Exception ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.REVIT_API_ERROR,
                    "自定义类别删除执行失败",
                    HttpStatusCode.InternalServerError,
                    ex.Message
                );
            }
        }

        /// <summary>
        /// 获取薄壳优化预设配置
        /// </summary>
        /// <returns>优化模式配置信息</returns>
        [HttpGet]
        [Route("modes")]
        public HttpResponseMessage GetOptimizeModes()
        {
            try
            {
                var modes = new[]
                {
                    new
                    {
                        Mode = ShellOptimizeMode.Conservative,
                        Name = "保守模式",
                        Description = "仅删除装饰元素，减少约30%文件大小",
                        EstimatedReduction = "30%",
                        DeletedElements = new[] { "配景", "植物", "装饰元素" }
                    },
                    new
                    {
                        Mode = ShellOptimizeMode.Standard,
                        Name = "标准模式",
                        Description = "删除家具和部分内墙，减少约65%文件大小",
                        EstimatedReduction = "65%",
                        DeletedElements = new[] { "家具", "橱柜", "配景", "植物", "部分灯具" }
                    },
                    new
                    {
                        Mode = ShellOptimizeMode.Aggressive,
                        Name = "激进模式",
                        Description = "删除所有内部元素，减少约80%文件大小",
                        EstimatedReduction = "80%",
                        DeletedElements = new[] { "家具", "设备", "天花板", "配景", "植物", "灯具", "内部装饰" }
                    },
                    new
                    {
                        Mode = ShellOptimizeMode.EnvelopeOnly,
                        Name = "仅保留围护+场地",
                        Description = "严格只保留外壳（外墙/屋顶/外门窗等）与场地地形，删除所有室内与链接模型",
                        EstimatedReduction = "-",
                        DeletedElements = new[] { "所有室内构件", "结构构件", "链接模型" }
                    }
                };

                return this.CreateSuccessResponse(modes, "优化模式配置获取成功");
            }
            catch (Exception ex)
            {
                return this.CreateErrorResponse(
                    ErrorCodes.REVIT_API_ERROR,
                    "获取优化模式配置失败",
                    HttpStatusCode.InternalServerError,
                    ex.Message
                );
            }
        }
    }
}