- MES 新增损耗台账 loss_ledger,差异确认损耗接口 ConfirmReceiveLoss(按工单归集) - 备料清单 preparation:MES 按 日计划×工单×工位×物料 实时计算,WMS 只读展示 PreparationList - 退料闭环:N5 工位托盘守卫(未完成禁止退料)、退料 AGV 自动派车(JBT21 空位判定 + 托盘回收链路)、退料参考剩余量接口(应剩余=实备-已耗-已退-已损) - 新增 AGV 车辆状态表 agv_vehicle_state 及查询 - 整合接驳台/叫料池/库存锁既有闭环,清理 sql 目录注释生成脚本与 catalog,更新文档
701 lines
31 KiB
Go
701 lines
31 KiB
Go
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"
|
||
"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 对齐):一级=合同号/科技项目号(二选一)→ 二级=产品工号 → 三级=产品序号
|
||
// contractNo=归属编号(随 ownershipType 二选一填写);projectNo 已废弃不再接收,字段仅防历史迁移
|
||
ContractNo string `json:"contractNo"`
|
||
OwnershipType string `json:"ownershipType"` // workorder=合同号/project=科技项目号/other=其他
|
||
ProductSerial string `json:"productSerial"`
|
||
// 工艺组合(唯一路线源头):[{flowId,stationNo}],工位号即顺序号,按工位号升序执行、可跳过未选工位
|
||
FlowCombination []map[string]int `json:"flowCombination"`
|
||
// 来源产品工艺(2026-10-09):建单选产品时带出默认产品工艺并自动填组合;
|
||
// 组合是快照可手改,本字段恒保留=来源定义(0=无来源,历史工单),供追溯与偏差提示。
|
||
ProductProcessId int `json:"productProcessId"`
|
||
}
|
||
|
||
// CreateWorkOrder 创建工单(状态恒 CREATED,后续用状态流转按钮推进)
|
||
func (s *Service) CreateWorkOrder(ctx context.Context, req WorkOrderReq, operator string) error {
|
||
// 收集式校验(报错一次收全 + 每条带怎么办,2026-10-20):字段问题全部列出、一次性返回,不再串行 return
|
||
ve := verr.New()
|
||
if req.ProductTypeId == 0 {
|
||
ve.Add("productTypeId", "请选择产品型号", "在「产品型号」下拉中选择本次要生产的产品")
|
||
}
|
||
if req.Quantity <= 0 {
|
||
req.Quantity = 1
|
||
}
|
||
if req.Quantity > 999 {
|
||
ve.Add("quantity", "单次建工单数量上限 999", "分批创建:每张工单不超过 999 台")
|
||
}
|
||
// 归属(一级编号):合同号/科技项目号 二选一;类型为其他时编号可空
|
||
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).
|
||
SetProductSerial(req.ProductSerial).
|
||
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 := fmt.Sprintf("%s-%03d", 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 允许改线并触发转产连锁;CREATED/PENDING 全可编辑。
|
||
if old.Status == "IN_PROGRESS" {
|
||
return errors.New("工单执行中,工艺组合不可修改;请先「暂停工单」再改线(转产)")
|
||
}
|
||
// 其余状态(CREATED/PENDING/PAUSED)允许修改工艺组合
|
||
// 收集式校验(报错一次收全 + 每条带怎么办,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).SetProductSerial(req.ProductSerial)
|
||
// 工艺组合(唯一路线源头):收集式校验已通过,此处直接写入
|
||
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),仅下拉搜索场景传参,列表页不传=全量,行为向后兼容。
|
||
func (s *Service) ListWorkOrders(ctx context.Context, orderNo, status, productCode, productName, contractNo, ownershipType, keyword string, limit 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)
|
||
}
|
||
// limit 截断(封顶 200):仅下拉搜索场景启用,防数据炸弹
|
||
if limit > 0 {
|
||
if limit > 200 {
|
||
limit = 200
|
||
}
|
||
q = q.Limit(limit)
|
||
}
|
||
return q.Order(ent.Desc(workorder.FieldCreatedAt), ent.Desc(workorder.FieldID)).All(ctx)
|
||
}
|
||
|
||
// ListProcessCards 流程卡列表(分页):每个工单=一张生产流程卡。
|
||
// 与 /process-card/by-model 不同,本接口不要求任何条件,支持按工单号/产品型号/关键字(工单号·产品编码·产品名称)筛选,
|
||
// 返回 {total, list},list 元素为工单基础字段(含成品SN productSerial、创建时间),供前端「流程卡列表」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
|
||
}
|