Files
SunYF af554cea75 feat: 同步失败台账双向可重试 + 拧紧枪按工位配置 + 虚拟工位体系 + 去Redis与文档口径对齐
- 同步失败台账:MES/WMS 双端新增台账与页面,跨系统通知失败落台账、人工重试或标记已处理,不自动重传;重试前先判对端终态;叫料、配送、出库回写失败提示指向台账;补幂等建表脚本与菜单权限。
- 拧紧枪:新增按工位配置页,展示控制器地址与三把枪通道号(仅供查看,不参与采集校验);「允许手填」由全局开关改为每工位开关,关闭时校验该工位已配控制器;终端启动/登录上报配置并按本工位拉取,扭矩手填框按本工位置灰;补全局值迁移到各工位的脚本。
- 工位体系:终端未配置工位号时登录页可选(含虚拟工位),固定工位模式保留;虚拟/线下位不叫料、不退料、不作转产目标,未采集绑定放行并说明原因;叫料期望接驳台改为选填。
- AGV与出库:补「出库单已送达」回写;空车回充、接驳台传感器失联、配送状态更新失败均落预警或留痕并提示人工核对;人工出库不引入送达状态;出库单支持目标工位/接驳台并扩展导出列。
- 基础设施:看板缓存由Redis改为MES进程内实现,文档与启动脚本同步去Redis;扫码监听支持多地址、端口被占自动降级;PLC对账与工位报警在MES不可达时降级放行并留日志。
- 文档与帮助:案例与部署手册按实测订正(工位绑定、菜单名称、补料由班组长代提、菜单覆盖对照、虚拟工位);迁移脚本改为本地即时执行并登记7个已执行脚本;三端页面帮助改为「业务/操作/影响范围/后果」四要素。
- 测试:新增独立Go模块,按三个业务场景做真实HTTP与真实写库的流水测试,含运行报告。
2026-11-09 18:58:47 +08:00

574 lines
22 KiB
Go
Raw Permalink 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 != "" {
if _, uerr := tx.OutboundOrder.Update().
Where(outboundorder.OutboundNoEQ(ob)).
SetDeliveryNo(dNo).Save(r.Context()); uerr != nil {
// 2026-11-08:本地写失败必须留痕(不回滚配送单,靠 Bug1 兜底反查路径补齐)
ctx.EventLog.Write(ctx0(), "delivery.outbound_link_failed", req.Operator,
"outbound_order", ob,
"配送单 "+dNo+" 关联出库单回写失败(已留痕,靠叫料单号兜底反查): "+uerr.Error(), nil)
}
}
}
}
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 {
// B11(2026-11-09):MES 已派车成功,本地置 DISPATCHED 失败 → 单据状态不一致。
// 不再只回 5xx 无留痕:落 event_log 供人工核对(MES 侧 AGV 任务已在途,无法简单反向撤销)。
ctx.EventLog.Write(ctx0(), "delivery.dispatch_status_failed", req.Operator, "delivery_order", o.DeliveryNo,
"MES 派车成功但配送单置 DISPATCHED 失败:"+uerr.Error()+"(MES 侧 AGV 任务已在途,请人工核对单据状态)", nil)
fail(w, http.StatusInternalServerError, "MES 派车成功,但配送单状态更新失败: "+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" {
if _, uerr := ctx.EntClient.DeliveryOrder.UpdateOneID(o.ID).SetStatus("DONE").Save(r.Context()); uerr != nil {
// 本地 DB 写失败(2026-11-08):不再静默吞错,返回 5xx 让调用方感知。
// 按「本地写失败」归类,只落 event_log 留痕,不进同步失败台账。
ctx.EventLog.Write(ctx0(), "delivery.done_update_failed", "AGV", "delivery_order", req.DeliveryNo,
"配送单 "+req.DeliveryNo+" 置 DONE 失败:"+uerr.Error()+"(请人工核对状态)", nil)
fail(w, http.StatusInternalServerError, "配送单置 DONE 失败: "+uerr.Error())
return
}
}
// Bug1(2026-11-08):配送单到位的同时把关联出库单置「已送达」。
// 主路径按出库单 delivery_no 精确匹配(建配送单时已回写);查不到时兜底走
// delivery_order_item.requestNo → remark="叫料单 "+requestNo 精确等值。
// 全在 WMS 库内闭环,条件更新保证重复调用幂等(已送达/已作废自动跳过)。
delivered, derr := markOutboundDelivered(r.Context(), ctx.EntClient, strings.TrimSpace(req.DeliveryNo))
if derr != nil {
fail(w, http.StatusInternalServerError, "出库单已送达回写失败: "+derr.Error())
return
}
if delivered > 0 {
ctx.EventLog.Write(ctx0(), "outbound.delivered", "AGV", "outbound", req.DeliveryNo,
"配送单 "+req.DeliveryNo+" 到位,关联出库单已回写「已送达」,共 "+strconv.Itoa(delivered)+" 张", nil)
}
ok(w, map[string]any{"delivered": delivered})
}
}
// markOutboundDelivered 按配送单号回写关联出库单「已送达」(2026-11-08 Bug1 修复)。
// 主路径:delivery_no 精确匹配;兜底(路径A):配送明细的叫料单号 → 出库单 remark 精确等值。
func markOutboundDelivered(ctx context.Context, client *ent.Client, deliveryNo string) (int, error) {
delivered, err := client.OutboundOrder.Update().
Where(outboundorder.DeliveryNoEQ(deliveryNo),
outboundorder.StatusEQ("已出库"), outboundorder.VoidedEQ(false)).
SetStatus("已送达").Save(ctx)
if err != nil {
return 0, err
}
if delivered > 0 {
return delivered, nil
}
items, err := client.DeliveryOrderItem.Query().
Where(deliveryorderitem.DeliveryNoEQ(deliveryNo)).All(ctx)
if err != nil {
return 0, err
}
total := 0
seen := map[string]bool{}
for _, it := range items {
rn := strings.TrimSpace(it.RequestNo)
if rn == "" || seen[rn] {
continue
}
seen[rn] = true
n, err := client.OutboundOrder.Update().
Where(outboundorder.RemarkEQ("叫料单 "+rn),
outboundorder.StatusEQ("已出库"), outboundorder.VoidedEQ(false)).
SetStatus("已送达").Save(ctx)
if err != nil {
return total, err
}
total += n
}
return total, nil
}
// deliveryStatusInternalHandler GET /api/internal/delivery/status?no=(MES 到位自动放行双重确认查询)
// 返回配送单当前状态(PENDING/DISPATCHED/DONE/CANCELLED);单不存在返回空串(兼容旧叫料单直派链路)。
func deliveryStatusInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
no := r.URL.Query().Get("no")
if no == "" {
fail(w, http.StatusBadRequest, "缺少配送单号")
return
}
o, err := ctx.EntClient.DeliveryOrder.Query().
Where(deliveryorder.DeliveryNoEQ(no)).First(r.Context())
if err != nil || o == nil {
ok(w, map[string]any{"status": ""}) // 旧链路 BizNo=叫料单号:无配送单,空状态
return
}
ok(w, map[string]any{"status": o.Status})
}
}
// 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": "已清台(台账置无托盘;物料账与库存不变)"})
}
}