TellmeRevitPluging/Controllers/TaskController.cs

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

namespace RevitHttpControl.Controllers
{
    /// <summary>
    /// 任务管理控制器
    /// </summary>
    [RoutePrefix("api")]
    public class TaskController : ApiController
    {
        /// <summary>
        /// 获取任务状态
        /// </summary>
        /// <param name="taskId">任务ID</param>
        /// <returns>任务状态响应</returns>
        [HttpGet]
        [Route("task/{taskId}")]
        public HttpResponseMessage GetTaskStatus(Guid taskId)
        {
            try
            {
                var taskStatus = TaskManager.Instance.GetTaskStatus(taskId);

                if (taskStatus == null)
                {
                    var notFoundResponse = new ApiResponse<object>
                    {
                        Success = false,
                        Code = 404,
                        Message = "任务不存在",
                        Data = new { error = "TASK_NOT_FOUND" }
                    };
                    return Request.CreateResponse(HttpStatusCode.NotFound, notFoundResponse);
                }

                var successResponse = new ApiResponse<TaskStatusResponse>
                {
                    Success = true,
                    Code = 200,
                    Message = "获取任务状态成功",
                    Data = taskStatus
                };

                return Request.CreateResponse(HttpStatusCode.OK, successResponse);
            }
            catch (Exception ex)
            {
                var errorResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 500,
                    Message = "获取任务状态时发生错误",
                    Data = new
                    {
                        error = "INTERNAL_ERROR",
                        errorDescription = ex.Message
                    }
                };
                return Request.CreateResponse(HttpStatusCode.InternalServerError, errorResponse);
            }
        }

        /// <summary>
        /// 旧版任务状态查询接口（向后兼容）
        /// </summary>
        /// <param name="taskId">任务ID</param>
        /// <returns>简化的任务状态响应</returns>
        [HttpGet]
        [Route("status/{taskId}")]
        public HttpResponseMessage GetLegacyTaskStatus(Guid taskId)
        {
            try
            {
                // 先检查是否是统计结果任务
                var statsResult = TaskManager.Instance.GetStatsResult(taskId);
                if (statsResult.HasValue)
                {
                    // 返回旧格式的响应
                    return Request.CreateResponse(HttpStatusCode.OK, new { result = statsResult.Value });
                }

                // 检查任务是否存在
                var taskStatus = TaskManager.Instance.GetTaskStatus(taskId);
                if (taskStatus == null)
                {
                    return Request.CreateResponse(HttpStatusCode.NotFound, "Task not found");
                }

                // 根据任务状态返回不同响应
                switch (taskStatus.Status)
                {
                    case TaskStatus.Completed:
                        return Request.CreateResponse(HttpStatusCode.OK, new { result = taskStatus.Result });
                    
                    case TaskStatus.Failed:
                        return Request.CreateResponse(HttpStatusCode.InternalServerError, 
                            new { error = taskStatus.ErrorMessage });
                    
                    case TaskStatus.Pending:
                    case TaskStatus.Running:
                        return Request.CreateResponse(HttpStatusCode.Accepted, 
                            new { status = "processing" });
                    
                    case TaskStatus.Cancelled:
                        return Request.CreateResponse(HttpStatusCode.Gone, 
                            new { status = "cancelled" });
                    
                    default:
                        return Request.CreateResponse(HttpStatusCode.OK, 
                            new { status = taskStatus.Status.ToString().ToLower() });
                }
            }
            catch (Exception ex)
            {
                return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message);
            }
        }

        /// <summary>
        /// 取消任务
        /// </summary>
        /// <param name="taskId">任务ID</param>
        /// <returns>取消任务响应</returns>
        [HttpDelete]
        [Route("task/{taskId}")]
        public HttpResponseMessage CancelTask(Guid taskId)
        {
            try
            {
                if (!TaskManager.Instance.TaskExists(taskId))
                {
                    var notFoundResponse = new ApiResponse<object>
                    {
                        Success = false,
                        Code = 404,
                        Message = "任务不存在",
                        Data = new { error = "TASK_NOT_FOUND" }
                    };
                    return Request.CreateResponse(HttpStatusCode.NotFound, notFoundResponse);
                }

                TaskManager.Instance.CancelTask(taskId);

                var successResponse = new ApiResponse<object>
                {
                    Success = true,
                    Code = 200,
                    Message = "任务已取消",
                    Data = new { taskId = taskId }
                };

                return Request.CreateResponse(HttpStatusCode.OK, successResponse);
            }
            catch (Exception ex)
            {
                var errorResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 500,
                    Message = "取消任务时发生错误",
                    Data = new
                    {
                        error = "INTERNAL_ERROR",
                        errorDescription = ex.Message
                    }
                };
                return Request.CreateResponse(HttpStatusCode.InternalServerError, errorResponse);
            }
        }

        /// <summary>
        /// 获取任务管理器状态
        /// </summary>
        /// <returns>任务管理器状态</returns>
        [HttpGet]
        [Route("tasks/status")]
        public HttpResponseMessage GetTaskManagerStatus()
        {
            try
            {
                var statusData = new
                {
                    totalTasks = TaskManager.Instance.GetTaskCount(),
                    pendingTasks = TaskManager.Instance.GetTaskCountByStatus(TaskStatus.Pending),
                    runningTasks = TaskManager.Instance.GetTaskCountByStatus(TaskStatus.Running),
                    completedTasks = TaskManager.Instance.GetTaskCountByStatus(TaskStatus.Completed),
                    failedTasks = TaskManager.Instance.GetTaskCountByStatus(TaskStatus.Failed),
                    cancelledTasks = TaskManager.Instance.GetTaskCountByStatus(TaskStatus.Cancelled)
                };

                var successResponse = new ApiResponse<object>
                {
                    Success = true,
                    Code = 200,
                    Message = "获取任务管理器状态成功",
                    Data = statusData
                };

                return Request.CreateResponse(HttpStatusCode.OK, successResponse);
            }
            catch (Exception ex)
            {
                var errorResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 500,
                    Message = "获取任务管理器状态时发生错误",
                    Data = new
                    {
                        error = "INTERNAL_ERROR",
                        errorDescription = ex.Message
                    }
                };
                return Request.CreateResponse(HttpStatusCode.InternalServerError, errorResponse);
            }
        }
    }
}