package logic import ( "context" "errors" "fmt" "sort" "strconv" "strings" "time" "bj_power_mes/ent" "bj_power_mes/ent/productprocess" "bj_power_mes/ent/productprocessitem" "bj_power_mes/ent/workorder" "bj_power_mes/internal/verr" ) // ---------- 产品工艺(2026-10-09 定稿) ---------- // // 产品工艺 = 产品级的工艺定义:只选工艺+顺序(seq 严格递增=串行),不绑工位。 // 工位在建工单时按「工位绑定」(station.flow_id) 自动推导(同工艺的全部启用工位), // 并复制为工单工艺组合 flow_combination 快照;产品工艺是模板,工单组合是实例快照。 // 校验口径(客户裁决):覆盖/顺序校验仅作保存时警告提示,不阻断保存(允许手改组合偏离)。 // ProductProcessItemReq 产品工艺明细项(flows 数组顺序即 seq 顺序) type ProductProcessItemReq struct { FlowId int `json:"flowId"` } // ProductProcessReq 产品工艺保存请求 type ProductProcessReq struct { Id int `json:"id"` ProductCode string `json:"productCode"` ProductName string `json:"productName"` Name string `json:"name"` Status string `json:"status"` Remark string `json:"remark"` Flows []ProductProcessItemReq `json:"flows"` } // ProductProcessItemVO 明细行(含实时反查的绑定工位号) type ProductProcessItemVO struct { Seq int `json:"seq"` FlowId int `json:"flowId"` FlowName string `json:"flowName"` StationNos []int `json:"stationNos"` // 该工艺当前绑定的启用工位号(升序,实时反查) } // ProductProcessVO 列表/详情视图 type ProductProcessVO struct { Id int `json:"id"` ProductCode string `json:"productCode"` ProductName string `json:"productName"` Name string `json:"name"` Status string `json:"status"` Remark string `json:"remark"` Flows []ProductProcessItemVO `json:"flows"` // 只读:被工单引用次数(总引用,含历史;展示用) UsedByWorkOrders int `json:"usedByWorkOrders"` // 只读:运行中工单(IN_PROGRESS/PAUSED)引用数 —— >0 时编辑接口拒绝(规则1,2026-10-20) RunningByWorkOrders int `json:"runningByWorkOrders"` // 只读:未开工工单(CREATED)引用数 —— >0 时允许编辑,前端保存前警告确认(规则1) CreatedByWorkOrders int `json:"createdByWorkOrders"` // 只读:可执行状态(所有工艺都有启用工位绑定且顺序可满足) Executable bool `json:"executable"` NotReady string `json:"notReady"` // 不可执行原因(可执行时为空) CreatedAt time.Time `json:"createdAt"` } // ListProductProcesses 产品工艺列表(分页;筛选:产品编码/状态/工艺反查/关键字)。 // page>0 真分页返回 map{total,list,page,pageSize};page=0 返回全量数组(工单页下拉用)。 func (s *Service) ListProductProcesses(ctx context.Context, productCode, status string, flowId int, keyword, name string, stepMin, stepMax int, page, pageSize int) (any, error) { q := s.ctx.EntClient.ProductProcess.Query() if productCode != "" { q = q.Where(productprocess.ProductCodeContainsFold(productCode)) } if status != "" { q = q.Where(productprocess.Status(status)) } if keyword != "" { kw := productprocess.Or( productprocess.NameContainsFold(keyword), productprocess.ProductCodeContainsFold(keyword), productprocess.ProductNameContainsFold(keyword), ) q = q.Where(kw) } if name != "" { q = q.Where(productprocess.NameContainsFold(name)) } // 工艺反查:只要包含该工艺的产品工艺 if flowId > 0 { items, err := s.ctx.EntClient.ProductProcessItem.Query(). Where(productprocessitem.FlowId(flowId)).All(ctx) if err != nil { return nil, err } ids := make([]int, 0, len(items)) for _, it := range items { ids = append(ids, it.ProductProcessId) } if len(ids) == 0 { ids = []int{-1} // 无命中:返回空集 } q = q.Where(productprocess.IDIn(ids...)) } pps, err := q.Order(ent.Desc(productprocess.FieldCreatedAt), ent.Desc(productprocess.FieldID)).All(ctx) if err != nil { return nil, err } // 名字映射(工艺/工位) flows, _ := s.ctx.EntClient.ProcessFlow.Query().All(ctx) flowName := map[int]string{} for _, f := range flows { flowName[f.ID] = f.Name } sts, _ := s.ctx.EntClient.Station.Query().All(ctx) byFlow := map[int][]int{} for _, st := range sts { if st.Status == "ENABLED" && st.FlowId > 0 { byFlow[st.FlowId] = append(byFlow[st.FlowId], st.StationNo) } } for k := range byFlow { sort.Ints(byFlow[k]) } // 明细按产品工艺分组 items, _ := s.ctx.EntClient.ProductProcessItem.Query(). Order(ent.Asc(productprocessitem.FieldProductProcessId), ent.Asc(productprocessitem.FieldSeq)).All(ctx) itemsOf := map[int][]*ent.ProductProcessItem{} for _, it := range items { itemsOf[it.ProductProcessId] = append(itemsOf[it.ProductProcessId], it) } // 工单引用计数(规则1,2026-10-20):总数 + 运行中(IN_PROGRESS/PAUSED)+ 未开工(CREATED)分档 used := map[int]int{} usedRunning := map[int]int{} usedCreated := map[int]int{} wos, _ := s.ctx.EntClient.WorkOrder.Query().Where(workorder.ProductProcessIdGT(0)).All(ctx) for _, w := range wos { used[w.ProductProcessId]++ switch w.Status { case "IN_PROGRESS", "PAUSED": usedRunning[w.ProductProcessId]++ case "CREATED", "PENDING": usedCreated[w.ProductProcessId]++ } } out := make([]*ProductProcessVO, 0, len(pps)) for _, p := range pps { vo := &ProductProcessVO{ Id: p.ID, ProductCode: p.ProductCode, ProductName: p.ProductName, Name: p.Name, Status: p.Status, Remark: p.Remark, UsedByWorkOrders: used[p.ID], RunningByWorkOrders: usedRunning[p.ID], CreatedByWorkOrders: usedCreated[p.ID], CreatedAt: p.CreatedAt, Flows: []ProductProcessItemVO{}, } for _, it := range itemsOf[p.ID] { vo.Flows = append(vo.Flows, ProductProcessItemVO{ Seq: it.Seq, FlowId: it.FlowId, FlowName: flowName[it.FlowId], StationNos: byFlow[it.FlowId], }) } vo.Executable, vo.NotReady = ppExecutable(vo) out = append(out, vo) } // 工序数范围过滤:按产品工艺的工艺顺序/工序条目数(vo.Flows 长度) if stepMin > 0 || stepMax > 0 { kept := make([]*ProductProcessVO, 0, len(out)) for _, vo := range out { n := len(vo.Flows) if stepMin > 0 && n < stepMin { continue } if stepMax > 0 && n > stepMax { continue } kept = append(kept, vo) } out = kept } if page > 0 { total := len(out) start := (page - 1) * pageSize if start > total { start = total } end := start + pageSize if end > total { end = total } return map[string]any{"total": total, "list": out[start:end], "page": page, "pageSize": pageSize}, nil } return out, nil } // ppExecutable 可执行判定:每道工艺都有启用的绑定工位,且按 seq 排列后工位号可满足递增 func ppExecutable(vo *ProductProcessVO) (bool, string) { prev := 0 for _, it := range vo.Flows { if len(it.StationNos) == 0 { return false, fmt.Sprintf("第%d道工艺「%s」暂无启用的绑定工位", it.Seq, it.FlowName) } if prev > 0 && it.StationNos[0] <= prev { return false, fmt.Sprintf("第%d道工艺「%s」(工位%d) 与上一道工位顺序冲突", it.Seq, it.FlowName, it.StationNos[0]) } prev = it.StationNos[len(it.StationNos)-1] } return true, "" } // SaveProductProcess 保存产品工艺(新建或整表覆盖明细)。 // 约束:① 产品必填,明细非空;② 同一工艺不能在同一产品工艺内出现两次(客户裁决); // ③ 一个产品对应一个产品工艺(新建时若该产品已存在 product_process,直接报错"该产品已有产品工艺,请直接编辑"); // ④ 规则1(2026-10-20):运行中工单(IN_PROGRESS/PAUSED)引用 → 禁编辑;仅未开工(CREATED)引用 → 允许(前端警告确认); // ⑤ 名称未传时按"${物料编码} ${物料名称} 工艺"兜底。 func (s *Service) SaveProductProcess(ctx context.Context, req ProductProcessReq, operator string) error { // 收集式校验(报错一次收全 + 每条带怎么办,2026-10-20):全部问题列出、一次性返回 ve := verr.New() if strings.TrimSpace(req.ProductCode) == "" { ve.Add("productCode", "请选择产品", "在「产品」下拉中选择产品(来自 WMS 物料档案,类型=成品)") } // 名称兜底(前端未传时按 物料编码 物料名称 工艺 生成) if strings.TrimSpace(req.Name) == "" { req.Name = strings.TrimSpace(req.ProductCode) + " " + strings.TrimSpace(req.ProductName) + " 工艺" } if len(req.Flows) == 0 { ve.Add("flows", "请至少选择一道工艺", "在「工艺流程」中点「加入」加入至少一道工艺,再用上下移按钮排好执行顺序") } seen := map[int]bool{} dupReported := map[int]bool{} for _, f := range req.Flows { if f.FlowId <= 0 { ve.Add("flows", "工艺选择无效", "删除无效行后,从工艺下拉中重新选择") continue } if seen[f.FlowId] { if !dupReported[f.FlowId] { ve.Add("flows", "同一工艺在同一产品工艺内出现两次", "重复工艺只保留一处(客户裁决:同一工艺在同一产品工艺内不能重复)") dupReported[f.FlowId] = true } continue } seen[f.FlowId] = true if _, err := s.ctx.EntClient.ProcessFlow.Get(ctx, f.FlowId); err != nil { ve.Add("flows", fmt.Sprintf("所选工艺不存在(ID=%d)", f.FlowId), "删除该行后,从工艺下拉中重新选择") } } status := req.Status if status == "" { status = "ACTIVE" } if status != "ACTIVE" && status != "INACTIVE" { ve.Add("status", "非法状态", "状态仅支持 启用/停用,请刷新页面后重试") } if req.Id > 0 { if _, err := s.ctx.EntClient.ProductProcess.Get(ctx, req.Id); err != nil { ve.Add("id", "产品工艺不存在", "列表可能已被他人修改,请关闭弹窗刷新后重试") } else if n, _ := s.ctx.EntClient.WorkOrder.Query(). Where(workorder.ProductProcessId(req.Id), workorder.StatusIn("IN_PROGRESS", "PAUSED")).Count(ctx); n > 0 { // 规则1(2026-10-20):运行中工单引用 → 拒绝编辑,给「复制工艺」一键跳转 ve.AddAction("productProcessId", "产线上还有运行中的工单,不能修改此工艺。", "如需调整,请复制一份新工艺修改,新工单使用新工艺。", "复制工艺", "/product-process?copy="+strconv.Itoa(req.Id)) } } else if strings.TrimSpace(req.ProductCode) != "" { // 一个产品对应一个产品工艺:新建时若已存在启用的则报错(停用的允许并存:复制场景) if n, _ := s.ctx.EntClient.ProductProcess.Query(). Where(productprocess.ProductCode(req.ProductCode), productprocess.Status("ACTIVE")).Count(ctx); n > 0 { ve.Add("productCode", "该产品已有启用中的产品工艺,请直接编辑", "在列表中找到该产品的工艺行点「编辑」;如需换版,先停用旧工艺再新建") } } if err := ve.OrNil(); err != nil { return err } var ppID int if req.Id > 0 { if _, err := s.ctx.EntClient.ProductProcess.UpdateOneID(req.Id). SetProductCode(req.ProductCode).SetProductName(req.ProductName). SetName(req.Name).SetStatus(status).SetRemark(req.Remark). Save(ctx); err != nil { return err } ppID = req.Id } else { p, err := s.ctx.EntClient.ProductProcess.Create(). SetProductCode(req.ProductCode).SetProductName(req.ProductName). SetName(req.Name).SetStatus(status).SetRemark(req.Remark). Save(ctx) if err != nil { return err } ppID = p.ID } // 明细整表覆盖(seq = 数组顺序,从 1 严格递增) _, _ = s.ctx.EntClient.ProductProcessItem.Delete(). Where(productprocessitem.ProductProcessId(ppID)).Exec(ctx) for i, f := range req.Flows { if err := s.ctx.EntClient.ProductProcessItem.Create(). SetProductProcessId(ppID).SetSeq(i + 1).SetFlowId(f.FlowId). Exec(ctx); err != nil { return err } } s.ctx.EventLog.Write(ctx, "product.process.save", "", operator, "product_process", fmt.Sprint(ppID), "保存产品工艺", map[string]any{"id": ppID, "name": req.Name, "productCode": req.ProductCode, "flows": len(req.Flows)}) return nil } // DeleteProductProcess 删除产品工艺(被工单引用过禁止删除,只能停用) func (s *Service) DeleteProductProcess(ctx context.Context, id int, operator string) error { if id <= 0 { return errors.New("缺少 id") } if n, _ := s.ctx.EntClient.WorkOrder.Query().Where(workorder.ProductProcessId(id)).Count(ctx); n > 0 { return fmt.Errorf("该产品工艺已被 %d 张工单引用,不能删除(只能停用)", n) } p, err := s.ctx.EntClient.ProductProcess.Get(ctx, id) if err != nil { return errors.New("产品工艺不存在") } _, _ = s.ctx.EntClient.ProductProcessItem.Delete().Where(productprocessitem.ProductProcessId(id)).Exec(ctx) if err := s.ctx.EntClient.ProductProcess.DeleteOneID(id).Exec(ctx); err != nil { return err } s.ctx.EventLog.Write(ctx, "product.process.delete", "", operator, "product_process", fmt.Sprint(id), "删除产品工艺", map[string]any{"id": id, "name": p.Name}) return nil } // SetProductProcessStatus 启用/停用(停用不删:历史工单按 product_process_id 反查当时定义) func (s *Service) SetProductProcessStatus(ctx context.Context, id int, status, operator string) error { if id <= 0 { return errors.New("缺少 id") } if status != "ACTIVE" && status != "INACTIVE" { return errors.New("非法状态") } p, err := s.ctx.EntClient.ProductProcess.Get(ctx, id) if err != nil { return errors.New("产品工艺不存在") } if p.Status == status { return nil } if err := s.ctx.EntClient.ProductProcess.UpdateOneID(id).SetStatus(status).Exec(ctx); err != nil { return err } action := "停用产品工艺" if status == "ACTIVE" { action = "启用产品工艺" } s.ctx.EventLog.Write(ctx, "product.process.status", "", operator, "product_process", fmt.Sprint(id), action, map[string]any{"id": id, "name": p.Name, "status": status}) return nil } // CopyProductProcessReq 产品工艺复制请求 type CopyProductProcessReq struct { SourceId int `json:"sourceId"` NewName string `json:"newName"` } // CopyProductProcess 复制产品工艺(全量深拷贝):主表 + 所有明细步骤(ProductProcessItem 按 seq 顺序)。 // 数据模型仅主表+明细两表,无独立"步骤考核标准/物料绑定"子表,故深拷贝二者即覆盖全部内容。 // 默认名"源名-副本";按规则1精神,复制是新工艺,不受"一个产品一个产品工艺"约束(同一产品可有多版本)。 func (s *Service) CopyProductProcess(ctx context.Context, req CopyProductProcessReq, operator string) (int, error) { if req.SourceId <= 0 { return 0, errors.New("缺少源产品工艺ID") } src, err := s.ctx.EntClient.ProductProcess.Get(ctx, req.SourceId) if err != nil { return 0, errors.New("源产品工艺不存在") } items, _ := s.ctx.EntClient.ProductProcessItem.Query(). Where(productprocessitem.ProductProcessId(src.ID)).Order(ent.Asc(productprocessitem.FieldSeq)).All(ctx) newName := strings.TrimSpace(req.NewName) if newName == "" { newName = src.Name + "-副本" } np, err := s.ctx.EntClient.ProductProcess.Create(). SetProductCode(src.ProductCode).SetProductName(src.ProductName). SetName(newName).SetStatus(src.Status).SetRemark(src.Remark).Save(ctx) if err != nil { return 0, err } for _, it := range items { if err := s.ctx.EntClient.ProductProcessItem.Create(). SetProductProcessId(np.ID).SetSeq(it.Seq).SetFlowId(it.FlowId).Exec(ctx); err != nil { return 0, err } } s.ctx.EventLog.Write(ctx, "product.process.copy", "", operator, "product_process", fmt.Sprint(np.ID), "复制产品工艺", map[string]any{"fromId": src.ID, "fromName": src.Name, "toId": np.ID, "toName": newName}) return np.ID, nil } // DeriveProductProcess 建单自动推导:按产品(或指定 id)取该产品的唯一产品工艺, // 每道工艺带出其全部启用的绑定工位(升序),拼成工艺组合与实时警告。 // 返回 map{productProcessId,name,items,combination,warnings};无产品工艺时 combination 为空并给提示。 func (s *Service) DeriveProductProcess(ctx context.Context, productCode string, id int) (map[string]any, error) { q := s.ctx.EntClient.ProductProcess.Query() if id > 0 { q = q.Where(productprocess.ID(id)) } else if productCode != "" { q = q.Where(productprocess.ProductCode(productCode), productprocess.Status("ACTIVE")) } else { return nil, errors.New("缺少产品编码或产品工艺ID") } pps, err := q.Order(ent.Desc(productprocess.FieldID)).All(ctx) if err != nil { return nil, err } res := map[string]any{ "productProcessId": 0, "name": "", "productCode": productCode, "items": []map[string]any{}, "combination": []map[string]int{}, "warnings": []string{}, } if len(pps) == 0 { res["warnings"] = []string{"该产品尚未配置产品工艺(可在「产品工艺」页创建)"} return res, nil } pp := pps[0] res["productProcessId"] = pp.ID res["name"] = pp.Name res["productCode"] = pp.ProductCode items, _ := s.ctx.EntClient.ProductProcessItem.Query(). Where(productprocessitem.ProductProcessId(pp.ID)). Order(ent.Asc(productprocessitem.FieldSeq)).All(ctx) flows, _ := s.ctx.EntClient.ProcessFlow.Query().All(ctx) flowName := map[int]string{} for _, f := range flows { flowName[f.ID] = f.Name } sts, _ := s.ctx.EntClient.Station.Query().All(ctx) byFlow := map[int][]int{} for _, st := range sts { if st.Status == "ENABLED" && st.FlowId > 0 { byFlow[st.FlowId] = append(byFlow[st.FlowId], st.StationNo) } } for k := range byFlow { sort.Ints(byFlow[k]) } warns := []string{} itemsVO := []map[string]any{} combination := []map[string]int{} for _, it := range items { stsOfFlow := byFlow[it.FlowId] itemsVO = append(itemsVO, map[string]any{ "seq": it.Seq, "flowId": it.FlowId, "flowName": flowName[it.FlowId], "stationNos": stsOfFlow, }) if len(stsOfFlow) == 0 { warns = append(warns, fmt.Sprintf("第%d道工艺「%s」暂无启用的绑定工位,请先在「工位绑定」中绑定", it.Seq, flowName[it.FlowId])) continue } for _, no := range stsOfFlow { combination = append(combination, map[string]int{"flowId": it.FlowId, "stationNo": no}) } } sort.Slice(combination, func(i, j int) bool { return combination[i]["stationNo"] < combination[j]["stationNo"] }) res["items"] = itemsVO res["combination"] = combination res["warnings"] = warns return res, nil } // ComboDeviationWarnings 工单工艺组合与产品工艺的偏差柔性警告(仅提示,不阻断保存): // 覆盖/个数——产品工艺的每道工艺都须出现在组合中,组合不得包含产品工艺之外的工艺。 // 顺序偏差已于 2026-10-20 客户裁定升级为硬拦截(见 ValidateWorkOrderComboStrict),此处不再重复提示。 func (s *Service) ComboDeviationWarnings(ctx context.Context, ppId int, combo []map[string]int) []string { if ppId <= 0 { return nil } pp, err := s.ctx.EntClient.ProductProcess.Get(ctx, ppId) if err != nil { return []string{"来源产品工艺已删除,无法比对"} } items, _ := s.ctx.EntClient.ProductProcessItem.Query(). Where(productprocessitem.ProductProcessId(ppId)). Order(ent.Asc(productprocessitem.FieldSeq)).All(ctx) if len(items) == 0 { return nil } flows, _ := s.ctx.EntClient.ProcessFlow.Query().All(ctx) flowName := map[int]string{} for _, f := range flows { flowName[f.ID] = f.Name } if len(combo) == 0 { return []string{fmt.Sprintf("未选择工艺组合:产品工艺「%s」共 %d 道工艺均未包含", pp.Name, len(items))} } inCombo := map[int][]int{} for _, c := range combo { fid, no := c["flowId"], c["stationNo"] if fid > 0 && no > 0 { inCombo[fid] = append(inCombo[fid], no) } } for k := range inCombo { sort.Ints(inCombo[k]) } ppFlowSet := map[int]bool{} for _, it := range items { ppFlowSet[it.FlowId] = true } // 个数汇总(客户裁决:顺序 或 个数 不符都要提示)——先给一条总数对不上的汇总,明细警告跟在后面 have, missingCnt, extraCnt := 0, 0, 0 for fid := range inCombo { if ppFlowSet[fid] { have++ } else { extraCnt++ } } missingCnt = len(items) - have warns := []string{} if missingCnt > 0 || extraCnt > 0 { warns = append(warns, fmt.Sprintf("工艺组合道数与产品工艺不符:产品工艺共 %d 道,组合包含 %d 道(缺 %d 道、多 %d 道)", len(items), have, missingCnt, extraCnt)) } for _, it := range items { name := flowName[it.FlowId] if len(inCombo[it.FlowId]) == 0 { warns = append(warns, fmt.Sprintf("工艺组合缺少第%d道工艺「%s」", it.Seq, name)) } } for fid, sts := range inCombo { if !ppFlowSet[fid] { warns = append(warns, fmt.Sprintf("工艺组合包含产品工艺之外的工艺「%s」(%d 个工位)", flowName[fid], len(sts))) } } return warns } // productProcessNamesByFlow 反查:工艺ID → 引用它的产品工艺名称列表(工位绑定/工艺列表只读展示用) func (s *Service) productProcessNamesByFlow(ctx context.Context) map[int][]string { items, _ := s.ctx.EntClient.ProductProcessItem.Query().All(ctx) out := map[int][]string{} if len(items) == 0 { return out } pps, _ := s.ctx.EntClient.ProductProcess.Query().All(ctx) name := map[int]string{} for _, p := range pps { name[p.ID] = p.Name } for _, it := range items { if n := name[it.ProductProcessId]; n != "" { out[it.FlowId] = append(out[it.FlowId], n) } } return out } // ppContainsFold 大小写无关包含(工艺列表按产品工艺名筛选用) func ppContainsFold(list []string, kw string) bool { for _, v := range list { if strings.Contains(strings.ToLower(v), strings.ToLower(kw)) { return true } } return false }