package logic import ( "context" "errors" "fmt" "sort" "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" "bj_power_mes/internal/verr" ) 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 对齐):一级=合同号/科技项目号(二选一)→ 二级=产品工号。 // 三级产品序号已定案=SN(2026-11-06 条22):SN 是每台工件的序列号、不是工单级字段, // 工单级 productSerial 字段已删除,SN 全部落在工件(workpiece.sn)上。 ContractNo string `json:"contractNo"` OwnershipType string `json:"ownershipType"` // workorder=合同号/project=科技项目号/other=其他 // 工艺组合(唯一路线源头):[{flowId,stationNo}],工位号即顺序号,按工位号升序执行、可跳过未选工位 FlowCombination []map[string]int `json:"flowCombination"` // 来源产品工艺(2026-10-09):建单选产品时带出默认产品工艺并自动填组合; // 组合是快照可手改,本字段恒保留=来源定义(0=无来源,历史工单),供追溯与偏差提示。 ProductProcessId int `json:"productProcessId"` // 产品序号前缀(SN 前缀):非空时 SN = 前缀-4位序号(如 SunYF-0001,不带工单号); // 为空保持「工单号-3位序号」。前缀全项目唯一,仅 CREATED 可改,改前缀走 POST /work-orders/sn-prefix。 SnPrefix string `json:"snPrefix"` } // CreateWorkOrder 创建工单(状态恒 CREATED,后续用状态流转按钮推进) func (s *Service) CreateWorkOrder(ctx context.Context, req WorkOrderReq, operator string) error { // 2026-11-13 拍板:排产/建工单必须读取「当前产线在用的混产模板」并校验产品范围。 // 同模板内多工单(多成品)混产直接放行;模板外新产品必须先清线并切换当前模板, // 不允许排产偷偷把新产品塞进不属于它的产线配置里。 // 2026-11-16 fail-close 收口:无在用模板 / 成品编码缺失一律拒绝,堵住"没配模板就跳过校验"的旁路。 tplName, products, tErr := s.ActiveMixProducts(ctx) if tErr != nil { return tErr } // 收集式校验(报错一次收全 + 每条带怎么办,2026-10-20):字段问题全部列出、一次性返回,不再串行 return ve := verr.New() if tplName == "" { ve.Add("mixTemplate", "当前产线没有设置「在用」混产模板,无法创建工单", "先到「工位管理」配置工位工艺绑定并保存为混产模板,再到混产模板页将其设为当前在用模板") } pc := strings.TrimSpace(req.ProductCode) if pc == "" { ve.Add("productCode", "工单缺少成品编码,无法校验混产范围", "请先确认所选产品型号档案已生成成品编码,再创建工单") } else if tplName != "" { allowed := false for _, c := range products { if c == pc { allowed = true break } } if !allowed { ve.Add("productCode", fmt.Sprintf("当前产线在用混产模板「%s」不含成品 %s", tplName, pc), "跨模板引入新产品需先清线,再到「工位管理 → 保存当前绑定为模板」切换当前模板") } } if req.ProductTypeId == 0 { ve.Add("productTypeId", "请选择产品型号", "在「产品型号」下拉中选择本次要生产的产品") } if req.Quantity <= 0 { req.Quantity = 1 } if req.Quantity > 999 { ve.Add("quantity", "单次建工单数量上限 999", "分批创建:每张工单不超过 999 台") } // 产品序号前缀:限长 32 字节,避免拼接后超出 workpiece.sn(64);全项目唯一,重复直接业务提示 req.SnPrefix = strings.TrimSpace(req.SnPrefix) if len(req.SnPrefix) > 32 { ve.Add("snPrefix", "产品序号前缀过长,最多 32 字节", "缩短前缀(≤32 字节)后再保存") } else if req.SnPrefix != "" { if taken, byNo := s.snPrefixTaken(ctx, req.SnPrefix, 0); taken { ve.Add("snPrefix", fmt.Sprintf("产品序号前缀「%s」已被工单 %s 使用,请勿重复使用", req.SnPrefix, byNo), "换一个前缀,或留空按产品工号自动生成") } } // 归属(一级编号):合同号/科技项目号 二选一;类型为其他时编号可空 if ot, oerr := validateOwnership(req.OwnershipType, req.ContractNo); oerr != nil { ve.Add("contractNo", oerr.Error(), "归属类型选「合同号/科技项目号」时必须填归属编号;选「其他」可不填") } else { req.OwnershipType = ot } // 工艺组合(唯一路线源头):逐条收集(重复/停用/不存在/绑定不匹配全部列出) var comboItems []FlowItem if len(req.FlowCombination) > 0 { items, cve := s.ValidateFlowCombinationCollect(ctx, req.FlowCombination) comboItems = items ve.Merge(cve) // 工序工位严格校验(2026-10-20 工单建单需求):每道工序都选、工位号严格递增(无产品工艺则交由既有逻辑) if sve := s.ValidateWorkOrderComboStrict(ctx, req.ProductProcessId, req.FlowCombination); sve.Len() > 0 { ve.Merge(sve) } } // 来源产品工艺:传了必须存在(ACTIVE/停用均可落——前端只列启用的,此处宽松校验存在性) if req.ProductProcessId > 0 { if _, perr := s.ctx.EntClient.ProductProcess.Get(ctx, req.ProductProcessId); perr != nil { ve.Add("productProcessId", "所选产品工艺不存在", "在「产品工艺」下拉中重新选择,或留空(建单后再配置组合)") } } if err := ve.OrNil(); err != nil { return err } // 工单号:未传入则按规则生成 WO-日期-001;若与已有工单号重复,自动递增序号(001→002…)。 if req.WorkOrderNo == "" { req.WorkOrderNo = defaultWorkOrderNo() } finalNo, nerr := s.resolveUniqueWorkOrderNo(ctx, req.WorkOrderNo) if nerr != nil { return nerr } req.WorkOrderNo = finalNo status := "CREATED" // 创建恒为已创建;不允许直接创建到后续状态 // 工艺组合 = 唯一路线源头([{flowId,stationNo}],工位号升序执行) tx, err := s.ctx.EntClient.Tx(ctx) if err != nil { return err } committed := false defer func() { if !committed { _ = tx.Rollback() } }() client := tx.Client() wo, err := client.WorkOrder.Create(). SetWorkOrderNo(req.WorkOrderNo). SetProductTypeId(req.ProductTypeId). SetProductCode(req.ProductCode). SetProductName(req.ProductName). SetQuantity(req.Quantity). SetContractNo(req.ContractNo). SetOwnershipType(req.OwnershipType). SetStatus(status).Save(ctx) if err != nil { return err } if req.PlanStart != "" { if t, err := parseDate(req.PlanStart); err == nil { wo, _ = client.WorkOrder.UpdateOneID(wo.ID).SetPlanStart(t).Save(ctx) } } if req.PlanEnd != "" { if t, err := parseDate(req.PlanEnd); err == nil { wo, _ = client.WorkOrder.UpdateOneID(wo.ID).SetPlanEnd(t).Save(ctx) } } // 工艺组合(唯一路线源头):收集式校验已通过,此处直接写入 if len(comboItems) > 0 { if _, err := client.WorkOrder.UpdateOneID(wo.ID).SetFlowCombination(flowItemsToMaps(comboItems)).Save(ctx); err != nil { return err } } // 来源产品工艺:存在性已校验,直接落库 if req.ProductProcessId > 0 { if _, err := client.WorkOrder.UpdateOneID(wo.ID).SetProductProcessId(req.ProductProcessId).Save(ctx); err != nil { return err } } // 创建人(Item M):取当前登录用户 if _, err := client.WorkOrder.UpdateOneID(wo.ID).SetCreatedBy(operator).Save(ctx); err != nil { return err } // 二.3 建工单(CREATED)按数量预生成 SN,全 NEW,与工单同事务提交(上限 999;命名 {工单号}-{3位序号})。 // 新工单无既有 SN,直接采用标准格式;若存在历史 SN 冲突由 Unique 约束兜底报错。 { bulk := make([]*ent.WorkpieceCreate, 0, req.Quantity) for i := 1; i <= req.Quantity; i++ { sn := makeSN(req.SnPrefix, req.WorkOrderNo, i) bulk = append(bulk, client.Workpiece.Create(). SetSn(sn).SetOrderNo(req.WorkOrderNo).SetWorkOrderId(wo.ID).SetStatus("NEW")) } if err := client.Workpiece.CreateBulk(bulk...).Exec(ctx); err != nil { return err } } if err := tx.Commit(); err != nil { return err } committed = true 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):允许调整工艺组合(其余字段锁定)—— 暂停后改线即「转产」,保存后触发 // 转产连锁(旧工位退料+在制工件转移+新工位重排备料,见 TransferProduction);如确需运行中换工位, // 应先暂停再改线,避免生产途中路线突变 // - 其余状态只读(已下发/执行中只能做状态流转,已完成/已取消只读) 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("工单不存在") } // 规则2(2026-10-20 拍板,2026-11-03 修订):IN_PROGRESS 不可改线(运行中路线固定,防串序); // PAUSED 允许改线并触发转产连锁。 if old.Status == "IN_PROGRESS" { return errors.New("工单执行中,工艺组合不可修改;请先「暂停工单」再改线(转产)") } // 工艺路线冻结守卫(2026-11-05 拍板):工单未完成(非 DONE/CANCELLED)时,工艺路线相关字段 //(工艺组合、来源产品工艺)禁止修改——保证工单路线快照与执行前后一致。 // 唯一例外:PAUSED 改线=「转产」,保留既有两步走闸门(GuardTransferReroute:退库收货+接驳台清空)。 if old.Status != "DONE" && old.Status != "CANCELLED" && old.Status != "PAUSED" { if req.FlowCombination != nil && !flowCombinationEqual(old.FlowCombination, req.FlowCombination) { return errors.New("该工单未完成,工艺路线(工序/工位组合)禁止修改;如需调整,请取消工单后重新建单,或先「暂停工单」按转产流程改线") } if req.ProductProcessId > 0 && req.ProductProcessId != old.ProductProcessId { return errors.New("该工单未完成,来源产品工艺禁止变更;如需调整,请取消工单后重新建单") } } // 收集式校验(报错一次收全 + 每条带怎么办,2026-10-20):字段问题全部列出、一次性返回 ve := verr.New() // 归属(一级编号):合同号/科技项目号 二选一;工程编号已废弃,不再改写 project_no(保留历史数据) if ot, oerr := validateOwnership(req.OwnershipType, req.ContractNo); oerr != nil { ve.Add("contractNo", oerr.Error(), "归属类型选「合同号/科技项目号」时必须填归属编号;选「其他」可不填") } else { req.OwnershipType = ot } // 工艺组合(唯一路线源头):传了才校验(编辑仅限「已创建」状态,上方已拦截) var comboItems []FlowItem if req.FlowCombination != nil { items, cve := s.ValidateFlowCombinationCollect(ctx, req.FlowCombination) comboItems = items ve.Merge(cve) // 工序工位严格校验(2026-10-20 工单建单需求):每道工序都选、工位号严格递增(无产品工艺则交由既有逻辑) if sve := s.ValidateWorkOrderComboStrict(ctx, req.ProductProcessId, req.FlowCombination); sve.Len() > 0 { ve.Merge(sve) } } // 来源产品工艺:传了必须存在(恒保留=来源定义,不随组合手改清空) if req.ProductProcessId > 0 { if _, perr := s.ctx.EntClient.ProductProcess.Get(ctx, req.ProductProcessId); perr != nil { ve.Add("productProcessId", "所选产品工艺不存在", "在「产品工艺」下拉中重新选择") } } if req.Quantity > 0 && req.Quantity < old.Quantity { // 二.3 边界#1:减数量只允许在所有预生成 SN 仍为 NEW 时进行(已有 SN 进入生产则禁止减) if nonNew, _ := s.ctx.EntClient.Workpiece.Query(). Where(workpiece.OrderNo(old.WorkOrderNo), workpiece.StatusNEQ("NEW")).Count(ctx); nonNew > 0 { ve.Add("quantity", fmt.Sprintf("该工单已有 %d 个 SN 进入生产(非 NEW),禁止减少工单数量", nonNew), "数量只能增加或不变;确需减少,先把已进入生产的 SN 完工/作废后再试") } } if err := ve.OrNil(); err != nil { return err } u := s.ctx.EntClient.WorkOrder.UpdateOneID(req.Id). SetContractNo(req.ContractNo).SetOwnershipType(req.OwnershipType) // 工艺组合(唯一路线源头):收集式校验已通过,此处直接写入 if comboItems != nil { u.SetFlowCombination(flowItemsToMaps(comboItems)) } // 来源产品工艺:存在性已校验,直接落库 if req.ProductProcessId > 0 { u.SetProductProcessId(req.ProductProcessId) } 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) } } // 转产两步走(2026-11-03 定论):先人工盘库退料、库房确认收货(退库闭环)后,才允许改线—— // 严禁一键全自动连锁。前置闸门不过则本次改线直接被拒。 if old.Status == "PAUSED" && len(req.FlowCombination) > 0 { if terr := s.GuardTransferReroute(ctx, old, req.FlowCombination); terr != nil { return terr } } 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) } // 转产改线后置动作(退料已由人工完成并通过前置闸门):在制工件转移 + 新工位重排备料。 // 失败只记日志/事件,不影响改线(现场可据此复核)。 if old.Status == "PAUSED" && len(req.FlowCombination) > 0 { if terr := s.TransferProduction(ctx, old, old.FlowCombination, req.FlowCombination, operator); terr != nil { s.ctx.EventLog.Write(ctx, "work.order.transfer.fail", old.WorkOrderNo, operator, "work_order", old.WorkOrderNo, "转产连锁部分失败(改线已保存,请现场复核):"+terr.Error(), nil) } } s.notifyDashboard() return nil } // ListWorkOrders 查询工单(支持工单号/状态/产品编码/产品名称/归属类型/归属编号 过滤; // 工程编号查询已随编号体系改造移除,字段保留仅防历史迁移)。 // keyword:跨字段模糊(工单号/产品编码/产品名称/合同号 任一命中),供下拉远程搜索用; // limit:>0 时启用截断(封顶 200),仅下拉搜索场景传参,列表页不传=全量,行为向后兼容; // offset:>0 时跳过前 N 条,配合 limit 供下拉滚动分页(不传=0,行为向后兼容); // firstStation:>0 时只返回「第1道工序候选工位含该工位」的工单(2026-11-16 上线建档下拉专用, // 与建档落点资格校验同口径),0=不过滤,行为向后兼容。 func (s *Service) ListWorkOrders(ctx context.Context, orderNo, status, productCode, productName, contractNo, ownershipType, keyword string, limit, offset int, firstStation int) ([]*ent.WorkOrder, error) { q := s.ctx.EntClient.WorkOrder.Query() if orderNo != "" { q = q.Where(workorder.WorkOrderNoContainsFold(orderNo)) } if status != "" { q = q.Where(workorder.Status(status)) } if productCode != "" { q = q.Where(workorder.ProductCodeContainsFold(productCode)) } if productName != "" { q = q.Where(workorder.ProductNameContainsFold(productName)) } if contractNo != "" { q = q.Where(workorder.ContractNoContainsFold(contractNo)) } if ownershipType != "" { q = q.Where(workorder.OwnershipType(ownershipType)) } // keyword 跨字段模糊(下拉远程搜索):工单号/产品编码/产品名称/合同号 任一命中 if keyword != "" { kw := workorder.Or( workorder.WorkOrderNoContainsFold(keyword), workorder.ProductCodeContainsFold(keyword), workorder.ProductNameContainsFold(keyword), workorder.ContractNoContainsFold(keyword), ) q = q.Where(kw) } // offset 分页偏移:仅下拉滚动分页传参,>0 才启用,不传时行为不变 if offset > 0 { q = q.Offset(offset) } q = q.Order(ent.Desc(workorder.FieldCreatedAt), ent.Desc(workorder.FieldID)) rows, err := q.All(ctx) if err != nil { return nil, err } if limit > 200 { limit = 200 } // 首道候选工位过滤:需取回后在内存按工艺组合计算(截断前过滤会漏),命中即收,达 limit 早停 if firstStation > 0 { out := make([]*ent.WorkOrder, 0, len(rows)) for _, w := range rows { items, _ := RouteStationsFromWO(ctx, s.ctx.EntClient, w) if len(items) == 0 { continue } route := groupFlowRoute(items) if len(route) > 0 && intsContains(route[0].Stations, firstStation) { out = append(out, w) } if limit > 0 && len(out) >= limit { break } } return out, nil } if limit > 0 && len(rows) > limit { rows = rows[:limit] } return rows, nil } // ListProcessCards 流程卡列表(分页):每个工单=一张生产流程卡。 // 与 /process-card/by-model 不同,本接口不要求任何条件,支持按工单号/产品型号/关键字(工单号·产品编码·产品名称)筛选, // 返回 {total, list},list 元素为工单基础字段(含创建时间;成品 SN 见工件明细 workpiece.sn),供前端「流程卡列表」Tab 展示。 func (s *Service) ListProcessCards(ctx context.Context, page, pageSize int, orderNo, productCode, keyword string) (int64, []*ent.WorkOrder, error) { if page < 1 { page = 1 } if pageSize < 1 { pageSize = 20 } if pageSize > 200 { pageSize = 200 } q := s.ctx.EntClient.WorkOrder.Query() if orderNo != "" { q = q.Where(workorder.WorkOrderNoContainsFold(orderNo)) } if productCode != "" { q = q.Where(workorder.ProductCodeContainsFold(productCode)) } if keyword != "" { kw := workorder.Or( workorder.WorkOrderNoContainsFold(keyword), workorder.ProductCodeContainsFold(keyword), workorder.ProductNameContainsFold(keyword), ) q = q.Where(kw) } total, err := q.Count(ctx) if err != nil { return 0, nil, err } list, err := q.Order(ent.Desc(workorder.FieldCreatedAt), ent.Desc(workorder.FieldID)). Offset((page - 1) * pageSize).Limit(pageSize).All(ctx) if err != nil { return 0, nil, err } return int64(total), list, nil } 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) } // 工单状态白名单(方案 A 定稿,问题.md 一/计划.md): // CREATED(已创建) / IN_PROGRESS(执行中) / PAUSED(已暂停) / DONE(已完成) / CANCELLED(已取消)。 // PENDING/CONFIRMED(待排产/已确认) 与 RELEASED(已下发) 为方案 A 前旧枚举,已废弃: // 新工单不再产生;本机不再放行。残留旧数据由"旧数据可删库"清理。 var workOrderStatuses = map[string]bool{ "CREATED": true, "IN_PROGRESS": true, "PAUSED": true, "DONE": true, "CANCELLED": true, } // workOrderTransitions 工单状态流转表:from → {to...}(方案 A) // CREATED 可下发并开工/取消;IN_PROGRESS 可暂停/完工; // PAUSED 可恢复/取消;DONE/CANCELLED 为终态,不再流转。 var workOrderTransitions = map[string]map[string]bool{ "CREATED": {"IN_PROGRESS": true, "CANCELLED": true}, "IN_PROGRESS": {"PAUSED": true, "DONE": true}, "PAUSED": {"IN_PROGRESS": true, "CANCELLED": true}, "DONE": {}, "CANCELLED": {}, // 存量兼容(残留 RELEASED 旧数据,等同已下发待开工):允许 →下发并开工/取消;新单不再产生。 "RELEASED": {"IN_PROGRESS": true, "CANCELLED": true}, } // SetWorkOrderStatus 工单状态流转(下发并开工/暂停/恢复/完工/取消)。 // 校验流转合法性;写 eventlog 记录 原状态/新状态/原因;终态联动处理(见 cancelPlansOfOrder)。 // 注意:下发并开工=IN_PROGRESS 仅做「置状态 + 事件日志 + 排产联动」,不调 WMS、不生成物料需求 // (备料单由「生成备料单」按钮/日排产独立触发),避免一次下发造成副作用越界。 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 == "IN_PROGRESS" { if len(wo.FlowCombination) == 0 { return errors.New("该工单未配置工艺组合,请先在工单编辑中勾选工艺组合后再下发并开工") } } // 完工门禁(2026-10-20 拍板):工单「已完成」必须以全部工件报工完成为前提, // 不允许未生产完即人工置完工(问题12:未开工显示已完工)。 if status == "DONE" && wo.FinishedNum < wo.Quantity { return fmt.Errorf("工单尚有 %d 台未报工完成(共 %d 台,已完工 %d 台),不能完工;请等全部工件报工完成后再点「完工」", wo.Quantity-wo.FinishedNum, wo.Quantity, wo.FinishedNum) } upd := s.ctx.EntClient.WorkOrder.UpdateOneID(id).SetStatus(status) if status == "IN_PROGRESS" { // 实际开始:仅在首次「下发并开工」且尚未记录时落库;重复开工不覆盖(幂等) if wo.ActualStart == nil { upd.SetActualStart(time.Now()) } } 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": "已创建", "IN_PROGRESS": "执行中", "PAUSED": "已暂停", "DONE": "已完成", "CANCELLED": "已取消", "RELEASED": "执行中", // 存量兼容:旧 RELEASED 等同已下发待开工 } if v, ok := m[s]; ok { return v } return s } // DeleteWorkOrder 删除工单(方案 A:仅「已创建」可删)。 // 安全条件:① 状态仅限 CREATED;② 无日排产记录;③ 未生成备料单; // ④ 无任何 SN 进入生产(状态≠NEW)。仅预生成的 NEW SN 不阻止删除(业务定稿·一.2 边界#2)。 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" { 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("该工单已有日排产记录,请先删除对应排产后再删除工单") } // 二.3 边界#2:有任何 SN 已进入生产(状态≠NEW) 则禁止删除;仅预生成未上线的 NEW SN 不阻止。 if n, err := s.ctx.EntClient.Workpiece.Query(). Where(workpiece.OrderNo(wo.WorkOrderNo), workpiece.StatusNEQ("NEW")).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 } // ---------- 强制完工(方案 A:终止 + 清单确认,2026-10-20 用户拍板) ---------- // 背景:现场存在「工单做不满必须关单」。与正常完工(SetWorkOrderStatus DONE 门禁:全部工件 // 报工完成)不同,强制完工允许 FinishedNum 0 && !seen[n] { seen[n] = true out = append(out, n) } } } return out, nil } // ForceCompletePreview 生成强制完工核对单(只读,不改任何数据)。 func (s *Service) ForceCompletePreview(ctx context.Context, id int) (*ForceCompleteReport, error) { wo, err := s.ctx.EntClient.WorkOrder.Get(ctx, id) if err != nil { return nil, errors.New("工单不存在") } if wo.Status != "IN_PROGRESS" && wo.Status != "PAUSED" { return nil, errors.New("仅「执行中/已暂停」的工单可强制完工") } return s.buildForceCompleteReport(ctx, wo) } // buildForceCompleteReport 汇总四项清单(只读)。 func (s *Service) buildForceCompleteReport(ctx context.Context, wo *ent.WorkOrder) (*ForceCompleteReport, error) { rep := &ForceCompleteReport{ WorkOrderNo: wo.WorkOrderNo, Status: wo.Status, Quantity: wo.Quantity, FinishedNum: wo.FinishedNum, Remaining: wo.Quantity - wo.FinishedNum, } // ① 未完成排产 plans, err := s.ctx.EntClient.DailyPlan.Query(). Where(dailyplan.OrderNo(wo.WorkOrderNo), dailyplan.StatusIn("PENDING", "PROCESSING")).All(ctx) if err == nil { for _, p := range plans { rep.PlansToCancel = append(rep.PlansToCancel, p.PlanDate+"("+strconv.Itoa(p.PlanQty)+" 台)") } } // ② 在途叫料(按排产覆盖工位近似圈定,见函数组注释④) stations, serr := s.stationsOfOrder(ctx, wo.WorkOrderNo) if serr == nil && len(stations) > 0 { pending, e1 := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.Status("PENDING"), materialrequest.StationNoIn(stations...)).All(ctx) if e1 == nil { for _, mr := range pending { rep.PendingCalls = append(rep.PendingCalls, mr.RequestNo+" 工位"+strconv.Itoa(mr.StationNo)+" "+mr.MaterialName) } } shipped, e2 := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.Status("SHIPPED"), materialrequest.StationNoIn(stations...)).All(ctx) if e2 == nil { for _, mr := range shipped { rep.ShippedCalls = append(rep.ShippedCalls, mr.RequestNo+" 工位"+strconv.Itoa(mr.StationNo)+" "+mr.MaterialName) } } } // ③ 在制工件 rep.InProduction, _ = s.ctx.EntClient.Workpiece.Query(). Where(workpiece.OrderNo(wo.WorkOrderNo), workpiece.StatusIn("ONLINE", "PROCESSING")).Count(ctx) // ④ 已报废/取走登记件数(R11 2026-11-03 拍板:核对单展示,先报废登记后强完) rep.ScrapCount, _ = s.ctx.EntClient.Workpiece.Query(). Where(workpiece.OrderNo(wo.WorkOrderNo), workpiece.Status("SCRAPPED")).Count(ctx) return rep, nil } // ForceComplete 执行强制完工(原因必填): // 在制工件 >0 直接拒绝;PENDING 叫料逐张取消(单张失败记日志继续,额度问题留待人工); // 排产经 syncPlansByOrderStatus 联动 CANCELLED 并重算叫料池;工单直接置 DONE(绕过完工门禁,属本操作本意)。 func (s *Service) ForceComplete(ctx context.Context, id int, reason, operator string) (*ForceCompleteReport, error) { if strings.TrimSpace(reason) == "" { return nil, errors.New("强制完工必须填写原因") } wo, err := s.ctx.EntClient.WorkOrder.Get(ctx, id) if err != nil { return nil, errors.New("工单不存在") } if wo.Status != "IN_PROGRESS" && wo.Status != "PAUSED" { return nil, errors.New("仅「执行中/已暂停」的工单可强制完工") } rep, err := s.buildForceCompleteReport(ctx, wo) if err != nil { return nil, err } if rep.InProduction > 0 { return nil, fmt.Errorf("还有 %d 件在制,实物去向必须先落定:正常完工报工,或先在「工件追溯」页走「报废 / 人工取走登记」(原因必填)后再强制完工", rep.InProduction) } // PENDING 叫料自动取消(释放占用额度);单张失败不阻断关单,失败明细进 event_log pendingBefore := append([]string(nil), rep.PendingCalls...) // 取消前快照(event_log 留痕用) cancelFail := make([]string, 0) for _, line := range pendingBefore { requestNo := strings.Fields(line)[0] if cerr := s.CancelCall(ctx, requestNo, 0, operator); cerr != nil { cancelFail = append(cancelFail, requestNo+":"+cerr.Error()) } } // 工单置 DONE(强制路径:绕过 FinishedNum 门禁) if _, uerr := s.ctx.EntClient.WorkOrder.UpdateOneID(id). SetStatus("DONE").SetCompletedAt(time.Now()).Save(ctx); uerr != nil { return nil, uerr } // 排产联动(DONE:完成量足→DONE、不足→CANCELLED)+ 叫料池重算 s.syncPlansByOrderStatus(ctx, wo.WorkOrderNo, "DONE", operator) rep, _ = s.buildForceCompleteReport(ctx, wo) // 重取快照(排产/叫料状态已变) s.ctx.EventLog.Write(ctx, "work.order.force_complete", wo.WorkOrderNo, operator, "work_order", wo.WorkOrderNo, "强制完工:原因「"+strings.TrimSpace(reason)+"」", map[string]any{ "reason": strings.TrimSpace(reason), "quantity": rep.Quantity, "finishedNum": rep.FinishedNum, "remaining": rep.Remaining, "plansToCancel": rep.PlansToCancel, "pendingCallsCancelled": pendingBefore, "pendingCallErrors": cancelFail, "shippedCalls": rep.ShippedCalls, "inProduction": rep.InProduction, }) s.notifyDashboard() return rep, nil } // makeSN 生成工件 SN(2026-11-10 定稿):前缀非空时 = 前缀-4位序号(如 SunYF-0001,不带工单号); // 为空时保持默认「工单号-3位序号」。前缀全项目唯一,保证 SN 不撞车。 func makeSN(prefix, orderNo string, seq int) string { if prefix == "" { return fmt.Sprintf("%s-%03d", orderNo, seq) } return fmt.Sprintf("%s-%04d", prefix, seq) } // snPrefixTaken 判断前缀是否已被其它工单的工件占用(全项目唯一校验,返回占用它的工单号)。 // 新格式 SN = 前缀-4位序号,故按「前缀-」前缀匹配;excludeOrderID 用于改前缀时排除本工单。 func (s *Service) snPrefixTaken(ctx context.Context, prefix string, excludeOrderID int) (bool, string) { if prefix == "" { return false, "" } q := s.ctx.EntClient.Workpiece.Query().Where(workpiece.SnHasPrefix(prefix + "-")) if excludeOrderID > 0 { q = q.Where(workpiece.WorkOrderIdNEQ(excludeOrderID)) } rows, err := q.Limit(1).All(ctx) if err != nil || len(rows) == 0 { return false, "" } return true, rows[0].OrderNo } // SNPrefixesOf 从现有 SN 反推工单的产品序号前缀(返回 工单ID → 前缀)。 // 兼容两种格式:旧「前缀+工单号-3位序号」/「工单号-3位序号」,新「前缀-4位序号」。 // 零存储、无需迁移、无需改 ent schema。 func (s *Service) SNPrefixesOf(ctx context.Context, wos []*ent.WorkOrder) map[int]string { out := map[int]string{} if len(wos) == 0 { return out } ids := make([]int, 0, len(wos)) for _, wo := range wos { ids = append(ids, wo.ID) } wps, err := s.ctx.EntClient.Workpiece.Query(). Where(workpiece.WorkOrderIdIn(ids...)). Order(ent.Asc(workpiece.FieldID)).All(ctx) if err != nil { return out } first := map[int]string{} for _, wp := range wps { if _, ok := first[wp.WorkOrderId]; !ok { first[wp.WorkOrderId] = wp.Sn } } for _, wo := range wos { sn := first[wo.ID] if sn == "" { out[wo.ID] = "" continue } // 旧格式:SN 内含工单号,取工单号之前的部分作为前缀(idx==0 表示无前缀的默认格式) if idx := strings.Index(sn, wo.WorkOrderNo); idx >= 0 { if idx > 0 { out[wo.ID] = sn[:idx] } else { out[wo.ID] = "" } continue } // 新格式:前缀-4位序号,不含工单号 if i := strings.LastIndex(sn, "-"); i > 0 { tail := sn[i+1:] if len(tail) == 4 && strings.IndexFunc(tail, func(r rune) bool { return r < '0' || r > '9' }) < 0 { out[wo.ID] = sn[:i] continue } } out[wo.ID] = "" } return out } // RegenerateSNPrefix 重设工单的产品序号前缀并重新生成全部 SN(仅 CREATED 可改)。 // 按 id 升序重排序号 1..N;新 SN 与库内其它工件冲突时收集式一次列全报错;用事务保证一致。 func (s *Service) RegenerateSNPrefix(ctx context.Context, id int, prefix, operator string) (int, error) { if id <= 0 { return 0, errors.New("缺少 id") } prefix = strings.TrimSpace(prefix) if len(prefix) > 32 { return 0, errors.New("产品序号前缀过长,最多 32 字节") } // 前缀全项目唯一:不同工单用同一前缀会生成相同 SN,重复直接给业务提示 if taken, byNo := s.snPrefixTaken(ctx, prefix, id); taken { return 0, fmt.Errorf("产品序号前缀「%s」已被工单 %s 使用,请勿重复使用", prefix, byNo) } wo, err := s.ctx.EntClient.WorkOrder.Get(ctx, id) if err != nil { return 0, errors.New("工单不存在") } if wo.Status != "CREATED" { return 0, errors.New("工单已开工,不能修改产品序号前缀") } wps, err := s.ctx.EntClient.Workpiece.Query(). Where(workpiece.WorkOrderId(id)). Order(ent.Asc(workpiece.FieldID)).All(ctx) if err != nil { return 0, err } if len(wps) == 0 { return 0, nil } newSNs := make([]string, len(wps)) for i := range wps { newSNs[i] = makeSN(prefix, wo.WorkOrderNo, i+1) } // 唯一性校验(收集式):新 SN 已被其它工件占用则一次列全 dup, err := s.ctx.EntClient.Workpiece.Query().Where(workpiece.SnIn(newSNs...)).All(ctx) if err != nil { return 0, err } conflicts := map[string]bool{} for _, d := range dup { if d.WorkOrderId != id { conflicts[d.Sn] = true } } if len(conflicts) > 0 { list := make([]string, 0, len(conflicts)) for sn := range conflicts { list = append(list, sn) } sort.Strings(list) return 0, fmt.Errorf("以下产品序号已被其它工件占用,无法重新生成:%s", strings.Join(list, "、")) } tx, err := s.ctx.EntClient.Tx(ctx) if err != nil { return 0, err } committed := false defer func() { if !committed { _ = tx.Rollback() } }() client := tx.Client() for i, wp := range wps { if e := client.Workpiece.UpdateOneID(wp.ID).SetSn(newSNs[i]).Exec(ctx); e != nil { return 0, e } } if err := tx.Commit(); err != nil { return 0, err } committed = true s.ctx.EventLog.Write(ctx, "work.order.sn_prefix", wo.WorkOrderNo, operator, "work_order", wo.WorkOrderNo, "重生成产品序号前缀:"+prefix, map[string]any{"prefix": prefix, "regenerated": len(wps)}) return len(wps), nil }