@@ -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 )
}
}