feat: 同步失败台账双向可重试 + 拧紧枪按工位配置 + 虚拟工位体系 + 去Redis与文档口径对齐

- 同步失败台账:MES/WMS 双端新增台账与页面,跨系统通知失败落台账、人工重试或标记已处理,不自动重传;重试前先判对端终态;叫料、配送、出库回写失败提示指向台账;补幂等建表脚本与菜单权限。
- 拧紧枪:新增按工位配置页,展示控制器地址与三把枪通道号(仅供查看,不参与采集校验);「允许手填」由全局开关改为每工位开关,关闭时校验该工位已配控制器;终端启动/登录上报配置并按本工位拉取,扭矩手填框按本工位置灰;补全局值迁移到各工位的脚本。
- 工位体系:终端未配置工位号时登录页可选(含虚拟工位),固定工位模式保留;虚拟/线下位不叫料、不退料、不作转产目标,未采集绑定放行并说明原因;叫料期望接驳台改为选填。
- AGV与出库:补「出库单已送达」回写;空车回充、接驳台传感器失联、配送状态更新失败均落预警或留痕并提示人工核对;人工出库不引入送达状态;出库单支持目标工位/接驳台并扩展导出列。
- 基础设施:看板缓存由Redis改为MES进程内实现,文档与启动脚本同步去Redis;扫码监听支持多地址、端口被占自动降级;PLC对账与工位报警在MES不可达时降级放行并留日志。
- 文档与帮助:案例与部署手册按实测订正(工位绑定、菜单名称、补料由班组长代提、菜单覆盖对照、虚拟工位);迁移脚本改为本地即时执行并登记7个已执行脚本;三端页面帮助改为「业务/操作/影响范围/后果」四要素。
- 测试:新增独立Go模块,按三个业务场景做真实HTTP与真实写库的流水测试,含运行报告。
This commit is contained in:
SunYF
2026-11-09 18:58:47 +08:00
parent 5e2640c13a
commit af554cea75
149 changed files with 35119 additions and 296 deletions
+4
View File
@@ -17,6 +17,10 @@ import (
// rawDB 持有底层 *sql.DB,供迁移期清理孤儿表(如已下线的 package_boxes)使用
var rawDB *sql.DB
// RawDB 返回启动期 MustNewDB 建立的底层连接池(只读共享,不额外建连接)。
// 供跨系统失败台账等轻量 raw SQL 场景使用;调用方须自行处理表不存在的错误。
func RawDB() *sql.DB { return rawDB }
// MustNewDB 创建 Ent 客户端并验证连接
func MustNewDB(c DatabaseConf) *ent.Client {
ec, err := NewDB(c)
+1 -1
View File
@@ -265,7 +265,7 @@ func scanNegativeStock(ctx *svc.ServiceContext) {
}
upsertAlert(ctx, ruleNegativeStock, "error",
"库存负数异常:"+name,
fmt.Sprintf("物料 %s(%s) 在 %s/%s 库存数量为 %.2f(负数),数据异常,请核对出入库流水并做盘点纠正",
fmt.Sprintf("物料 %s(%s) 在 %s/%s 库存数量为 %d(负数),数据异常,请核对出入库流水并做盘点纠正",
inv.MaterialCode, name, inv.ZoneCode, inv.ShelfNo, inv.Quantity),
target)
}
+46 -5
View File
@@ -11,8 +11,10 @@ import (
"bj_power_wms/ent"
"bj_power_wms/ent/inventory"
"bj_power_wms/ent/outboundorder"
"bj_power_wms/internal/mesclient"
"bj_power_wms/internal/svc"
"bj_power_wms/internal/syncfailure"
"github.com/zeromicro/go-zero/core/logx"
)
@@ -74,6 +76,38 @@ func callCompleteHandler(ctx *svc.ServiceContext) http.HandlerFunc {
if operator == "" {
operator = "warehouse"
}
// 幂等守卫(2026-11-08 Bug2):本单若已在 WMS 出过库,说明前一次「完成备料」的
// 出库已提交、只是通知 MES 失败。此处只重发通知,绝不重跑 doGeneralOutbound 造成重复出库。
// 判定完全基于 WMS 本地出库单 remark 精确等值,不依赖任何 MES 接口(MES 不可达时仍生效)。
prior, perr := ctx.EntClient.OutboundOrder.Query().
Where(outboundorder.RemarkEQ("叫料单 "+strings.TrimSpace(req.RequestNo)),
outboundorder.VoidedEQ(false)).All(r.Context())
if perr == nil && len(prior) > 0 {
priorSent := 0
priorNos := make([]string, 0, len(prior))
for _, ob := range prior {
priorSent += ob.Quantity
priorNos = append(priorNos, ob.OutboundNo)
}
priorJoined := strings.Join(priorNos, ",")
notify := map[string]any{
"requestNo": req.RequestNo, "sentQty": priorSent,
"outboundNo": priorJoined, "operator": operator,
}
if cerr := ctx.Mes.CallComplete(r.Context(), req.RequestNo, float64(priorSent), priorJoined, operator); cerr != nil {
syncfailure.Record(ctx.SQLDB, "WMS→MES", "call.complete", req.RequestNo,
"/api/internal/call/complete", notify, cerr.Error())
fail(w, http.StatusBadGateway, "已出库,通知MES失败,请在同步失败台账重试通知: "+cerr.Error())
return
}
ok(w, map[string]any{
"requestNo": req.RequestNo, "sentQty": priorSent, "reqQty": priorSent,
"outboundNos": priorJoined, "short": 0, "agvNote": "(已出库,仅重发通知)",
})
return
}
// 1. 取 MES 叫料单并校验状态
list, err := ctx.Mes.ListMaterialRequests(r.Context(), "PENDING")
if err != nil {
@@ -91,10 +125,11 @@ func callCompleteHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusNotFound, "叫料单不存在或已不是待备料状态(可能已被其他仓库处理)")
return
}
if call.TargetDock == "" {
fail(w, http.StatusBadRequest, "该叫料单未指定目标接驳台,不能配送")
return
}
// 2026-11-09 用户拍板 A(案例.md:100/108/565):期望接驳台是叫料时的
// 「非必填意向」,可留空;实际接驳台由库管在「建配送单」时选定(只能空台)。
// 本层是「完成备料」(叫料层),故允许 TargetDock 为空,不再硬拒。
// 配送单创建 / 派车的 TargetDock 必填仍保留在 delivery.go:128-131 与 :371-373:
// 叫料层可空 ≠ 配送单层可空,两层不得混淆。
need := int(call.ReqQty + 0.5)
if need <= 0 {
fail(w, http.StatusBadRequest, "叫料单请求量异常")
@@ -204,7 +239,13 @@ func callCompleteHandler(ctx *svc.ServiceContext) http.HandlerFunc {
joined := strings.Join(outboundNos, ",")
if cerr := ctx.Mes.CallComplete(r.Context(), call.RequestNo, float64(sentTotal), joined, operator); cerr != nil {
logx.Errorf("call complete notify MES failed: requestNo=%s err=%v", call.RequestNo, cerr)
fail(w, http.StatusBadGateway, "已出库(单号 "+joined+"),但通知 MES 失败,请重试「完成备料」: "+cerr.Error())
// 出库已提交,不回滚;落失败台账供人工重试(best-effort,写失败只打日志不阻断)
syncfailure.Record(ctx.SQLDB, "WMS→MES", "call.complete", call.RequestNo,
"/api/internal/call/complete", map[string]any{
"requestNo": call.RequestNo, "sentQty": sentTotal,
"outboundNo": joined, "operator": operator,
}, cerr.Error())
fail(w, http.StatusBadGateway, "已出库(单号 "+joined+"),通知MES失败,请在同步失败台账重试通知: "+cerr.Error())
return
}
+72 -5
View File
@@ -229,9 +229,14 @@ func deliveryCreateHandler(ctx *svc.ServiceContext) http.HandlerFunc {
// 出库单回写配送单号(配送历史可追溯;多出库单逗号分隔逐一回写)
for _, ob := range strings.Split(m.OutboundNo, ",") {
if ob = strings.TrimSpace(ob); ob != "" {
_, _ = tx.OutboundOrder.Update().
if _, uerr := tx.OutboundOrder.Update().
Where(outboundorder.OutboundNoEQ(ob)).
SetDeliveryNo(dNo).Save(r.Context())
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)
}
}
}
}
@@ -384,7 +389,11 @@ func deliveryDispatchHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return
}
if _, uerr := ctx.EntClient.DeliveryOrder.UpdateOneID(o.ID).SetStatus("DISPATCHED").Save(r.Context()); uerr != nil {
fail(w, http.StatusInternalServerError, uerr.Error())
// 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": "配送单已派车(空车前往装货点,到位待令后确认装车)"})
@@ -409,12 +418,70 @@ func deliveryDeliveredInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc
return
}
if o.Status == "DISPATCHED" {
_, _ = ctx.EntClient.DeliveryOrder.UpdateOneID(o.ID).SetStatus("DONE").Save(r.Context())
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
}
}
ok(w, nil)
// 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 {
+4 -11
View File
@@ -143,15 +143,8 @@ func batchFlipInspectionHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
// 后端复核不合格数 = 检验数 - 合格数(不信任前端)
rejectQty := inspectQty - passQty
// 第几批/共几件:序列号=否(sn_mode=2)必填且均≥1;序列号=是忽略前端传值、落库 0=未填
// 第几批/共几件已下线(2026-11-08):前端不再采集,字段保留落库 0(schema Default(0) 不动)
batchSeq, batchTotal := 0, 0
if inv.SnMode == snModeBatch {
if it.BatchSeq < 1 || it.BatchTotal < 1 {
fail(w, http.StatusBadRequest, "序列号=否来料检验需填写第几批与共几件: "+it.TargetId)
return
}
batchSeq, batchTotal = it.BatchSeq, it.BatchTotal
}
items = append(items, item{
id: it.TargetId, inv: inv, targetType: tt, material: inv.MaterialCode,
status: it.Status, inspectQty: inspectQty, passQty: passQty, rejectQty: rejectQty,
@@ -431,8 +424,8 @@ func exportInspectionHandler(ctx *svc.ServiceContext) http.HandlerFunc {
// xlsx 导出
if r.URL.Query().Get("format") == "xlsx" {
// 列名按客户口径(问题记录 L150):检验说明→相关标准、检验员→记录人、检验日期→记录日期、增加归属;
// 图号=物料编码(L18 合并裁决)。第几批/共几件(2026-10-04 客户需求)随批次/SN 列展示,0=未填显示 "-"
headers := []string{"ID", "对象", "批次/SN", "第几批", "共几件", "图号", "名称", "检验类型", "结论", "检验数", "合格数", "不合格数", "相关标准", "报检单号", "检测单号", "归属单号", "生产厂家", "记录人", "备注", "记录日期"}
// 图号=物料编码(L18 合并裁决)。2026-11-08 移除「第几批/共几件」两列(字段仍落库 0)。
headers := []string{"ID", "对象", "批次/SN", "图号", "名称", "检验类型", "结论", "检验数", "合格数", "不合格数", "相关标准", "报检单号", "检测单号", "归属单号", "生产厂家", "记录人", "备注", "记录日期"}
matrix := make([][]any, 0, len(list))
for _, rec := range list {
obj := rec.TargetType
@@ -442,7 +435,7 @@ func exportInspectionHandler(ctx *svc.ServiceContext) http.HandlerFunc {
obj = "SN"
}
matrix = append(matrix, []any{
rec.ID, obj, rec.TargetID, intOrDash(rec.BatchSeq), intOrDash(rec.BatchTotal), rec.MaterialCode, rec.MaterialName,
rec.ID, obj, rec.TargetID, rec.MaterialCode, rec.MaterialName,
inspectionTypeLabel(rec.InspectionType), rec.Status,
rec.InspectQty, rec.PassQty, rec.RejectQty, rec.RelatedStandard, rec.ReportNo,
rec.InspectionNo, rec.OwnershipNo, rec.Manufacturer, rec.Inspector, rec.Remark,
+4 -3
View File
@@ -10,10 +10,11 @@ import (
"bj_power_wms/internal/svc"
)
// 视为"已完成"的工单状态(查询时排到最后,未完成的优先显示)
// 视为"已完成"的工单状态(查询时排到最后,未完成的优先显示)。
// 2026-11-09 清理:对齐 MES 实际状态机 CREATED/IN_PROGRESS/PAUSED/DONE/CANCELLED
//(存量 RELEASED 兼容);旧白名单中的 FINISHED/COMPLETED/CLOSED/中文值为死值。
var mesDoneStatuses = map[string]bool{
"FINISHED": true, "COMPLETED": true, "DONE": true,
"CLOSED": true, "已完结": true, "已完成": true,
"DONE": true, "CANCELLED": true,
}
type mesOrder struct {
+6 -2
View File
@@ -478,6 +478,7 @@ func exportOutboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
materialCode := r.URL.Query().Get("materialCode")
boxNo := r.URL.Query().Get("boxNo")
ownershipNo := r.URL.Query().Get("ownershipNo")
targetStation := r.URL.Query().Get("targetStation")
startDate, endDate, rerr := normalizeExportRange(r.URL.Query().Get("startDate"), r.URL.Query().Get("endDate"))
if rerr != nil {
fail(w, http.StatusBadRequest, rerr.Error())
@@ -505,6 +506,9 @@ func exportOutboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
if ownershipNo != "" {
q = q.Where(outboundorder.OwnershipNoContainsFold(ownershipNo))
}
if targetStation != "" {
q = q.Where(outboundorder.TargetStationEQ(targetStation))
}
list, err := q.Order(ent.Desc("created_at"), ent.Desc("id")).All(ctx0())
if err != nil {
@@ -537,7 +541,7 @@ func exportOutboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
// xlsx 导出
if r.URL.Query().Get("format") == "xlsx" {
headers := []string{"出库单号", "类型", "状态", "类别", "工单号", "归属单号", "图号", "物料名称", "库位", "数量", "目标工位", "装箱号", "合同号", "SN清单", "创建时间"}
headers := []string{"出库单号", "类型", "状态", "类别", "工单号", "归属单号", "图号", "物料名称", "库位", "数量", "目标工位", "目标接驳台", "备注", "装箱号", "合同号", "SN清单", "创建时间"}
matrix := make([][]any, 0, len(rows))
for _, row := range rows {
ob := row.OutboundOrder
@@ -545,7 +549,7 @@ func exportOutboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
ob.OutboundNo, outboundTypeLabel(ob.OutboundType), ob.Status, outboundCategoryLabel(ob.OutboundCategory), ob.OrderNo,
ob.OwnershipNo, ob.MaterialCode, ob.MaterialName,
locationText(ob.ZoneCode, ob.ShelfNo, ob.LayerNo, ob.PositionNo),
ob.Quantity, ob.TargetStation, ob.BoxNo, ob.ContractNo, row.SnCodes,
ob.Quantity, ob.TargetStation, ob.TargetDock, ob.Remark, ob.BoxNo, ob.ContractNo, row.SnCodes,
unixFmt(ob.CreatedAt),
})
}
@@ -197,9 +197,13 @@ func markOutboundDeliveredHandler(ctx *svc.ServiceContext) http.HandlerFunc {
aff, err := ctx.EntClient.OutboundOrder.Update().
Where(outboundorder.OutboundNoEQ(no), outboundorder.StatusEQ("已出库"), outboundorder.VoidedEQ(false)).
SetStatus("已送达").Save(ctx0())
if err == nil {
delivered += aff
if err != nil {
// 本地 DB 写失败(2026-11-08):不再静默跳过,返回 5xx 让调用方感知。
// 调用方 MES 侧会落 event_log / 台账;此处不落同步失败台账。
fail(w, http.StatusInternalServerError, "出库单已送达回写失败: "+err.Error())
return
}
delivered += aff
}
if delivered > 0 {
ctx.EventLog.Write(ctx0(), "outbound.delivered", "AGV", "outbound", strings.Join(req.OutboundNos, ","),
+6 -1
View File
@@ -49,6 +49,8 @@ var seedPermissions = []seedPerm{
{"attachment:view", "附件中心", "MENU", "/attachment", "Folder", 138, ""},
{"backup:manage", "数据归档", "MENU", "/data-archive", "Tools", 140, ""},
{"sys.settings:view", "基础设置", "MENU", "/settings", "Setting", 150, ""},
// 同步失败台账(2026-11-08):跨系统通知失败人工重试,菜单码同时作为后端 requirePerm 校验码
{"sync:retry", "同步失败台账", "MENU", "/sync-failure", "Refresh", 152, ""},
{"sys.settings:edit", "保存基础设置", "BUTTON", "", "", 290, "sys.settings:view"},
// ===== 按钮权限 =====
{"inbound:create", "批量入库", "BUTTON", "", "", 200, "inbound:view"},
@@ -232,7 +234,10 @@ func SeedRBAC(ctx *svc.ServiceContext, operator string) (createdP, createdR, bou
// 不触碰自建角色(避免影响管理员的自定义授权)。
builtin := map[string]bool{"admin": true, "operator": true, "inspector": true}
for _, m := range seedRoleMeta {
if m.Code == "admin" || !builtin[m.Code] {
// T4(2026-11-08):admin 不再跳过并集补授。此前 admin 被排除,
// 存量库新增 MENU 权限码(如 sync:retry「同步失败台账」)只有全量重跑 seed
// 才会覆盖;这里让 admin 与其他内置角色一样按 seedRoleCodes 幂等补齐。
if !builtin[m.Code] {
continue
}
rl, err := ctx.EntClient.Role.Query().Where(role.CodeEQ(m.Code)).Only(ctx0())
@@ -13,6 +13,7 @@ import (
"bj_power_wms/ent/material"
"bj_power_wms/ent/returnorder"
"bj_power_wms/internal/svc"
"bj_power_wms/internal/syncfailure"
"github.com/zeromicro/go-zero/core/logx"
)
@@ -457,6 +458,12 @@ func confirmReturnOrderHandler(ctx *svc.ServiceContext) http.HandlerFunc {
if strings.TrimSpace(ro.RefNo) != "" && ctx.Mes != nil {
if merr := ctx.Mes.CallReturnConfirm(ctx0(), ro.RefNo, receiveBy, receiveQty, receiveDiff, req.ReceiveNote); merr != nil {
logx.Errorf("return confirm notify MES failed: returnNo=%s refNo=%s err=%v", ro.ReturnNo, ro.RefNo, merr)
// 收货事务已提交,不阻断;落失败台账供人工重放通知(best-effort,不自动重试)
syncfailure.Record(ctx.SQLDB, "WMS→MES", "return.confirm", ro.RefNo,
"/api/internal/call/return-confirm", map[string]any{
"requestNo": ro.RefNo, "operator": receiveBy,
"receiveQty": receiveQty, "receiveDiff": receiveDiff, "receiveNote": req.ReceiveNote,
}, merr.Error())
}
}
ok(w, map[string]any{"returnNo": ro.ReturnNo, "status": "RECEIVED", "addedQty": receiveQty,
+9
View File
@@ -69,6 +69,15 @@ func RegisterHandlers(server *rest.Server, ctx *svc.ServiceContext) {
},
)
// 同步失败台账(2026-11-08):只记「本地已提交、对端通知失败」的跨系统回调,人工重试,不自动重传
server.AddRoutes(
[]rest.Route{
{Method: http.MethodGet, Path: "/api/sync-failures", Handler: requirePerm(ctx, "sync:retry", syncFailureListHandler(ctx))},
{Method: http.MethodPost, Path: "/api/sync-failures/retry", Handler: requirePerm(ctx, "sync:retry", syncFailureRetryHandler(ctx))},
{Method: http.MethodPost, Path: "/api/sync-failures/ignore", Handler: requirePerm(ctx, "sync:retry", syncFailureIgnoreHandler(ctx))},
},
)
// 入库
server.AddRoutes(
[]rest.Route{
@@ -0,0 +1,97 @@
package handler
import (
"net/http"
"strconv"
"strings"
"bj_power_wms/internal/svc"
"bj_power_wms/internal/syncfailure"
)
// syncFailureListHandler GET /api/sync-failures 同步失败台账列表(人工可见,不自动重试)
func syncFailureListHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
rows, err := syncfailure.List(ctx.SQLDB, r.URL.Query().Get("status"), r.URL.Query().Get("bizType"))
if err != nil {
fail(w, http.StatusInternalServerError, "查询同步失败台账失败(部署时请先手工执行迁移 SQL 建表): "+err.Error())
return
}
ok(w, rows)
}
}
// syncFailureRetryHandler POST /api/sync-failures/retry?id=
// 只按台账 endpoint + payload_json 原样重放通知,绝不重跑 doGeneralOutbound 等本地业务。
// 重试前先查对端终态;已终态直接置 SUCCESS,不重复通知。
func syncFailureRetryHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
id, err := strconv.ParseInt(strings.TrimSpace(r.URL.Query().Get("id")), 10, 64)
if err != nil || id <= 0 {
fail(w, http.StatusBadRequest, "缺少有效的 id")
return
}
row, err := syncfailure.Get(ctx.SQLDB, id)
if err != nil {
fail(w, http.StatusNotFound, "台账记录不存在: "+err.Error())
return
}
if row.Status == "SUCCESS" {
ok(w, map[string]any{"id": id, "status": "SUCCESS", "note": "已成功,无需重试"})
return
}
if ctx.Mes == nil {
fail(w, http.StatusInternalServerError, "MES 未配置,无法重放通知")
return
}
payload := syncfailure.Payload(row)
// 叫料完成备料:先查 MES 叫料单终态,避免通知已成功但响应丢失时重复回写
if row.BizType == "call.complete" {
if requestNo, isStr := payload["requestNo"].(string); isStr && requestNo != "" {
status, serr := ctx.Mes.CallStatus(r.Context(), requestNo)
if serr == nil && status != "" && status != "PENDING" {
_ = syncfailure.MarkSuccess(ctx.SQLDB, id)
ok(w, map[string]any{"id": id, "status": "SUCCESS", "note": "对端已终态(" + status + "),无需重放"})
return
}
}
}
if err := ctx.Mes.PostRaw(r.Context(), row.Endpoint, payload); err != nil {
_ = syncfailure.MarkRetryFailed(ctx.SQLDB, id, err.Error())
// 对端非 PENDING 属「通知其实已成功」,按幂等成功收口
if strings.Contains(err.Error(), "仅待备料的叫料单可完成备料") {
_ = syncfailure.MarkSuccess(ctx.SQLDB, id)
ok(w, map[string]any{"id": id, "status": "SUCCESS", "note": "对端已终态,无需重放"})
return
}
fail(w, http.StatusBadGateway, "重试失败(已计入 retry_count): "+err.Error())
return
}
_ = syncfailure.MarkSuccess(ctx.SQLDB, id)
ctx.EventLog.Write(ctx0(), "sync.failure.retry", "warehouse", "sync_failure", strconv.FormatInt(id, 10),
"同步失败台账人工重试成功:"+row.BizType+" / "+row.BizKey, nil)
ok(w, map[string]any{"id": id, "status": "SUCCESS"})
}
}
// syncFailureIgnoreHandler POST /api/sync-failures/ignore?id= 线下已处理 → DEAD 留痕
func syncFailureIgnoreHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
id, err := strconv.ParseInt(strings.TrimSpace(r.URL.Query().Get("id")), 10, 64)
if err != nil || id <= 0 {
fail(w, http.StatusBadRequest, "缺少有效的 id")
return
}
operator := r.Header.Get("X-Username")
if operator == "" {
operator = "warehouse"
}
if err := syncfailure.Ignore(ctx.SQLDB, id, operator); err != nil {
fail(w, http.StatusInternalServerError, "标记已处理失败: "+err.Error())
return
}
ctx.EventLog.Write(ctx0(), "sync.failure.ignore", operator, "sync_failure", strconv.FormatInt(id, 10),
"同步失败台账人工标记已处理", nil)
ok(w, map[string]any{"id": id, "status": "DEAD"})
}
}
+69 -4
View File
@@ -151,7 +151,8 @@ type DeliveryAgvItem struct {
Qty float64 `json:"qty"`
}
// getJSON MES GET 通用(带 token;返回 body 的 data 字段)
// getJSON MES GET 通用(带 token;返回 body 的 data 字段)。
// 2026-11-09 缺陷修复:同 postJSON——HTTP 200 + 业务码≠0 也透出错误原文。
func (c *Client) getJSON(ctx context.Context, path string, out any) error {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+path, nil)
if err != nil {
@@ -175,19 +176,29 @@ func (c *Client) getJSON(ctx context.Context, path string, out any) error {
return fmt.Errorf("MES 返回 HTTP %d", resp.StatusCode)
}
var env struct {
Code int `json:"code"`
Data json.RawMessage `json:"data"`
Code int `json:"code"`
Message string `json:"message"`
Data json.RawMessage `json:"data"`
}
if err := json.Unmarshal(raw, &env); err != nil {
return err
}
if env.Code != 0 {
if env.Message != "" {
return fmt.Errorf("MES 业务错误(code=%d): %s", env.Code, env.Message)
}
return fmt.Errorf("MES 业务错误 code=%d", env.Code)
}
if out != nil && len(env.Data) > 0 {
return json.Unmarshal(env.Data, out)
}
return nil
}
// postJSON MES POST 通用(带 token;非 2xx 透出业务错误原文)
// postJSON MES POST 通用(带 token)。
// 2026-11-09 缺陷修复:MES 业务失败 = HTTP 200 + code≠0(common/httpx.Fail),
// 此前只透出非 2xx,HTTP 200 的业务拒绝(如派车点位冲突)被当成功 → 上游假成功。
// 现统一解包 envelope:非 2xx 或业务码≠0 均透出错误原文。
func (c *Client) postJSON(ctx context.Context, path string, body any) error {
b, _ := json.Marshal(body)
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+path, bytes.NewReader(b))
@@ -212,6 +223,17 @@ func (c *Client) postJSON(ctx context.Context, path string, body any) error {
}
return fmt.Errorf("MES 返回 HTTP %d", resp.StatusCode)
}
var env struct {
Code int `json:"code"`
Message string `json:"message"`
}
_ = json.Unmarshal(raw, &env)
if env.Code != 0 {
if env.Message != "" {
return fmt.Errorf("MES 业务错误(code=%d): %s", env.Code, env.Message)
}
return fmt.Errorf("MES 业务错误 code=%d", env.Code)
}
return nil
}
@@ -763,6 +785,39 @@ func (c *Client) UpsertMaterial(ctx context.Context, m MaterialUpsert) error {
return nil
}
// CallStatus 查询 MES 叫料单状态(同步失败台账重试前判对端终态)。
// 已 SHIPPED/DONE 说明通知其实已成功,台账直接置 SUCCESS,不再重放。
func (c *Client) CallStatus(ctx context.Context, requestNo string) (string, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet,
c.BaseURL()+"/api/internal/call/status?requestNo="+url.QueryEscape(requestNo), nil)
if err != nil {
return "", err
}
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return "", err
}
defer resp.Body.Close()
if resp.StatusCode >= 300 {
return "", &RespError{Status: resp.StatusCode}
}
var env struct {
Code int `json:"code"`
Message string `json:"message"`
Data struct {
Status string `json:"status"`
} `json:"data"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return "", err
}
if env.Code != 0 {
return "", errors.New(env.Message)
}
return env.Data.Status, nil
}
// CallComplete 通知 MES 仓库已完成备料(B5):实发量 + WMS 出库单号。
// MES 侧只做状态迁移(PENDING→SHIPPED)与四数账记账,不反向调 WMS 出库。
func (c *Client) CallComplete(ctx context.Context, requestNo string, sentQty float64, outboundNo, operator string) error {
@@ -786,6 +841,16 @@ func (c *Client) CallReturnConfirm(ctx context.Context, requestNo, operator stri
return c.postInternal(ctx, "/api/internal/call/return-confirm", b, "MES 叫料单退库确认回写失败")
}
// PostRaw 同步失败台账人工重试:按 endpoint 原样重放通知请求体。
// 只重放通知,绝不重跑任何本地业务(如 doGeneralOutbound 出库扣减)。
func (c *Client) PostRaw(ctx context.Context, path string, payload map[string]any) error {
b, err := json.Marshal(payload)
if err != nil {
return err
}
return c.postInternal(ctx, path, b, "同步失败重试")
}
// postInternal 通用内部 POST:带 X-API-TOKEN;解析 MES 业务错误(HTTP 200 + body{code≠0} 必须判读)
func (c *Client) postInternal(ctx context.Context, path string, body []byte, errPrefix string) error {
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+path, bytes.NewReader(body))
@@ -2,6 +2,7 @@ package svc
import (
"context"
"database/sql"
"strings"
"bj_power_wms/ent"
@@ -15,6 +16,7 @@ import (
type ServiceContext struct {
Config config.Config
EntClient *ent.Client
SQLDB *sql.DB
EventLog *eventlog.Writer
Mes *mesclient.Client
Backup *backup.Service
@@ -55,6 +57,7 @@ func NewServiceContext(c config.Config) *ServiceContext {
return &ServiceContext{
Config: c,
EntClient: entClient,
SQLDB: db.RawDB(),
EventLog: eventlog.NewWriter(entClient),
Mes: mes,
// 备份/清理:attRoot 用 WMS 附件根目录;sibling 为 MES 内部接口地址与 token,
@@ -0,0 +1,153 @@
// Package syncfailure 跨系统调用失败台账(2026-11-08)。
// 口径:① 只记「本地事务已提交、对端通知失败」的跨系统回调,供人工重试;
// ② 不自动重试(遵守 2026-11-05「断网即失败、禁止离线队列/自动补传」拍板);
// ③ 写入一律 best-effort:表未建或插入失败只打日志,绝不阻断业务;
// ④ 表由部署时手工执行迁移 SQL 建立,启动期禁止任何 DDL。
package syncfailure
import (
"database/sql"
"encoding/json"
"log"
"strings"
"time"
)
// Row 一条失败台账
type Row struct {
ID int64 `json:"id"`
Direction string `json:"direction"`
BizType string `json:"bizType"`
BizKey string `json:"bizKey"`
Endpoint string `json:"endpoint"`
PayloadJSON string `json:"payloadJson"`
ErrorMsg string `json:"errorMsg"`
IdempotencyKey string `json:"idempotencyKey"`
Status string `json:"status"`
RetryCount int `json:"retryCount"`
CreatedAt int64 `json:"createdAt"`
LastErrorAt int64 `json:"lastErrorAt"`
HandledBy string `json:"handledBy"`
}
// Key 幂等键:direction|biz_type|biz_key;重复失败只更新同一行,不会产生重复通知。
func Key(direction, bizType, bizKey string) string {
return direction + "|" + bizType + "|" + bizKey
}
// Record 落一条失败台账。payload 序列化后存 payload_json,重试时按 endpoint 原样重放。
// best-effort:任何错误只打日志返回,调用方无需处理。
func Record(db *sql.DB, direction, bizType, bizKey, endpoint string, payload any, errMsg string) {
if db == nil {
return
}
body, err := json.Marshal(payload)
if err != nil {
body = []byte("{}")
}
now := time.Now().Unix()
_, err = db.Exec(
`INSERT INTO sync_failure
(direction, biz_type, biz_key, endpoint, payload_json, error_msg,
idempotency_key, status, retry_count, created_at, last_error_at, handled_by)
VALUES ($1,$2,$3,$4,$5,$6,$7,'PENDING',0,$8,$8,'')
ON CONFLICT (idempotency_key) DO UPDATE SET
error_msg = EXCLUDED.error_msg,
last_error_at = EXCLUDED.last_error_at,
status = 'PENDING',
handled_by = ''
WHERE sync_failure.status <> 'SUCCESS'`,
direction, bizType, bizKey, endpoint, string(body), errMsg,
Key(direction, bizType, bizKey), now)
if err != nil {
log.Printf("[sync-failure] 落台账失败(已退回日志,不阻断业务) %s/%s/%s: %v",
direction, bizType, bizKey, err)
}
}
// List 台账列表;status/bizType 为空表示不过滤。
func List(db *sql.DB, status, bizType string) ([]Row, error) {
if db == nil {
return []Row{}, nil
}
q := `SELECT id, direction, biz_type, biz_key, endpoint, payload_json, error_msg,
idempotency_key, status, retry_count, created_at, last_error_at, handled_by
FROM sync_failure WHERE 1=1`
args := []any{}
if strings.TrimSpace(status) != "" {
args = append(args, strings.TrimSpace(status))
q += " AND status = $" + itoa(len(args))
}
if strings.TrimSpace(bizType) != "" {
args = append(args, strings.TrimSpace(bizType))
q += " AND biz_type = $" + itoa(len(args))
}
q += " ORDER BY id DESC LIMIT 500"
rows, err := db.Query(q, args...)
if err != nil {
return nil, err
}
defer rows.Close()
out := []Row{}
for rows.Next() {
var r Row
if err := rows.Scan(&r.ID, &r.Direction, &r.BizType, &r.BizKey, &r.Endpoint,
&r.PayloadJSON, &r.ErrorMsg, &r.IdempotencyKey, &r.Status, &r.RetryCount,
&r.CreatedAt, &r.LastErrorAt, &r.HandledBy); err != nil {
return nil, err
}
out = append(out, r)
}
return out, rows.Err()
}
// Get 按 ID 取一条(重试前读取 endpoint/payload_json)。
func Get(db *sql.DB, id int64) (Row, error) {
var r Row
err := db.QueryRow(
`SELECT id, direction, biz_type, biz_key, endpoint, payload_json, error_msg,
idempotency_key, status, retry_count, created_at, last_error_at, handled_by
FROM sync_failure WHERE id = $1`, id).
Scan(&r.ID, &r.Direction, &r.BizType, &r.BizKey, &r.Endpoint,
&r.PayloadJSON, &r.ErrorMsg, &r.IdempotencyKey, &r.Status, &r.RetryCount,
&r.CreatedAt, &r.LastErrorAt, &r.HandledBy)
return r, err
}
// Payload 解析 payload_json 为重放用的请求体。
func Payload(r Row) map[string]any {
m := map[string]any{}
_ = json.Unmarshal([]byte(r.PayloadJSON), &m)
return m
}
// MarkSuccess 重试成功 / 对端已终态 → SUCCESS。
func MarkSuccess(db *sql.DB, id int64) error {
_, err := db.Exec(`UPDATE sync_failure SET status='SUCCESS', error_msg='', last_error_at=$2 WHERE id=$1`,
id, time.Now().Unix())
return err
}
// MarkRetryFailed 重试失败 → retry_count+1,记录最后错误;超过 10 次置 DEAD 待人工处置。
func MarkRetryFailed(db *sql.DB, id int64, errMsg string) error {
_, err := db.Exec(
`UPDATE sync_failure SET retry_count = retry_count + 1, error_msg = $2,
last_error_at = $3,
status = CASE WHEN retry_count + 1 >= 10 THEN 'DEAD' ELSE 'PENDING' END
WHERE id = $1`, id, errMsg, time.Now().Unix())
return err
}
// Ignore 线下已处理 → DEAD,留痕处理人。
func Ignore(db *sql.DB, id int64, handledBy string) error {
_, err := db.Exec(`UPDATE sync_failure SET status='DEAD', handled_by=$2, last_error_at=$3 WHERE id=$1`,
id, handledBy, time.Now().Unix())
return err
}
func itoa(n int) string {
if n < 10 {
return string(rune('0' + n))
}
return string(rune('0'+n/10)) + string(rune('0'+n%10))
}