Files
bj_power/bj_power_mes/internal/logic/material.go
T
SunYF 8be6e03a15 docs: 统一修正全项目“SN管理”相关术语为“序列号”
本次 commit 统一修正了全项目范围内关于 SN 管理的术语表述,将原“SN管理”、“序列号件”、“批次件”等表述调整为“序列号”、“序列号=是”、“序列号=否”,同时同步更新了相关文档、代码注释、前端提示文本、数据库 schema 注释、API 文档等,确保全链路术语统一,消除理解歧义。
2026-10-10 15:58:59 +08:00

550 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"
"math"
"sort"
"strconv"
"strings"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/dock"
"bj_power_mes/ent/flowmaterial"
"bj_power_mes/ent/materialrequest"
"bj_power_mes/ent/workorder"
"bj_power_mes/internal/wmsclient"
)
// GenerateMaterialRequest 按日排产 + 工单工艺组合 + 工艺物料清单(flow_material) 自动算料,生成工位级备料单。
//
// 算法(2026-09-22 生产模型定稿):
// - 路线来源:工单 flow_combination([{flowId,stationNo}],工位号即顺序号)。无组合的工单跳过并记日志。
// - 物料来源:组合条目涉及工艺的 flow_material(工艺物料清单 ⊆ 产品物料清单)。
// - 数量:备料 = 组合条目 × flow_material × 分产量——各工位量取日排产 stationPlanQty
// (全有值且和>0 时采用,否则同工艺工位平均拆、余数补前位);reqQty = 分产量 × 单台用量 ×(1+损耗率)。
// - 目标接驳台:取 station.dock_code(无接驳台则留空待仓管指定)。
// - 物料清单(BOM 即物料清单)中未被任何涉及工艺引用的物料:记 eventlog(bom.unassigned) 告警
// (bom.unassigned = 物料清单未分配,BOM 即物料清单),不阻断生成。
//
// 生成前校验:涉及物料编码须在 WMS 物料档案存在,有缺失返回 missing(不生成);
// WMS 不可达/异常时降级为"全部存在"并记 eventlog,避免 WMS 抖动阻塞产线。
// 返回值:count=本次生成条数;missing=WMS 中不存在的物料编码(非空时 count=0)。
func (s *Service) GenerateMaterialRequest(ctx context.Context, planDate string, operator string) (int, []string, error) {
plans, err := s.ListDailyPlans(ctx, "", planDate, "")
if err != nil {
return 0, nil, err
}
if len(plans) == 0 {
return 0, nil, errors.New("该日期没有排产计划")
}
type planGroup struct {
plan *ent.DailyPlan
wo *ent.WorkOrder
items []FlowItem // 工单工艺组合(工位号升序)
fmByFlow map[int][]*ent.FlowMaterial // 工艺ID → 工艺物料清单
}
groups := make([]planGroup, 0, len(plans))
codeSet := map[string]bool{}
for _, plan := range plans {
if plan.Status == "CANCELLED" || plan.Status == "DONE" {
continue // 已取消/已完成的排产不再算料
}
wo, err := s.ctx.EntClient.WorkOrder.Query().
Where(workorder.WorkOrderNo(plan.OrderNo)).Only(ctx)
if err != nil {
continue
}
items, _ := RouteStationsFromWO(ctx, s.ctx.EntClient, wo)
if len(items) == 0 {
s.ctx.EventLog.Write(ctx, "material.request.skip", plan.OrderNo, operator, "material_request", plan.OrderNo,
"工单未配置工艺组合,本日跳过备料", map[string]any{"planDate": plan.PlanDate})
continue
}
g := planGroup{plan: plan, wo: wo, items: items, fmByFlow: map[int][]*ent.FlowMaterial{}}
for _, it := range items {
if _, done := g.fmByFlow[it.FlowId]; done {
continue
}
fms, err := s.ctx.EntClient.FlowMaterial.Query().
Where(flowmaterial.FlowId(it.FlowId)).All(ctx)
if err != nil {
continue
}
g.fmByFlow[it.FlowId] = fms
for _, fm := range fms {
if fm.MaterialCode != "" {
codeSet[fm.MaterialCode] = true
}
}
}
groups = append(groups, g)
}
if len(groups) == 0 {
return 0, nil, errors.New("该日期排产均无有效工单工艺组合,无法生成备料单")
}
// 阶段1:WMS 物料存在性校验(全部存在才生成)
codes := make([]string, 0, len(codeSet))
for c := range codeSet {
codes = append(codes, c)
}
missing, wmsErr := s.ctx.Wms.MaterialExists(ctx, codes)
if wmsErr != nil {
// 降级:WMS 不可达按"全部存在"放行,记日志供事后核查
s.ctx.EventLog.Write(ctx, "material.request.wms_skip", "", operator, "material_request", planDate,
"WMS 物料校验不可达,已降级放行", map[string]any{"planDate": planDate, "error": wmsErr.Error()})
} else if len(missing) > 0 {
return 0, missing, nil
}
// 阶段2:全部存在 → 按 组合条目 × flow_material × 分产量 拆料生成
// 幂等查重(AITEST 闭环实测缺陷):同 工单+排产日+物料+工位+工艺 已有备料单则跳过,
// 否则每次调用 generate 都翻倍生成重复单据(重复出库/重复备料,生产级事故源)。
existing, _ := s.ctx.EntClient.MaterialRequest.Query().
Where(materialrequest.PlanDateEQ(planDate)).All(ctx)
existKey := make(map[string]bool, len(existing))
for _, mr := range existing {
existKey[mr.OrderNo+"|"+mr.MaterialCode+"|"+strconv.Itoa(mr.StationNo)+"|"+strconv.Itoa(mr.FlowId)] = true
}
created := 0
tsBase := time.Now().Format("20060102150405")
seq := 1
for _, g := range groups {
// 工位产量分配(日排产层):stationNo(字符串键) → 计划产量
stationQty := map[int]int{}
for k, v := range g.plan.StationPlanQty {
if n, e := strconv.Atoi(k); e == nil {
stationQty[n] = v
}
}
// 工艺ID → 该工艺涉及的全部工位(组合内升序)
stationsByFlow := map[int][]int{}
for _, it := range g.items {
stationsByFlow[it.FlowId] = append(stationsByFlow[it.FlowId], it.StationNo)
}
// 工位号 → 默认接驳台编码:真源 = dock 表(一工位可绑 R1/R2 多个接驳台,按编码升序取第一个为默认)
dockByStation := map[int]string{}
if dks, e := s.ctx.EntClient.Dock.Query().
Where(dock.StationNoIn(RouteStationsOfWO(g.items)...), dock.DockTypeEQ("line")).
Order(ent.Asc(dock.FieldStationNo), ent.Asc(dock.FieldDockCode)).
All(ctx); e == nil {
for _, d := range dks {
if _, ok := dockByStation[d.StationNo]; !ok && d.DockCode != "" {
dockByStation[d.StationNo] = d.DockCode
}
}
}
for flowId, stations := range stationsByFlow {
fms := g.fmByFlow[flowId]
if len(fms) == 0 {
continue // 该工艺未配置物料清单 → 无料可备
}
// 分产量:stationPlanQty 全有值且和>0 直接采用,否则平均拆、余数补前位
qtys := splitQtyToStations(stations, g.plan.PlanQty, stationQty)
for _, fm := range fms {
if fm.MaterialCode == "" {
continue
}
for i, stNo := range stations {
q := qtys[i]
if q <= 0 {
continue
}
// 损耗向上取整:备料单需求数量必须为整数(接料/出库按整数收发),
// 小数 reqQty 会使接料接口(int)永远无法收满、备料单永远无法完结(AITEST 闭环实测缺陷)
reqQty := math.Ceil(float64(q) * fm.UnitQty * (1 + fm.LossRate/100))
if reqQty <= 0 {
continue
}
// 幂等:该 工单+物料+工位+工艺 当日已有单则跳过(重复调用不翻倍)
dedupKey := g.plan.OrderNo + "|" + fm.MaterialCode + "|" + strconv.Itoa(stNo) + "|" + strconv.Itoa(flowId)
if existKey[dedupKey] {
continue
}
reqNo := fmt.Sprintf("MR%s%03d", tsBase, seq)
seq++
_ = s.ctx.EntClient.MaterialRequest.Create().
SetRequestNo(reqNo).SetOrderNo(g.plan.OrderNo).SetPlanDate(g.plan.PlanDate).
SetMaterialCode(fm.MaterialCode).SetMaterialName(fm.MaterialName).
SetUnit(fm.Unit).SetSnMode(fm.SnMode).SetReqQty(reqQty).
SetStatus("PENDING").SetOperator(operator).
SetStationNo(stNo).SetFlowId(flowId).SetTargetDock(dockByStation[stNo]).Exec(ctx)
created++
}
}
}
}
s.ctx.EventLog.Write(ctx, "material.request.generate", "", operator, "material_request", planDate, "按日排产+工单工艺组合+工艺物料清单生成工位级备料单", map[string]any{"planDate": planDate, "count": created})
// 需求10:把每个工单的「工单级需求总量」同步给 WMS 台账(幂等,失败降级不阻塞)。
// 必须先同步 total_qty,后续自动出库才能在台账上累加 out_qty 并判定缺口/领料完结。
synced := map[string]bool{}
for _, g := range groups {
if synced[g.plan.OrderNo] {
continue
}
synced[g.plan.OrderNo] = true
if e := s.SyncOrderLedger(ctx, g.plan.OrderNo, operator); e != nil {
s.ctx.EventLog.Write(ctx, "material.ledger.sync_fail", "", operator, "material_request", g.plan.OrderNo,
"工单需求量同步 WMS 台账失败", map[string]any{"orderNo": g.plan.OrderNo, "error": e.Error()})
}
}
// 生成后立即自动出库(客户第1条:平时无需操作)。缺料/失败不阻塞生成,仅记预警等待补库存。
if _, short := s.AutoOutboundRequests(ctx, planDate, "", operator); len(short) > 0 {
s.ctx.EventLog.Write(ctx, "material.outbound.short", "", operator, "material_request", planDate,
"备料自动出库未齐套", map[string]any{"planDate": planDate, "short": strings.Join(short, "; ")})
}
s.notifyDashboard()
return created, nil, nil
}
// SyncOrderLedger 计算并向 WMS 下发某工单的「工单级物料需求总量」(需求10)。
//
// 需求量口径(AITEST 闭环实测修正):= 该工单全部备料单 reqQty 之和(损耗按工位拆单逐单向上取整)。
// 原按「工单数量×单台用量」整体取整的算法与工位级拆单逐单取整必然不一致(拆单合计 ≥ 整体取整),
// 会导致自动出库合计触发 WMS 台账超量拦截、备料单永远无法出齐(如 拆单合计 8 > 整体取整 7)。
// 改为聚合备料单:total 与单据精确自洽,generate 幂等生成新单后重复调用自动增长,WMS 侧按
// orderNo+materialCode 幂等 upsert total_qty。
// 工单尚无备料单时不下发(保持 WMS 既有 total 不变,避免误清零)。
func (s *Service) SyncOrderLedger(ctx context.Context, orderNo, operator string) error {
wo, err := s.ctx.EntClient.WorkOrder.Query().
Where(workorder.WorkOrderNo(orderNo)).Only(ctx)
if err != nil {
return err
}
mrs, err := s.ctx.EntClient.MaterialRequest.Query().
Where(materialrequest.OrderNoEQ(orderNo)).All(ctx)
if err != nil {
return err
}
if len(mrs) == 0 {
return nil
}
agg := map[string]int{} // materialCode → ΣreqQty(逐单向上取整后求和)
names := map[string]string{}
for _, mr := range mrs {
agg[mr.MaterialCode] += int(math.Ceil(mr.ReqQty))
names[mr.MaterialCode] = mr.MaterialName
}
items := make([]wmsclient.LedgerSyncItem, 0, len(agg))
for code, total := range agg {
if total <= 0 {
continue
}
items = append(items, wmsclient.LedgerSyncItem{
MaterialCode: code,
MaterialName: names[code],
TotalQty: total,
})
}
if len(items) == 0 {
return nil
}
return s.ctx.Wms.LedgerSync(ctx, orderNo, wo.ProductCode, operator, items)
}
// AutoOutboundRequests 工单备料自动出库(客户第1条:备料出库根据 MES 排产自动生成,平时无需操作)。
//
// 对指定排产日 / 工单下的备料单,按 FIFO 从 WMS「合格」在库库存自动领料:
// - 序列号=否(snMode=2):按批次号升序逐批出库,直到补足未出数量;
// - 序列号=是(snMode=1):按可用 SN 逐件出库。
//
// 幂等:只出「未出数量 = 需求量 − 已发数量」,重复调用不会超领。
// 库存不足的行已出部分照常计入 sentQty,差额维持待备料并触发「备料未齐套」预警,
// 库存补齐后再次调用即可补出(补出由 WMS 台账强约束兜底,不会超出工单 物料清单需求)。
// 返回:本次补足(出库总量达标)的备料单条数、未出齐的明细文案。
func (s *Service) AutoOutboundRequests(ctx context.Context, planDate, orderNo, operator string) (int, []string) {
list, err := s.ListMaterialRequests(ctx, MaterialRequestQuery{OrderNo: orderNo, PlanDate: planDate})
if err != nil {
return 0, []string{"查询备料单失败: " + err.Error()}
}
// 补料单(refill)优先于排产备料(plan):先把补料发出,避免产线因缺料停线。
sort.SliceStable(list, func(i, j int) bool {
return list[i].Source == "REFILL" && list[j].Source != "REFILL"
})
done := 0
short := make([]string, 0)
for _, mr := range list {
need := int(mr.ReqQty - mr.SentQty + 0.5)
if need <= 0 {
continue
}
batches, sns, err := s.ctx.Wms.StockBatches(ctx, mr.MaterialCode)
if err != nil {
short = append(short, fmt.Sprintf("%s %s 查询 WMS 库存失败", mr.OrderNo, mr.MaterialCode))
continue
}
dock := mr.TargetDock
if dock == "" {
dock = "DOCK01"
}
remain := need
outboundNos := make([]string, 0, 4)
// 出库参数:补料(source=REFILL) 记为 refill 类型并默认叫车,且携带超领原因
// (补料常因损耗/报废超出 物料清单需求,WMS 侧有原因才放行)。
obType := "workorder"
if mr.Source == "REFILL" {
obType = "refill"
}
// C2 幂等键轮次:同一备料单每次 StockDeduct 调用用稳定唯一键,
// 网络超时重试时 WMS 按键复用已生成的出库单,杜绝重复扣减。
round := 0
opts := wmsclient.StockDeductOpts{
Qty: need, Operator: operator, TargetDock: dock,
OutboundType: obType, NeedAgv: mr.NeedAgv, OverReason: mr.OverReason,
}
if mr.SnMode == 1 {
for _, sn := range sns {
if remain <= 0 {
break
}
round++
opts.SnList = []string{sn}
opts.BatchNo = ""
opts.Qty = 1
// 幂等键必须含备料单号:同工单+同物料会按工位拆成多张备料单,
// 若只用 orderNo+物料做键,各单 round=1 必然撞键——WMS 幂等复用吞掉
// 第二张单的扣减,MES 却虚增 sent_qty 并置 LOCKED(账实不符,AITEST 闭环实测)。
opts.IdempotencyKey = fmt.Sprintf("IDEM-%s-%s-%d", mr.RequestNo, sn, round)
no, _, _, e := s.ctx.Wms.StockDeduct(ctx, mr.OrderNo, mr.MaterialCode, opts)
if e != nil {
break
}
outboundNos = append(outboundNos, no)
remain--
}
} else {
for _, b := range batches {
if remain <= 0 {
break
}
take := b.Avail
if take > remain {
take = remain
}
if take <= 0 {
continue
}
round++
opts.SnList = nil
opts.BatchNo = b.BatchNo
opts.Qty = take
opts.ZoneCode = b.ZoneCode
// 同上:幂等键含备料单号,杜绝工位级拆单跨单撞键(AITEST 闭环实测缺陷)
opts.IdempotencyKey = fmt.Sprintf("IDEM-%s-%s-%d", mr.RequestNo, b.BatchNo, round)
no, _, _, e := s.ctx.Wms.StockDeduct(ctx, mr.OrderNo, mr.MaterialCode, opts)
if e != nil {
break
}
outboundNos = append(outboundNos, no)
remain -= take
}
}
sent := need - remain
if sent > 0 {
// C3 行锁 + 钳制:在事务内锁定该行后重读 sentQty 并重算,避免并发/重试重复累计;
// 以 reqQty 为上限钳制,杜绝超出 物料清单需求量的虚高计数(网络重试幂等复用场景下尤其关键)。
applied := false
if tx, txErr := s.ctx.EntClient.Tx(ctx); txErr == nil {
locked, lErr := tx.MaterialRequest.Query().
Where(materialrequest.ID(mr.ID)).ForUpdate().Only(ctx)
if lErr == nil {
newSent := locked.SentQty + float64(sent)
if newSent > locked.ReqQty {
newSent = locked.ReqQty // 钳制到需求量上限
}
upd := tx.MaterialRequest.UpdateOneID(locked.ID).SetSentQty(newSent)
if remain == 0 {
// 出库量已达标:备料完成,等 AGV 配送(WMS 下发后回写 DELIVERING)
upd = upd.SetStatus("LOCKED")
}
if _, e := upd.Save(ctx); e == nil {
_ = tx.Commit()
applied = true
if remain == 0 {
done++
}
s.ctx.EventLog.Write(ctx, "material.outbound.auto", mr.OrderNo, operator, "material_request", mr.RequestNo,
"备料自动出库", map[string]any{"materialCode": mr.MaterialCode, "qty": sent, "outboundNos": strings.Join(outboundNos, ",")})
}
}
if !applied {
_ = tx.Rollback()
}
}
if !applied {
// 行锁事务不可用时的兜底:直接原子累加(并发下仍有极小概率重复累计,由 WMS 幂等键兜底扣减)
upd := s.ctx.EntClient.MaterialRequest.UpdateOneID(mr.ID).AddSentQty(float64(sent))
if remain == 0 {
upd = upd.SetStatus("LOCKED")
done++
}
if _, e := upd.Save(ctx); e == nil {
s.ctx.EventLog.Write(ctx, "material.outbound.auto", mr.OrderNo, operator, "material_request", mr.RequestNo,
"备料自动出库", map[string]any{"materialCode": mr.MaterialCode, "qty": sent, "outboundNos": strings.Join(outboundNos, ",")})
}
}
}
if remain > 0 {
short = append(short, fmt.Sprintf("%s %s 缺 %d", mr.OrderNo, mr.MaterialCode, remain))
s.Evaluate(ctx, "material_shortage", 1, "备料未齐套",
fmt.Sprintf("工单 %s 物料 %s 自动出库后仍缺 %d(已出 %d/%d)", mr.OrderNo, mr.MaterialCode, remain, sent, need),
"material_request", mr.RequestNo, mr.OrderNo)
}
}
if done > 0 {
s.notifyDashboard()
}
return done, short
}
// splitQtyToStations 把日总量 dayQty 拆分到 stations 各工位:
// 优先使用 stationQty 显式分配(其和>0 时直接采用);否则平均分配(余数补到前面工位)。
func splitQtyToStations(stations []int, dayQty int, stationQty map[int]int) []int {
n := len(stations)
out := make([]int, n)
usePlan := true
sum := 0
for _, st := range stations {
v, ok := stationQty[st]
if !ok {
usePlan = false
break
}
sum += v
}
if usePlan && sum > 0 {
for i, st := range stations {
out[i] = stationQty[st]
}
return out
}
if n == 0 {
return out
}
base := dayQty / n
for i := 0; i < n; i++ {
out[i] = base
}
for i := 0; i < dayQty-base*n; i++ {
out[i]++
}
return out
}
// MaterialRequestQuery 备料单查询条件(零值=不过滤)。
// 统一入口:原 ListMaterialRequests / ListMaterialRequestsFiltered 两套位置参数合并到本结构,
// 避免参数越加越长、调用点易错。
type MaterialRequestQuery struct {
OrderNo string
PlanDate string
Status string
MaterialCode string
MaterialName string
TargetDock string
StationNo string
Source string // PLAN / REFILL
RequestNo string // 备料单号(独立模糊筛选;列表页禁用关键字混搜)
}
// ListMaterialRequests 备料单查询(大小写不敏感)。
func (s *Service) ListMaterialRequests(ctx context.Context, o MaterialRequestQuery) ([]*ent.MaterialRequest, error) {
q := s.ctx.EntClient.MaterialRequest.Query()
if o.OrderNo != "" {
q = q.Where(materialrequest.OrderNoEqualFold(o.OrderNo))
}
if o.PlanDate != "" {
q = q.Where(materialrequest.PlanDate(o.PlanDate))
}
if o.Status != "" {
q = q.Where(materialrequest.Status(o.Status))
}
if o.MaterialCode != "" {
q = q.Where(materialrequest.MaterialCodeContainsFold(o.MaterialCode))
}
if o.MaterialName != "" {
q = q.Where(materialrequest.MaterialNameContainsFold(o.MaterialName))
}
if o.TargetDock != "" {
q = q.Where(materialrequest.TargetDockEqualFold(o.TargetDock))
}
if o.Source != "" {
q = q.Where(materialrequest.Source(o.Source))
}
if o.RequestNo != "" {
q = q.Where(materialrequest.RequestNoContainsFold(o.RequestNo))
}
if o.StationNo != "" {
if n, e := strconv.Atoi(o.StationNo); e == nil {
q = q.Where(materialrequest.StationNo(n))
}
}
return q.Order(ent.Desc(materialrequest.FieldCreatedAt), ent.Desc(materialrequest.FieldID)).All(ctx)
}
// ReceiveMaterialRequest 接料确认(两个入口共用:工位终端扫码接料 / MES 备料页人工点「已接料」)。
//
// 字段口径(2026-09-19 定稿):写 receivedQty(已接料),**不再累加 sentQty**。
//
// sentQty 已发出量 [写者:自动出库] —— 幂等基准「还需发多少 = reqQty − sentQty」
// receivedQty 已接料量 [写者:本方法] —— 在途 = sentQty − receivedQty
//
// 上限 = 已发出量(工位只能接到仓库已发出来的料),不超接。
// qty<=0 表示「确认本批全部剩余」,适合扫码/一键接料;>0 为本次实收批次量。
// 累计接到 sentQty 且已发齐 reqQty → 状态置 DONE(送达并与接料双完结)。
func (s *Service) ReceiveMaterialRequest(ctx context.Context, requestNo string, qty int, operator string) error {
mr, err := s.ctx.EntClient.MaterialRequest.Query().
Where(materialrequest.RequestNo(requestNo)).Only(ctx)
if err != nil {
return errors.New("备料单不存在")
}
sent := int(mr.SentQty)
already := int(mr.ReceivedQty)
pending := sent - already // 已发出但尚未接料(在途)
if pending < 0 {
pending = 0
}
add := qty
if add <= 0 {
add = pending // 确认本批全部剩余
}
if add > pending {
add = pending // 不超接:上限是仓库已发出的量
}
if add < 0 {
add = 0
}
newReceived := already + add
upd := s.ctx.EntClient.MaterialRequest.UpdateOneID(mr.ID).
SetReceivedQty(float64(newReceived)).
SetReceivedAt(time.Now().Unix()).
SetReceiveBy(operator)
if mr.Status != "DONE" && sent >= int(mr.ReqQty) && newReceived >= sent {
upd.SetStatus("DONE")
}
if _, err = upd.Save(ctx); err != nil {
return err
}
s.ctx.EventLog.Write(ctx, "material.request.receive", requestNo, operator, "material_request", requestNo,
"接料确认", map[string]any{"add": add, "receivedQty": newReceived, "sentQty": sent,
"reqQty": int(mr.ReqQty), "awaiting": sent - newReceived})
s.notifyDashboard()
return nil
}
// SetMaterialRequestStatus 推进备料单状态(WMS 下发 AGV DELIVERING / 到位 DONE)
func (s *Service) SetMaterialRequestStatus(ctx context.Context, requestNo, status string) error {
n, err := s.ctx.EntClient.MaterialRequest.Update().
Where(materialrequest.RequestNo(requestNo)).
SetStatus(status).
Save(ctx)
if err != nil {
return err
}
if n == 0 {
return errors.New("备料单不存在")
}
s.notifyDashboard()
return nil
}