按模块说明

一、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 更新重新生成。
This commit is contained in:
SunYF
2026-11-05 19:18:18 +08:00
parent 46fcb59079
commit 1d1dc1bdd8
102 changed files with 12953 additions and 379 deletions
+4 -1
View File
@@ -133,6 +133,7 @@ func callCompleteHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
picks := make([]pick, 0, 4)
remain := need
totalAvail := 0
for _, inv := range rows {
if remain <= 0 {
break
@@ -151,16 +152,18 @@ func callCompleteHandler(ctx *svc.ServiceContext) http.HandlerFunc {
continue
}
picks = append(picks, pick{sn: inv.SnCode, take: 1})
totalAvail++
remain--
continue
}
if inv.SnMode == snModeBatch {
picks = append(picks, pick{batchNo: inv.BatchNo, take: take})
totalAvail += avail
remain -= take
}
}
if len(picks) == 0 {
fail(w, http.StatusConflict, "WMS 无可用合格库存(在库/合格),无法完成备料")
fail(w, http.StatusConflict, "缺料无法完成备料:物料「"+call.MaterialName+"("+call.MaterialCode+")」工位 "+strconv.Itoa(call.StationNo)+" 请求量 "+itoa(need)+",合格可用量 "+itoa(totalAvail)+",请先补入库或走补料审批")
return
}
+487
View File
@@ -0,0 +1,487 @@
package handler
// ============ 配送单(2026-11-05 拍板:叫料与送料彻底拆开) ============
// 一个叫料包(package_no)可拆多张配送单;一单=一次托盘配送(接驳台左右手必选且只能选空台:
// 传感器+台账,不一致拒选)。配送单必有配送详情(物料、各多少、工位、工艺、日排产)——
// 创建时从叫料单 plan_breakdown 快照落 delivery_order_item。
// 状态机:PENDING 待配送 →(派车)DISPATCHED 配送中 →(卸货放行回写)DONE 已送达;CANCELLED 已取消。
// WMS 代叫料与工位终端同一套逻辑(转发 MES CreateCallOrders)。
import (
"context"
"fmt"
"net/http"
"strconv"
"strings"
"time"
"bj_power_wms/ent"
"bj_power_wms/ent/deliveryorder"
"bj_power_wms/ent/deliveryorderitem"
"bj_power_wms/ent/outboundorder"
"bj_power_wms/internal/mesclient"
"bj_power_wms/internal/svc"
)
// fmtErr 安全取错误文本(err 可能为 nil)
func fmtErr(err error) string {
if err == nil {
return ""
}
return err.Error()
}
func deliveryNoNew() string { return fmt.Sprintf("DL%d", time.Now().UnixNano()) }
// deliveryItemsRemaining 汇总每张叫料单已配送量(排除已取消的配送单)
func deliveryItemsRemaining(ctx *svc.ServiceContext, reqCtx context.Context, requestNos []string) map[string]float64 {
used := map[string]float64{}
if len(requestNos) == 0 {
return used
}
items, err := ctx.EntClient.DeliveryOrderItem.Query().
Where(deliveryorderitem.RequestNoIn(requestNos...)).All(reqCtx)
if err != nil {
return used
}
statusByDelivery := map[string]string{}
for _, it := range items {
st, ok := statusByDelivery[it.DeliveryNo]
if !ok {
o, e := ctx.EntClient.DeliveryOrder.Query().
Where(deliveryorder.DeliveryNoEQ(it.DeliveryNo)).First(reqCtx)
if e != nil || o == nil {
continue
}
st = o.Status
statusByDelivery[it.DeliveryNo] = st
}
if st == "CANCELLED" {
continue
}
used[it.RequestNo] += it.Qty
}
return used
}
// deliveryPackageHandler GET /api/delivery/package?packageNo=
// 按包查可配送明细(默认勾选全部未送完物料行):叫料单 + 已配送量 + 剩余可送量。
func deliveryPackageHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if ctx.Mes == nil {
fail(w, http.StatusInternalServerError, "MES 未配置")
return
}
pkg := strings.TrimSpace(r.URL.Query().Get("packageNo"))
if pkg == "" {
fail(w, http.StatusBadRequest, "缺少包号")
return
}
mrs, err := ctx.Mes.ListMaterialRequestsByPackage(r.Context(), pkg)
if err != nil {
fail(w, http.StatusBadGateway, "拉取叫料包失败: "+err.Error())
return
}
nos := make([]string, 0, len(mrs))
for _, m := range mrs {
nos = append(nos, m.RequestNo)
}
used := deliveryItemsRemaining(ctx, r.Context(), nos)
rows := make([]map[string]any, 0, len(mrs))
for _, m := range mrs {
if m.Status != "SHIPPED" || m.SentQty <= 0 {
continue // 仅已发货(备料完成)的可配送
}
delivered := used[m.RequestNo]
remain := m.SentQty - delivered
rows = append(rows, map[string]any{
"requestNo": m.RequestNo, "materialCode": m.MaterialCode,
"materialName": m.MaterialName, "unit": m.Unit, "snMode": m.SnMode,
"stationNo": m.StationNo, "sentQty": m.SentQty, "delivered": delivered,
"remainQty": remain, "outboundNo": m.OutboundNo,
"expectedDock": m.TargetDock, "callDate": m.CallDate,
})
}
ok(w, map[string]any{"packageNo": pkg, "rows": rows})
}
}
// deliveryCreateHandler POST /api/delivery/create
// body: {packageNo, targetDock, operator, remark, items:[{requestNo, qty}]}
// 校验:接驳台属于该工位且为空(传感器为准,台账不一致拒选);量 ≤ 剩余可送量。
func deliveryCreateHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if ctx.Mes == nil {
fail(w, http.StatusInternalServerError, "MES 未配置")
return
}
var req struct {
PackageNo string `json:"packageNo"`
TargetDock string `json:"targetDock"`
Operator string `json:"operator"`
Remark string `json:"remark"`
Items []struct {
RequestNo string `json:"requestNo"`
Qty float64 `json:"qty"`
} `json:"items"`
}
if err := parseJSON(r, &req); err != nil || strings.TrimSpace(req.PackageNo) == "" ||
strings.TrimSpace(req.TargetDock) == "" || len(req.Items) == 0 {
fail(w, http.StatusBadRequest, "包号、配送接驳台与配送明细必填")
return
}
mrs, err := ctx.Mes.ListMaterialRequestsByPackage(r.Context(), req.PackageNo)
if err != nil || len(mrs) == 0 {
fail(w, http.StatusBadGateway, "拉取叫料包失败: "+fmtErr(err))
return
}
stationNo := mrs[0].StationNo
mrBy := map[string]mesclient.MaterialRequest{}
for _, m := range mrs {
mrBy[m.RequestNo] = m
}
// 接驳台校验:属于该工位、启用、传感器+台账均为空(左右手必选,只能选空台)
docks, derr := ctx.Mes.StationDockPallets(r.Context(), stationNo)
if derr != nil {
fail(w, http.StatusBadGateway, "读取接驳台状态失败: "+fmtErr(derr))
return
}
dockOK := false
for _, d := range docks {
if d.DockCode != req.TargetDock {
continue
}
dockOK = true
if d.PlcOk && d.HasPallet {
fail(w, http.StatusConflict, "接驳台 "+req.TargetDock+"("+d.Name+")传感器显示有托盘,只能配送至空台")
return
}
if !d.PlcOk && d.LedgerPallet {
fail(w, http.StatusConflict, "接驳台 "+req.TargetDock+"("+d.Name+")台账有托盘且 PLC 离线无法核实,请先现场核实或人工清台")
return
}
}
if !dockOK {
fail(w, http.StatusBadRequest, "接驳台 "+req.TargetDock+" 不属于工位"+fmt.Sprint(stationNo)+"或已停用,请重选")
return
}
// 剩余可送量校验
nos := make([]string, 0, len(req.Items))
for _, it := range req.Items {
nos = append(nos, it.RequestNo)
}
used := deliveryItemsRemaining(ctx, r.Context(), nos)
for _, it := range req.Items {
m, mop := mrBy[it.RequestNo]
if !mop {
fail(w, http.StatusBadRequest, "叫料单 "+it.RequestNo+" 不在该包内")
return
}
if it.Qty <= 0 {
fail(w, http.StatusBadRequest, "配送数量必须大于 0("+m.MaterialCode+")")
return
}
remain := m.SentQty - used[it.RequestNo]
if it.Qty > remain {
fail(w, http.StatusBadRequest, fmt.Sprintf("%s 剩余可送 %v,本次配送 %v 超出", m.MaterialCode, remain, it.Qty))
return
}
}
// 建单 + 明细快照(物料×量×工位×工单×工艺×排产日)
tx, terr := ctx.EntClient.Tx(r.Context())
if terr != nil {
fail(w, http.StatusInternalServerError, terr.Error())
return
}
committed := false
defer func() {
if !committed {
_ = tx.Rollback()
}
}()
dNo := deliveryNoNew()
if _, cerr := tx.DeliveryOrder.Create().
SetDeliveryNo(dNo).SetPackageNo(req.PackageNo).SetStationNo(stationNo).
SetTargetDock(req.TargetDock).SetStatus("PENDING").
SetOperator(req.Operator).SetRemark(req.Remark).Save(r.Context()); cerr != nil {
fail(w, http.StatusInternalServerError, "创建配送单失败: "+cerr.Error())
return
}
for _, it := range req.Items {
m := mrBy[it.RequestNo]
orderNo, flowName, planDate := "", "", m.CallDate
if len(m.PlanBreakdown) > 0 {
orderNo = m.PlanBreakdown[0].OrderNo
flowName = m.PlanBreakdown[0].FlowName
planDate = m.PlanBreakdown[0].PlanDate
} else if m.WorkOrderNo != "" {
orderNo = m.WorkOrderNo
}
if _, cerr := tx.DeliveryOrderItem.Create().
SetDeliveryNo(dNo).SetRequestNo(m.RequestNo).
SetMaterialCode(m.MaterialCode).SetMaterialName(m.MaterialName).
SetUnit(m.Unit).SetQty(it.Qty).SetStationNo(m.StationNo).
SetOrderNo(orderNo).SetFlowName(flowName).SetPlanDate(planDate).
SetSnMode(m.SnMode).Save(r.Context()); cerr != nil {
fail(w, http.StatusInternalServerError, "写配送明细失败: "+cerr.Error())
return
}
// 出库单回写配送单号(配送历史可追溯;多出库单逗号分隔逐一回写)
for _, ob := range strings.Split(m.OutboundNo, ",") {
if ob = strings.TrimSpace(ob); ob != "" {
_, _ = tx.OutboundOrder.Update().
Where(outboundorder.OutboundNoEQ(ob)).
SetDeliveryNo(dNo).Save(r.Context())
}
}
}
if cerr := tx.Commit(); cerr != nil {
fail(w, http.StatusInternalServerError, cerr.Error())
return
}
committed = true
ok(w, map[string]any{"deliveryNo": dNo})
}
}
// deliveryListHandler GET /api/delivery/list 配送列表/历史(可按日期/工位/包号/状态筛选)
func deliveryListHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
q := ctx.EntClient.DeliveryOrder.Query().Order(ent.Desc(deliveryorder.FieldCreatedAt))
if v := strings.TrimSpace(r.URL.Query().Get("status")); v != "" {
q = q.Where(deliveryorder.StatusEQ(v))
}
if v := strings.TrimSpace(r.URL.Query().Get("packageNo")); v != "" {
q = q.Where(deliveryorder.PackageNoEQ(v))
}
if v, e := strconv.Atoi(r.URL.Query().Get("stationNo")); e == nil && v > 0 {
q = q.Where(deliveryorder.StationNoEQ(v))
}
orders, err := q.All(r.Context())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
// 物料种数/总件数
type row struct {
*ent.DeliveryOrder
Kinds int `json:"kinds"`
TotalQty float64 `json:"totalQty"`
CreatedAt int64 `json:"createdAt"`
}
out := make([]row, 0, len(orders))
for _, o := range orders {
items, _ := ctx.EntClient.DeliveryOrderItem.Query().
Where(deliveryorderitem.DeliveryNoEQ(o.DeliveryNo)).All(r.Context())
kinds, total := len(items), 0.0
for _, it := range items {
total += it.Qty
}
out = append(out, row{DeliveryOrder: o, Kinds: kinds, TotalQty: total, CreatedAt: o.CreatedAt.Unix()})
}
ok(w, map[string]any{"total": len(out), "list": out})
}
}
// deliveryDetailHandler GET /api/delivery/detail?deliveryNo=
// 配送详情:单头 + item 明细(物料×量×工位×工单×工艺×排产日)+ 关联出库单号。
func deliveryDetailHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
dNo := strings.TrimSpace(r.URL.Query().Get("deliveryNo"))
if dNo == "" {
fail(w, http.StatusBadRequest, "缺少配送单号")
return
}
o, err := ctx.EntClient.DeliveryOrder.Query().
Where(deliveryorder.DeliveryNoEQ(dNo)).First(r.Context())
if err != nil {
fail(w, http.StatusNotFound, "配送单不存在")
return
}
items, _ := ctx.EntClient.DeliveryOrderItem.Query().
Where(deliveryorderitem.DeliveryNoEQ(dNo)).All(r.Context())
obs, _ := ctx.EntClient.OutboundOrder.Query().
Where(outboundorder.DeliveryNoEQ(dNo)).All(r.Context())
outNos := make([]string, 0, len(obs))
for _, ob := range obs {
outNos = append(outNos, ob.OutboundNo)
}
ok(w, map[string]any{"order": o, "items": items, "outboundNos": outNos})
}
}
// deliveryCancelHandler POST /api/delivery/cancel 仅待配送可取消
func deliveryCancelHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
DeliveryNo string `json:"deliveryNo"`
}
if err := parseJSON(r, &req); err != nil || req.DeliveryNo == "" {
fail(w, http.StatusBadRequest, "缺少配送单号")
return
}
o, err := ctx.EntClient.DeliveryOrder.Query().
Where(deliveryorder.DeliveryNoEQ(req.DeliveryNo)).First(r.Context())
if err != nil {
fail(w, http.StatusNotFound, "配送单不存在")
return
}
if o.Status != "PENDING" {
fail(w, http.StatusConflict, "仅待配送的配送单可取消")
return
}
if _, uerr := ctx.EntClient.DeliveryOrder.UpdateOneID(o.ID).SetStatus("CANCELLED").Save(r.Context()); uerr != nil {
fail(w, http.StatusInternalServerError, uerr.Error())
return
}
ok(w, nil)
}
}
// deliveryDispatchHandler POST /api/delivery/dispatch 派车(AGV 派车改配送单驱动)
func deliveryDispatchHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if ctx.Mes == nil {
fail(w, http.StatusInternalServerError, "MES 未配置,无法派车")
return
}
var req struct {
DeliveryNo string `json:"deliveryNo"`
Operator string `json:"operator"`
}
if err := parseJSON(r, &req); err != nil || req.DeliveryNo == "" {
fail(w, http.StatusBadRequest, "缺少配送单号")
return
}
o, err := ctx.EntClient.DeliveryOrder.Query().
Where(deliveryorder.DeliveryNoEQ(req.DeliveryNo)).First(r.Context())
if err != nil {
fail(w, http.StatusNotFound, "配送单不存在")
return
}
if o.Status != "PENDING" {
fail(w, http.StatusConflict, "仅待配送的配送单可派车")
return
}
if o.TargetDock == "" {
fail(w, http.StatusConflict, "配送单未选接驳台,请先编辑")
return
}
items, _ := ctx.EntClient.DeliveryOrderItem.Query().
Where(deliveryorderitem.DeliveryNoEQ(o.DeliveryNo)).All(r.Context())
if len(items) == 0 {
fail(w, http.StatusConflict, "配送单无明细")
return
}
rows := make([]mesclient.DeliveryAgvItem, 0, len(items))
for _, it := range items {
rows = append(rows, mesclient.DeliveryAgvItem{RequestNo: o.DeliveryNo,
MaterialCode: it.MaterialCode, MaterialName: it.MaterialName,
Unit: it.Unit, Qty: it.Qty})
}
if derr := ctx.Mes.DispatchDelivery(r.Context(), o.DeliveryNo, o.TargetDock, req.Operator, rows); derr != nil {
fail(w, http.StatusBadGateway, "MES 派车失败: "+fmtErr(derr))
return
}
if _, uerr := ctx.EntClient.DeliveryOrder.UpdateOneID(o.ID).SetStatus("DISPATCHED").Save(r.Context()); uerr != nil {
fail(w, http.StatusInternalServerError, uerr.Error())
return
}
ok(w, map[string]any{"message": "配送单已派车(空车前往装货点,到位待令后确认装车)"})
}
}
// deliveryDeliveredInternalHandler POST /api/internal/delivery/delivered(MES 卸货放行回写)
// 配送单 DISPATCHED → DONE;配送单不存在时忽略(兼容旧叫料单直派链路)。
func deliveryDeliveredInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
DeliveryNo string `json:"deliveryNo"`
}
if err := parseJSON(r, &req); err != nil || req.DeliveryNo == "" {
fail(w, http.StatusBadRequest, "缺少配送单号")
return
}
o, err := ctx.EntClient.DeliveryOrder.Query().
Where(deliveryorder.DeliveryNoEQ(req.DeliveryNo)).First(r.Context())
if err != nil || o == nil {
ok(w, nil) // 忽略:旧链路 BizNo=叫料单号
return
}
if o.Status == "DISPATCHED" {
_, _ = ctx.EntClient.DeliveryOrder.UpdateOneID(o.ID).SetStatus("DONE").Save(r.Context())
}
ok(w, nil)
}
}
// callCreateProxyHandler POST /api/call/create WMS 代叫料(与工位终端同一套逻辑)
func callCreateProxyHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if ctx.Mes == nil {
fail(w, http.StatusInternalServerError, "MES 未配置")
return
}
var req struct {
StationNo int `json:"stationNo"`
CallDate string `json:"callDate"`
Force bool `json:"force"`
Operator string `json:"operator"`
Items []map[string]any `json:"items"`
}
if err := parseJSON(r, &req); err != nil || req.StationNo <= 0 || len(req.Items) == 0 {
fail(w, http.StatusBadRequest, "工位号与叫料明细必填")
return
}
if err := ctx.Mes.CreateCall(r.Context(), req.StationNo, req.CallDate, req.Force, req.Items, req.Operator); err != nil {
fail(w, http.StatusBadGateway, "MES 叫料失败: "+fmtErr(err))
return
}
ok(w, map[string]any{"message": "代叫料已提交(与工位终端同一套叫料包逻辑)"})
}
}
// callPoolRawProxyHandler GET /api/call/pool-raw?stationNo= 代叫料对话框池行数据源
func callPoolRawProxyHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if ctx.Mes == nil {
fail(w, http.StatusInternalServerError, "MES 未配置")
return
}
n, e := strconv.Atoi(r.URL.Query().Get("stationNo"))
if e != nil || n <= 0 {
fail(w, http.StatusBadRequest, "缺少工位号")
return
}
rows, err := ctx.Mes.StationPoolRaw(r.Context(), n)
if err != nil {
fail(w, http.StatusBadGateway, "拉取叫料池失败: "+fmtErr(err))
return
}
ok(w, map[string]any{"rows": rows})
}
}
// palletClearHandler POST /api/pallet/clear 人工清台(台账卡死兜底;仅清台账不碰账)
func palletClearHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if ctx.Mes == nil {
fail(w, http.StatusInternalServerError, "MES 未配置")
return
}
var req struct {
DockCode string `json:"dockCode"`
Operator string `json:"operator"`
Reason string `json:"reason"`
}
if err := parseJSON(r, &req); err != nil || req.DockCode == "" {
fail(w, http.StatusBadRequest, "缺少接驳台编码")
return
}
if err := ctx.Mes.DockClear(r.Context(), req.DockCode, req.Operator, req.Reason); err != nil {
fail(w, http.StatusBadGateway, "MES 清台失败: "+fmtErr(err))
return
}
ok(w, map[string]any{"message": "已清台(台账置无托盘;物料账与库存不变)"})
}
}
+43 -2
View File
@@ -308,6 +308,20 @@ func internalDisplayCallsHandler(ctx *svc.ServiceContext) http.HandlerFunc {
"SHIPPED": "配送中",
"DONE": "已送达",
}
// 2026-11-05 叫料包拍板:同一叫料包(package_no)在大屏聚合为一行——
// 名称=首物料+“等N种”,数量=包内请求量合计;状态取包内最落后进度
//(PENDING > SHIPPED > DONE);无包号(存量单)逐单展示,兼容不变。
type pkgAgg struct {
time string
stationNo int
material string
qty float64
kinds int
rank int
}
rankOf := map[string]int{"PENDING": 0, "SHIPPED": 1, "DONE": 2}
pkgs := map[string]*pkgAgg{}
order := []string{} // 保持 MES 排序(created desc)
for _, m := range list { // MES 已按 created_at desc, id desc 排序(logic/call.go:743)
label, ok2 := keep[m.Status]
if !ok2 {
@@ -323,9 +337,36 @@ func internalDisplayCallsHandler(ctx *svc.ServiceContext) http.HandlerFunc {
if mat == "" {
mat = m.MaterialCode
}
if m.PackageNo == "" {
calls = append(calls, map[string]any{
"time": t, "stationNo": m.StationNo, "material": mat,
"qty": m.ReqQty, "status": label, "statusKey": m.Status,
})
continue
}
pg := pkgs[m.PackageNo]
if pg == nil {
pg = &pkgAgg{time: t, stationNo: m.StationNo, material: mat, rank: 0}
pkgs[m.PackageNo] = pg
order = append(order, m.PackageNo)
}
pg.qty += m.ReqQty
pg.kinds++
if rankOf[m.Status] > pg.rank {
pg.rank = rankOf[m.Status]
}
}
statusKeys := []string{"PENDING", "SHIPPED", "DONE"}
for _, pkgNo := range order {
pg := pkgs[pkgNo]
mat := pg.material
if pg.kinds > 1 {
mat = fmt.Sprintf("%s 等%d种", mat, pg.kinds)
}
sk := statusKeys[pg.rank]
calls = append(calls, map[string]any{
"time": t, "stationNo": m.StationNo, "material": mat,
"qty": m.ReqQty, "status": label, "statusKey": m.Status,
"time": pg.time, "stationNo": pg.stationNo, "material": mat,
"qty": pg.qty, "status": keep[sk], "statusKey": sk,
})
if len(calls) >= 30 {
break
+1 -1
View File
@@ -336,7 +336,7 @@ func makeOutboundHandler(ctx *svc.ServiceContext, outboundType string) http.Hand
}
avail := b.Quantity - b.LockedQty
if avail < actualQty {
fail(w, http.StatusConflict, "批次库存不足: "+req.BatchNo+" 可用 "+itoa(avail))
fail(w, http.StatusConflict, "批次库存不足: 物料「"+m.Name+"("+req.MaterialCode+")」批次 "+req.BatchNo+" 需要 "+itoa(actualQty)+",可用 "+itoa(avail))
return
}
aff, err := tx.Inventory.Update().
+14
View File
@@ -114,6 +114,18 @@ func RegisterHandlers(server *rest.Server, ctx *svc.ServiceContext) {
{Method: http.MethodGet, Path: "/api/pallet/residual", Handler: palletResidualHandler(ctx)},
// JBT21 空位查询(2026-11-04 定稿 Q5:无空位派 AGV 回收按钮禁用并提示;只读转发 MES)
{Method: http.MethodGet, Path: "/api/pallet/jbt21-free", Handler: Jbt21FreeHandler(ctx)},
// 人工清台(2026-11-05 兜底:托盘被人工卸走后台账卡死;仅清台账不碰账)
{Method: http.MethodPost, Path: "/api/pallet/clear", Handler: requirePerm(ctx, "call:manage", palletClearHandler(ctx))},
// 配送单(2026-11-05 拍板:叫料与送料拆开——一包可拆多张配送单,一单=一次托盘配送)
{Method: http.MethodGet, Path: "/api/delivery/list", Handler: requirePerm(ctx, "call:view", deliveryListHandler(ctx))},
{Method: http.MethodGet, Path: "/api/delivery/detail", Handler: requirePerm(ctx, "call:view", deliveryDetailHandler(ctx))},
{Method: http.MethodGet, Path: "/api/delivery/package", Handler: requirePerm(ctx, "call:view", deliveryPackageHandler(ctx))},
{Method: http.MethodPost, Path: "/api/delivery/create", Handler: requirePerm(ctx, "call:manage", deliveryCreateHandler(ctx))},
{Method: http.MethodPost, Path: "/api/delivery/cancel", Handler: requirePerm(ctx, "call:manage", deliveryCancelHandler(ctx))},
{Method: http.MethodPost, Path: "/api/delivery/dispatch", Handler: requirePerm(ctx, "call:manage", deliveryDispatchHandler(ctx))},
// WMS 代叫料(2026-11-05 拍板:与工位终端同一套叫料包逻辑)
{Method: http.MethodPost, Path: "/api/call/create", Handler: requirePerm(ctx, "call:manage", callCreateProxyHandler(ctx))},
{Method: http.MethodGet, Path: "/api/call/pool-raw", Handler: requirePerm(ctx, "call:view", callPoolRawProxyHandler(ctx))},
},
)
@@ -358,6 +370,8 @@ func RegisterHandlers(server *rest.Server, ctx *svc.ServiceContext) {
{Method: http.MethodPost, Path: "/api/internal/inventory/dispose", Handler: wrapInternal(ctx)(internalInventoryDisposeHandler(ctx))},
// AGV 到位回写(MES AGV 回调调用):出库单 已出库 → 已送达(补齐状态机无写者的断头路)
{Method: http.MethodPost, Path: "/api/internal/outbound/delivered", Handler: wrapInternal(ctx)(markOutboundDeliveredHandler(ctx))},
// 配送单送达回写(2026-11-05 拍板:AGV 卸货放行后 MES 回写;配送单不存在时忽略,兼容旧链路)
{Method: http.MethodPost, Path: "/api/internal/delivery/delivered", Handler: wrapInternal(ctx)(deliveryDeliveredInternalHandler(ctx))},
},
)
}