Files
bj_power/bj_power_wms/internal/handler/delivery.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

488 lines
17 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 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": "已清台(台账置无托盘;物料账与库存不变)"})
}
}