pig-farm-controller/internal/controller/feed/feed.go

// Package feed 提供饲料控制功能
// 实现饲料制备和分配的控制逻辑
// 通过任务执行器执行具体控制任务
package feed

import (
	"strconv"
	"time"

	"git.huangwc.com/pig/pig-farm-controller/internal/controller"
	"git.huangwc.com/pig/pig-farm-controller/internal/logs"
	"git.huangwc.com/pig/pig-farm-controller/internal/model"
	"git.huangwc.com/pig/pig-farm-controller/internal/storage/repository"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

// Controller 饲料控制器
// 管理饲料制备和分配设备的控制逻辑
type Controller struct {
	feedPlanRepo repository.FeedPlanRepo
	logger       *logs.Logger
}

// NewController 创建并返回一个新的饲料控制器实例
func NewController(feedPlanRepo repository.FeedPlanRepo) *Controller {
	// TODO: 实现饲料控制器初始化
	return &Controller{
		feedPlanRepo: feedPlanRepo,
		logger:       logs.NewLogger(),
	}
}

type ListPlansResponse struct {
	Plans []ListPlanResponseItem `json:"plans"`
}

type ListPlanResponseItem struct {
	// ID 计划ID
	ID uint `json:"id"`

	// Name 计划名称
	Name string `json:"name"`

	// Description 计划描述
	Description string `json:"description"`

	// Type 计划类型
	Type model.FeedingPlanType `json:"type"`

	// Enabled 是否启用
	Enabled bool `json:"enabled"`

	// ScheduleCron 定时任务表达式
	ScheduleCron *string `json:"schedule_cron,omitempty"`
}

// ListPlans 获取饲料计划列表
func (c *Controller) ListPlans(ctx *gin.Context) {

	introductions, err := c.feedPlanRepo.ListAllPlanIntroduction()
	if err != nil {
		c.logger.Error("获取设备列表失败: " + err.Error())
		controller.SendErrorResponse(ctx, controller.InternalServerErrorCode, "获取计划列表失败")
	}

	resp := ListPlansResponse{
		Plans: []ListPlanResponseItem{},
	}
	for _, introduction := range introductions {
		resp.Plans = append(resp.Plans, ListPlanResponseItem{
			ID:          introduction.ID,
			Name:        introduction.Name,
			Description: introduction.Description,
			Enabled:     introduction.Enabled,
			Type:        introduction.Type,
		})
	}

	controller.SendSuccessResponse(ctx, "success", resp)
}

// DetailResponse 喂料计划主表
type DetailResponse struct {
	// ID 计划ID
	ID uint `json:"id"`

	// Name 计划名称
	Name string `json:"name"`

	// Description 计划描述
	Description string `json:"description"`

	// Type 计划类型(手动触发/自动触发)
	Type model.FeedingPlanType `json:"type"`

	// Enabled 是否启用
	Enabled bool `json:"enabled"`

	// ScheduleCron 定时任务表达式(仅当Type为auto时有效)
	ScheduleCron *string `json:"scheduleCron"`

	// ExecutionLimit 执行次数限制(0表示无限制，仅当Type为auto时有效)
	ExecutionLimit int `json:"executionLimit"`

	// ParentID 父计划ID（用于支持子计划结构）
	ParentID *uint `json:"parentID"`

	// OrderInParent 在父计划中的执行顺序
	OrderInParent *int `json:"orderInParent"`

	// IsMaster 是否为主计划（主计划可以包含子计划）
	IsMaster bool `json:"isMaster"`

	// CreatedAt 创建时间
	CreatedAt time.Time `json:"createdAt"`

	// UpdatedAt 更新时间
	UpdatedAt time.Time `json:"updatedAt"`

	// DeletedAt 删除时间(用于软删除)
	DeletedAt gorm.DeletedAt `json:"deletedAt"`

	// Steps 计划步骤列表
	Steps []FeedingPlanStep `json:"steps"`

	// SubPlans 子计划列表
	SubPlans []DetailResponse `json:"subPlans"`
}

// FeedingPlanStep 喂料计划步骤表，表示计划中的每个设备动作
type FeedingPlanStep struct {
	// ID 步骤ID
	ID uint `json:"id"`

	// PlanID 关联的计划ID
	PlanID uint `json:"planID"`

	// StepOrder 步骤顺序
	StepOrder int `json:"stepOrder"`

	// DeviceID 关联的设备ID
	DeviceID uint `json:"deviceID"`

	// TargetValue 目标值(达到该值后停止工作切换到下一个设备)
	TargetValue float64 `json:"targetValue"`

	// Action 动作(如:打开设备)
	Action string `json:"action"`

	// ScheduleCron 步骤定时任务表达式(可选)
	ScheduleCron *string `json:"scheduleCron"`

	// ExecutionLimit 步骤执行次数限制(0表示无限制)
	ExecutionLimit int `json:"executionLimit"`

	// CreatedAt 创建时间
	CreatedAt time.Time `json:"createdAt"`

	// UpdatedAt 更新时间
	UpdatedAt time.Time `json:"updatedAt"`

	// DeletedAt 删除时间(用于软删除)
	DeletedAt gorm.DeletedAt `json:"deletedAt"`
}

// Detail 获取饲料计划列细节
func (c *Controller) Detail(ctx *gin.Context) {
	// 获取路径参数中的计划ID
	planIDStr := ctx.Param("id")
	planID, err := strconv.ParseUint(planIDStr, 10, 32)
	if err != nil {
		controller.SendErrorResponse(ctx, controller.InvalidParameterCode, "无效的计划ID")
		return
	}

	// 从仓库中获取计划详情
	plan, err := c.feedPlanRepo.FindFeedingPlanByID(uint(planID))
	if err != nil {
		c.logger.Error("获取计划详情失败: " + err.Error())
		controller.SendErrorResponse(ctx, controller.InternalServerErrorCode, "获取计划详情失败")
		return
	}

	// 转换为响应结构体
	resp := c.convertToDetailResponse(plan)

	controller.SendSuccessResponse(ctx, "success", resp)
}

// convertToDetailResponse 将数据库模型转换为响应结构体
func (c *Controller) convertToDetailResponse(plan *model.FeedingPlan) *DetailResponse {
	resp := &DetailResponse{
		ID:             plan.ID,
		Name:           plan.Name,
		Description:    plan.Description,
		Type:           plan.Type,
		Enabled:        plan.Enabled,
		ScheduleCron:   plan.ScheduleCron,
		ExecutionLimit: plan.ExecutionLimit,
		ParentID:       plan.ParentID,
		OrderInParent:  plan.OrderInParent,
		IsMaster:       plan.IsMaster,
		CreatedAt:      plan.CreatedAt,
		UpdatedAt:      plan.UpdatedAt,
		DeletedAt:      plan.DeletedAt,
		Steps:          make([]FeedingPlanStep, len(plan.Steps)),
		SubPlans:       make([]DetailResponse, len(plan.SubPlans)),
	}

	// 转换步骤
	for i, step := range plan.Steps {
		resp.Steps[i] = FeedingPlanStep{
			ID:             step.ID,
			PlanID:         step.PlanID,
			StepOrder:      step.StepOrder,
			DeviceID:       step.DeviceID,
			TargetValue:    step.TargetValue,
			Action:         step.Action,
			ScheduleCron:   step.ScheduleCron,
			ExecutionLimit: step.ExecutionLimit,
			CreatedAt:      step.CreatedAt,
			UpdatedAt:      step.UpdatedAt,
			DeletedAt:      step.DeletedAt,
		}
	}

	// 转换子计划
	for i, subPlan := range plan.SubPlans {
		// 递归转换子计划
		subPlanModel := &model.FeedingPlan{
			ID:             subPlan.ID,
			Name:           subPlan.Name,
			Description:    subPlan.Description,
			Type:           subPlan.Type,
			Enabled:        subPlan.Enabled,
			ScheduleCron:   subPlan.ScheduleCron,
			ExecutionLimit: subPlan.ExecutionLimit,
			ParentID:       subPlan.ParentID,
			OrderInParent:  subPlan.OrderInParent,
			IsMaster:       subPlan.IsMaster,
			CreatedAt:      subPlan.CreatedAt,
			UpdatedAt:      subPlan.UpdatedAt,
			DeletedAt:      subPlan.DeletedAt,
			Steps:          subPlan.Steps,
			SubPlans:       subPlan.SubPlans,
		}
		resp.SubPlans[i] = *c.convertToDetailResponse(subPlanModel)
	}

	return resp
}