package logic import ( "context" "errors" "fmt" "strconv" "strings" "time" "bj_power_mes/ent" "bj_power_mes/ent/dailyplan" "bj_power_mes/ent/materialrequest" "bj_power_mes/ent/workorder" "bj_power_mes/ent/workpiece" ) type WorkOrderReq struct { Id int `json:"id"` WorkOrderNo string `json:"workOrderNo"` ProductTypeId int `json:"productTypeId"` ProductCode string `json:"productCode"` ProductName string `json:"productName"` Quantity int `json:"quantity"` Status string `json:"status"` PlanStart string `json:"planStart"` PlanEnd string `json:"planEnd"` // 客户编号体系(2026-09-30 对齐):一级=合同号/科技项目号(二选一)→ 二级=产品工号 → 三级=产品序号 // contractNo=归属编号(随 ownershipType 二选一填写);projectNo 已废弃不再接收,字段仅防历史迁移 ContractNo string `json:"contractNo"` OwnershipType string `json:"ownershipType"` // workorder=合同号/project=科技项目号/other=其他 ProductSerial string `json:"productSerial"` // 完成日期(必填,前端强制;yyyy-MM-dd) DueDate string `json:"dueDate"` // 工艺组合(唯一路线源头):[{flowId,stationNo}],工位号即顺序号,按工位号升序执行、可跳过未选工位 FlowCombination []map[string]int `json:"flowCombination"` } // CreateWorkOrder 创建工单(状态恒 CREATED,后续用状态流转按钮推进) func (s *Service) CreateWorkOrder(ctx context.Context, req WorkOrderReq, operator string) error { if req.ProductTypeId == 0 { return errors.New("请选择产品型号") } if req.Quantity <= 0 { req.Quantity = 1 } // 归属(一级编号):合同号/科技项目号 二选一;类型为其他时编号可空 ownershipType, err := validateOwnership(req.OwnershipType, req.ContractNo) if err != nil { return err } req.OwnershipType = ownershipType // 工单号:未传入则按规则生成 WO-日期-001;若与已有工单号重复,自动递增序号(001→002…)。 if req.WorkOrderNo == "" { req.WorkOrderNo = defaultWorkOrderNo() } finalNo, err := s.resolveUniqueWorkOrderNo(ctx, req.WorkOrderNo) if err != nil { return err } req.WorkOrderNo = finalNo status := req.Status if status == "" { status = "CREATED" } if status != "CREATED" { status = "CREATED" // 创建恒为已创建;不允许直接创建到后续状态 } // 工艺组合 = 唯一路线源头([{flowId,stationNo}],工位号升序执行) b := s.ctx.EntClient.WorkOrder.Create(). SetWorkOrderNo(req.WorkOrderNo). SetProductTypeId(req.ProductTypeId). SetProductCode(req.ProductCode). SetProductName(req.ProductName). SetQuantity(req.Quantity). SetContractNo(req.ContractNo). SetOwnershipType(req.OwnershipType). SetProductSerial(req.ProductSerial). SetStatus(status) if req.PlanStart != "" { if t, err := parseDate(req.PlanStart); err == nil { b.SetPlanStart(t) } } if req.PlanEnd != "" { if t, err := parseDate(req.PlanEnd); err == nil { b.SetPlanEnd(t) } } // 完成日期(Item M):前端必填,后端有值即落库 if req.DueDate != "" { if t, err := parseDate(req.DueDate); err == nil { b.SetDueDate(t) } } // 工艺组合(唯一路线源头):传了才校验并写入 if len(req.FlowCombination) > 0 { items, err := s.ValidateFlowCombination(ctx, req.FlowCombination) if err != nil { return err } b.SetFlowCombination(flowItemsToMaps(items)) } // 创建人(Item M):取当前登录用户 b.SetCreatedBy(operator) if _, err := b.Save(ctx); err != nil { return err } s.ctx.EventLog.Write(ctx, "work.order.create", req.WorkOrderNo, operator, "work_order", req.WorkOrderNo, "创建工单", map[string]any{"quantity": req.Quantity}) s.notifyDashboard() return nil } // defaultWorkOrderNo 工单号默认规则:WO-YYYYMMDD-001(如 WO-20260918-001)。 func defaultWorkOrderNo() string { return fmt.Sprintf("WO-%s-001", time.Now().Format("20060102")) } // ownershipTypes 归属类型值域(与 WMS inventories.ownership_type 一致) var ownershipTypes = map[string]bool{ "workorder": true, // 合同号 "project": true, // 科技项目号 "other": true, // 其他 } // validateOwnership 归属校验:类型须在值域内(空=未选择,允许);类型为合同号/科技项目号时归属编号必填, // 「其他」可不填(与 WMS 半成品入库同口径)。返回规范化后的归属类型。 func validateOwnership(ownershipType, ownershipNo string) (string, error) { if ownershipType == "" { return "", nil } if !ownershipTypes[ownershipType] { return "", errors.New("非法的归属类型") } if ownershipType != "other" && strings.TrimSpace(ownershipNo) == "" { return "", errors.New("归属类型为合同号/科技项目号时必填归属编号") } return ownershipType, nil } // resolveUniqueWorkOrderNo 工单号唯一性保障:若 want 已存在,则按尾部序号自动递增 // (WO-20260918-001 → 002 → 003…),最多尝试 999 次,仍冲突则报错由前端手动指定。 // 尾部序号解析失败(无数字后缀)时,退化为在末尾追加 -001/-002…。 func (s *Service) resolveUniqueWorkOrderNo(ctx context.Context, want string) (string, error) { parts := strings.Split(want, "-") prefix := want seq := 0 if len(parts) >= 2 { if n, err := strconv.Atoi(parts[len(parts)-1]); err == nil { seq = n prefix = strings.Join(parts[:len(parts)-1], "-") } } for i := 0; i < 999; i++ { cand := want if i > 0 { cand = fmt.Sprintf("%s-%03d", prefix, seq+i) } cnt, err := s.ctx.EntClient.WorkOrder.Query().Where(workorder.WorkOrderNo(cand)).Count(ctx) if err != nil { return "", err } if cnt == 0 { return cand, nil } } return "", errors.New("工单号自动编号失败(序号已用尽),请手动指定工单号") } // UpdateWorkOrder 编辑工单。 // - 「已创建」(含存量 PENDING):全字段可编辑 // - 「已暂停」(PAUSED):仅允许调整工艺组合(其余字段锁定),且须无在制工件—— // 在制工件按当前组合走完,防止运行中路线突变;变更写 eventlog 留痕 // - 其余状态只读(已下发/执行中只能做状态流转,已完成/已取消只读) func (s *Service) UpdateWorkOrder(ctx context.Context, req WorkOrderReq, operator string) error { if req.Id == 0 { return errors.New("缺少 id") } old, err := s.ctx.EntClient.WorkOrder.Get(ctx, req.Id) if err != nil { return errors.New("工单不存在") } pausedEdit := old.Status == "PAUSED" if old.Status != "CREATED" && old.Status != "PENDING" && !pausedEdit { return errors.New("仅「已创建」可编辑全部字段;「已暂停」仅允许调整工艺组合;其余状态只能做状态流转") } // 已暂停:仅工艺组合可改(在制守卫 + 留痕),其余字段一律拒绝 if pausedEdit { if req.FlowCombination == nil { return errors.New("已暂停的工单仅允许调整工艺组合") } inflight, _ := s.ctx.EntClient.Workpiece.Query(). Where(workpiece.OrderNo(old.WorkOrderNo), workpiece.StatusNEQ("DONE")). Count(ctx) if inflight > 0 { return fmt.Errorf("该工单还有 %d 个在制/未完工工件,请先完成或撤回后再调整工艺组合", inflight) } items, err := s.ValidateFlowCombination(ctx, req.FlowCombination) if err != nil { return err } if err := s.ctx.EntClient.WorkOrder.UpdateOneID(req.Id). SetFlowCombination(flowItemsToMaps(items)).Exec(ctx); err != nil { return err } s.ctx.EventLog.Write(ctx, "work.order.flow_change", old.WorkOrderNo, operator, "work_order", old.WorkOrderNo, "已暂停工单调整工艺组合", map[string]any{"old": old.FlowCombination, "new": flowItemsToMaps(items)}) s.notifyDashboard() return nil } if old.Status != "CREATED" && old.Status != "PENDING" { return errors.New("仅「已创建」状态的工单可编辑;生产中或已结束的工单只能做状态流转") } // 归属(一级编号):合同号/科技项目号 二选一;工程编号已废弃,不再改写 project_no(保留历史数据) ownershipType, err := validateOwnership(req.OwnershipType, req.ContractNo) if err != nil { return err } u := s.ctx.EntClient.WorkOrder.UpdateOneID(req.Id). SetContractNo(req.ContractNo).SetOwnershipType(ownershipType).SetProductSerial(req.ProductSerial) // 工艺组合(唯一路线源头):传了才校验并覆盖写入(编辑仅限「已创建」状态,上方已校验) if req.FlowCombination != nil { items, err := s.ValidateFlowCombination(ctx, req.FlowCombination) if err != nil { return err } u.SetFlowCombination(flowItemsToMaps(items)) } if req.Quantity > 0 { u.SetQuantity(req.Quantity) } if req.ProductCode != "" { u.SetProductCode(req.ProductCode) } if req.ProductName != "" { u.SetProductName(req.ProductName) } if req.PlanStart != "" { if t, err := parseDate(req.PlanStart); err == nil { u.SetPlanStart(t) } } if req.PlanEnd != "" { if t, err := parseDate(req.PlanEnd); err == nil { u.SetPlanEnd(t) } } if req.DueDate != "" { if t, err := parseDate(req.DueDate); err == nil { u.SetDueDate(t) } } if err := u.Exec(ctx); err != nil { return err } wo, err := s.ctx.EntClient.WorkOrder.Get(ctx, req.Id) if err == nil { s.ctx.EventLog.Write(ctx, "work.order.update", wo.WorkOrderNo, operator, "work_order", wo.WorkOrderNo, "更新工单", nil) } s.notifyDashboard() return nil } // ListWorkOrders 查询工单(支持工单号/状态/产品编码/产品名称/归属类型/归属编号 过滤; // 工程编号查询已随编号体系改造移除,字段保留仅防历史迁移) func (s *Service) ListWorkOrders(ctx context.Context, orderNo, status, productCode, productName, contractNo, ownershipType, dueFrom, dueTo string) ([]*ent.WorkOrder, error) { q := s.ctx.EntClient.WorkOrder.Query() if orderNo != "" { q = q.Where(workorder.WorkOrderNoContains(orderNo)) } if status != "" { q = q.Where(workorder.Status(status)) } if productCode != "" { q = q.Where(workorder.ProductCodeContains(productCode)) } if productName != "" { q = q.Where(workorder.ProductNameContains(productName)) } if contractNo != "" { q = q.Where(workorder.ContractNoContains(contractNo)) } if ownershipType != "" { q = q.Where(workorder.OwnershipType(ownershipType)) } // 完成日期范围(Item M) if dueFrom != "" { if t, err := parseDate(dueFrom); err == nil { q = q.Where(workorder.DueDateGTE(t)) } } if dueTo != "" { if t, err := parseDate(dueTo); err == nil { q = q.Where(workorder.DueDateLTE(t)) } } return q.Order(ent.Desc(workorder.FieldCreatedAt), ent.Desc(workorder.FieldID)).All(ctx) } func (s *Service) GetWorkOrder(ctx context.Context, id int) (*ent.WorkOrder, error) { if id > 0 { return s.ctx.EntClient.WorkOrder.Get(ctx, id) } return s.ctx.EntClient.WorkOrder.Query().Order(ent.Desc(workorder.FieldID)).First(ctx) } // 工单状态白名单(统一枚举:已创建/已下发/执行中/已暂停/已完成/已取消) var workOrderStatuses = map[string]bool{ "CREATED": true, "RELEASED": true, "IN_PROGRESS": true, "PAUSED": true, "DONE": true, "CANCELLED": true, } // workOrderTransitions 工单状态流转表:from → {to...} // CREATED 可下发/取消;RELEASED 可开工/取消;IN_PROGRESS 可暂停/完工; // PAUSED 可恢复/取消;DONE/CANCELLED 为终态,不再流转。 var workOrderTransitions = map[string]map[string]bool{ "CREATED": {"RELEASED": true, "CANCELLED": true}, "RELEASED": {"IN_PROGRESS": true, "CANCELLED": true}, "IN_PROGRESS": {"PAUSED": true, "DONE": true}, "PAUSED": {"IN_PROGRESS": true, "CANCELLED": true}, "DONE": {}, "CANCELLED": {}, // 兼容存量旧枚举:PENDING(待排产)≈已创建可发布,CONFIRMED(已确认)≈已下发可开工 "PENDING": {"RELEASED": true, "CANCELLED": true}, "CONFIRMED": {"IN_PROGRESS": true, "CANCELLED": true}, } // SetWorkOrderStatus 工单状态流转(发布/开工/暂停/恢复/完工/取消)。 // 校验流转合法性;写 eventlog 记录 原状态/新状态/原因;终态联动处理(见 cancelPlansOfOrder)。 func (s *Service) SetWorkOrderStatus(ctx context.Context, id int, status, reason, operator string) error { if id <= 0 { return errors.New("缺少 id") } if !workOrderStatuses[status] { return errors.New("非法的工单状态") } wo, err := s.ctx.EntClient.WorkOrder.Get(ctx, id) if err != nil { return errors.New("工单不存在") } if wo.Status == status { return nil // 幂等:状态相同直接成功 } if !workOrderTransitions[wo.Status][status] { return fmt.Errorf("不允许从「%s」变更为「%s」", statusTextCN(wo.Status), statusTextCN(status)) } // 工艺组合守卫:下发/开工必须有工艺组合(建单允许空组合,组合是"怎么生产"的前提) // 多工单混生产:移除原"单工单互斥"(一条产线允许同时执行多个工单; // 工位级天然串行=一个工位一次装一个工件,备料/报工/追溯全按工单挂账互不干扰) if status == "RELEASED" || status == "IN_PROGRESS" { if len(wo.FlowCombination) == 0 { return errors.New("该工单未配置工艺组合,请先在工单编辑中勾选工艺组合后再下发/开工") } } upd := s.ctx.EntClient.WorkOrder.UpdateOneID(id).SetStatus(status) if status == "DONE" { now := time.Now() upd.SetCompletedAt(now) } if err := upd.Exec(ctx); err != nil { return err } // 状态变更操作日志:原状态/新状态/原因 s.ctx.EventLog.Write(ctx, "work.order.status", wo.WorkOrderNo, operator, "work_order", wo.WorkOrderNo, "变更工单状态", map[string]any{"from": wo.Status, "to": status, "reason": reason}) // 联动:DONE/CANCELLED → 该工单未完成排产批量取消;IN_PROGRESS → 排产置执行中 s.syncPlansByOrderStatus(ctx, wo.WorkOrderNo, status, operator) s.notifyDashboard() return nil } // statusTextCN 状态枚举中文文案 func statusTextCN(s string) string { m := map[string]string{ "CREATED": "已创建", "RELEASED": "已下发", "IN_PROGRESS": "执行中", "PAUSED": "已暂停", "DONE": "已完成", "CANCELLED": "已取消", } if v, ok := m[s]; ok { return v } return s } // DeleteWorkOrder 删除工单。 // 安全条件:① 状态仅限 已创建(CREATED,兼容存量 PENDING/CONFIRMED 未开始生产);② 无日排产记录; // ③ 未生成备料单;④ 无任何工件生产数据。已下发/执行中/已暂停/已完成/已取消一律不可删除。 func (s *Service) DeleteWorkOrder(ctx context.Context, id int, operator string) error { if id <= 0 { return errors.New("缺少 id") } wo, err := s.ctx.EntClient.WorkOrder.Get(ctx, id) if err != nil { return errors.New("工单不存在") } if wo.Status != "CREATED" && wo.Status != "PENDING" && wo.Status != "CONFIRMED" { return errors.New("仅「已创建」状态的工单可删除;已下发、执行中或已结束的工单不能删除") } if n, err := s.ctx.EntClient.DailyPlan.Query().Where(dailyplan.OrderNo(wo.WorkOrderNo)).Count(ctx); err == nil && n > 0 { return errors.New("该工单已有日排产记录,请先删除对应排产后再删除工单") } if n, err := s.ctx.EntClient.MaterialRequest.Query().Where(materialrequest.OrderNo(wo.WorkOrderNo)).Count(ctx); err == nil && n > 0 { return errors.New("该工单已生成备料单,不能删除") } if n, err := s.ctx.EntClient.Workpiece.Query().Where(workpiece.OrderNo(wo.WorkOrderNo)).Count(ctx); err == nil && n > 0 { return errors.New("该工单已有工件生产数据,不能删除") } if err := s.ctx.EntClient.WorkOrder.DeleteOneID(id).Exec(ctx); err != nil { return err } s.ctx.EventLog.Write(ctx, "work.order.delete", wo.WorkOrderNo, operator, "work_order", wo.WorkOrderNo, "删除工单", map[string]any{"status": wo.Status}) return nil }