426 lines
17 KiB
Go
426 lines
17 KiB
Go
package plan
|
|
|
|
import (
|
|
"errors"
|
|
"strconv"
|
|
|
|
"git.huangwc.com/pig/pig-farm-controller/internal/app/controller"
|
|
task "git.huangwc.com/pig/pig-farm-controller/internal/app/service/task"
|
|
"git.huangwc.com/pig/pig-farm-controller/internal/infra/logs"
|
|
"git.huangwc.com/pig/pig-farm-controller/internal/infra/models"
|
|
"git.huangwc.com/pig/pig-farm-controller/internal/infra/repository"
|
|
"github.com/gin-gonic/gin"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// --- 请求和响应 DTO 定义 ---
|
|
|
|
// CreatePlanRequest 定义创建计划请求的结构体
|
|
type CreatePlanRequest struct {
|
|
Name string `json:"name" binding:"required" example:"猪舍温度控制计划"`
|
|
Description string `json:"description" example:"根据温度自动调节风扇和加热器"`
|
|
ExecutionType models.PlanExecutionType `json:"execution_type" binding:"required" example:"automatic"`
|
|
ExecuteNum uint `json:"execute_num,omitempty" example:"10"`
|
|
CronExpression string `json:"cron_expression" example:"0 0 6 * * *"`
|
|
ContentType models.PlanContentType `json:"content_type" binding:"required" example:"tasks"`
|
|
SubPlanIDs []uint `json:"sub_plan_ids,omitempty"`
|
|
Tasks []TaskRequest `json:"tasks,omitempty"`
|
|
}
|
|
|
|
// PlanResponse 定义计划详情响应的结构体
|
|
type PlanResponse struct {
|
|
ID uint `json:"id" example:"1"`
|
|
Name string `json:"name" example:"猪舍温度控制计划"`
|
|
Description string `json:"description" example:"根据温度自动调节风扇和加热器"`
|
|
ExecutionType models.PlanExecutionType `json:"execution_type" example:"automatic"`
|
|
Status models.PlanStatus `json:"status" example:"0"`
|
|
ExecuteNum uint `json:"execute_num" example:"10"`
|
|
ExecuteCount uint `json:"execute_count" example:"0"`
|
|
CronExpression string `json:"cron_expression" example:"0 0 6 * * *"`
|
|
ContentType models.PlanContentType `json:"content_type" example:"tasks"`
|
|
SubPlans []SubPlanResponse `json:"sub_plans,omitempty"`
|
|
Tasks []TaskResponse `json:"tasks,omitempty"`
|
|
}
|
|
|
|
// ListPlansResponse 定义获取计划列表响应的结构体
|
|
type ListPlansResponse struct {
|
|
Plans []PlanResponse `json:"plans"`
|
|
Total int `json:"total" example:"100"`
|
|
}
|
|
|
|
// UpdatePlanRequest 定义更新计划请求的结构体
|
|
type UpdatePlanRequest struct {
|
|
Name string `json:"name" example:"猪舍温度控制计划V2"`
|
|
Description string `json:"description" example:"更新后的描述"`
|
|
ExecutionType models.PlanExecutionType `json:"execution_type" example:"automatic"`
|
|
ExecuteNum uint `json:"execute_num,omitempty" example:"10"`
|
|
CronExpression string `json:"cron_expression" example:"0 0 6 * * *"`
|
|
ContentType models.PlanContentType `json:"content_type" example:"tasks"`
|
|
SubPlanIDs []uint `json:"sub_plan_ids,omitempty"`
|
|
Tasks []TaskRequest `json:"tasks,omitempty"`
|
|
}
|
|
|
|
// SubPlanResponse 定义子计划响应结构体
|
|
type SubPlanResponse struct {
|
|
ID uint `json:"id" example:"1"`
|
|
ParentPlanID uint `json:"parent_plan_id" example:"1"`
|
|
ChildPlanID uint `json:"child_plan_id" example:"2"`
|
|
ExecutionOrder int `json:"execution_order" example:"1"`
|
|
ChildPlan *PlanResponse `json:"child_plan,omitempty"`
|
|
}
|
|
|
|
// TaskRequest 定义任务请求结构体
|
|
type TaskRequest struct {
|
|
Name string `json:"name" example:"打开风扇"`
|
|
Description string `json:"description" example:"打开1号风扇"`
|
|
ExecutionOrder int `json:"execution_order" example:"1"`
|
|
Type models.TaskType `json:"type" example:"waiting"`
|
|
Parameters map[string]interface{} `json:"parameters,omitempty"`
|
|
}
|
|
|
|
// TaskResponse 定义任务响应结构体
|
|
type TaskResponse struct {
|
|
ID int `json:"id" example:"1"`
|
|
PlanID uint `json:"plan_id" example:"1"`
|
|
Name string `json:"name" example:"打开风扇"`
|
|
Description string `json:"description" example:"打开1号风扇"`
|
|
ExecutionOrder int `json:"execution_order" example:"1"`
|
|
Type models.TaskType `json:"type" example:"waiting"`
|
|
Parameters map[string]interface{} `json:"parameters,omitempty"`
|
|
}
|
|
|
|
// --- Controller 定义 ---
|
|
|
|
// Controller 定义了计划相关的控制器
|
|
type Controller struct {
|
|
logger *logs.Logger
|
|
planRepo repository.PlanRepository
|
|
analysisPlanTaskManager *task.AnalysisPlanTaskManager
|
|
}
|
|
|
|
// NewController 创建一个新的 Controller 实例
|
|
func NewController(logger *logs.Logger, planRepo repository.PlanRepository, analysisPlanTaskManager *task.AnalysisPlanTaskManager) *Controller {
|
|
return &Controller{
|
|
logger: logger,
|
|
planRepo: planRepo,
|
|
analysisPlanTaskManager: analysisPlanTaskManager,
|
|
}
|
|
}
|
|
|
|
// --- 接口方法实现 ---
|
|
|
|
// CreatePlan godoc
|
|
// @Summary 创建计划
|
|
// @Description 创建一个新的计划，包括其基本信息和所有关联的子计划/任务。
|
|
// @Tags 计划管理
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param plan body CreatePlanRequest true "计划信息"
|
|
// @Success 200 {object} controller.Response{data=plan.PlanResponse} "业务码为201代表创建成功"
|
|
// @Router /api/v1/plans [post]
|
|
func (c *Controller) CreatePlan(ctx *gin.Context) {
|
|
var req CreatePlanRequest
|
|
if err := ctx.ShouldBindJSON(&req); err != nil {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "无效的请求体: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// 使用已有的转换函数，它已经包含了验证和重排逻辑
|
|
planToCreate, err := PlanFromCreateRequest(&req)
|
|
if err != nil {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "计划数据校验失败: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// 调用仓库方法创建计划
|
|
if err := c.planRepo.CreatePlan(planToCreate); err != nil {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "创建计划失败: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// 创建成功后，调用 manager 确保触发器任务定义存在，但不立即加入待执行队列
|
|
if err := c.analysisPlanTaskManager.EnsureAnalysisTaskDefinition(planToCreate.ID); err != nil {
|
|
// 这是一个非阻塞性错误，我们只记录日志，因为主流程（创建计划）已经成功
|
|
c.logger.Errorf("为新创建的计划 %d 确保触发器任务定义失败: %v", planToCreate.ID, err)
|
|
}
|
|
|
|
// 使用已有的转换函数将创建后的模型转换为响应对象
|
|
resp, err := PlanToResponse(planToCreate)
|
|
if err != nil {
|
|
c.logger.Errorf("创建计划: 序列化响应失败: %v", err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "计划创建成功，但响应生成失败")
|
|
return
|
|
}
|
|
|
|
// 使用统一的成功响应函数
|
|
controller.SendResponse(ctx, controller.CodeCreated, "计划创建成功", resp)
|
|
}
|
|
|
|
// GetPlan godoc
|
|
// @Summary 获取计划详情
|
|
// @Description 根据计划ID获取单个计划的详细信息。
|
|
// @Tags 计划管理
|
|
// @Produce json
|
|
// @Param id path int true "计划ID"
|
|
// @Success 200 {object} controller.Response{data=plan.PlanResponse} "业务码为200代表成功获取"
|
|
// @Router /api/v1/plans/{id} [get]
|
|
func (c *Controller) GetPlan(ctx *gin.Context) {
|
|
// 1. 从 URL 路径中获取 ID
|
|
idStr := ctx.Param("id")
|
|
id, err := strconv.ParseUint(idStr, 10, 32)
|
|
if err != nil {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "无效的计划ID格式")
|
|
return
|
|
}
|
|
|
|
// 2. 调用仓库层获取计划详情
|
|
plan, err := c.planRepo.GetPlanByID(uint(id))
|
|
if err != nil {
|
|
// 判断是否为“未找到”错误
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
controller.SendErrorResponse(ctx, controller.CodeNotFound, "计划不存在")
|
|
return
|
|
}
|
|
// 其他数据库错误视为内部错误
|
|
c.logger.Errorf("获取计划详情失败: %v", err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "获取计划详情时发生内部错误")
|
|
return
|
|
}
|
|
|
|
// 3. 将模型转换为响应 DTO
|
|
resp, err := PlanToResponse(plan)
|
|
if err != nil {
|
|
c.logger.Errorf("获取计划详情: 序列化响应失败: %v", err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "获取计划详情失败: 内部数据格式错误")
|
|
return
|
|
}
|
|
|
|
// 4. 发送成功响应
|
|
controller.SendResponse(ctx, controller.CodeSuccess, "获取计划详情成功", resp)
|
|
}
|
|
|
|
// ListPlans godoc
|
|
// @Summary 获取计划列表
|
|
// @Description 获取所有计划的列表
|
|
// @Tags 计划管理
|
|
// @Produce json
|
|
// @Success 200 {object} controller.Response{data=plan.ListPlansResponse} "业务码为200代表成功获取列表"
|
|
// @Router /api/v1/plans [get]
|
|
func (c *Controller) ListPlans(ctx *gin.Context) {
|
|
// 1. 调用仓库层获取所有计划
|
|
plans, err := c.planRepo.ListBasicPlans()
|
|
if err != nil {
|
|
c.logger.Errorf("获取计划列表失败: %v", err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "获取计划列表时发生内部错误")
|
|
return
|
|
}
|
|
|
|
// 2. 将模型转换为响应 DTO
|
|
planResponses := make([]PlanResponse, 0, len(plans))
|
|
for _, p := range plans {
|
|
resp, err := PlanToResponse(&p)
|
|
if err != nil {
|
|
c.logger.Errorf("获取计划列表: 序列化响应失败: %v", err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "获取计划列表失败: 内部数据格式错误")
|
|
return
|
|
}
|
|
planResponses = append(planResponses, *resp)
|
|
}
|
|
|
|
// 3. 构造并发送成功响应
|
|
resp := ListPlansResponse{
|
|
Plans: planResponses,
|
|
Total: len(planResponses),
|
|
}
|
|
controller.SendResponse(ctx, controller.CodeSuccess, "获取计划列表成功", resp)
|
|
}
|
|
|
|
// UpdatePlan godoc
|
|
// @Summary 更新计划
|
|
// @Description 根据计划ID更新计划的详细信息。
|
|
// @Tags 计划管理
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path int true "计划ID"
|
|
// @Param plan body UpdatePlanRequest true "更新后的计划信息"
|
|
// @Success 200 {object} controller.Response{data=plan.PlanResponse} "业务码为200代表更新成功"
|
|
// @Router /api/v1/plans/{id} [put]
|
|
func (c *Controller) UpdatePlan(ctx *gin.Context) {
|
|
// 1. 从 URL 路径中获取 ID
|
|
idStr := ctx.Param("id")
|
|
id, err := strconv.ParseUint(idStr, 10, 32)
|
|
if err != nil {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "无效的计划ID格式")
|
|
return
|
|
}
|
|
|
|
// 2. 绑定请求体
|
|
var req UpdatePlanRequest
|
|
if err := ctx.ShouldBindJSON(&req); err != nil {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "无效的请求体: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// 3. 将请求转换为模型(转换函数带校验)
|
|
planToUpdate, err := PlanFromUpdateRequest(&req)
|
|
if err != nil {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "计划数据校验失败: "+err.Error())
|
|
return
|
|
}
|
|
planToUpdate.ID = uint(id) // 确保ID被设置
|
|
|
|
// 4. 检查计划是否存在
|
|
_, err = c.planRepo.GetBasicPlanByID(uint(id))
|
|
if err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
controller.SendErrorResponse(ctx, controller.CodeNotFound, "计划不存在")
|
|
return
|
|
}
|
|
c.logger.Errorf("获取计划详情失败: %v", err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "获取计划详情时发生内部错误")
|
|
return
|
|
}
|
|
|
|
// 5. 调用仓库方法更新计划
|
|
if err := c.planRepo.UpdatePlan(planToUpdate); err != nil {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "更新计划失败: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// 更新成功后，调用 manager 确保触发器任务定义存在
|
|
if err := c.analysisPlanTaskManager.EnsureAnalysisTaskDefinition(planToUpdate.ID); err != nil {
|
|
// 这是一个非阻塞性错误，我们只记录日志
|
|
c.logger.Errorf("为更新后的计划 %d 确保触发器任务定义失败: %v", planToUpdate.ID, err)
|
|
}
|
|
|
|
// 6. 获取更新后的完整计划用于响应
|
|
updatedPlan, err := c.planRepo.GetPlanByID(uint(id))
|
|
if err != nil {
|
|
c.logger.Errorf("获取更新后的计划详情失败: %v", err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "获取更新后计划详情时发生内部错误")
|
|
return
|
|
}
|
|
|
|
// 7. 将模型转换为响应 DTO
|
|
resp, err := PlanToResponse(updatedPlan)
|
|
if err != nil {
|
|
c.logger.Errorf("更新计划: 序列化响应失败: %v", err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "计划更新成功，但响应生成失败")
|
|
return
|
|
}
|
|
|
|
// 8. 发送成功响应
|
|
controller.SendResponse(ctx, controller.CodeSuccess, "计划更新成功", resp)
|
|
}
|
|
|
|
// DeletePlan godoc
|
|
// @Summary 删除计划
|
|
// @Description 根据计划ID删除计划。
|
|
// @Tags 计划管理
|
|
// @Produce json
|
|
// @Param id path int true "计划ID"
|
|
// @Success 200 {object} controller.Response "业务码为200代表删除成功"
|
|
// @Router /api/v1/plans/{id} [delete]
|
|
func (c *Controller) DeletePlan(ctx *gin.Context) {
|
|
// 1. 从 URL 路径中获取 ID
|
|
idStr := ctx.Param("id")
|
|
id, err := strconv.ParseUint(idStr, 10, 32)
|
|
if err != nil {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "无效的计划ID格式")
|
|
return
|
|
}
|
|
|
|
// 2. 调用仓库层删除计划
|
|
if err := c.planRepo.DeletePlan(uint(id)); err != nil {
|
|
c.logger.Errorf("删除计划失败: %v", err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "删除计划时发生内部错误")
|
|
return
|
|
}
|
|
|
|
// 3. 发送成功响应
|
|
controller.SendResponse(ctx, controller.CodeSuccess, "计划删除成功", nil)
|
|
}
|
|
|
|
// StartPlan godoc
|
|
// @Summary 启动计划
|
|
// @Description 根据计划ID启动一个计划的执行。
|
|
// @Tags 计划管理
|
|
// @Produce json
|
|
// @Param id path int true "计划ID"
|
|
// @Success 200 {object} controller.Response "业务码为200代表成功启动计划"
|
|
// @Router /api/v1/plans/{id}/start [post]
|
|
func (c *Controller) StartPlan(ctx *gin.Context) {
|
|
// 1. 从 URL 路径中获取 ID
|
|
idStr := ctx.Param("id")
|
|
id, err := strconv.ParseUint(idStr, 10, 32)
|
|
if err != nil {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "无效的计划ID格式")
|
|
return
|
|
}
|
|
|
|
// 2. 检查计划是否存在
|
|
plan, err := c.planRepo.GetBasicPlanByID(uint(id))
|
|
if err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
controller.SendErrorResponse(ctx, controller.CodeNotFound, "计划不存在")
|
|
return
|
|
}
|
|
c.logger.Errorf("启动计划时获取计划信息失败: %v", err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "获取计划信息时发生内部错误")
|
|
return
|
|
}
|
|
|
|
// 3. 检查计划当前状态
|
|
if plan.Status == models.PlanStatusEnabled {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "计划已处于启动状态，无需重复操作")
|
|
return
|
|
}
|
|
|
|
// 4. 更新计划状态为“已启动”
|
|
if err := c.planRepo.UpdatePlanStatus(plan.ID, models.PlanStatusEnabled); err != nil {
|
|
c.logger.Errorf("更新计划 #%d 状态为 '已启动' 失败: %v", plan.ID, err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "更新计划状态失败")
|
|
return
|
|
}
|
|
c.logger.Infof("已成功更新计划 #%d 的状态为 '已启动'", plan.ID)
|
|
|
|
// 5. 为计划创建或更新触发器
|
|
if err := c.analysisPlanTaskManager.CreateOrUpdateTrigger(plan.ID); err != nil {
|
|
// 此处错误不回滚状态，因为状态更新已成功，但需要明确告知用户触发器创建失败
|
|
c.logger.Errorf("为计划 #%d 创建或更新触发器失败: %v", plan.ID, err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "计划状态已更新，但创建执行触发器失败，请检查计划配置或稍后重试")
|
|
return
|
|
}
|
|
|
|
// 6. 发送成功响应
|
|
controller.SendResponse(ctx, controller.CodeSuccess, "计划已成功启动", nil)
|
|
}
|
|
|
|
// StopPlan godoc
|
|
// @Summary 停止计划
|
|
// @Description 根据计划ID停止一个正在执行的计划。
|
|
// @Tags 计划管理
|
|
// @Produce json
|
|
// @Param id path int true "计划ID"
|
|
// @Success 200 {object} controller.Response "业务码为200代表成功停止计划"
|
|
// @Router /api/v1/plans/{id}/stop [post]
|
|
func (c *Controller) StopPlan(ctx *gin.Context) {
|
|
// 1. 从 URL 路径中获取 ID
|
|
idStr := ctx.Param("id")
|
|
id, err := strconv.ParseUint(idStr, 10, 32)
|
|
if err != nil {
|
|
controller.SendErrorResponse(ctx, controller.CodeBadRequest, "无效的计划ID格式")
|
|
return
|
|
}
|
|
|
|
// 2. 调用仓库层方法，该方法内部处理事务
|
|
if err := c.planRepo.StopPlanTransactionally(uint(id)); err != nil {
|
|
c.logger.Errorf("停止计划 #%d 失败: %v", id, err)
|
|
controller.SendErrorResponse(ctx, controller.CodeInternalError, "停止计划时发生内部错误: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// 3. 发送成功响应
|
|
controller.SendResponse(ctx, controller.CodeSuccess, "计划已成功停止", nil)
|
|
}
|