Files
bj_power/bj_power_wms/internal/handler/outbound.go
T
SunYF 1d1dc1bdd8 按模块说明
一、MES — 叫料单扩展(schema + 逻辑)​

material_request 新增字段:packageNo(叫料包号,一次提交=一包)、callDate(叫料日,默认当天)、planBreakdown(jsonb,工单×排产日明细 []CallPlanBreakdown);targetDock 语义降级为"期望接驳台(可空,配送时 WMS 确定实际台)"。
新增 internal/logic/call_plan.go:实时计算「叫料需求明细(工单×排产日×物料)」,派生两类提示(当日剩余未叫 / 跨日量明细),不落库、不拦提交;接驳台空台校验 EnsureStationDocksEmpty、托盘回库 DispatchPalletReturnManual、人工清台 ClearDockLedger、配送单派车 DispatchDeliveryAgv、工位物料明细 StationMaterialDetail。
新增 internal/handler/production/call_pkg.go:8 个 MES 内部端点(X-API-TOKEN 网关),供 WMS 调用——叫料需求明细、按包查单、接驳台状态、托盘回库、人工清台、配送单派车、叫料池原始行、工位物料明细、WMS 代叫料。
internal/handler/production/call.go、internal/logic/call.go、agv.go、qty_report.go、routes_production.go、wmsclient/client.go、db.go 同步接入上述逻辑。
二、WMS — 配送单(新功能,叫料与送料彻底拆开)​

新增 schema/delivery_order.go + delivery_order_item.go 及 ent 生成代码:delivery_order(PENDING→DISPATCHED→DONE / CANCELLED,一单=一次托盘配送)、delivery_order_item(配送物料明细快照:工单/工艺/排产日)。
新增 internal/handler/delivery.go + 路由 + DeliveryOrders.vue 页面(仓储作业 → 配送单)。
mesclient/client.go 扩展:MES 叫料单结构补 packageNo/callDate/workOrderNo/planBreakdown,新增 PoolRow/DockPalletState/DeliveryAgvItem/getJSON 等。
CallQueue.vue:按叫料包展示,新增「代叫料」「建配送单」按钮与对话框;出库单回写所属配送单号(outbound_order 加字段);AGV 派送改由配送单驱动。
三、工位终端 — 叫料体验升级

MaterialPanel.vue:新增「本工位物料明细」卡(工艺物料全集×工位账四数,量为 0 也显示);叫料改为「叫料包」模式(默认当天、可勾选分批、可选其他排产日、期望接驳台可空),新增叫料日选择器、两条提示横幅(当日剩余未叫 / 跨日量明细)、托盘回库按钮。
InspectPanel.vue/Main.vue/OnlinePanel.vue/OfflinePanel.vue/WorkPanel.vue/SyncQueueDialog.vue/api/index.js/internal/handler/line.go/routes.go 同步接入接驳台状态、托盘回库、下班双台空台校验等。
web/static/index.html 构建刷新。
四、文档

案例.md:重写第 5/6/8/9 节与新「配送单」流程,补「模拟模式跳过接驳台校验」说明,库管员菜单加「配送单」;并修正"本单箱体"等措辞歧义。
客户问题.md:同步本轮拍板口径。
五、构建产物 / 同步

多个 MES 前端页面(.vue)随本次改动统一重新构建刷新;ent 生成代码(MES material_request、WMS delivery_order/outbound_order 相关)随 schema 更新重新生成。
2026-11-05 19:18:18 +08:00

