feat: 退料闭环定稿(损耗台账/备料清单/退料AGV自动派车/剩余量参考)+ 工位托盘守卫

- MES 新增损耗台账 loss_ledger,差异确认损耗接口 ConfirmReceiveLoss(按工单归集)
- 备料清单 preparation:MES 按 日计划×工单×工位×物料 实时计算,WMS 只读展示 PreparationList
- 退料闭环:N5 工位托盘守卫(未完成禁止退料)、退料 AGV 自动派车(JBT21 空位判定 + 托盘回收链路)、退料参考剩余量接口(应剩余=实备-已耗-已退-已损)
- 新增 AGV 车辆状态表 agv_vehicle_state 及查询
- 整合接驳台/叫料池/库存锁既有闭环,清理 sql 目录注释生成脚本与 catalog,更新文档
This commit is contained in:
SunYF
2026-11-04 19:06:03 +08:00
parent 42bcf395d2
commit 46fcb59079
123 changed files with 10666 additions and 3227 deletions
@@ -41,6 +41,34 @@ func ConfirmCallLoadHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
}
// DispatchCallHandler POST /call/dispatch {requestNo}
// 库管人工派车(2026-11-03 定论:废除备料完成自动派车)——叫料队列点「送货」,AGV 才出发去装货点。
func DispatchCallHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
RequestNo string `json:"requestNo"`
Operator string `json:"operator"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
fail(w, http.StatusBadRequest, "参数错误: "+err.Error())
return
}
if req.RequestNo == "" {
fail(w, http.StatusBadRequest, "requestNo 必填")
return
}
op := r.Header.Get("X-Username")
if op == "" {
op = req.Operator
}
if err := ctx.Mes.AgvDispatch(r.Context(), req.RequestNo, op); err != nil {
fail(w, http.StatusBadGateway, err.Error())
return
}
ok(w, map[string]any{"ok": true})
}
}
// PalletDocksHandler GET /pallet/docks —— 接驳台台账列表(托盘工作台:谁有托盘/空托盘待回收)。
func PalletDocksHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
@@ -94,6 +122,19 @@ func dockViews(docks []mesclient.DockRow) []map[string]any {
return out
}
// Jbt21FreeHandler GET /pallet/jbt21-free
// 库房接驳台 JBT21 空位查询(转发 MES):无空位时托盘回收「派 AGV」按钮禁用并提示(2026-11-04 定稿 Q5)。
func Jbt21FreeHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
free, reason, err := ctx.Mes.Jbt21Free(r.Context())
if err != nil {
fail(w, http.StatusBadGateway, "MES 不可达: "+err.Error())
return
}
ok(w, map[string]any{"free": free, "reason": reason})
}
}
// PalletDispatchHandler POST /pallet/dispatch {dockCode, operator}
// 库管派 AGV 回收指定工位接驳台的托盘(空车段免弹窗,到位待令后确认装车)。
func PalletDispatchHandler(ctx *svc.ServiceContext) http.HandlerFunc {
@@ -0,0 +1,44 @@
package handler
import (
"net/http"
"bj_power_wms/internal/svc"
)
// ---------- P1 备料清单(2026-11-04 用户拍板) ----------
// queryPreparationListHandler GET /api/preparation/list
// 备料清单(只读):转发 MES 实时计算结果(今天及以后×工单×工位×物料×数量)。
// 不触发任何业务动作、不管库存(库存不足照显示)。权限码 preparation:view。
func queryPreparationListHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
list, err := ctx.Mes.FetchPreparationList(r.Context())
if err != nil {
fail(w, http.StatusBadGateway, "MES 备料清单拉取失败:"+err.Error())
return
}
ok(w, list)
}
}
// ---------- E4 托盘余料明细(2026-11-04 拍板) ----------
// palletResidualHandler GET /api/pallet/residual?dock=XXX
// 指定接驳台托盘余料明细(只读):转发 MES(最近送达该接驳台的 AGV 运输段 materials_json)。
// 供托盘工作台「代发起退料」弹窗自动带出,库管核对后提交。
func palletResidualHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
dock := r.URL.Query().Get("dock")
if dock == "" {
fail(w, http.StatusBadRequest, "缺少接驳台编码(dock)")
return
}
rows, err := ctx.Mes.FetchPalletResidual(r.Context(), dock)
if err != nil {
fail(w, http.StatusBadGateway, "MES 余料明细拉取失败:"+err.Error())
return
}
ok(w, rows)
}
}
+5 -3
View File
@@ -32,6 +32,8 @@ var seedPermissions = []seedPerm{
{"inbound:view", "入库管理", "MENU", "/inbound", "Download", 20, ""},
{"outbound:view", "出库管理", "MENU", "/outbound", "Upload", 30, ""},
{"call:view", "叫料队列", "MENU", "/call-queue", "Bell", 35, ""},
// P1(2026-11-04 用户拍板):备料清单——只读展示"今天及以后×工单×工位×物料×数量",数据源 MES 日排产实时算
{"preparation:view", "备料清单", "MENU", "/preparation", "Tickets", 36, ""},
{"inventory:view", "库存查询", "MENU", "/inventory", "Search", 40, ""},
{"inspection:view", "来料检验", "MENU", "/inspection-incoming", "CircleCheck", 50, ""},
{"stocktake:view", "库存盘点", "MENU", "/stocktake", "List", 60, ""},
@@ -142,9 +144,9 @@ func SeedRBAC(ctx *svc.ServiceContext, operator string) (createdP, createdR, bou
}
codes := seedRoleCodes()
// 退役权限码清理(幂等):随功能退役的权限码及存量角色里的旧码一并摘除。
// - ledger:view:工单备料台账页随「自动备料流」退役(B5 2026-10-13)
// - agv:manage / agv:dispatch:AGV 配送页随 GUI 一并移除,AGV 真源迁 MES(E.1 2026-10-17)
for _, dead := range []string{"ledger:view", "agv:manage", "agv:dispatch"} {
// - ledger:view:工单备料台账随用户 2026-11-04 明确拍板移除(D1 移除),不再复活
for _, dead := range []string{"agv:manage", "agv:dispatch", "ledger:view"} {
_, _ = ctx.EntClient.Permission.Delete().Where(permission.CodeEQ(dead)).Exec(ctx0())
}
if allRoles, _ := ctx.EntClient.Role.Query().All(ctx0()); len(allRoles) > 0 {
@@ -152,7 +154,7 @@ func SeedRBAC(ctx *svc.ServiceContext, operator string) (createdP, createdR, bou
kept := make([]string, 0, len(rl.PermissionCodes))
changed := false
for _, c := range rl.PermissionCodes {
if c == "ledger:view" || c == "agv:manage" || c == "agv:dispatch" {
if c == "agv:manage" || c == "agv:dispatch" || c == "ledger:view" {
changed = true
continue
}
+374 -35
View File
@@ -1,6 +1,7 @@
package handler
import (
"fmt"
"net/http"
"sort"
"strconv"
@@ -18,18 +19,22 @@ import (
// returnOrderCreateRequest 工位退库/叫料单退库预建(MES 经 /api/internal/return-order 调用)
type returnOrderCreateRequest struct {
OrderNo string `json:"orderNo"`
SN string `json:"sn"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Spec string `json:"spec"`
Qty int `json:"qty"`
Unit string `json:"unit"`
Reason string `json:"reason"`
Operator string `json:"operator"`
StationNo int `json:"stationNo"`
ReturnDock string `json:"returnDock"` // 2026-11-03 拍板:退料接驳台(AGV 拉货依据)
RefNo string `json:"refNo"` // B5:叫料单退库时的叫料单号(仓库确认收回后回调 MES 关单回补)
OrderNo string `json:"orderNo"`
SN string `json:"sn"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Spec string `json:"spec"`
Qty int `json:"qty"`
Unit string `json:"unit"`
Reason string `json:"reason"`
Operator string `json:"operator"`
StationNo int `json:"stationNo"`
ReturnDock string `json:"returnDock"` // 2026-11-03 拍板:退料接驳台(退料托盘放置位置)
LossReason string `json:"lossReason"` // 2026-11-04 拍板:损耗原因(巡检/代退料一律必填,转产退料实际<理论时必填)
TransportMode string `json:"transportMode"` // 2026-11-04 定稿:运输方式 agv/manual(必填;agv=传感器检测到托盘且库房有空位自动派车)
RefNo string `json:"refNo"` // B5:叫料单退库时的叫料单号(仓库确认收回后回调 MES 关单回补)
// 拍板2(2026-11-04):PLC 离线人工强行确认退料——前端弹风险提示后确认携带 forceConfirm=true。
ForceConfirm bool `json:"forceConfirm"`
}
// returnOrderConfirmRequest WMS 库管确认收货(客户诉求 问题14 退库闭环)。
@@ -47,6 +52,12 @@ type returnOrderConfirmRequest struct {
BatchNo string `json:"batchNo"`
SNList []string `json:"snList"`
Remark string `json:"remark"`
// 2026-11-03 拍板(R18):库管可记录收货差异——实收<应退即为差异,按实收加回库存。
// 2026-11-04 定稿(F):损耗确认移 WMS——实收<应退时差异必须就地定性:填损耗原因 →
// 落 MES 损耗台账(挂工单);MES 侧只读展示,不再设确认按钮。
ReceiveQty int `json:"receiveQty"` // 实收数量(0=整单全收,向后兼容)
ReceiveNote string `json:"receiveNote"` // 差异备注
LossReason string `json:"lossReason"` // 实收<应退时必填:损耗原因(直接落 MES 损耗台账)
}
// createReturnOrderInternalHandler 预建「待确认收货」退库单(X-API-TOKEN 内部接口)
@@ -61,23 +72,47 @@ func createReturnOrderInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc
fail(w, http.StatusBadRequest, "materialCode 与 qty(>0) 必填")
return
}
// G 兜底(2026-11-04 拍板):refNo 为空 = 巡检退料/库管代退料(无理论量)→ 损耗原因后端必填,
// 防绕过前端;refNo 非空(转产退料/叫料单退库)由 MES 侧按"实际<理论"口径校验,此处不强拦。
if strings.TrimSpace(req.RefNo) == "" && strings.TrimSpace(req.LossReason) == "" {
fail(w, http.StatusBadRequest, "损耗原因必填(巡检退料/代退料一律必填)")
return
}
// 运输方式(2026-11-04 定稿):agv/manual 必填——agv=传感器检测到接驳台有托盘且库房接驳台
// 有空位时自动派车拉运(库管不点派车);manual=无 AGV 人工搬运,退料单照常等库管收货。
if req.TransportMode != "agv" && req.TransportMode != "manual" {
fail(w, http.StatusBadRequest, "运输方式必选(AGV / 人工)")
return
}
// N5(2026-11-04 拍板)退料前提 + 拍板2:工位传感器无托盘(工件已完工离开工位)才允许退料。
// 三态:allowed=放行;needForce=true=PLC 离线(前端弹风险提示,ForceConfirm=true 放行);
// needForce=false=硬拒(传感器有托盘等,强行确认不适用)。MES 不可达仍拒绝(无法确认工件已完工)。
if req.StationNo > 0 && ctx.Mes != nil {
g, gerr := ctx.Mes.StationReturnGuard(ctx0(), req.StationNo)
if gerr != nil {
fail(w, http.StatusBadGateway, "退料前置校验失败(MES 不可达,无法确认工件已完工):"+gerr.Error())
return
}
if !g.Allowed {
if g.NeedForce {
if !req.ForceConfirm {
// 业务码 2409:PLC 离线需人工强行确认(HTTP 200 便于前端拦截器识别弹窗)
failCode(w, http.StatusOK, 2409, g.Reason)
return
}
} else {
fail(w, http.StatusConflict, g.Reason)
return
}
}
}
// B5:带 refNo = 叫料单退库(source_type=call;确认收回后凭 ref_no 回调 MES 关单回补)
sourceType := "station"
if strings.TrimSpace(req.RefNo) != "" {
sourceType = "call"
}
// 防止重复预建(同一工单+物料+工位+未收货,仅首条生效)
dup, _ := ctx.EntClient.ReturnOrder.Query().
Where(
returnorder.OrderNoEQ(req.OrderNo),
returnorder.MaterialCodeEQ(req.MaterialCode),
returnorder.StationNoEQ(req.StationNo),
returnorder.StatusEQ("PENDING"),
).Exist(ctx0())
if dup {
ok(w, map[string]any{"dup": true, "msg": "已存在待确认退库单"})
return
}
// 2026-11-04 拍板:取消「同工单+物料+工位+PENDING 仅首条生效」防重——允许同工单+物料+工位
// 存在多张 PENDING 退料单(分批退),同物料连退多批各生成一张单、不再被吞。
rec, err := ctx.EntClient.ReturnOrder.Create().
SetReturnNo(genReturnNo()).
SetSourceType(sourceType).
@@ -91,6 +126,8 @@ func createReturnOrderInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc
SetQty(req.Qty).
SetNillableUnit(strPtr(req.Unit)).
SetReturnDock(req.ReturnDock).
SetLossReason(req.LossReason).
SetTransportMode(req.TransportMode).
SetReason(req.Reason).
SetOperator(req.Operator).
SetStatus("PENDING").
@@ -128,10 +165,60 @@ func confirmReturnOrderHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusConflict, "该退库单已收货")
return
}
// R19(2026-11-03 拍板):转产退料(带工单号)确认收货前校验接驳台台面已清空(托盘已被 AGV 拉走),
// 与 MES GuardTransferReroute 同口径;台面未清空拦截,先完成 AGV 拉运或人工收口再确认。
// MES 不可达时不阻断(与既有回写失败不阻断口径一致),仅记日志。
if strings.TrimSpace(ro.OrderNo) != "" && strings.TrimSpace(ro.ReturnDock) != "" && ctx.Mes != nil {
docks, derr := ctx.Mes.ListDocks(ctx0())
if derr != nil {
logx.Errorf("return confirm check dock cleared failed: returnNo=%s dock=%s err=%v", ro.ReturnNo, ro.ReturnDock, derr)
} else {
for _, d := range docks {
if d.DockCode == ro.ReturnDock && !d.Cleared {
fail(w, http.StatusConflict, "接驳台 "+ro.ReturnDock+" 台面未清空(仍有托盘),请先完成 AGV 拉运或人工收口后再确认收货")
return
}
}
}
}
// R18(2026-11-03 拍板):实收数量(收货差异)。实收<应退即为少收差异,按实收加回库存;
// 差异记「待核」,不自动进损耗台账,以库管真实核算为准。
receiveQty := ro.Qty
if req.ReceiveQty > 0 {
if req.ReceiveQty > ro.Qty {
fail(w, http.StatusBadRequest, "实收数量("+strconv.Itoa(req.ReceiveQty)+")不能大于应退数量("+strconv.Itoa(ro.Qty)+")")
return
}
receiveQty = req.ReceiveQty
}
receiveDiff := ro.Qty - receiveQty
receiveBy := r.Header.Get("X-Username")
if receiveBy == "" {
receiveBy = "库管"
}
// F(2026-11-04 定稿):实收<应退 → 损耗原因必填,就地落 MES 损耗台账(MES 只读展示)。
// 先落账(MES 按 returnNo 幂等防重,重复提交安全)再走收货事务,保证「收货成功=损耗已落账」。
lossReason := strings.TrimSpace(req.LossReason)
if receiveDiff > 0 {
if lossReason == "" {
fail(w, http.StatusBadRequest, "实收数量("+strconv.Itoa(receiveQty)+")少于应退("+strconv.Itoa(ro.Qty)+"),请填写损耗原因(差异须落损耗台账)")
return
}
if ctx.Mes != nil {
mName := ro.MaterialName
if m, merr := ctx.EntClient.Material.Query().Where(material.CodeEQ(ro.MaterialCode)).First(ctx0()); merr == nil && m != nil {
mName = m.Name
}
if lerr := ctx.Mes.LossConfirm(ctx0(), ro.ReturnNo, ro.OrderNo, ro.StationNo,
ro.MaterialCode, mName, float64(ro.Qty), float64(receiveQty), float64(receiveDiff),
lossReason, receiveBy); lerr != nil {
fail(w, http.StatusBadGateway, "损耗落账失败:"+lerr.Error()+"(请稍后重试确认收货)")
return
}
}
}
// 序列号方式由物料档案 sn_mode 决定(1=序列号=是逐个扫SN,2=序列号=否按数量;2026-09-30 与类型解耦),
// 默认序列号=否(档案缺失兜底)。
@@ -168,6 +255,9 @@ func confirmReturnOrderHandler(ctx *svc.ServiceContext) http.HandlerFunc {
Where(returnorder.ID(ro.ID), returnorder.StatusEQ("PENDING")).
SetStatus("RECEIVED").
SetReceiveBy(receiveBy).
SetReceiveQty(receiveQty).
SetReceiveDiff(receiveDiff).
SetReceiveNote(req.ReceiveNote).
SetReceiveAt(time.Now().Unix()).
Save(ctx0())
if err != nil {
@@ -204,8 +294,8 @@ func confirmReturnOrderHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusBadRequest, "序列号=是退库需逐个扫码录入 SN")
return
}
if len(sns) != ro.Qty {
fail(w, http.StatusBadRequest, "扫码 SN 数("+strconv.Itoa(len(sns))+")与退库数量("+strconv.Itoa(ro.Qty)+")不符")
if len(sns) != receiveQty {
fail(w, http.StatusBadRequest, "扫码 SN 数("+strconv.Itoa(len(sns))+")与实收数量("+strconv.Itoa(receiveQty)+")不符")
return
}
for _, sn := range sns {
@@ -298,7 +388,7 @@ func confirmReturnOrderHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return
}
if _, err = tx.Inventory.UpdateOneID(existing.ID).
AddQuantity(ro.Qty).SetUpdatedAt(time.Now().Unix()).Save(ctx0()); err != nil {
AddQuantity(receiveQty).SetUpdatedAt(time.Now().Unix()).Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "库存加回失败: "+err.Error())
return
}
@@ -313,7 +403,7 @@ func confirmReturnOrderHandler(ctx *svc.ServiceContext) http.HandlerFunc {
SetMaterialCode(ro.MaterialCode).
SetNillableMaterialName(strPtr(mName)).
SetBatchNo(bn).
SetQuantity(ro.Qty).SetLockedQty(0).
SetQuantity(receiveQty).SetLockedQty(0).
SetQualityStatus(quality).
SetStatus("在库").
SetInboundNo("RET:" + ro.ReturnNo)
@@ -351,17 +441,26 @@ func confirmReturnOrderHandler(ctx *svc.ServiceContext) http.HandlerFunc {
rtLabel = "问题物料"
}
locStr := strings.Join([]string{req.ZoneCode, req.ShelfNo, req.LayerNo, req.PositionNo}, "/")
diffDesc := ""
if receiveDiff > 0 {
diffDesc = " 收货差异" + strconv.Itoa(receiveDiff) + "(待核)"
}
ctx.EventLog.Write(ctx0(), "return.order.confirm", receiveBy, "return_order", ro.ReturnNo,
"确认收货 "+ro.MaterialCode+" x"+strconv.Itoa(ro.Qty)+" 库存已加回("+rtLabel+"/"+quality+")",
"确认收货 "+ro.MaterialCode+" 实收"+strconv.Itoa(receiveQty)+"/应退"+strconv.Itoa(ro.Qty)+" 库存已按实收加回("+rtLabel+"/"+quality+")"+diffDesc,
map[string]any{"orderNo": ro.OrderNo, "stationNo": ro.StationNo, "returnType": req.ReturnType,
"qualityStatus": quality, "location": locStr, "snList": req.SNList, "batchNo": req.BatchNo})
// B5 退库闭环终点:叫料单退库确认收回 → 通知 MES 关单并回补叫料池额度(失败不阻断收货,仅记日志)
"qualityStatus": quality, "location": locStr, "snList": req.SNList, "batchNo": req.BatchNo,
"receiveQty": receiveQty, "receiveDiff": receiveDiff, "receiveNote": req.ReceiveNote})
// D1 工单备料台账已于 2026-11-04 按用户拍板移除:退库确认不再回写台账 returned_qty;
// 收货差异改走 T2 人工「确认损耗」(MES 叫料单列表按钮 → loss_ledgers)。
// B5 退库闭环终点:叫料单退库确认收回 → 通知 MES 关单并按实收回补叫料池额度(失败不阻断收货,仅记日志);
// R18:带回实收量/差异/备注,MES 落「待核」差异,不自动进损耗台账。
if strings.TrimSpace(ro.RefNo) != "" && ctx.Mes != nil {
if merr := ctx.Mes.CallReturnConfirm(ctx0(), ro.RefNo, receiveBy); merr != 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)
}
}
ok(w, map[string]any{"returnNo": ro.ReturnNo, "status": "RECEIVED", "addedQty": ro.Qty, "qualityStatus": quality})
ok(w, map[string]any{"returnNo": ro.ReturnNo, "status": "RECEIVED", "addedQty": receiveQty,
"receiveDiff": receiveDiff, "qualityStatus": quality})
}
}
@@ -435,8 +534,248 @@ func queryReturnOrdersHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
}
// genReturnNo 退库单号:时间戳(秒) + 纳秒尾号,避免同秒并发撞号(return_no 唯一约束)
// genReturnNo 退库单号:时间戳(秒) + 微秒尾号(6位),避免同秒连发撞号(return_no 唯一约束)。
// 2026-11-04 N3 实测修复:原纳秒%1000 尾号在同一秒内连续建单时高频碰撞(唯一键 23505),
// 库房/工位连续退第二张单会被打断。
func genReturnNo() string {
ts := time.Now()
return "TH" + ts.Format("20060102150405") + strconv.Itoa(ts.Nanosecond()%1000)
return "TH" + ts.Format("20060102150405") + fmt.Sprintf("%06d", ts.Nanosecond()/1000)
}
// ============ 取消退料单 / 自动派车标记 / 余量参考值(2026-11-04 口径定稿) ============
// cancelReturnOrderShared 取消退料单共享逻辑(库房取消/工位取消同源):
// 仅 PENDING 可取消(已收货 RECEIVED 不可取消、已取消 CANCELLED 幂等返回);
// 已自动派车的单联动作废未完成 AGV 任务——AGV 已装车运输中则拒绝取消(D2 口径);
// 取消不产生任何库存变动(库存加回只发生在确认收货事务内)。
// source_type=call 的单取消后不回调 MES 关单回补(料未回库,叫料池额度不恢复),仅留痕。
func cancelReturnOrderShared(ctx *svc.ServiceContext, returnNo string, stationNo int, operator, reason string) (map[string]any, int, error) {
ro, err := ctx.EntClient.ReturnOrder.Query().
Where(returnorder.ReturnNoEQ(returnNo)).Only(ctx0())
if err != nil {
return nil, http.StatusNotFound, fmt.Errorf("退库单不存在: %s", returnNo)
}
if ro.Status == "RECEIVED" {
return nil, http.StatusConflict, fmt.Errorf("该退库单已收货,不可取消")
}
if ro.Status == "CANCELLED" {
return map[string]any{"returnNo": ro.ReturnNo, "status": "CANCELLED"}, 0, nil // 幂等
}
// 工位取消:只能取消自己工位的单(库房取消不限工位,stationNo 传 0 表示库房)
if stationNo > 0 && ro.StationNo != stationNo {
return nil, http.StatusForbidden, fmt.Errorf("只能取消本工位发起的退料单")
}
cancelReason := strings.TrimSpace(reason)
if cancelReason == "" {
cancelReason = "未填写原因"
}
// 已自动派车:联动取消未完成 AGV 任务;AGV 已装车运输中 → 拒绝取消(D2)
if ro.DispatchedAt > 0 && strings.TrimSpace(ro.ReturnDock) != "" && ctx.Mes != nil {
res, cerr := ctx.Mes.CancelAgvByDock(ctx0(), ro.ReturnDock, "退料单 "+ro.ReturnNo+" 已取消,联动作废 AGV 任务")
if cerr != nil {
return nil, http.StatusBadGateway, fmt.Errorf("取消 AGV 任务失败:%w(请确认 AGV 状态后重试)", cerr)
}
if res != nil && res["hasInTransit"] == true {
return nil, http.StatusConflict, fmt.Errorf("该退料单的 AGV 已装车运输中,不可取消;请等 AGV 卸货完成后再处理")
}
}
aff, uerr := ctx.EntClient.ReturnOrder.Update().
Where(returnorder.ID(ro.ID), returnorder.StatusEQ("PENDING")).
SetStatus("CANCELLED").
SetCancelledBy(operator).
SetCancelReason(cancelReason).
Save(ctx0())
if uerr != nil {
return nil, http.StatusInternalServerError, fmt.Errorf("取消退库单失败: %w", uerr)
}
if aff == 0 {
return nil, http.StatusConflict, fmt.Errorf("该退库单状态已变化,请刷新后重试")
}
ctx.EventLog.Write(ctx0(), "return.order.cancel", operator, "return_order", ro.ReturnNo,
"取消退库单 "+ro.MaterialCode+" x"+strconv.Itoa(ro.Qty)+",原因:"+cancelReason,
map[string]any{"stationNo": ro.StationNo, "orderNo": ro.OrderNo, "dispatched": ro.DispatchedAt > 0})
return map[string]any{"returnNo": ro.ReturnNo, "status": "CANCELLED"}, 0, nil
}
// cancelReturnOrderHandler POST /api/return-order/cancel {returnNo, reason}
// 库房取消 PENDING 退料单(含工位终端发起的申请;权限 return:confirm,与收货同权)。
func cancelReturnOrderHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
ReturnNo string `json:"returnNo"`
Reason string `json:"reason"`
}
if err := parseJSON(r, &req); err != nil {
fail(w, http.StatusBadRequest, "参数错误: "+err.Error())
return
}
if req.ReturnNo == "" {
fail(w, http.StatusBadRequest, "returnNo 必填")
return
}
operator := r.Header.Get("X-Username")
if operator == "" {
operator = "库管"
}
res, code, err := cancelReturnOrderShared(ctx, req.ReturnNo, 0, operator, req.Reason)
if err != nil {
fail(w, code, err.Error())
return
}
ok(w, res)
}
}
// cancelReturnOrderInternalHandler POST /api/internal/return-order/cancel {returnNo, stationNo, operator, reason}
// 工位取消自己发起的 PENDING 退料单(工位终端 → MES 转发;校验工位归属)。
func cancelReturnOrderInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
ReturnNo string `json:"returnNo"`
StationNo int `json:"stationNo"`
Operator string `json:"operator"`
Reason string `json:"reason"`
}
if err := parseJSON(r, &req); err != nil {
fail(w, http.StatusBadRequest, "参数错误: "+err.Error())
return
}
if req.ReturnNo == "" || req.StationNo <= 0 {
fail(w, http.StatusBadRequest, "returnNo 与 stationNo 必填")
return
}
op := req.Operator
if op == "" {
op = "工位" + strconv.Itoa(req.StationNo)
}
res, code, err := cancelReturnOrderShared(ctx, req.ReturnNo, req.StationNo, op, req.Reason)
if err != nil {
fail(w, code, err.Error())
return
}
ok(w, res)
}
}
// stationReturnListInternalHandler GET /api/internal/return-order/station-list?stationNo=
// 工位终端「我的退料单」列表(PENDING 可取消;全部状态可查)。
func stationReturnListInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
stationNo, _ := strconv.Atoi(r.URL.Query().Get("stationNo"))
if stationNo <= 0 {
fail(w, http.StatusBadRequest, "stationNo 必填")
return
}
list, err := ctx.EntClient.ReturnOrder.Query().
Where(returnorder.StationNoEQ(stationNo)).
Order(ent.Desc("created_at"), ent.Desc("id")).
Limit(100).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
ok(w, list)
}
}
// pendingAgvReturnsInternalHandler GET /api/internal/return-order/pending-agv
// 待自动派车退料单(PENDING + 运输方式=agv + 未派车)——MES 自动派车扫描轮询本接口。
func pendingAgvReturnsInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
list, err := ctx.EntClient.ReturnOrder.Query().
Where(
returnorder.StatusEQ("PENDING"),
returnorder.TransportModeEQ("agv"),
returnorder.DispatchedAtEQ(0),
returnorder.ReturnDockNEQ(""),
).Order(ent.Asc("id")).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
out := make([]map[string]any, 0, len(list))
for _, ro := range list {
out = append(out, map[string]any{
"returnNo": ro.ReturnNo, "returnDock": ro.ReturnDock,
"stationNo": ro.StationNo, "orderNo": ro.OrderNo,
})
}
ok(w, out)
}
}
// markReturnDispatchedInternalHandler POST /api/internal/return-order/mark-dispatched {returnNo}
// MES 自动派车成功后回写派车标记(防重复派车)。
func markReturnDispatchedInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
ReturnNo string `json:"returnNo"`
}
if err := parseJSON(r, &req); err != nil || req.ReturnNo == "" {
fail(w, http.StatusBadRequest, "returnNo 必填")
return
}
if _, err := ctx.EntClient.ReturnOrder.Update().
Where(returnorder.ReturnNoEQ(req.ReturnNo), returnorder.StatusEQ("PENDING")).
SetDispatchedAt(time.Now().Unix()).Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
ok(w, map[string]any{"ok": true})
}
}
// returnedSummaryInternalHandler GET /api/internal/return-order/returned-summary?stationNo=
// 已退余量汇总(同工单+物料+工位 已提交退料合计;PENDING+RECEIVED 计入,已取消不计)。
// 余量参考值数据源之一:剩余余量 = 应剩余量 − 已退余量 − 已损耗(MES 聚合)。
func returnedSummaryInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
stationNo, _ := strconv.Atoi(r.URL.Query().Get("stationNo"))
if stationNo <= 0 {
fail(w, http.StatusBadRequest, "stationNo 必填")
return
}
rows, err := ctx.EntClient.ReturnOrder.Query().
Where(
returnorder.StationNoEQ(stationNo),
returnorder.StatusIn("PENDING", "RECEIVED"),
).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
type key struct{ orderNo, code string }
sum := map[key]int{}
for _, ro := range rows {
sum[key{orderNo: ro.OrderNo, code: ro.MaterialCode}] += ro.Qty
}
out := make([]map[string]any, 0, len(sum))
for k, v := range sum {
out = append(out, map[string]any{"orderNo": k.orderNo, "materialCode": k.code, "returnedQty": v})
}
ok(w, out)
}
}
// returnReferenceHandler GET /api/return-order/reference?stationNo=
// 余量参考值(WMS 代退料展示):转发 MES 聚合结果(应剩余量−已退余量−已损耗)。
// 参考值仅展示不阻断提交(G2),库管可修改实际退量。
func returnReferenceHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
stationNo, _ := strconv.Atoi(r.URL.Query().Get("stationNo"))
if stationNo <= 0 {
fail(w, http.StatusBadRequest, "stationNo 必填")
return
}
if ctx.Mes == nil {
fail(w, http.StatusBadGateway, "MES 未连接,无法计算参考值")
return
}
rows, err := ctx.Mes.FetchReturnReference(r.Context(), stationNo)
if err != nil {
fail(w, http.StatusBadGateway, "参考值获取失败(MES 不可达): "+err.Error())
return
}
ok(w, rows)
}
}
+24
View File
@@ -104,10 +104,23 @@ func RegisterHandlers(server *rest.Server, ctx *svc.ServiceContext) {
{Method: http.MethodPost, Path: "/api/call/reject", Handler: requirePerm(ctx, "call:manage", callRejectHandler(ctx))},
// AGV 三段链装货确认(2026-11-03 三层机制):到位待令 → 库管「确认装车并送货」
{Method: http.MethodPost, Path: "/api/call/confirm-load", Handler: requirePerm(ctx, "call:manage", ConfirmCallLoadHandler(ctx))},
// 库管人工派车(2026-11-03 定论:废除备料完成自动派车):点「送货」AGV 才出发
{Method: http.MethodPost, Path: "/api/call/dispatch", Handler: requirePerm(ctx, "call:manage", DispatchCallHandler(ctx))},
// 托盘工作台(2026-11-03):接驳台台账列表 + 手动派 AGV 回收空托盘(单点步进、到位待令)
{Method: http.MethodGet, Path: "/api/pallet/docks", Handler: PalletDocksHandler(ctx)},
{Method: http.MethodGet, Path: "/api/pallet/station-docks", Handler: StationDocksProxyHandler(ctx)},
{Method: http.MethodPost, Path: "/api/pallet/dispatch", Handler: requirePerm(ctx, "call:manage", PalletDispatchHandler(ctx))},
// E4 托盘余料明细(2026-11-04 拍板):代发起退料弹窗自动带出(只读转发 MES)
{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)},
},
)
// P1 备料清单(2026-11-04 用户拍板):只读展示"今天及以后×工单×工位×物料×数量",数据源 MES 日排产实时算
server.AddRoutes(
[]rest.Route{
{Method: http.MethodGet, Path: "/api/preparation/list", Handler: requirePerm(ctx, "preparation:view", queryPreparationListHandler(ctx))},
},
)
@@ -205,6 +218,11 @@ func RegisterHandlers(server *rest.Server, ctx *svc.ServiceContext) {
{Method: http.MethodGet, Path: "/api/return-order/suggest-location", Handler: suggestReturnLocationHandler(ctx)},
// 库管代工位退料(2026-11-03 拍板):库管替操作工建退库单(选工位/工单/物料/数量/接驳台)
{Method: http.MethodPost, Path: "/api/return-order/manual", Handler: createReturnOrderInternalHandler(ctx)},
// 取消 PENDING 退料单(2026-11-04 拍板:库房可取消工位申请;已收货不可取消;联动作废未完成 AGV 任务)
{Method: http.MethodPost, Path: "/api/return-order/cancel", Handler: cancelReturnOrderHandler(ctx)},
// 余量参考值(2026-11-04 定稿:剩余余量=应剩余量−已退余量−已损耗,转发 MES 聚合;仅展示不阻断)
{Method: http.MethodGet, Path: "/api/return-order/reference", Handler: returnReferenceHandler(ctx)},
// D1 工单备料台账已于 2026-11-04 按用户拍板移除(台账页/路由/权限一并退役,不再复活)
},
)
@@ -330,6 +348,12 @@ func RegisterHandlers(server *rest.Server, ctx *svc.ServiceContext) {
{Method: http.MethodGet, Path: "/api/internal/materials", Handler: wrapInternal(ctx)(queryMaterialsHandler(ctx))},
{Method: http.MethodGet, Path: "/api/internal/material/list-all", Handler: wrapInternal(ctx)(listMaterialsHandler(ctx))},
{Method: http.MethodPost, Path: "/api/internal/return-order", Handler: wrapInternal(ctx)(createReturnOrderInternalHandler(ctx))},
// 取消退料单/派车标记/工位列表/已退汇总(2026-11-04 口径定稿)
{Method: http.MethodPost, Path: "/api/internal/return-order/cancel", Handler: wrapInternal(ctx)(cancelReturnOrderInternalHandler(ctx))},
{Method: http.MethodGet, Path: "/api/internal/return-order/station-list", Handler: wrapInternal(ctx)(stationReturnListInternalHandler(ctx))},
{Method: http.MethodGet, Path: "/api/internal/return-order/pending-agv", Handler: wrapInternal(ctx)(pendingAgvReturnsInternalHandler(ctx))},
{Method: http.MethodPost, Path: "/api/internal/return-order/mark-dispatched", Handler: wrapInternal(ctx)(markReturnDispatchedInternalHandler(ctx))},
{Method: http.MethodGet, Path: "/api/internal/return-order/returned-summary", Handler: wrapInternal(ctx)(returnedSummaryInternalHandler(ctx))},
// MES 质量检验(过程检/完工检)判不合格 → 联动 WMS 在库处置(按物料+SN/批次定位库存行)
{Method: http.MethodPost, Path: "/api/internal/inventory/dispose", Handler: wrapInternal(ctx)(internalInventoryDisposeHandler(ctx))},
// AGV 到位回写(MES AGV 回调调用):出库单 已出库 → 已送达(补齐状态机无写者的断头路)