Files
bj_power/bj_power_mes/internal/logic/workorder.go
T
SunYF d92ca803d5 feat: 来料检处置项实体与复检、日排产达成对比、PLC/WMS 传输日志
- WMS 新增「检验处置项」实体(schema + ent 生成码),配套检验记录实体调整与复检接口,完善来料检/不良退货/入库检验前端
- MES 日排产:新增达成率统计与计划对比逻辑,调整日排产前端与流程卡/工序流
- 日志与传输:MES 新增 PLC 日志与 WMS 客户端传输日志,WMS 新增 MES 客户端传输日志
- MES 其他:扫码、工单/工件、AGV 客户端与告警、产品导入等逻辑完善及前端调整
- 工位终端:上线面板/作业面板、工件 handler 与 MES 客户端调整
- 配置与文档:更新 mes-api.yaml、三端构建产物与问题记录文档
2026-11-16 16:42:44 +08:00

937 lines
40 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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<Quantity,但前置更严、副作用更透明:
// ① 仅 IN_PROGRESS / PAUSED 可强制完工;
// ② 在制工件(ONLINE/PROCESSING)必须为 0 —— 不允许「随单终止」,实物去向必须先落定;
// ③ 未完成排产自动置 CANCELLED(复用 syncPlansByOrderStatus 联动 + 叫料池重算);
// ④ 在途叫料单不绑工单(schema/material_request.go:14 定稿),按「该工单排产覆盖的工位」
// 近似圈定:PENDING 自动取消(CancelCall 释放占用额度);SHIPPED 仅列出(人工签收/退回),不阻断关单;
// ⑤ 落 event_log(work.order.force_complete):谁 / 何时 / 原因 / 四项清单快照。
// ForceCompleteReport 强制完工核对单(预览与执行共用同一快照结构)。
type ForceCompleteReport struct {
WorkOrderNo string `json:"workOrderNo"`
Status string `json:"status"`
Quantity int `json:"quantity"`
FinishedNum int `json:"finishedNum"`
Remaining int `json:"remaining"` // 剩余未完工台数(仅展示,不拦)
PlansToCancel []string `json:"plansToCancel"` // 未完成排产(自动 CANCELLED):日期+数量
PendingCalls []string `json:"pendingCalls"` // PENDING 叫料单(自动取消)
ShippedCalls []string `json:"shippedCalls"` // SHIPPED 叫料单(人工签收或退回)
InProduction int `json:"inProduction"` // 在制工件数(必须 0 才能关单)
// R11(2026-11-03 拍板):已报废/取走登记件数。实物去向落定 = 完工报工或报废登记(SCRAPPED 不计在制);
// 强完前必须走完部分报废登记,此数供核对单展示。
ScrapCount int `json:"scrapCount"`
}
// stationsOfOrder 圈定工单排产覆盖的工位号集合:来自日排产 stationPlanQty 的键(工位号字符串)。
func (s *Service) stationsOfOrder(ctx context.Context, orderNo string) ([]int, error) {
plans, err := s.ctx.EntClient.DailyPlan.Query().Where(dailyplan.OrderNo(orderNo)).All(ctx)
if err != nil {
return nil, err
}
seen := map[int]bool{}
out := make([]int, 0, 8)
for _, p := range plans {
for k := range p.StationPlanQty {
if n, e := strconv.Atoi(k); e == nil && n > 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
}