707 lines
26 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package handler
import (
"encoding/json"
"net/http"
"strings"
"time"
"bj_power_wms/ent"
"bj_power_wms/ent/inventory"
"bj_power_wms/ent/material"
"bj_power_wms/ent/outbounddetail"
"bj_power_wms/ent/outboundorder"
"bj_power_wms/internal/svc"
"github.com/zeromicro/go-zero/core/logx"
)
// queryOutboundHandler 出库单查询
// 客户诉求 L96-108:按 归属单号 / 名称图号 / 日期范围 / 目标工位 查询,多条件取交集;
// 修复此前"前端传了 outboundType/日期但后端忽略"的缺陷。
func queryOutboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
page := atoi(r.URL.Query().Get("page"), 1)
pageSize := atoi(r.URL.Query().Get("pageSize"), 20)
orderNo := r.URL.Query().Get("orderNo")
materialCode := r.URL.Query().Get("materialCode")
outboundNo := r.URL.Query().Get("outboundNo")
boxNo := r.URL.Query().Get("boxNo")
outboundType := r.URL.Query().Get("outboundType")
outboundCategory := r.URL.Query().Get("outboundCategory")
ownershipNo := r.URL.Query().Get("ownershipNo")
materialName := r.URL.Query().Get("materialName")
targetStation := r.URL.Query().Get("targetStation")
status := r.URL.Query().Get("status")
inspectionNo := r.URL.Query().Get("inspectionNo")
q := ctx.EntClient.OutboundOrder.Query()
if status != "" {
q = q.Where(outboundorder.StatusEQ(status))
}
if orderNo != "" {
q = q.Where(outboundorder.OrderNoEqualFold(orderNo))
}
if materialCode != "" {
q = q.Where(outboundorder.MaterialCodeEqualFold(materialCode))
}
if outboundNo != "" {
q = q.Where(outboundorder.OutboundNoEqualFold(outboundNo))
}
if boxNo != "" {
q = q.Where(outboundorder.BoxNoContainsFold(boxNo))
}
if ownershipNo != "" {
q = q.Where(outboundorder.OwnershipNoContainsFold(ownershipNo))
}
if outboundType != "" {
q = q.Where(outboundorder.OutboundTypeEQ(outboundType))
}
if outboundCategory != "" {
q = q.Where(outboundorder.OutboundCategoryEQ(outboundCategory))
}
if materialName != "" {
q = q.Where(outboundorder.MaterialNameContainsFold(materialName))
}
if targetStation != "" {
q = q.Where(outboundorder.TargetStationEQ(targetStation))
}
if inspectionNo != "" {
q = q.Where(outboundorder.InspectionNoContainsFold(inspectionNo))
}
if v := r.URL.Query().Get("productWorkNo"); v != "" {
q = q.Where(outboundorder.ProductWorkNoContainsFold(v))
}
if v := r.URL.Query().Get("startDate"); v != "" {
if t, err := time.ParseInLocation("2006-01-02", v, time.Local); err == nil {
q = q.Where(outboundorder.CreatedAtGTE(t.Unix()))
}
}
if v := r.URL.Query().Get("endDate"); v != "" {
if t, err := time.ParseInLocation("2006-01-02", v, time.Local); err == nil {
q = q.Where(outboundorder.CreatedAtLTE(t.Add(24 * time.Hour).Unix()))
}
}
total, err := q.Count(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
list, err := q.Order(ent.Desc("created_at"), ent.Desc("id")).
Offset((page - 1) * pageSize).Limit(pageSize).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
// 附带明细
type row struct {
*ent.OutboundOrder
Details []*ent.OutboundDetail `json:"details"`
}
rows := make([]row, 0, len(list))
for _, ob := range list {
details, _ := ctx.EntClient.OutboundDetail.Query().
Where(outbounddetail.OutboundNoEQ(ob.OutboundNo)).
All(ctx0())
rows = append(rows, row{ob, details})
}
ok(w, map[string]any{
"total": total,
"list": rows,
"page": page,
"pageSize": pageSize,
})
}
}
// generalOutboundRequest 通用出库请求(不依赖 MES 工单)
// 客户诉求 问题记录 L96-108:通用出库先点选类别(退料/样品/报废/发货/其他手输),
// 并记录归属(工单号/科技项目号/其他)与目标工位。
type generalOutboundRequest struct {
MaterialCode string `json:"materialCode"`
BatchNo string `json:"batchNo"`
SnList []string `json:"snList"`
Qty int `json:"qty"`
Operator string `json:"operator"`
ZoneCode string `json:"zoneCode"`
ShelfNo string `json:"shelfNo"`
LayerNo string `json:"layerNo"`
PositionNo string `json:"positionNo"`
BoxNo string `json:"boxNo"`
ContractNo string `json:"contractNo"`
Remark string `json:"remark"`
OutboundNo string `json:"outboundNo"` // 可选:留空自动生成;填了必须唯一(如 OB20260921-001)
OutboundCategory string `json:"outboundCategory"` // return(退料)/supplier_return(退货退供应商)/sample(样品)/scrap(报废)/deliver(发货)/other(其他)
InspectionNo string `json:"inspectionNo"` // 可选:检测单号,退货/报废等需溯源检验单据
OwnershipType string `json:"ownershipType"` // workorder/project/other
OwnershipNo string `json:"ownershipNo"`
TargetStation string `json:"targetStation"`
TargetDock string `json:"targetDock"` // 目标接驳台(叫AGV时必填)
NeedAgv bool `json:"needAgv"` // 是否叫AGV配送到接驳台(可选)
BorrowFrom map[string]int `json:"borrowFrom"` // 跨工位借料来源(call 备料出库专用):stationNo→借用量(已排除本工位自取)
}
// makeOutboundHandler 通用出库 / 科技项目出库 共用工厂(B1/B2 逻辑拆分)。
// 两者底层完全一致(出库单 + 库存扣减 + 出库明细 原子提交;库存用条件原子更新避免负库存),
// 仅 outboundType(单据类型)与归属(ownership) 不同:
// - outboundType="general" → 通用出库(归属可选 合同号/其他,拒绝科技项目号)
// - outboundType="project" → 科技项目出库(强锁归属=科技项目号)
// 支持序列号=否(数量)与序列号=是(SN),序列号方式按物料档案 sn_mode 分叉(2026-09-30 解耦);
// 填箱号时一并把装箱信息(箱号/SN清单/合同号)落到统一的出库主表,不再另建装箱表。
func makeOutboundHandler(ctx *svc.ServiceContext, outboundType string) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req generalOutboundRequest
if err := parseJSON(r, &req); err != nil {
fail(w, http.StatusBadRequest, "参数错误: "+err.Error())
return
}
// B1/B2 逻辑拆分:科技项目出库(project) 与 通用出库(general) 共用本流程,仅单据类型与归属不同。
if outboundType == "project" {
req.OwnershipType = "project" // 科技项目出库强锁归属=科技项目号
} else if req.OwnershipType == "project" {
fail(w, http.StatusBadRequest, "通用出库不支持「科技项目号」归属,请使用「科技项目出库」入口")
return
}
if req.MaterialCode == "" {
fail(w, http.StatusBadRequest, "materialCode 必填")
return
}
if req.BatchNo == "" && len(req.SnList) == 0 {
fail(w, http.StatusBadRequest, "batchNo 或 snList 至少提供一个")
return
}
// 物料档案:sn_mode 守卫 + 出库单冗余类型
m, merr := ctx.EntClient.Material.Query().
Where(material.CodeEQ(req.MaterialCode)).
Only(ctx0())
if merr != nil {
fail(w, http.StatusBadRequest, "物料不存在: "+req.MaterialCode)
return
}
// sn_mode 守卫(2026-09-30 解耦定稿):物料档案未设置序列号(是/否),禁止出库
if m.SnMode == snModeUnset {
fail(w, http.StatusBadRequest, "请先在物料档案设置序列号(是/否)")
return
}
// 客户诉求 L96-108:出库类别必选;选「其他」时备注必填(承载手输原因)
if req.OutboundCategory == "" {
fail(w, http.StatusBadRequest, "出库类别必选(退料/样品/报废/发货/其他)")
return
}
if req.OutboundCategory == "other" && strings.TrimSpace(req.Remark) == "" {
fail(w, http.StatusBadRequest, "出库类别为「其他」时必须填写原因")
return
}
// 序列号方式(2026-09-30 解耦):按提交内容推导——带 SN 清单=序列号=是,否则=序列号=否(数量)
snMode := snModeBatch
if len(req.SnList) > 0 {
snMode = snModeSN
}
// SN 出库数量以列表长度计
actualQty := req.Qty
if snMode == snModeSN {
actualQty = len(req.SnList)
}
if actualQty <= 0 {
fail(w, http.StatusBadRequest, "数量必须大于 0")
return
}
// 盘点冻结守卫(问题2):盘点期间该批库存禁止出库。
if !assertNotFrozenTargets(ctx, w, req.BatchNo, req.SnList) {
return
}
// 四级库位:条9 强校验——显式填了任一层级即校验 SN/批次所在货位与所填一致;
// 全部未填才走兜底(不强制)
specZone, specShelf, specLayer, specPos := req.ZoneCode, req.ShelfNo, req.LayerNo, req.PositionNo
locSpecified := specZone != "" || specShelf != "" || specLayer != "" || specPos != ""
// 库位兜底(与工单出库同口径):未填的层级按「批次在库 → 首个 SN 在库」补全
req.ZoneCode, req.ShelfNo, req.LayerNo, req.PositionNo =
outboundLocationFallback(ctx, req.BatchNo, req.SnList, req.ZoneCode, req.ShelfNo, req.LayerNo, req.PositionNo)
outboundNo := strings.TrimSpace(req.OutboundNo)
if outboundNo != "" {
if err := validateUniqueNo(ctx, "OB", outboundNo); err != nil {
fail(w, http.StatusBadRequest, err.Error())
return
}
} else {
no, err := nextDailyNo(ctx, "OB")
if err != nil {
fail(w, http.StatusInternalServerError, "生成出库单号失败: "+err.Error())
return
}
outboundNo = no
}
tx, err := ctx.EntClient.Tx(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, "开启事务失败: "+err.Error())
return
}
committed := false
defer func() {
if !committed {
_ = tx.Rollback()
}
}()
pw := "" // 产品工号:从源库存取,出库单创建后回填(五页带出)
obCreate := tx.OutboundOrder.Create().
SetOutboundNo(outboundNo).
SetOutboundType(outboundType).
SetStatus("已出库").
SetNeedAgv(req.NeedAgv).
SetNillableTargetDock(strPtr(req.TargetDock)).
SetNillableOutboundCategory(strPtr(req.OutboundCategory)).
SetNillableOwnershipType(strPtr(req.OwnershipType)).
SetNillableOwnershipNo(strPtr(req.OwnershipNo)).
SetNillableInspectionNo(strPtr(req.InspectionNo)).
SetNillableTargetStation(strPtr(req.TargetStation)).
SetMaterialCode(req.MaterialCode).
SetManageMode(m.ManageMode).
SetSnMode(snMode).
SetNillableBatchNo(strPtr(req.BatchNo)).
SetNillableZoneCode(strPtr(req.ZoneCode)).
SetNillableShelfNo(strPtr(req.ShelfNo)).
SetNillableLayerNo(strPtr(req.LayerNo)).
SetNillablePositionNo(strPtr(req.PositionNo)).
SetQuantity(0).
SetNillableOperator(strPtr(req.Operator)).
SetNillableRemark(strPtr(req.Remark)).
SetNillableBoxNo(strPtr(req.BoxNo)).
SetNillableContractNo(strPtr(req.ContractNo))
if len(req.BorrowFrom) > 0 {
obCreate.SetBorrowFrom(req.BorrowFrom)
}
ob, err := obCreate.Save(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, "创建出库单失败: "+err.Error())
return
}
// 批次扣减(序列号=否,按数量)
if req.BatchNo != "" {
bq := tx.Inventory.Query().
Where(inventory.SnModeEQ(snModeBatch), inventory.BatchNoEQ(req.BatchNo), inventory.MaterialCodeEQ(req.MaterialCode),
inventory.StatusIn("在库", "锁定")) // 条9 前置:仅允许对在库/锁定库存行出库(必须有有效库存行)
// 条9:指定了库位时按该库位的批次行校验可用量
if locSpecified {
if specZone != "" {
bq = bq.Where(inventory.ZoneCodeEQ(specZone))
}
if specShelf != "" {
bq = bq.Where(inventory.ShelfNoEQ(specShelf))
}
if specLayer != "" {
bq = bq.Where(inventory.LayerNoEQ(specLayer))
}
if specPos != "" {
bq = bq.Where(inventory.PositionNoEQ(specPos))
}
}
b, err := bq.Only(ctx0())
if err != nil {
// 区分「批次不存在」「批次不属于所选物料」「不在指定库位」三种情况给出明确中文错误
if locSpecified {
if exist, e2 := tx.Inventory.Query().
Where(inventory.SnModeEQ(snModeBatch), inventory.BatchNoEQ(req.BatchNo), inventory.MaterialCodeEQ(req.MaterialCode)).
Exist(ctx0()); e2 == nil && exist {
fail(w, http.StatusBadRequest, "SN/批次不在指定库位: "+req.BatchNo)
return
}
}
if exist, e2 := tx.Inventory.Query().
Where(inventory.SnModeEQ(snModeBatch), inventory.BatchNoEQ(req.BatchNo)).
Exist(ctx0()); e2 == nil && exist {
fail(w, http.StatusBadRequest, "批次不属于所选物料: "+req.BatchNo+" / "+req.MaterialCode)
return
}
fail(w, http.StatusBadRequest, "批次不存在: "+req.BatchNo)
return
}
pw = b.ProductWorkNo // 取源库存产品工号,回填出库单
// 质量门禁(U5,客户口径):发货/样品/其他类出库仅允许「合格」品流向下游;
// 退货/报废/退料类豁免(本身即处置不合格品)。
if outboundBlocksUnqualified(req.OutboundCategory) && !qualityShippable(b.QualityStatus) {
fail(w, http.StatusConflict, "批次 "+req.BatchNo+" 质量状态为「"+qualityLabel(b.QualityStatus)+"」,"+outboundCategoryLabel(req.OutboundCategory)+"出库仅允许合格品(请先完成质量检验/处置)")
return
}
avail := b.Quantity - b.LockedQty
if avail < actualQty {
fail(w, http.StatusConflict, "批次库存不足: 物料「"+m.Name+"("+req.MaterialCode+")」批次 "+req.BatchNo+" 需要 "+itoa(actualQty)+",可用 "+itoa(avail))
return
}
aff, err := tx.Inventory.Update().
Where(inventory.ID(b.ID), inventory.QuantityGTE(actualQty)).
AddQuantity(-actualQty).
AddLockedQty(-min(actualQty, b.LockedQty)).
Save(ctx0())
if err != nil || aff == 0 {
fail(w, http.StatusConflict, "批次扣减失败(库存不足或并发冲突): "+req.BatchNo)
return
}
// 同步核销本批次的 ACTIVE 锁记录(FIFO 递减,扣到 0 置 CONSUMED),消除残留锁
consumeLocksForBatch(tx, req.BatchNo, req.MaterialCode, min(actualQty, b.LockedQty))
if _, err = tx.OutboundDetail.Create().
SetOutboundNo(outboundNo).
SetBatchNo(req.BatchNo).
SetMaterialCode(req.MaterialCode).
SetQuantity(actualQty).
Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "创建出库明细失败: "+err.Error())
return
}
}
// SN 扣减(序列号=是):仅在库/锁定的 SN 可出库
if len(req.SnList) > 0 {
// 质量门禁(U5,客户口径):发货/样品/其他类出库仅允许「合格」SN;退货/报废/退料类豁免。
if outboundBlocksUnqualified(req.OutboundCategory) {
passCnt, _ := tx.Inventory.Query().
Where(inventory.SnModeEQ(snModeSN), inventory.SnCodeIn(req.SnList...),
inventory.MaterialCodeEQ(req.MaterialCode), inventory.QualityStatusIn(QStatusPass)).
Count(ctx0())
if passCnt < len(req.SnList) {
fail(w, http.StatusConflict, "所选 SN 含非合格品(未检/不合格/待退),"+outboundCategoryLabel(req.OutboundCategory)+"出库仅允许合格品(请先完成质量检验/处置)")
return
}
}
for _, sn := range req.SnList {
// 条9 强校验:SN 须属于所选物料,且(填了任一库位层级时)所在货位须与所填一致
invRow, e := tx.Inventory.Query().
Where(inventory.SnModeEQ(snModeSN), inventory.SnCodeEQ(sn), inventory.MaterialCodeEQ(req.MaterialCode)).
Only(ctx0())
if e != nil {
fail(w, http.StatusBadRequest, "SN 不存在或不属于该物料: "+sn)
return
}
if locSpecified && !locationMatches(invRow, specZone, specShelf, specLayer, specPos) {
fail(w, http.StatusBadRequest, "SN/批次不在指定库位")
return
}
if pw == "" {
pw = invRow.ProductWorkNo
}
aff, err := tx.Inventory.Update().
Where(inventory.SnModeEQ(snModeSN), inventory.SnCodeEQ(sn),
inventory.MaterialCodeEQ(req.MaterialCode), inventory.StatusIn("在库", "锁定")).
SetStatus("出库").
SetNillableZoneCode(strPtr(req.ZoneCode)).
Save(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, "SN 出库失败: "+sn+" "+err.Error())
return
}
if aff == 0 {
fail(w, http.StatusBadRequest, "SN 不可出库(非在库/锁定): "+sn)
return
}
// 同步核销该 SN 的 ACTIVE 锁记录,消除残留锁
consumeLocksForSN(tx, []string{sn})
if _, err = tx.OutboundDetail.Create().
SetOutboundNo(outboundNo).
SetSnCode(sn).
SetMaterialCode(req.MaterialCode).
SetQuantity(1).
Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "创建出库明细失败: "+err.Error())
return
}
}
}
// 回写实际数量 + 装箱 SN 清单(JSON)
upd := tx.OutboundOrder.UpdateOneID(ob.ID).SetQuantity(actualQty)
if len(req.SnList) > 0 && req.BoxNo != "" {
upd.SetBoxSnList(snListJSON(req.SnList))
}
if _, err = upd.Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "更新出库单失败: "+err.Error())
return
}
// 回填产品工号(从源库存取,五页带出展示/筛选)
if pw != "" {
if _, e := tx.OutboundOrder.UpdateOneID(ob.ID).SetNillableProductWorkNo(strPtr(pw)).Save(ctx0()); e != nil {
fail(w, http.StatusInternalServerError, "回填产品工号失败: "+e.Error())
return
}
}
if err = tx.Commit(); err != nil {
fail(w, http.StatusInternalServerError, "提交事务失败: "+err.Error())
return
}
committed = true
typeLabel := "通用出库"
if outboundType == "project" {
typeLabel = "科技项目出库"
}
ctx.EventLog.Write(ctx0(), "outbound."+outboundType, r.Header.Get("X-Username"), "outbound", outboundNo,
typeLabel+" "+req.MaterialCode+" ×"+itoa(actualQty),
map[string]any{"qty": actualQty, "boxNo": req.BoxNo, "snCount": len(req.SnList)})
logx.Infof("%s outbound: material=%s qty=%d box=%s", outboundType, req.MaterialCode, actualQty, req.BoxNo)
ok(w, map[string]any{
"outboundNo": outboundNo,
"qty": actualQty,
"boxNo": req.BoxNo,
"type": outboundType,
})
}
}
// snListJSON 把 SN 列表序列化为 JSON 数组字符串
func snListJSON(sn []string) string {
b, err := json.Marshal(sn)
if err != nil {
return "[]"
}
return string(b)
}
// exportOutboundHandler 统一主表全部出库记录导出
// 不依赖前端分页,一次返回全部(可按类型/工单/物料/箱号/归属单号过滤),便于整表导出。
func exportOutboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
outboundType := r.URL.Query().Get("outboundType")
status := r.URL.Query().Get("status")
orderNo := r.URL.Query().Get("orderNo")
materialCode := r.URL.Query().Get("materialCode")
boxNo := r.URL.Query().Get("boxNo")
ownershipNo := r.URL.Query().Get("ownershipNo")
startDate, endDate, rerr := normalizeExportRange(r.URL.Query().Get("startDate"), r.URL.Query().Get("endDate"))
if rerr != nil {
fail(w, http.StatusBadRequest, rerr.Error())
return
}
startUnix, endUnix := exportRangeUnix(startDate, endDate)
q := ctx.EntClient.OutboundOrder.Query()
q = q.Where(outboundorder.CreatedAtGTE(startUnix), outboundorder.CreatedAtLTE(endUnix))
if outboundType != "" {
q = q.Where(outboundorder.OutboundTypeEQ(outboundType))
}
if status != "" {
q = q.Where(outboundorder.StatusEQ(status))
}
if orderNo != "" {
q = q.Where(outboundorder.OrderNoEqualFold(orderNo))
}
if materialCode != "" {
q = q.Where(outboundorder.MaterialCodeEqualFold(materialCode))
}
if boxNo != "" {
q = q.Where(outboundorder.BoxNoContainsFold(boxNo))
}
if ownershipNo != "" {
q = q.Where(outboundorder.OwnershipNoContainsFold(ownershipNo))
}
list, err := q.Order(ent.Desc("created_at"), ent.Desc("id")).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
type exportRow struct {
*ent.OutboundOrder
SnCodes string `json:"snCodes"`
Details []*ent.OutboundDetail `json:"details"`
}
rows := make([]exportRow, 0, len(list))
for _, ob := range list {
details, _ := ctx.EntClient.OutboundDetail.Query().
Where(outbounddetail.OutboundNoEQ(ob.OutboundNo)).
All(ctx0())
er := exportRow{OutboundOrder: ob, SnCodes: "", Details: details}
sns := make([]string, 0, len(details))
for _, d := range details {
if d.SnCode != "" {
sns = append(sns, d.SnCode)
}
}
if len(sns) > 0 {
er.SnCodes = strings.Join(sns, ",")
}
rows = append(rows, er)
}
// xlsx 导出
if r.URL.Query().Get("format") == "xlsx" {
headers := []string{"出库单号", "类型", "状态", "类别", "工单号", "归属单号", "图号", "物料名称", "库位", "数量", "目标工位", "装箱号", "合同号", "SN清单", "创建时间"}
matrix := make([][]any, 0, len(rows))
for _, row := range rows {
ob := row.OutboundOrder
matrix = append(matrix, []any{
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,
unixFmt(ob.CreatedAt),
})
}
sendExcel(w, xlsxFilename("出库管理"), headers, matrix)
return
}
ok(w, map[string]any{"total": len(rows), "list": rows})
}
}
func min(a, b int) int {
if a < b {
return a
}
return b
}
// isDuplicateOutboundNo 判定 DB 错误是否唯一约束冲突(出库单号 ux_outbound_orders_outbound_no)。
// 用于幂等键并发落库时把 500 转为幂等复用,避免重复扣减。
func isDuplicateOutboundNo(err error) bool {
if err == nil {
return false
}
msg := strings.ToLower(err.Error())
return strings.Contains(msg, "ux_outbound_orders_outbound_no") ||
strings.Contains(msg, "duplicate key") ||
strings.Contains(msg, "violates unique constraint")
}
// locationMatches 条9 库位强校验:按「用户显式填了的层级」逐级比对库存行货位,
// 未填的层级不参与比较(任一层级不一致即判定不在指定库位)。
func locationMatches(row *ent.Inventory, zone, shelf, layer, pos string) bool {
if zone != "" && row.ZoneCode != zone {
return false
}
if shelf != "" && row.ShelfNo != shelf {
return false
}
if layer != "" && row.LayerNo != layer {
return false
}
if pos != "" && row.PositionNo != pos {
return false
}
return true
}
// locationText 库位展示串。入库/出库/库存统一口径:`Z02 A架/3层/12位`,无内容返回空串。
// outboundLocationFallback 出库四级库位兜底(客户诉求 一.9「出库相同」)。
//
// 调用方(MES 备料自动出库、前端手工出库)可能只传了区域甚至什么都没传;
// 这里按「指定批次在库的实际货位 → 首个出库 SN 在库的实际货位」顺序,
// 把**缺失的层级**补全,使出库单、列表、导出都能留痕到具体货位(货架/层/位置号)。
// 只补空值、不覆盖调用方显式指定的值。
func outboundLocationFallback(ctx *svc.ServiceContext, batchNo string, snList []string,
zoneCode, shelfNo, layerNo, positionNo string) (string, string, string, string) {
if zoneCode != "" && shelfNo != "" && layerNo != "" && positionNo != "" {
return zoneCode, shelfNo, layerNo, positionNo
}
var src *ent.Inventory
if batchNo != "" {
src, _ = ctx.EntClient.Inventory.Query().
Where(inventory.SnModeEQ(snModeBatch), inventory.BatchNoEQ(batchNo)).Only(ctx0())
}
if src == nil && len(snList) > 0 {
src, _ = ctx.EntClient.Inventory.Query().
Where(inventory.SnModeEQ(snModeSN), inventory.SnCodeEQ(snList[0])).Only(ctx0())
}
if src == nil {
return zoneCode, shelfNo, layerNo, positionNo
}
if zoneCode == "" {
zoneCode = src.ZoneCode
}
if shelfNo == "" {
shelfNo = src.ShelfNo
}
if layerNo == "" {
layerNo = src.LayerNo
}
if positionNo == "" {
positionNo = src.PositionNo
}
return zoneCode, shelfNo, layerNo, positionNo
}
// locationText 库位显示文案(区域/货架/层/位置号)——列表与导出共用。
func locationText(zoneCode, shelfNo, layerNo, positionNo string) string {
parts := make([]string, 0, 3)
if shelfNo != "" {
parts = append(parts, shelfNo+"架")
}
if layerNo != "" {
parts = append(parts, layerNo+"层")
}
if positionNo != "" {
parts = append(parts, positionNo+"位")
}
loc := strings.Join(parts, "/")
if zoneCode == "" {
return loc
}
if loc == "" {
return zoneCode
}
return zoneCode + " " + loc
}
// outboundCategoryLabel 出库类别显示中文(客户诉求 L96-108:退料/样品/报废/发货/其他)
// outboundTypeLabel 出库类型中文(界面禁英文)
func outboundTypeLabel(v string) string {
switch v {
case "workorder":
return "备料出库"
case "refill":
return "补料出库"
case "general":
return "通用出库"
case "project":
return "科技项目出库"
default:
return "通用出库"
}
}
func outboundCategoryLabel(v string) string {
switch v {
case "return":
return "退料"
case "sample":
return "样品"
case "scrap":
return "报废"
case "deliver":
return "发货"
case "supplier_return":
return "退货"
case "call":
return "叫料配送"
case "other":
return "其他"
default:
return ""
}
}
// outboundBlocksUnqualified 出库质量门禁判定(U5,客户口径):
// 发货(deliver)/样品(sample)/其他(other) 及任何未知类别 → 拦截不合格/待退品(默认拦截,避免漏洞);
// 退货(supplier_return,退回供应商)/报废(scrap)/退料(return,工位退料) → 豁免(本身即在处置不合格品)。
func outboundBlocksUnqualified(category string) bool {
switch category {
case "supplier_return", "scrap", "return":
return false
default:
return true
}
}