Files
bj_power/bj_power_mes/internal/logic/call_plan.go
T
SunYF 1e92b2a596 feat: 核心业务实体扩充(混产模板/产品BOM/试制记录)、WMS 库存检验增强与前端通用能力
- MES 新增实体:混产模板、产品BOM、产品工艺物料、试制记录(schema + ent 生成码 + logic/handler/前端页)
- WMS 实体增强:检验记录、库存、半成品重构;新增序列号库存与短缺代报
- AGV 与产能:AGV 手动点位与链路、物料守卫、短缺预测、原因字典
- 前端通用能力:新增下一步引导组件 NextStepBar,统一帮助文档/布局/请求拦截与操作列
- 工位终端:界面与各 handler 调整(api/store/绑定/PLC/拧紧/上报等)
- 配置与文档:更新 mes-api.yaml、WMS README 及案例/产线API/问题记录/项目说明/流程说明
2026-11-15 12:17:39 +08:00

479 lines
18 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
// 2026-11-05 叫料包拍板支持层(叫料与送料彻底拆开):
// ① CallPlanDetail 叫料需求明细(工单×排产日×物料,实时计算不落库)——池底层 工位×物料
// 聚合记账不动(两层并存),本明细层供「当日剩余没叫/跨日量」提示与 plan_breakdown 拆分。
// ② EnsureStationDocksEmpty / StationDockPallets 两接驳台都为空才能叫料(传感器为准)。
// ③ DispatchPalletReturnManual 托盘回库(传感器为准、台账软校验,不一致由操作人确认留痕)。
// ④ ClearDockLedger 人工清台(托盘被人工卸走后台账卡死兜底;仅清台账不碰账)。
// ⑤ DispatchDeliveryAgv 配送单派车(WMS 配送单驱动,BizNo=配送单号)。
// ⑥ StationMaterialDetail 工位物料明细(工艺物料全集 左连接 工位账四数,量为0也显示)。
import (
"context"
"errors"
"fmt"
"math"
"sort"
"strconv"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/callpool"
"bj_power_mes/ent/dailyplan"
"bj_power_mes/ent/dock"
"bj_power_mes/ent/flowmaterial"
"bj_power_mes/ent/materialrequest"
"bj_power_mes/ent/workorder"
"bj_power_mes/schema"
)
// ErrDockPLCOffline PLC 离线无法核实接驳台为空(前端提示后可强行提交——离线降级拍板口径)
var ErrDockPLCOffline = errors.New("PLC 离线,无法确认接驳台是否为空")
// CallPlanDetailRow 叫料需求明细行(工单×排产日×物料维度)
type CallPlanDetailRow struct {
PlanDate string `json:"planDate"`
OrderNo string `json:"orderNo"`
FlowID int `json:"flowId"`
FlowName string `json:"flowName"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Unit string `json:"unit"`
NeedQty int `json:"needQty"`
CalledQty int `json:"calledQty"`
RemainQty int `json:"remainQty"`
}
// CallPlanDetail 明细全集 + 两类提示(当日剩余没叫 / 跨日量明细)——实时计算不落库不拦提交
type CallPlanDetail struct {
Today string `json:"today"`
Rows []CallPlanDetailRow `json:"rows"`
TodayRemain []CallPlanDetailRow `json:"todayRemain"`
CrossDayRemain []CallPlanDetailRow `json:"crossDayRemain"`
}
// CallPlanDetail 叫料需求明细:复刻 recomputePoolStations 的派生算法,按 工单×排产日×物料 展开;
// 已叫量从 material_request.plan_breakdown 汇总(存量单 breakdown 为空时按 call_date/工单号归并)。
func (s *Service) CallPlanDetail(ctx context.Context, stationNo int) (*CallPlanDetail, error) {
today := time.Now().Format("2006-01-02")
type key struct {
date string
order string
flow int
mat string
}
need := map[key]*CallPlanDetailRow{}
plans, err := s.ctx.EntClient.DailyPlan.Query().
Where(dailyplan.Status("CONFIRMED")).All(ctx)
if err != nil {
return nil, err
}
flowNameCache := map[int]string{}
for _, p := range plans {
wo, werr := s.ctx.EntClient.WorkOrder.Query().
Where(workorder.WorkOrderNo(p.OrderNo)).First(ctx)
if werr != nil || wo == nil {
continue
}
items, rerr := RouteStationsFromWO(ctx, s.ctx.EntClient, wo)
if rerr != nil || len(items) == 0 {
continue
}
fmByFlow, merr := s.MaterialsByFlowForWO(ctx, s.ctx.EntClient, wo, flowIdsOf(items))
if merr != nil {
continue
}
stationsByFlow := map[int][]int{}
for _, it := range items {
stationsByFlow[it.FlowId] = append(stationsByFlow[it.FlowId], it.StationNo)
}
stationQty := map[int]int{}
for k, v := range p.StationPlanQty {
if n, e := strconv.Atoi(k); e == nil {
stationQty[n] = v
}
}
for flowId, stations := range stationsByFlow {
fms := fmByFlow[flowId]
if len(fms) == 0 {
continue
}
qtys := splitQtyToStations(stations, p.PlanQty, stationQty)
for i, stNo := range stations {
if stNo != stationNo {
continue
}
q := qtys[i]
if q <= 0 {
continue
}
if _, ok := flowNameCache[flowId]; !ok {
flowNameCache[flowId] = s.flowNameById(ctx, flowId)
}
for _, fm := range fms {
if fm.MaterialCode == "" {
continue
}
needQty := int(math.Ceil(float64(q) * fm.UnitQty))
if needQty <= 0 {
continue
}
k := key{p.PlanDate, p.OrderNo, flowId, fm.MaterialCode}
r := need[k]
if r == nil {
r = &CallPlanDetailRow{PlanDate: p.PlanDate, OrderNo: p.OrderNo,
FlowID: flowId, FlowName: flowNameCache[flowId],
MaterialCode: fm.MaterialCode, MaterialName: fm.MaterialName, Unit: fm.Unit}
need[k] = r
}
r.NeedQty += needQty
}
}
}
}
// 已叫量:活跃叫料单(待备料/已发货/已完成——已取消/已驳回/退库不计)
called := map[key]int{}
mrs, _ := s.ctx.EntClient.MaterialRequest.Query().
Where(materialrequest.StationNo(stationNo),
materialrequest.StatusIn("PENDING", "SHIPPED", "DONE")).All(ctx)
for _, mr := range mrs {
if len(mr.PlanBreakdown) > 0 {
for _, b := range mr.PlanBreakdown {
called[key{b.PlanDate, b.OrderNo, b.FlowID, mr.MaterialCode}] += int(b.Qty)
}
} else {
// 存量单兼容:无明细按 叫料日×工单号 归并(空=未拆分)
called[key{mr.CallDate, mr.WorkOrderNo, 0, mr.MaterialCode}] += int(mr.ReqQty)
}
}
out := CallPlanDetail{Today: today, Rows: []CallPlanDetailRow{},
TodayRemain: []CallPlanDetailRow{}, CrossDayRemain: []CallPlanDetailRow{}}
for k, r := range need {
r.CalledQty = called[k]
if r.CalledQty > r.NeedQty {
r.CalledQty = r.NeedQty
}
r.RemainQty = r.NeedQty - r.CalledQty
out.Rows = append(out.Rows, *r)
if r.RemainQty > 0 {
if k.date == today {
out.TodayRemain = append(out.TodayRemain, *r)
} else {
out.CrossDayRemain = append(out.CrossDayRemain, *r)
}
}
}
sort.Slice(out.Rows, func(i, j int) bool {
a, b := out.Rows[i], out.Rows[j]
if a.PlanDate != b.PlanDate {
return a.PlanDate < b.PlanDate
}
if a.OrderNo != b.OrderNo {
return a.OrderNo < b.OrderNo
}
return a.MaterialCode < b.MaterialCode
})
sort.Slice(out.TodayRemain, func(i, j int) bool { return out.TodayRemain[i].MaterialCode < out.TodayRemain[j].MaterialCode })
sort.Slice(out.CrossDayRemain, func(i, j int) bool {
a, b := out.CrossDayRemain[i], out.CrossDayRemain[j]
if a.PlanDate != b.PlanDate {
return a.PlanDate < b.PlanDate
}
return a.MaterialCode < b.MaterialCode
})
return &out, nil
}
// splitPlanBreakdown 把本次叫料量按 工单×排产日 明细拆分(FIFO:最早排产日优先、同日按工单号序);
// 只分配「需求−已叫」的余量;无可分配明细时退化为单行(planDate=叫料日,存量兼容)。
func (s *Service) splitPlanBreakdown(ctx context.Context, stationNo int, materialCode string, qty int, callDate string) []schema.CallPlanBreakdown {
detail, err := s.CallPlanDetail(ctx, stationNo)
if err != nil || detail == nil {
return []schema.CallPlanBreakdown{{PlanDate: callDate, Qty: float64(qty)}}
}
out := []schema.CallPlanBreakdown{}
for _, r := range detail.Rows {
if qty <= 0 {
break
}
if r.MaterialCode != materialCode {
continue
}
room := r.NeedQty - r.CalledQty
if room <= 0 {
continue
}
take := room
if take > qty {
take = qty
}
out = append(out, schema.CallPlanBreakdown{OrderNo: r.OrderNo, PlanDate: r.PlanDate,
FlowID: r.FlowID, FlowName: r.FlowName, Qty: float64(take)})
qty -= take
}
if qty > 0 {
out = append(out, schema.CallPlanBreakdown{PlanDate: callDate, Qty: float64(qty)})
}
return out
}
// DockPalletState 接驳台托盘状态(实时传感器为准;PLC 不可达时回退台账并标注 plcOk=false)
type DockPalletState struct {
DockCode string `json:"dockCode"`
Name string `json:"name"`
Side string `json:"side"`
HasPallet bool `json:"hasPallet"`
LedgerPallet bool `json:"ledgerPallet"`
PlcOk bool `json:"plcOk"`
}
// StationDockPallets 按工位批量读左右接驳台实时传感器(叫料空台校验/下班校验共用)。
func (s *Service) StationDockPallets(ctx context.Context, stationNo int) ([]DockPalletState, error) {
dks, err := s.ctx.EntClient.Dock.Query().
Where(dock.StationNo(stationNo)).Order(ent.Asc(dock.FieldDockCode)).All(ctx)
if err != nil {
return nil, err
}
out := []DockPalletState{}
for _, d := range dks {
if d.Status == "DISABLED" {
continue
}
st := DockPalletState{DockCode: d.DockCode, Name: d.Name, Side: d.Side,
LedgerPallet: d.HasPallet, HasPallet: d.HasPallet}
if s.ctx.PLC != nil && !s.ctx.PLC.IsMock() {
if has, e := s.ctx.PLC.Get().QueryDockPallet(ctx, d.DockCode); e == nil {
st.PlcOk = true
st.HasPallet = has
}
}
out = append(out, st)
}
return out, nil
}
// EnsureStationDocksEmpty 两接驳台都为空才允许叫料(2026-11-05 拍板:提交时校验)。
// 传感器为准;PLC 离线返回 ErrDockPLCOffline(前端提示后可强行提交);台账仅软校验留痕。
func (s *Service) EnsureStationDocksEmpty(ctx context.Context, stationNo int) error {
if s.ctx.PLC == nil || s.ctx.PLC.IsMock() {
return nil // mock PLC 无真实传感器:跳过校验
}
dks, err := s.ctx.EntClient.Dock.Query().
Where(dock.StationNo(stationNo)).All(ctx)
if err != nil || len(dks) == 0 {
return nil // 无接驳台配置不拦
}
for _, d := range dks {
if d.Status == "DISABLED" {
continue
}
has, e := s.ctx.PLC.Get().QueryDockPallet(ctx, d.DockCode)
if e != nil {
return ErrDockPLCOffline
}
if has {
return fmt.Errorf("工位%d 接驳台 %s(%s)有托盘,请先退料或点「托盘回库」拉走后再叫料", stationNo, d.DockCode, d.Name)
}
if d.HasPallet {
// 台账与传感器不一致:以传感器(空)为准放行,留痕
s.ctx.EventLog.Write(ctx, "dock.pallet_mismatch", "", "", "dock", d.DockCode,
"叫料空台校验:台账有托盘但传感器为空,以传感器为准放行", nil)
}
}
return nil
}
// DispatchPalletReturnManual 工位终端「托盘回库」(2026-11-05 拍板):
// 物理拉回仓库 JBT21,不是退料——物料账仍挂工位、WMS 库存不变(PALLET 链不碰任何账),
// 系统内一律按空托盘理解(盘上有无料都不管)。判定以传感器为准、台账软校验;
// 不一致由操作人确认(confirmHasPallet=true)并留痕。
func (s *Service) DispatchPalletReturnManual(ctx context.Context, dockCode, operator string, confirmHasPallet bool) error {
d, err := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(dockCode)).First(ctx)
if err != nil || d == nil {
return fmt.Errorf("接驳台 %s 不存在", dockCode)
}
if d.Status == "DISABLED" {
return fmt.Errorf("接驳台 %s 已停用", dockCode)
}
hasPallet := d.HasPallet
plcOk := false
if s.ctx.PLC != nil && !s.ctx.PLC.IsMock() {
if has, e := s.ctx.PLC.Get().QueryDockPallet(ctx, dockCode); e == nil {
plcOk = true
hasPallet = has
}
}
if plcOk && !hasPallet {
if d.HasPallet && !confirmHasPallet {
return errors.New("传感器显示该接驳台无托盘(台账有托盘)。如托盘确实已不在台上,请库管在 WMS 托盘工作台「人工清台」更正;如确认有托盘,请勾选「确认台上有托盘」后重试")
}
if !d.HasPallet {
return fmt.Errorf("接驳台 %s 无托盘,无需回库", dockCode)
}
// 操作人坚持有托盘:按台账派车并留痕
s.ctx.EventLog.Write(ctx, "dock.pallet_return_confirm", operator, "", "dock", dockCode,
"托盘回库:传感器为空但操作人确认台上有托盘,按台账派车", nil)
} else if !plcOk && !hasPallet {
return fmt.Errorf("接驳台 %s 台账无托盘(PLC 离线无法核实),无需回库", dockCode)
}
if free, reason := s.Jbt21Free(ctx); !free {
return fmt.Errorf("库房接驳台 %s 暂无空位:%s。请先卸走库房接驳台上的托盘后再派车", dockStoreCode, reason)
}
_, err = s.dispatchAgvSegment(ctx, agvSegInput{
Kind: "GO_LOAD", BizType: "PALLET", BizNo: dockCode,
Source: "", Target: dockCode, Operator: operator,
})
if err == nil {
s.ctx.EventLog.Write(ctx, "dock.pallet_return", operator, "", "dock", dockCode,
"托盘回库已派车(物理拉回仓库,非退料;物料账与库存不变)", nil)
}
return err
}
// ClearDockLedger 人工清台(2026-11-05 兜底):托盘被人工卸走(未走 AGV)后台账卡 hasPallet=true,
// 会卡住 Jbt21Free 空位判定与防撞校验——库管在 WMS 托盘工作台手动清台并留痕。
// 仅清台账,不碰任何库存/池账/工件账。
func (s *Service) ClearDockLedger(ctx context.Context, dockCode, operator, reason string) error {
d, err := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(dockCode)).First(ctx)
if err != nil || d == nil {
return fmt.Errorf("接驳台 %s 不存在", dockCode)
}
if !d.HasPallet {
return errors.New("该接驳台账账本无托盘,无需清台")
}
if uerr := s.ctx.EntClient.Dock.UpdateOneID(d.ID).SetHasPallet(false).SetPalletRef("").Exec(ctx); uerr != nil {
return uerr
}
s.ctx.EventLog.Write(ctx, "dock.manual_clear", operator, "", "dock", dockCode,
"人工清台:台账置无托盘(托盘已被人工卸走;物料账/库存不变) 原因:"+reason, nil)
return nil
}
// DeliveryAgvItem 配送单物料行(WMS 派车时传入)
type DeliveryAgvItem struct {
RequestNo string `json:"requestNo"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Unit string `json:"unit"`
Qty float64 `json:"qty"`
}
// DispatchDeliveryAgv 配送单派车(2026-11-05 拍板:AGV 派车改配送单驱动):
// WMS 校验配送单后转发(BizType=CALL、BizNo=配送单号、关联单号=配送单号)→
// 空车段(GO_LOAD)前往装货点 JBT21 → 到位待令 → 库管「确认装车并送货」
// (目标=配送单接驳台,随物料行下发)→ 卸货放行后经 /api/internal/delivery/delivered 回写已送达。
func (s *Service) DispatchDeliveryAgv(ctx context.Context, deliveryNo, targetDock string, items []DeliveryAgvItem, operator string) error {
if deliveryNo == "" || targetDock == "" {
return errors.New("配送单号与配送接驳台必填")
}
if len(items) == 0 {
return errors.New("配送单无明细,不能派车")
}
if d, derr := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(dockStoreCode)).First(ctx); derr == nil && d != nil && d.Status == "DISABLED" {
return fmt.Errorf("库房接驳台 %s 已停用,拒绝派车(请恢复接驳台或人工配送)", dockStoreCode)
}
rows := make([]AgvSubmitRow, 0, len(items))
for _, it := range items {
rows = append(rows, AgvSubmitRow{RequestNo: deliveryNo, MaterialCode: it.MaterialCode,
MaterialName: it.MaterialName, Unit: it.Unit, Qty: it.Qty, TargetDock: targetDock})
}
s.checkSensorVsLedger(ctx, dockStoreCode, true, deliveryNo)
taskNo, err := s.dispatchAgvSegment(ctx, agvSegInput{
Kind: "GO_LOAD", BizType: "CALL", BizNo: deliveryNo,
Source: "", Target: dockStoreCode,
Materials: rows, Operator: operator,
})
if err != nil {
return err
}
s.ctx.EventLog.Write(ctx, "delivery.dispatch", "", operator, "delivery_order", deliveryNo,
fmt.Sprintf("配送单 %s 派车成功(AGV 任务 %s,目标 %s)", deliveryNo, taskNo, targetDock), nil)
return nil
}
// StationMaterialDetailRow 工位物料明细行(工艺物料全集 左连接 工位账四数)
type StationMaterialDetailRow struct {
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Spec string `json:"spec"`
Unit string `json:"unit"`
SnMode int `json:"snMode"`
FlowName string `json:"flowName"`
ReqQty int `json:"reqQty"`
AdjQty int `json:"adjQty"`
SentQty int `json:"sentQty"`
AvailQty int `json:"availQty"`
}
// StationMaterialDetail 工位物料明细(2026-11-05 拍板:比叫料列表更突出,量为0也显示、
// 不分左右托盘):工艺全集 = 活跃工单(下发/进行/暂停)组合中绑定本工位的工艺;
// 池(工位×物料)为记账层,两层并存。
func (s *Service) StationMaterialDetail(ctx context.Context, stationNo int) ([]StationMaterialDetailRow, error) {
flowIds := map[int]bool{}
wos, _ := s.ctx.EntClient.WorkOrder.Query().
Where(workorder.StatusIn("RELEASED", "IN_PROGRESS", "PAUSED")).All(ctx)
for _, wo := range wos {
items, err := RouteStationsFromWO(ctx, s.ctx.EntClient, wo)
if err != nil {
continue
}
for _, it := range items {
if it.StationNo == stationNo {
flowIds[it.FlowId] = true
}
}
}
poolRows, _ := s.ctx.EntClient.CallPool.Query().Where(callpool.StationNo(stationNo)).All(ctx)
poolBy := map[string]*ent.CallPool{}
for _, r := range poolRows {
poolBy[r.MaterialCode] = r
}
out := []StationMaterialDetailRow{}
seen := map[string]bool{}
fidList := make([]int, 0, len(flowIds))
for fid := range flowIds {
fidList = append(fidList, fid)
}
sort.Ints(fidList)
for _, fid := range fidList {
fms, _ := s.ctx.EntClient.FlowMaterial.Query().Where(flowmaterial.FlowId(fid)).All(ctx)
for _, fm := range fms {
if fm.MaterialCode == "" || seen[fm.MaterialCode] {
continue
}
seen[fm.MaterialCode] = true
row := StationMaterialDetailRow{MaterialCode: fm.MaterialCode, MaterialName: fm.MaterialName,
Spec: fm.Spec, Unit: fm.Unit, SnMode: fm.SnMode, FlowName: s.flowNameById(ctx, fid)}
if r := poolBy[fm.MaterialCode]; r != nil {
row.ReqQty = r.ReqQty
row.AdjQty = r.AdjQty
row.SentQty = r.SentQty
row.AvailQty = poolAvail(r.ReqQty, r.AdjQty, r.SentQty, r.ReservedQty)
}
out = append(out, row)
}
}
// 有在途/占用但活跃工艺已不再覆盖的物料也补出(池有、工艺无:显示为「—」工艺)
keys := make([]string, 0, len(poolBy))
for k := range poolBy {
keys = append(keys, k)
}
sort.Strings(keys)
for _, mc := range keys {
if seen[mc] {
continue
}
seen[mc] = true
r := poolBy[mc]
row := StationMaterialDetailRow{MaterialCode: mc, MaterialName: r.MaterialName,
Unit: r.Unit, SnMode: r.SnMode, FlowName: "—"}
row.ReqQty = r.ReqQty
row.AdjQty = r.AdjQty
row.SentQty = r.SentQty
row.AvailQty = poolAvail(r.ReqQty, r.AdjQty, r.SentQty, r.ReservedQty)
out = append(out, row)
}
return out, nil
}