Files
bj_power/bj_power_mes/internal/logic/call_plan.go
T
SunYF 1d1dc1bdd8 按模块说明
一、MES — 叫料单扩展(schema + 逻辑)​

material_request 新增字段:packageNo(叫料包号,一次提交=一包)、callDate(叫料日,默认当天)、planBreakdown(jsonb,工单×排产日明细 []CallPlanBreakdown);targetDock 语义降级为"期望接驳台(可空,配送时 WMS 确定实际台)"。
新增 internal/logic/call_plan.go:实时计算「叫料需求明细(工单×排产日×物料)」,派生两类提示(当日剩余未叫 / 跨日量明细),不落库、不拦提交;接驳台空台校验 EnsureStationDocksEmpty、托盘回库 DispatchPalletReturnManual、人工清台 ClearDockLedger、配送单派车 DispatchDeliveryAgv、工位物料明细 StationMaterialDetail。
新增 internal/handler/production/call_pkg.go:8 个 MES 内部端点(X-API-TOKEN 网关),供 WMS 调用——叫料需求明细、按包查单、接驳台状态、托盘回库、人工清台、配送单派车、叫料池原始行、工位物料明细、WMS 代叫料。
internal/handler/production/call.go、internal/logic/call.go、agv.go、qty_report.go、routes_production.go、wmsclient/client.go、db.go 同步接入上述逻辑。
二、WMS — 配送单(新功能,叫料与送料彻底拆开)​

新增 schema/delivery_order.go + delivery_order_item.go 及 ent 生成代码:delivery_order(PENDING→DISPATCHED→DONE / CANCELLED,一单=一次托盘配送)、delivery_order_item(配送物料明细快照:工单/工艺/排产日)。
新增 internal/handler/delivery.go + 路由 + DeliveryOrders.vue 页面(仓储作业 → 配送单)。
mesclient/client.go 扩展:MES 叫料单结构补 packageNo/callDate/workOrderNo/planBreakdown,新增 PoolRow/DockPalletState/DeliveryAgvItem/getJSON 等。
CallQueue.vue:按叫料包展示,新增「代叫料」「建配送单」按钮与对话框;出库单回写所属配送单号(outbound_order 加字段);AGV 派送改由配送单驱动。
三、工位终端 — 叫料体验升级

MaterialPanel.vue:新增「本工位物料明细」卡(工艺物料全集×工位账四数,量为 0 也显示);叫料改为「叫料包」模式(默认当天、可勾选分批、可选其他排产日、期望接驳台可空),新增叫料日选择器、两条提示横幅(当日剩余未叫 / 跨日量明细)、托盘回库按钮。
InspectPanel.vue/Main.vue/OnlinePanel.vue/OfflinePanel.vue/WorkPanel.vue/SyncQueueDialog.vue/api/index.js/internal/handler/line.go/routes.go 同步接入接驳台状态、托盘回库、下班双台空台校验等。
web/static/index.html 构建刷新。
四、文档

案例.md:重写第 5/6/8/9 节与新「配送单」流程,补「模拟模式跳过接驳台校验」说明,库管员菜单加「配送单」;并修正"本单箱体"等措辞歧义。
客户问题.md:同步本轮拍板口径。
五、构建产物 / 同步

多个 MES 前端页面(.vue)随本次改动统一重新构建刷新;ent 生成代码(MES material_request、WMS delivery_order/outbound_order 相关)随 schema 更新重新生成。
2026-11-05 19:18:18 +08:00

487 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 := map[int][]*ent.FlowMaterial{}
for _, it := range items {
if _, done := fmByFlow[it.FlowId]; done {
continue
}
fms, ferr := s.ctx.EntClient.FlowMaterial.Query().
Where(flowmaterial.FlowId(it.FlowId)).All(ctx)
if ferr != nil {
continue
}
fmByFlow[it.FlowId] = fms
}
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
}