Files
bj_power/bj_power_mes/internal/logic/workorder.go
T

537 lines
21 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"
"strconv"
"strings"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/dailyplan"
"bj_power_mes/ent/workorder"
"bj_power_mes/ent/workpiece"
)
type WorkOrderReq struct {
Id int `json:"id"`
WorkOrderNo string `json:"workOrderNo"`
ProductTypeId int `json:"productTypeId"`
ProductCode string `json:"productCode"`
ProductName string `json:"productName"`
Quantity int `json:"quantity"`
Status string `json:"status"`
PlanStart string `json:"planStart"`
PlanEnd string `json:"planEnd"`
// 客户编号体系(2026-09-30 对齐):一级=合同号/科技项目号(二选一)→ 二级=产品工号 → 三级=产品序号
// contractNo=归属编号(随 ownershipType 二选一填写);projectNo 已废弃不再接收,字段仅防历史迁移
ContractNo string `json:"contractNo"`
OwnershipType string `json:"ownershipType"` // workorder=合同号/project=科技项目号/other=其他
ProductSerial string `json:"productSerial"`
// 完成日期(必填,前端强制;yyyy-MM-dd)
DueDate string `json:"dueDate"`
// 工艺组合(唯一路线源头):[{flowId,stationNo}],工位号即顺序号,按工位号升序执行、可跳过未选工位
FlowCombination []map[string]int `json:"flowCombination"`
// 来源产品工艺(2026-10-09):建单选产品时带出默认产品工艺并自动填组合;
// 组合是快照可手改,本字段恒保留=来源定义(0=无来源,历史工单),供追溯与偏差提示。
ProductProcessId int `json:"productProcessId"`
}
// CreateWorkOrder 创建工单(状态恒 CREATED,后续用状态流转按钮推进)
func (s *Service) CreateWorkOrder(ctx context.Context, req WorkOrderReq, operator string) error {
if req.ProductTypeId == 0 {
return errors.New("请选择产品型号")
}
if req.Quantity <= 0 {
req.Quantity = 1
}
// 归属(一级编号):合同号/科技项目号 二选一;类型为其他时编号可空
ownershipType, err := validateOwnership(req.OwnershipType, req.ContractNo)
if err != nil {
return err
}
req.OwnershipType = ownershipType
// 工单号:未传入则按规则生成 WO-日期-001;若与已有工单号重复,自动递增序号(001→002…)。
if req.WorkOrderNo == "" {
req.WorkOrderNo = defaultWorkOrderNo()
}
finalNo, err := s.resolveUniqueWorkOrderNo(ctx, req.WorkOrderNo)
if err != nil {
return err
}
req.WorkOrderNo = finalNo
status := req.Status
if status == "" {
status = "CREATED"
}
if status != "CREATED" {
status = "CREATED" // 创建恒为已创建;不允许直接创建到后续状态
}
// 工艺组合 = 唯一路线源头([{flowId,stationNo}],工位号升序执行)
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)
}
}
// 完成日期(Item M):前端必填,后端有值即落库
if req.DueDate != "" {
if t, err := parseDate(req.DueDate); err == nil {
wo, _ = client.WorkOrder.UpdateOneID(wo.ID).SetDueDate(t).Save(ctx)
}
}
// 工艺组合(唯一路线源头):传了才校验并写入
if len(req.FlowCombination) > 0 {
items, err := s.ValidateFlowCombination(ctx, req.FlowCombination)
if err != nil {
return err
}
if _, err := client.WorkOrder.UpdateOneID(wo.ID).SetFlowCombination(flowItemsToMaps(items)).Save(ctx); err != nil {
return err
}
}
// 来源产品工艺:传了必须存在( ACTIVE/停用均可落——前端只列启用的,此处宽松校验存在性)
if req.ProductProcessId > 0 {
if _, err := s.ctx.EntClient.ProductProcess.Get(ctx, req.ProductProcessId); err != nil {
return errors.New("所选产品工艺不存在")
}
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 约束兜底报错。
if req.Quantity > 0 {
if req.Quantity > 999 {
return errors.New("单次建工单数量上限 999,请分批创建")
}
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):仅允许调整工艺组合(其余字段锁定),且须无在制工件——
// 在制工件按当前组合走完,防止运行中路线突变;变更写 eventlog 留痕
// - 其余状态只读(已下发/执行中只能做状态流转,已完成/已取消只读)
func (s *Service) UpdateWorkOrder(ctx context.Context, req WorkOrderReq, operator string) error {
if req.Id == 0 {
return errors.New("缺少 id")
}
old, err := s.ctx.EntClient.WorkOrder.Get(ctx, req.Id)
if err != nil {
return errors.New("工单不存在")
}
pausedEdit := old.Status == "PAUSED"
if old.Status != "CREATED" && old.Status != "PENDING" && !pausedEdit {
return errors.New("仅「已创建」可编辑全部字段;「已暂停」仅允许调整工艺组合;其余状态只能做状态流转")
}
// 已暂停:仅工艺组合可改(在制守卫 + 留痕),其余字段一律拒绝
if pausedEdit {
if req.FlowCombination == nil {
return errors.New("已暂停的工单仅允许调整工艺组合")
}
inflight, _ := s.ctx.EntClient.Workpiece.Query().
Where(workpiece.OrderNo(old.WorkOrderNo), workpiece.StatusNEQ("DONE")).
Count(ctx)
if inflight > 0 {
return fmt.Errorf("该工单还有 %d 个在制/未完工工件,请先完成或撤回后再调整工艺组合", inflight)
}
items, err := s.ValidateFlowCombination(ctx, req.FlowCombination)
if err != nil {
return err
}
if err := s.ctx.EntClient.WorkOrder.UpdateOneID(req.Id).
SetFlowCombination(flowItemsToMaps(items)).Exec(ctx); err != nil {
return err
}
s.ctx.EventLog.Write(ctx, "work.order.flow_change", old.WorkOrderNo, operator, "work_order", old.WorkOrderNo,
"已暂停工单调整工艺组合", map[string]any{"old": old.FlowCombination, "new": flowItemsToMaps(items)})
s.notifyDashboard()
return nil
}
if old.Status != "CREATED" && old.Status != "PENDING" {
return errors.New("仅「已创建」状态的工单可编辑;生产中或已结束的工单只能做状态流转")
}
// 归属(一级编号):合同号/科技项目号 二选一;工程编号已废弃,不再改写 project_no(保留历史数据)
ownershipType, err := validateOwnership(req.OwnershipType, req.ContractNo)
if err != nil {
return err
}
u := s.ctx.EntClient.WorkOrder.UpdateOneID(req.Id).
SetContractNo(req.ContractNo).SetOwnershipType(ownershipType).SetProductSerial(req.ProductSerial)
// 工艺组合(唯一路线源头):传了才校验并覆盖写入(编辑仅限「已创建」状态,上方已校验)
if req.FlowCombination != nil {
items, err := s.ValidateFlowCombination(ctx, req.FlowCombination)
if err != nil {
return err
}
u.SetFlowCombination(flowItemsToMaps(items))
}
// 来源产品工艺:传了必须存在(恒保留=来源定义,不随组合手改清空)
if req.ProductProcessId > 0 {
if _, err := s.ctx.EntClient.ProductProcess.Get(ctx, req.ProductProcessId); err != nil {
return errors.New("所选产品工艺不存在")
}
u.SetProductProcessId(req.ProductProcessId)
}
if req.Quantity > 0 {
// 二.3 边界#1:减数量只允许在所有预生成 SN 仍为 NEW 时进行(已有 SN 进入生产则禁止减)
if req.Quantity < old.Quantity {
nonNew, _ := s.ctx.EntClient.Workpiece.Query().
Where(workpiece.OrderNo(old.WorkOrderNo), workpiece.StatusNEQ("NEW")).Count(ctx)
if nonNew > 0 {
return fmt.Errorf("该工单已有 %d 个 SN 进入生产(非 NEW),禁止减少工单数量", nonNew)
}
}
u.SetQuantity(req.Quantity)
}
if req.ProductCode != "" {
u.SetProductCode(req.ProductCode)
}
if req.ProductName != "" {
u.SetProductName(req.ProductName)
}
if req.PlanStart != "" {
if t, err := parseDate(req.PlanStart); err == nil {
u.SetPlanStart(t)
}
}
if req.PlanEnd != "" {
if t, err := parseDate(req.PlanEnd); err == nil {
u.SetPlanEnd(t)
}
}
if req.DueDate != "" {
if t, err := parseDate(req.DueDate); err == nil {
u.SetDueDate(t)
}
}
if err := u.Exec(ctx); err != nil {
return err
}
wo, err := s.ctx.EntClient.WorkOrder.Get(ctx, req.Id)
if err == nil {
s.ctx.EventLog.Write(ctx, "work.order.update", wo.WorkOrderNo, operator, "work_order", wo.WorkOrderNo, "更新工单", nil)
}
s.notifyDashboard()
return nil
}
// ListWorkOrders 查询工单(支持工单号/状态/产品编码/产品名称/归属类型/归属编号 过滤;
// 工程编号查询已随编号体系改造移除,字段保留仅防历史迁移)。
// keyword:跨字段模糊(工单号/产品编码/产品名称/合同号 任一命中),供下拉远程搜索用;
// limit:>0 时启用截断(封顶 200),仅下拉搜索场景传参,列表页不传=全量,行为向后兼容。
func (s *Service) ListWorkOrders(ctx context.Context, orderNo, status, productCode, productName, contractNo, ownershipType, dueFrom, dueTo, 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))
}
// 完成日期范围(Item M)
if dueFrom != "" {
if t, err := parseDate(dueFrom); err == nil {
q = q.Where(workorder.DueDateGTE(t))
}
}
if dueTo != "" {
if t, err := parseDate(dueTo); err == nil {
q = q.Where(workorder.DueDateLTE(t))
}
}
// 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("该工单未配置工艺组合,请先在工单编辑中勾选工艺组合后再下发并开工")
}
}
upd := s.ctx.EntClient.WorkOrder.UpdateOneID(id).SetStatus(status)
if status == "DONE" {
now := time.Now()
upd.SetCompletedAt(now)
}
if err := upd.Exec(ctx); err != nil {
return err
}
// 状态变更操作日志:原状态/新状态/原因
s.ctx.EventLog.Write(ctx, "work.order.status", wo.WorkOrderNo, operator, "work_order", wo.WorkOrderNo, "变更工单状态",
map[string]any{"from": wo.Status, "to": status, "reason": reason})
// 联动:DONE/CANCELLED → 该工单未完成排产批量取消;IN_PROGRESS → 排产置执行中
s.syncPlansByOrderStatus(ctx, wo.WorkOrderNo, status, operator)
s.notifyDashboard()
return nil
}
// statusTextCN 状态枚举中文文案
func statusTextCN(s string) string {
m := map[string]string{
"CREATED": "已创建", "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
}