package handler import ( "fmt" "net/http" "sort" "strings" "time" "bj_power_wms/ent" "bj_power_wms/ent/inventory" "bj_power_wms/ent/inventorylock" "bj_power_wms/ent/material" "bj_power_wms/ent/predicate" "bj_power_wms/ent/zone" "bj_power_wms/internal/svc" "entgo.io/ent/dialect/sql" ) // stockKey 库存聚合行的唯一标识(组合键)+ 明细下钻的过滤条件 // 注意(方案 §A1):质量状态不再进入分组键——质量降为"列",避免同一物料/区域被质量拆成多行。 type stockKey struct { MaterialCode string ZoneCode string ShelfNo string // 货架号(§A1:库位四级进分组键,一物一库位一行) LayerNo string // 第几层 PositionNo string // 位置号 SnMode int // 序列号 1序列号=是/2序列号=否(2026-09-30 与类型解耦) } // categoryLabel 物料类别中文名 func categoryLabel(c int) string { switch c { case invCatSemi: return "半成品" case invCatFinished: return "成品" default: return "原材料" } } // typeLabelOf 汇总行类型标签(与区域汇总「其他」口径一致):物料类型 manage_mode=3 → 其他;否则按类型标签。 func typeLabelOf(matManageMode int) string { if matManageMode == invManageOther { return "其他" } return manageModeLabel(matManageMode) } // stockAggRow 聚合主列表的行结构(按 物料+区域+序列号方式 聚合,只返回数量,不铺开明细) // 质量状态降为"列"(合格/未检/不合格三列数量),不再作为拆行维度(方案 §A1)。 // ID = 组内最近入库的库存行真实主键(inventory.id)——聚合视图无自身实体,取真实主键,禁止伪 id type stockAggRow struct { ID int64 `json:"id"` // inventory.id(组内最近入库行) MaterialCode string `json:"materialCode"` // 物料编码 MaterialName string `json:"materialName"` // 物料名称 Spec string `json:"spec"` // 规格型号 SnMode int `json:"snMode"` // 库存行序列号方式 1序列号=是(逐件SN)/2序列号=否(数量)(2026-09-30 解耦) ItemType int `json:"itemType"` // 物料类别(1原材料/3成品/4其他) MatManageMode int `json:"matManageMode"` // 物料档案类型(1结构件/2电气件/3其他):类型标签判定用 ZoneCode string `json:"zoneCode"` // 区域 ShelfNo string `json:"shelfNo"` // 货架号 LayerNo string `json:"layerNo"` // 第几层 PositionNo string `json:"positionNo"` // 位置号 QtyQualified int `json:"qtyQualified"` // 合格数量 QtyPending int `json:"qtyPending"` // 未检数量 QtyRejected int `json:"qtyRejected"` // 不合格数量 TotalQty int `json:"totalQty"` // 总数量(结构件=数量求和;电气件=SN 行数) LockedQty int `json:"lockedQty"` // 锁定量 AvailQty int `json:"availQty"` // 可用量 = 合格行数量合计 − 锁定量(= 在库 − 未检 − 不合格 − 锁定,客户口径) BatchCount int `json:"batchCount"` // 批次数量(结构件维度的行数) SnCount int `json:"snCount"` // SN 数量(电气件维度的行数) LastInboundNo string `json:"lastInboundNo"` // 最近入库单号 CreatedAt int64 `json:"createdAt"` // 最近一次入库时间(聚合组内最大 created_at) } // queryStockHandler 库存查询(主列表 = 按物料聚合数量) // 统一查询 inventory 一张表,按 物料编码+区域+质量状态+管理粒度 分组聚合, // 只返回每个物料的数量/锁定/可用与 批次数/SN数,不把每个批次/SN 平铺出来(避免 SN 泄漏与数据量膨胀)。 // 明细通过 /api/stock/details 点击下钻(分页懒加载)。 func queryStockHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { materialCode := r.URL.Query().Get("materialCode") materialName := r.URL.Query().Get("materialName") // 物料名称模糊 keyword := r.URL.Query().Get("keyword") // 模糊搜索:物料编码/批次号/SN 任一匹配(下拉拾取器用) zoneCode := r.URL.Query().Get("zoneCode") shelfNo := r.URL.Query().Get("shelfNo") // 货架号(§A4 库位四级联动) layerNo := r.URL.Query().Get("layerNo") // 第几层 positionNo := r.URL.Query().Get("positionNo") // 位置号 qualityStatus := r.URL.Query().Get("qualityStatus") ownershipNo := r.URL.Query().Get("ownershipNo") // W8 库存按归属查(2026-09-29):合同号/科技项目号/其他编号 模糊 manageMode := r.URL.Query().Get("manageMode") // 1/2/空=全部 category := r.URL.Query().Get("category") // 1原材料/2半成品/3成品/空=全部(完工检 SN 拾取器按成品过滤) inboundNo := r.URL.Query().Get("inboundNo") startDate := r.URL.Query().Get("startDate") // 默认近3个月(由接口保证) endDate := r.URL.Query().Get("endDate") page := atoi(r.URL.Query().Get("page"), 1) pageSize := atoi(r.URL.Query().Get("pageSize"), 20) rows, total, err := aggregateStock(ctx, aggregateStockArgs{ MaterialCode: materialCode, MaterialName: materialName, Keyword: keyword, ZoneCode: zoneCode, ShelfNo: shelfNo, LayerNo: layerNo, PositionNo: positionNo, QualityStatus: qualityStatus, OwnershipNo: ownershipNo, ManageMode: manageMode, Category: category, InboundNo: inboundNo, StartDate: startDate, EndDate: endDate, Page: page, PageSize: pageSize, }) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } ok(w, map[string]any{ "list": rows, "total": total, "page": page, "pageSize": pageSize, }) } } // aggregateStockArgs 聚合主列表的筛选条件 type aggregateStockArgs struct { MaterialCode string MaterialName string Keyword string // 模糊搜索:物料编码/批次号/SN 任一匹配(下拉拾取器用) ZoneCode string ShelfNo string // 货架号(方案 §A4 库位四级联动筛选) LayerNo string // 第几层 PositionNo string // 位置号 QualityStatus string OwnershipNo string // W8 库存按归属查:归属编号模糊(合同号/科技项目号/其他编号) ManageMode string Category string // 1原材料/2半成品/3成品/空=全部 InboundNo string StartDate string EndDate string Page int PageSize int } // aggregateStock 按物料聚合库存主数据。 // 用相机内存聚合(inventory 表每物料的行数有限:结构件=批次数、电气件=SN 数), // 先拉取符合状态条件的行,在 Go 侧分组聚合,再做内存分页。 // 这样避免手写 GROUP BY 子查询的复杂度,且数据量受"在库/锁定"上限约束,安全可控。 func aggregateStock(ctx *svc.ServiceContext, a aggregateStockArgs) ([]*stockAggRow, int, error) { q := ctx.EntClient.Inventory.Query() // 仅展示在库/锁定(出库/使用/报废不计入库存) q = q.Where(inventory.StatusIn("在库", "锁定")) // 序列号=否隐藏数量为 0 的行(序列号=是行 quantity 恒为 1) q = q.Where(inventory.Or(inventory.SnModeEQ(snModeSN), inventory.QuantityGT(0))) if a.MaterialCode != "" { q = q.Where(inventory.MaterialCodeContains(a.MaterialCode)) } if a.MaterialName != "" { q = q.Where(inventory.MaterialNameContains(a.MaterialName)) } if a.Keyword != "" { // 模糊搜索:物料编码 / 批次号 / SN 任一命中(库存拾取下拉用);ContainsFold 大小写不敏感 q = q.Where(inventory.Or( inventory.MaterialCodeContainsFold(a.Keyword), inventory.BatchNoContainsFold(a.Keyword), inventory.SnCodeContainsFold(a.Keyword), )) } if a.ZoneCode != "" { q = q.Where(inventory.ZoneCodeEqualFold(a.ZoneCode)) } if a.ShelfNo != "" { q = q.Where(inventory.ShelfNoEqualFold(a.ShelfNo)) } if a.LayerNo != "" { q = q.Where(inventory.LayerNoEqualFold(a.LayerNo)) } if a.PositionNo != "" { q = q.Where(inventory.PositionNoEqualFold(a.PositionNo)) } if a.QualityStatus != "" { // 质量状态仅作"筛选"维度(快捷定位未检/合格/不合格),不进分组键(方案 §A1/§A5) q = q.Where(inventory.QualityStatusEQ(a.QualityStatus)) } if a.InboundNo != "" { q = q.Where(inventory.InboundNoContains(a.InboundNo)) } if a.OwnershipNo != "" { // W8 库存按归属查(2026-09-29):归属编号模糊,大小写不敏感 q = q.Where(inventory.OwnershipNoContainsFold(a.OwnershipNo)) } // 类型(manage_mode)下拉:结构件=1 / 电气件=2 / 其他=3,一律按物料档案类型取编码集 IN,不与物料类别(itemType)字段混用 switch a.ManageMode { case "1", "2": codes := materialCodesByManageMode(ctx, atoi(a.ManageMode, 0)) if len(codes) == 0 { return []*stockAggRow{}, 0, nil } q = q.Where(inventory.MaterialCodeIn(codes...)) case "3": codes := materialCodesByManageMode(ctx, invManageOther) if len(codes) == 0 { return []*stockAggRow{}, 0, nil } q = q.Where(inventory.MaterialCodeIn(codes...)) } if a.Category == "1" { q = q.Where(inventory.CategoryEQ(invCatRaw)) } else if a.Category == "2" { q = q.Where(inventory.CategoryEQ(invCatSemi)) } else if a.Category == "3" { q = q.Where(inventory.CategoryEQ(invCatFinished)) } else { // 半成品是自产中间品,不计入库存体系(其流转在「半成品管理」单独记录), // 未显式指定物料类别时,库位明细/导出口径一律排除半成品,与物料汇总/区域汇总保持一致。 q = q.Where(inventory.CategoryNEQ(invCatSemi)) } // 时间筛选:默认近3个月 startUnix := int64(0) if a.StartDate != "" { if t, err := time.ParseInLocation("2006-01-02", a.StartDate, time.Local); err == nil { startUnix = t.Unix() } } endUnix := int64(0) if a.EndDate != "" { if t, err := time.ParseInLocation("2006-01-02", a.EndDate, time.Local); err == nil { endUnix = t.Add(24 * time.Hour).Unix() // 含当天全天 } } if a.StartDate == "" && a.EndDate == "" { startUnix = time.Now().AddDate(0, -3, 0).Unix() // 默认近3个月 } if startUnix > 0 { q = q.Where(inventory.CreatedAtGTE(startUnix)) } if endUnix > 0 { q = q.Where(inventory.CreatedAtLTE(endUnix)) } all, err := q.Order(ent.Desc("created_at"), ent.Desc("id")).All(ctx0()) if err != nil { return nil, 0, err } // 收集物料信息(名称/规格/物料类别从 materials 表补齐,字段更权威) matName := map[string]string{} matSpec := map[string]string{} matItemType := map[string]int{} matManageMode := map[string]int{} matCodes := []string{} seen := map[string]bool{} for _, inv := range all { if !seen[inv.MaterialCode] { seen[inv.MaterialCode] = true matCodes = append(matCodes, inv.MaterialCode) } } if len(matCodes) > 0 { mats, _ := ctx.EntClient.Material.Query(). Where(material.CodeIn(matCodes...)).All(ctx0()) for _, m := range mats { matName[m.Code] = m.Name matSpec[m.Code] = m.Spec matItemType[m.Code] = m.ItemType matManageMode[m.Code] = m.ManageMode } } // 分组聚合(质量状态降为列,不进分组键,方案 §A1) type agg struct { totalQty int lockedQty int qQualified int qPending int qRejected int batchCnt int snCnt int lastInbNo string lastTime int64 lastInvID int64 // 组内最近入库的库存行真实主键(inventory.id),作行标识 } group := map[stockKey]*agg{} order := []stockKey{} for _, inv := range all { zc := inv.ZoneCode if zc == "" { zc = "未分区" } key := stockKey{inv.MaterialCode, zc, inv.ShelfNo, inv.LayerNo, inv.PositionNo, inv.SnMode} g, ok := group[key] if !ok { g = &agg{} group[key] = g order = append(order, key) } if inv.SnMode == snModeBatch { g.totalQty += inv.Quantity g.lockedQty += inv.LockedQty g.batchCnt++ } else { g.totalQty++ if inv.Status == "锁定" { g.lockedQty++ } g.snCnt++ } // 质量分布(未检=空或非合格/不合格);数量口径同总量:结构件按行数量、电气件按 1 switch inv.QualityStatus { case "合格": g.qQualified += qtyOf(inv) case "不合格": g.qRejected += qtyOf(inv) default: g.qPending += qtyOf(inv) } // all 已按 created_at desc, id desc 排序,首见即最近一条 if inv.CreatedAt > g.lastTime { g.lastTime = inv.CreatedAt g.lastInbNo = inv.InboundNo g.lastInvID = int64(inv.ID) } } total := len(order) // 分页 start := (a.Page - 1) * a.PageSize if start < 0 { start = 0 } end := start + a.PageSize if end > total { end = total } rows := make([]*stockAggRow, 0, end-start) for i := start; i < end; i++ { key := order[i] g := group[key] name := matName[key.MaterialCode] if name == "" { name = key.MaterialCode } rows = append(rows, &stockAggRow{ ID: g.lastInvID, // 组内最近入库的库存行真实主键(inventory.id),禁止伪 id MaterialCode: key.MaterialCode, MaterialName: name, Spec: matSpec[key.MaterialCode], SnMode: key.SnMode, ItemType: matItemType[key.MaterialCode], MatManageMode: matManageMode[key.MaterialCode], ZoneCode: key.ZoneCode, ShelfNo: key.ShelfNo, LayerNo: key.LayerNo, PositionNo: key.PositionNo, QtyQualified: g.qQualified, QtyPending: g.qPending, QtyRejected: g.qRejected, TotalQty: g.totalQty, LockedQty: g.lockedQty, AvailQty: g.qQualified - g.lockedQty, BatchCount: g.batchCnt, SnCount: g.snCnt, LastInboundNo: g.lastInbNo, CreatedAt: g.lastTime, }) } return rows, total, nil } // materialAggRow 物料汇总行(按 物料编码 聚合,忽略区域与质量状态) // 回答"这个物料总共有多少":总数/锁定/可用 + 质量分布(合格/未检/不合格) + 分布区域列表。 // ID 取物料主表(material)主键——聚合视图无自身实体,主表 ID 即行标识,禁止伪 id。 type materialAggRow struct { ID int64 `json:"id"` // 物料主表 ID(material.id,档案缺失时为 0) MaterialCode string `json:"materialCode"` MaterialName string `json:"materialName"` Spec string `json:"spec"` SnMode int `json:"snMode"` // 库存行序列号方式 1序列号=是/2序列号=否(2026-09-30 解耦) ItemType int `json:"itemType"` // 物料类别(1原材料/3成品/4其他) MatManageMode int `json:"matManageMode"` // 物料档案类型(1结构件/2电气件/3其他):类型标签判定用 Category int `json:"category"` // 物料类别 1原材料/2半成品/3成品 TotalQty int `json:"totalQty"` // 总数量(序列号=否=数量求和;序列号=是=SN 行数) LockedQty int `json:"lockedQty"` // 锁定量 AvailQty int `json:"availQty"` // 可用量 = 合格行数量合计 − 锁定量(= 在库 − 未检 − 不合格 − 锁定,客户口径) SafetyStock int `json:"safetyStock"` // 安全库存(物料档案快照;>0 且可用量低于它 → 前端红标预警) QtyQualified int `json:"qtyQualified"` // 合格数量 QtyPending int `json:"qtyPending"` // 未检数量 QtyRejected int `json:"qtyRejected"` // 不合格数量 Zones []string `json:"zones"` // 分布区域列表 ZoneCount int `json:"zoneCount"` // 分布区域数 BatchCount int `json:"batchCount"` // 批次数(结构件维度的行数) SnCount int `json:"snCount"` // SN 数(电气件维度的行数) LastInboundNo string `json:"lastInboundNo"` // 最近入库单号 MaterialCreatedAt int64 `json:"materialCreatedAt"` // 物料主表创建时间(material.created_at) CreatedAt int64 `json:"createdAt"` // 最近一次入库时间 } // materialSummaryArgs 物料汇总的筛选条件 type materialSummaryArgs struct { MaterialCode string MaterialName string OwnershipNo string // W8 问题8 归属编号模糊(合同号/科技项目号/其他编号),口径同 aggregateStock ManageMode string Category string // 1原材料/2半成品/3成品/空=全部 Page int PageSize int } // materialSummaryHandler 物料汇总(按物料聚合所有区域/质量状态) // GET /api/stock/material-summary?materialCode=&materialName=&manageMode=&page=&pageSize= // 返回 rows: 一物料一行,含 总数/可用/锁定/合格/未检/不合格/分布区域。明细经 /stock/details 点击下钻。 // 与主列表不同:汇总忽略区域/质量/入库时间筛选(回答总量问题,只认物料与类型)。 func materialSummaryHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { rows, total, err := aggregateMaterialSummary(ctx, materialSummaryArgs{ MaterialCode: r.URL.Query().Get("materialCode"), MaterialName: r.URL.Query().Get("materialName"), OwnershipNo: r.URL.Query().Get("ownershipNo"), // W8 问题8 物料汇总按归属查 ManageMode: r.URL.Query().Get("manageMode"), Category: r.URL.Query().Get("category"), Page: atoi(r.URL.Query().Get("page"), 1), PageSize: atoi(r.URL.Query().Get("pageSize"), 20), }) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } ok(w, map[string]any{"rows": rows, "total": total}) } } // aggregateMaterialSummary 按物料编码聚合全部在库库存(忽略区域/质量/时间维度),Go 侧内存聚合 + 分页。 func aggregateMaterialSummary(ctx *svc.ServiceContext, a materialSummaryArgs) ([]*materialAggRow, int, error) { q := ctx.EntClient.Inventory.Query() q = q.Where(inventory.StatusIn("在库", "锁定")) q = q.Where(inventory.Or(inventory.SnModeEQ(snModeSN), inventory.QuantityGT(0))) if a.MaterialCode != "" { q = q.Where(inventory.MaterialCodeContains(a.MaterialCode)) } if a.MaterialName != "" { q = q.Where(inventory.MaterialNameContains(a.MaterialName)) } if a.OwnershipNo != "" { // W8 问题8 物料汇总按归属查(2026-10-04):先按归属过滤库存行再按物料聚合, // 口径同 aggregateStock(/stock/query 库位明细):归属编号模糊、大小写不敏感。 q = q.Where(inventory.OwnershipNoContainsFold(a.OwnershipNo)) } // 类型(manage_mode)下拉:结构件=1 / 电气件=2 / 其他=3,一律按物料档案类型取编码集 IN,不与物料类别(itemType)字段混用 switch a.ManageMode { case "1", "2": codes := materialCodesByManageMode(ctx, atoi(a.ManageMode, 0)) if len(codes) == 0 { return []*materialAggRow{}, 0, nil } q = q.Where(inventory.MaterialCodeIn(codes...)) case "3": codes := materialCodesByManageMode(ctx, invManageOther) if len(codes) == 0 { return []*materialAggRow{}, 0, nil } q = q.Where(inventory.MaterialCodeIn(codes...)) } if a.Category == "1" { q = q.Where(inventory.CategoryEQ(invCatRaw)) } else if a.Category == "2" { q = q.Where(inventory.CategoryEQ(invCatSemi)) } else if a.Category == "3" { q = q.Where(inventory.CategoryEQ(invCatFinished)) } else { // 半成品是自产中间品,不计入库存体系(不参与常规库存汇总/缺货预警统计), // 其流转在「半成品管理」单独记录;未显式指定物料类别时,汇总口径一律排除半成品。 q = q.Where(inventory.CategoryNEQ(invCatSemi)) } all, err := q.Order(ent.Desc("created_at"), ent.Desc("id")).All(ctx0()) if err != nil { return nil, 0, err } // 物料名称/规格/物料类别/主表ID/主表创建时间补全 matName := map[string]string{} matSpec := map[string]string{} matItemType := map[string]int{} matManageMode := map[string]int{} matSafety := map[string]int{} // 安全库存(物料档案),红标预警判定用 matID := map[string]int64{} matCreatedAt := map[string]int64{} matCodes := []string{} seen := map[string]bool{} for _, inv := range all { if !seen[inv.MaterialCode] { seen[inv.MaterialCode] = true matCodes = append(matCodes, inv.MaterialCode) } } if len(matCodes) > 0 { mats, _ := ctx.EntClient.Material.Query(). Where(material.CodeIn(matCodes...)).All(ctx0()) for _, m := range mats { matName[m.Code] = m.Name matSpec[m.Code] = m.Spec matItemType[m.Code] = m.ItemType matManageMode[m.Code] = m.ManageMode matSafety[m.Code] = m.SafetyStock matID[m.Code] = int64(m.ID) matCreatedAt[m.Code] = m.CreatedAt } } type agg struct { totalQty int lockedQty int qQualified int qPending int qRejected int mSnMode int // 序列号方式(同物料唯一,取首见行的值) mCategory int // 物料类别(同物料唯一,取首见行的值) batchCnt int snCnt int zones []string zoneSeen map[string]bool lastInbNo string lastTime int64 } group := map[string]*agg{} // key: materialCode order := []string{} for _, inv := range all { key := inv.MaterialCode g, ok := group[key] if !ok { g = &agg{mSnMode: inv.SnMode, mCategory: inv.Category, zoneSeen: map[string]bool{}} group[key] = g order = append(order, key) } // 数量 if inv.SnMode == snModeBatch { g.totalQty += inv.Quantity g.lockedQty += inv.LockedQty g.batchCnt++ } else { g.totalQty++ if inv.Status == "锁定" { g.lockedQty++ } g.snCnt++ } // 质量分布(未检=空或非合格/不合格) switch inv.QualityStatus { case "合格": g.qQualified += qtyOf(inv) case "不合格": g.qRejected += qtyOf(inv) default: g.qPending += qtyOf(inv) } // 分布区域 zc := inv.ZoneCode if zc == "" { zc = "未分区" } if !g.zoneSeen[zc] { g.zoneSeen[zc] = true g.zones = append(g.zones, zc) } if inv.CreatedAt > g.lastTime { g.lastTime = inv.CreatedAt g.lastInbNo = inv.InboundNo } } total := len(order) start := (a.Page - 1) * a.PageSize if start < 0 { start = 0 } end := start + a.PageSize if end > total { end = total } rows := make([]*materialAggRow, 0, end-start) for i := start; i < end; i++ { code := order[i] g := group[code] name := matName[code] if name == "" { name = code } rows = append(rows, &materialAggRow{ ID: matID[code], MaterialCode: code, MaterialName: name, Spec: matSpec[code], SnMode: g.mSnMode, ItemType: matItemType[code], MatManageMode: matManageMode[code], Category: g.mCategory, TotalQty: g.totalQty, LockedQty: g.lockedQty, AvailQty: g.qQualified - g.lockedQty, SafetyStock: matSafety[code], QtyQualified: g.qQualified, QtyPending: g.qPending, QtyRejected: g.qRejected, Zones: g.zones, ZoneCount: len(g.zones), BatchCount: g.batchCnt, SnCount: g.snCnt, LastInboundNo: g.lastInbNo, MaterialCreatedAt: matCreatedAt[code], CreatedAt: g.lastTime, }) } return rows, total, nil } // qtyOf 库存行计入数量的口径:序列号=否按行数量、序列号=是按 1(2026-09-30 改按 sn_mode 判定) func qtyOf(inv *ent.Inventory) int { if inv.SnMode == snModeBatch { return inv.Quantity } return 1 } // stockDetailsHandler 原始批次/SN 明细(点击聚合行下钻;也是库存拾取器/出库批次下拉的数据源) // GET /api/stock/details?materialCode=&zoneCode=&shelfNo=&layerNo=&positionNo=&qualityStatus=&snMode=&category=&itemType=&keyword=&page=&pageSize= // 返回原始批次/SN 明细行(扁平展示,含 SN/批次号/质量状态);keyword 模糊匹配 图号/批次号/SN(同 /stock/query 口径)。 // snMode:1=序列号=是(取SN清单) / 2=序列号=否(取批次下拉);2026-09-30 由 manageMode 参数改为 snMode(序列号口径)。 func stockDetailsHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { materialCode := r.URL.Query().Get("materialCode") zoneCode := r.URL.Query().Get("zoneCode") if zoneCode == "未分区" { zoneCode = "" } shelfNo := r.URL.Query().Get("shelfNo") layerNo := r.URL.Query().Get("layerNo") positionNo := r.URL.Query().Get("positionNo") qualityStatus := r.URL.Query().Get("qualityStatus") keyword := r.URL.Query().Get("keyword") snMode := atoi(r.URL.Query().Get("snMode"), 0) category := atoi(r.URL.Query().Get("category"), 0) page := atoi(r.URL.Query().Get("page"), 1) pageSize := atoi(r.URL.Query().Get("pageSize"), 50) q := ctx.EntClient.Inventory.Query() q = q.Where(inventory.StatusIn("在库", "锁定")) q = q.Where(inventory.Or(inventory.SnModeEQ(snModeSN), inventory.QuantityGT(0))) if materialCode != "" { q = q.Where(inventory.MaterialCodeEqualFold(materialCode)) } if zoneCode != "" { q = q.Where(inventory.ZoneCodeEqualFold(zoneCode)) } if shelfNo != "" { q = q.Where(inventory.ShelfNoEqualFold(shelfNo)) } if layerNo != "" { q = q.Where(inventory.LayerNoEqualFold(layerNo)) } if positionNo != "" { q = q.Where(inventory.PositionNoEqualFold(positionNo)) } if qualityStatus != "" { q = q.Where(inventory.QualityStatusEQ(qualityStatus)) } if keyword != "" { q = q.Where(inventory.Or( inventory.MaterialCodeContainsFold(keyword), inventory.BatchNoContainsFold(keyword), inventory.SnCodeContainsFold(keyword), )) } if snMode != 0 { q = q.Where(inventory.SnModeEQ(snMode)) } if category != 0 { q = q.Where(inventory.CategoryEQ(category)) } else { // 默认排除半成品(与库存明细/汇总口径一致);显式传入 category=2 仍包含。 q = q.Where(inventory.CategoryNEQ(invCatSemi)) } 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 } ok(w, map[string]any{ "list": list, "total": total, "page": page, "pageSize": pageSize, }) } } // exportStockHandler 库存汇总全量导出(xlsx) // 与 /stock/query 同一套聚合逻辑,但导出当前筛选下的全部行(不分页)。 // 支持 ?view=material 导出「物料汇总」(/stock/material-summary 的全量版本)。 // 返回 .xlsx 二进制,文件名 = 库存汇总_时间.xlsx。 func exportStockHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if r.URL.Query().Get("view") == "zone" { out, err := buildZoneSummary(ctx, zoneSummaryArgs{ ZoneCode: r.URL.Query().Get("zoneCode"), QualityStatus: r.URL.Query().Get("qualityStatus"), ManageMode: r.URL.Query().Get("manageMode"), }) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } // 条6:导出与列表同口径,一具体货位一行,含货架/层/位置号 headers := []string{"ID", "区域编码", "区域名称", "货架", "层", "位置号", "合格", "未检", "不合格", "结构件", "电气件", "其他", "最近入库时间"} matrix := make([][]any, 0, len(out)) for _, rw := range out { id := any("") if rw.ID > 0 { id = rw.ID } matrix = append(matrix, []any{ id, rw.ZoneCode, rw.ZoneName, rw.ShelfNo, rw.LayerNo, rw.PositionNo, rw.QtyQualified, rw.QtyPending, rw.QtyRejected, rw.QtyStruct, rw.QtyElec, rw.QtyOther, unixFmt(rw.LastCreatedAt), }) } sendExcel(w, xlsxFilename("区域汇总"), headers, matrix) return } if r.URL.Query().Get("view") == "material" { rows, _, err := aggregateMaterialSummary(ctx, materialSummaryArgs{ MaterialCode: r.URL.Query().Get("materialCode"), MaterialName: r.URL.Query().Get("materialName"), OwnershipNo: r.URL.Query().Get("ownershipNo"), // 导出与物料汇总页签同筛选口径 ManageMode: r.URL.Query().Get("manageMode"), Category: r.URL.Query().Get("category"), Page: 1, PageSize: 1000000, // 全量 }) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } // 列头与「物料汇总」页签对齐:汇总行去掉误导性的「最近入库单」(§A6),类型带「其他」标签 headers := []string{"ID", "图号", "物料名称", "规格", "类型", "总数量", "合格", "未检", "不合格", "分布区域", "批次数", "SN数", "物料创建时间", "最近入库时间"} matrix := make([][]any, 0, len(rows)) for _, rw := range rows { id := any("") if rw.ID > 0 { id = rw.ID } matrix = append(matrix, []any{ id, rw.MaterialCode, rw.MaterialName, rw.Spec, typeLabelOf(rw.MatManageMode), rw.TotalQty, rw.QtyQualified, rw.QtyPending, rw.QtyRejected, strings.Join(rw.Zones, "、"), rw.BatchCount, rw.SnCount, unixFmt(rw.MaterialCreatedAt), unixFmt(rw.CreatedAt), }) } sendExcel(w, xlsxFilename("物料汇总"), headers, matrix) return } startDate, endDate, rerr := normalizeExportRange(r.URL.Query().Get("startDate"), r.URL.Query().Get("endDate")) if rerr != nil { fail(w, http.StatusBadRequest, rerr.Error()) return } rows, _, err := aggregateStock(ctx, aggregateStockArgs{ MaterialCode: r.URL.Query().Get("materialCode"), MaterialName: r.URL.Query().Get("materialName"), ZoneCode: r.URL.Query().Get("zoneCode"), ShelfNo: r.URL.Query().Get("shelfNo"), LayerNo: r.URL.Query().Get("layerNo"), PositionNo: r.URL.Query().Get("positionNo"), QualityStatus: r.URL.Query().Get("qualityStatus"), OwnershipNo: r.URL.Query().Get("ownershipNo"), ManageMode: r.URL.Query().Get("manageMode"), InboundNo: r.URL.Query().Get("inboundNo"), StartDate: startDate, EndDate: endDate, Page: 1, PageSize: 1000000, // 全量 }) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } // 列头与「库位明细」页签对齐:库位四级 + 质量三列;汇总行去掉误导性的「最近入库单」(§A6) headers := []string{"ID", "图号", "物料名称", "规格", "类型", "区域", "货架", "层", "位置", "合格", "未检", "不合格", "总数量", "批次数", "SN数", "最近入库时间"} matrix := make([][]any, 0, len(rows)) for _, rw := range rows { matrix = append(matrix, []any{ rw.ID, rw.MaterialCode, rw.MaterialName, rw.Spec, typeLabelOf(rw.MatManageMode), rw.ZoneCode, rw.ShelfNo, rw.LayerNo, rw.PositionNo, rw.QtyQualified, rw.QtyPending, rw.QtyRejected, rw.TotalQty, rw.BatchCount, rw.SnCount, unixFmt(rw.CreatedAt), }) } sendExcel(w, xlsxFilename("库存汇总"), headers, matrix) } } // zoneSummaryArgs 区域汇总(货位级)的筛选条件(条6) type zoneSummaryArgs struct { ZoneCode string // 区域筛选;"未分区"/"(未分区)" = 只看未分区库存 QualityStatus string // 质量状态筛选(合格/未检/不合格) ManageMode string // 类型筛选 1结构件/2电气件/3其他,按物料档案 manage_mode } // zoneSummRow 区域汇总行(条6:一具体货位一行,按 区域/货架/层/位置号 四级聚合) // 质量(合格/未检/不合格)与类型(结构件/电气件/其他)均降为列,主维度为完整四级货位。 // 缺货架/层的库存归入该区域下「(未分配货架)」合成行(ShelfNo 为空即合成行);缺区域归「(未分区)」。 // ID 取区域主表(zone)主键——聚合视图无自身实体,主表字段即行标识,禁止伪 id;合成行 ID 为 0。 type zoneSummRow struct { ID int64 `json:"id"` // 区域主表 ID(zone.id,未分区/合成行为 0) ZoneCode string `json:"zoneCode"` ZoneName string `json:"zoneName"` ShelfNo string `json:"shelfNo"` // 货架号(「(未分配货架)」合成行与未分区行为空) LayerNo string `json:"layerNo"` // 第几层 PositionNo string `json:"positionNo"` // 位置号 QtyQualified int `json:"qtyQualified"` // 合格数量 QtyPending int `json:"qtyPending"` // 未检数量 QtyRejected int `json:"qtyRejected"` // 不合格数量 QtyStruct int `json:"qtyStruct"` // 结构件数量 QtyElec int `json:"qtyElec"` // 电气件数量 QtyOther int `json:"qtyOther"` // 其他(辅料/工装/试验设备)数量 LastCreatedAt int64 `json:"lastCreatedAt"` // 组内最近一次入库时间 } // buildZoneSummary 区域汇总聚合:供列表接口与导出共用(条6 改造)。 // 一具体货位一行:按 区域/货架/层/位置号 四级聚合,质量(合格/未检/不合格) 与 // 类型(结构件/电气件/其他) 均降为列。缺货架/层归「(未分配货架)」合成行,缺区域归「(未分区)」, // 两类合成行置顶。支持筛选:区域 / 质量状态 / 类型(manage_mode)。 func buildZoneSummary(ctx *svc.ServiceContext, a zoneSummaryArgs) ([]zoneSummRow, error) { zones, err := ctx.EntClient.Zone.Query().Where(zone.LevelEQ(1)).All(ctx0()) if err != nil { return nil, err } zoneNameMap := map[string]string{} zoneIDMap := map[string]int64{} for _, z := range zones { zoneNameMap[z.ZoneCode] = z.ZoneName zoneIDMap[z.ZoneCode] = int64(z.ID) } const zoneUnassigned = "(未分区)" const locUnassigned = "(未分配货架)" // 区域汇总属常规库存汇总口径,排除半成品(半成品单独记录,不并入库存体系) q := ctx.EntClient.Inventory.Query(). Where(inventory.StatusIn("在库", "锁定"), inventory.CategoryNEQ(invCatSemi)) // 条6 筛选:区域 / 质量状态 / 类型(manage_mode) if a.ZoneCode == "未分区" || a.ZoneCode == zoneUnassigned { q = q.Where(inventory.ZoneCodeEQ("")) } else if a.ZoneCode != "" { q = q.Where(inventory.ZoneCodeEqualFold(a.ZoneCode)) } if a.QualityStatus != "" { q = q.Where(inventory.QualityStatusEQ(a.QualityStatus)) } switch a.ManageMode { case "1", "2": codes := materialCodesByManageMode(ctx, atoi(a.ManageMode, 0)) if len(codes) == 0 { return []zoneSummRow{}, nil } q = q.Where(inventory.MaterialCodeIn(codes...)) case "3": codes := materialCodesByManageMode(ctx, invManageOther) if len(codes) == 0 { return []zoneSummRow{}, nil } q = q.Where(inventory.MaterialCodeIn(codes...)) } rows, err := q.All(ctx0()) if err != nil { return nil, err } // 物料类型(manageMode)映射:manage_mode=3 → 其他(辅料/工装/试验设备) mats, _ := ctx.EntClient.Material.Query().All(ctx0()) manageModeMap := make(map[string]int, len(mats)) for _, m := range mats { manageModeMap[m.Code] = m.ManageMode } // 一具体货位一行:质量与类型均为列(数量口径:结构件按行数量、电气件按 1) type zoneLocKey struct { zone, shelf, layer, pos string } agg := map[zoneLocKey]*zoneSummRow{} order := []zoneLocKey{} for _, inv := range rows { zc := inv.ZoneCode shelf, layer, pos := inv.ShelfNo, inv.LayerNo, inv.PositionNo if zc == "" { // 条6:缺区域归「(未分区)」合成行(全部未分区库存合为一行) zc = zoneUnassigned shelf, layer, pos = "", "", "" } else if shelf == "" || layer == "" { // 条6:缺货架/层归该区域下的「(未分配货架)」合成行 shelf, layer, pos = "", "", "" } key := zoneLocKey{zc, shelf, layer, pos} g, ok := agg[key] if !ok { g = &zoneSummRow{ZoneCode: zc, ShelfNo: shelf, LayerNo: layer, PositionNo: pos} agg[key] = g order = append(order, key) } qty := qtyOf(inv) switch inv.QualityStatus { case "合格": g.QtyQualified += qty case "不合格": g.QtyRejected += qty default: g.QtyPending += qty } switch { case manageModeMap[inv.MaterialCode] == invManageOther: g.QtyOther += qty case inv.ManageMode == 2: g.QtyElec += qty default: g.QtyStruct += qty } if inv.CreatedAt > g.LastCreatedAt { g.LastCreatedAt = inv.CreatedAt } } out := make([]zoneSummRow, 0, len(order)) for _, k := range order { g := agg[k] if k.zone == zoneUnassigned { g.ZoneName = zoneUnassigned } else { name := zoneNameMap[k.zone] if name == "" { name = k.zone } g.ZoneName = name g.ID = zoneIDMap[k.zone] } out = append(out, *g) } // 排序:「(未分区)」置顶;其余按区域排序,区域内「(未分配货架)」合成行置顶, // 再按 货架/层/位置号 升序 sort.Slice(out, func(i, j int) bool { x, y := out[i], out[j] xu, yu := x.ZoneCode == zoneUnassigned, y.ZoneCode == zoneUnassigned if xu != yu { return xu } if x.ZoneCode != y.ZoneCode { return x.ZoneCode < y.ZoneCode } xs, ys := x.ShelfNo == "", y.ShelfNo == "" if xs != ys { return xs } if x.ShelfNo != y.ShelfNo { return x.ShelfNo < y.ShelfNo } if x.LayerNo != y.LayerNo { return x.LayerNo < y.LayerNo } return x.PositionNo < y.PositionNo }) return out, nil } // zoneSummaryHandler 区域库存汇总(条6:按完整四级货位聚合,一具体货位一行) // GET /api/stock/zone-summary?zoneCode=&qualityStatus=&manageMode= // 返回 rows: zoneSummRow(含货位四级 + 质量/类型列 + 组内最近入库时间); // 缺货架/层归「(未分配货架)」合成行、缺区域归「(未分区)」,均置顶。 func zoneSummaryHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { out, err := buildZoneSummary(ctx, zoneSummaryArgs{ ZoneCode: r.URL.Query().Get("zoneCode"), QualityStatus: r.URL.Query().Get("qualityStatus"), ManageMode: r.URL.Query().Get("manageMode"), }) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } ok(w, map[string]any{"rows": out}) } } // invAvailGTE 自定义谓词:可用量(quantity - locked_qty) >= need // 用于锁库存时的原子条件校验,避免并发超锁。 func invAvailGTE(need int) predicate.Inventory { return predicate.Inventory(func(s *sql.Selector) { s.Where(sql.ExprP( fmt.Sprintf("%s.%s - %s.%s >= ?", inventory.Table, inventory.FieldQuantity, inventory.Table, inventory.FieldLockedQty), need, )) }) } // lockStockHandler 工单锁定库存(库存占用) // body: { orderNo, items: [{ materialCode, batchNo?, sn?, qty }] } // 锁定为"增量"操作:结构件 locked_qty += qty;电气件状态置 锁定。绝不覆盖终值。 // 锁批次用原子增量 + 可用量条件校验;锁 SN 用状态条件原子更新,杜绝超锁与并发冲突。 func lockStockHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var req struct { OrderNo string `json:"orderNo"` Items []struct { MaterialCode string `json:"materialCode"` BatchNo string `json:"batchNo"` Sn string `json:"sn"` Qty int `json:"qty"` } `json:"items"` } if err := parseJSON(r, &req); err != nil { fail(w, http.StatusBadRequest, "参数错误: "+err.Error()) return } if req.OrderNo == "" || len(req.Items) == 0 { fail(w, http.StatusBadRequest, "orderNo 和 items 必填") return } locked := 0 for _, item := range req.Items { if item.MaterialCode == "" { continue } // 盘点冻结守卫(问题2):盘点期间锁定量亦冻结,禁止新锁定。 if item.Sn != "" { if fno := frozenByStocktake(ctx, "", item.Sn, ""); fno != "" { fail(w, http.StatusConflict, "SN "+item.Sn+" 正在盘点单 "+fno+" 锁定中,盘点期间禁止锁定") return } } else if item.BatchNo != "" { if fno := frozenByStocktake(ctx, item.BatchNo, "", ""); fno != "" { fail(w, http.StatusConflict, "批次 "+item.BatchNo+" 正在盘点单 "+fno+" 锁定中,盘点期间禁止锁定") return } } // 序列号=是:锁 SN(原子:仅 在库 且 合格 才能锁) if item.Sn != "" { aff, err := ctx.EntClient.Inventory.Update(). Where(inventory.SnModeEQ(snModeSN), inventory.SnCodeEQ(item.Sn), inventory.StatusEQ("在库"), inventory.QualityStatusIn(QStatusPass)). SetStatus("锁定").SetLockedQty(1). Save(ctx0()) if err != nil { fail(w, http.StatusInternalServerError, "锁定 SN 失败: "+err.Error()) return } if aff == 0 { fail(w, http.StatusBadRequest, "SN 不在库、不存在,或质量状态非「合格」: "+item.Sn) return } ctx.EntClient.InventoryLock.Create(). SetTargetType("SN"). SetTargetID(item.Sn). SetMaterialCode(item.MaterialCode). SetLockedQty(1). SetOrderNo(req.OrderNo). SetStatus("ACTIVE"). SaveX(ctx0()) locked++ continue } // 序列号=否:锁批次数量(原子增量 + 可用量校验) qty := item.Qty if qty <= 0 { qty = 1 } b, err := ctx.EntClient.Inventory.Query(). Where(inventory.SnModeEQ(snModeBatch), inventory.BatchNoEQ(item.BatchNo)).Only(ctx0()) if err != nil { fail(w, http.StatusBadRequest, "批次不存在: "+item.BatchNo) return } avail := b.Quantity - b.LockedQty if avail < qty { fail(w, http.StatusConflict, "批次库存不足: "+item.BatchNo+" 可用 "+itoa(avail)) return } // 质量门禁(客户口径):仅「合格」批次可锁库(未检/不合格/待退 不可锁) if b.QualityStatus != QStatusPass { fail(w, http.StatusConflict, "批次 "+item.BatchNo+" 质量状态为「"+qualityLabel(b.QualityStatus)+"」,仅合格品可锁库") return } aff, err := ctx.EntClient.Inventory.Update(). Where(inventory.ID(b.ID), invAvailGTE(qty)). AddLockedQty(qty). Save(ctx0()) if err != nil || aff == 0 { fail(w, http.StatusConflict, "锁定失败(库存不足或并发冲突): "+item.BatchNo) return } ctx.EntClient.InventoryLock.Create(). SetTargetType("BATCH"). SetTargetID(item.BatchNo). SetMaterialCode(item.MaterialCode). SetLockedQty(qty). SetOrderNo(req.OrderNo). SetStatus("ACTIVE"). SaveX(ctx0()) locked += qty } ctx.EventLog.Write(ctx0(), "inventory.lock", r.Header.Get("X-Username"), "inventory_lock", req.OrderNo, "锁定库存 orderNo="+req.OrderNo+" 共锁定"+itoa(locked), nil) ok(w, map[string]any{"locked": locked}) } } // unlockStockHandler 释放库存锁定(取消锁定/返工) func unlockStockHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var req struct { OrderNo string `json:"orderNo"` LockIDs []int `json:"lockIds"` } if err := parseJSON(r, &req); err != nil { fail(w, http.StatusBadRequest, "参数错误") return } q := ctx.EntClient.InventoryLock.Query(). Where(inventorylock.StatusEQ("ACTIVE")) if req.OrderNo != "" { q = q.Where(inventorylock.OrderNoEQ(req.OrderNo)) } if len(req.LockIDs) > 0 { q = q.Where(inventorylock.IDIn(req.LockIDs...)) } locks, err := q.All(ctx0()) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } // 盘点冻结守卫(问题2):盘点期间锁定量亦冻结,禁止解锁。 // unlock 无事务且用 SaveX,故先全量校验再释放,避免部分解锁后中断造成不一致。 for _, l := range locks { var fno string if l.TargetType == "SN" { fno = frozenByStocktake(ctx, "", l.TargetID, "") } else { fno = frozenByStocktake(ctx, l.TargetID, "", "") } if fno != "" { fail(w, http.StatusConflict, "目标 "+l.TargetID+" 正在盘点单 "+fno+" 锁定中,盘点期间禁止解锁") return } } released := 0 for _, l := range locks { // 还原批次锁定数 / SN 状态 if l.TargetType == "BATCH" { ctx.EntClient.Inventory.Update(). Where(inventory.BatchNoEQ(l.TargetID)). AddLockedQty(-l.LockedQty). SaveX(ctx0()) // 防止并发下锁定数为负 ctx.EntClient.Inventory.Update(). Where(inventory.BatchNoEQ(l.TargetID), inventory.LockedQtyLT(0)). SetLockedQty(0). SaveX(ctx0()) } else if l.TargetType == "SN" { ctx.EntClient.Inventory.Update(). Where(inventory.SnCodeEQ(l.TargetID), inventory.StatusEQ("锁定")). SetStatus("在库").SetLockedQty(0). SaveX(ctx0()) } ctx.EntClient.InventoryLock.UpdateOneID(l.ID). SetStatus("RELEASED").ExecX(ctx0()) released++ } ctx.EventLog.Write(ctx0(), "inventory.unlock", r.Header.Get("X-Username"), "inventory_lock", req.OrderNo, "释放库存锁定 orderNo="+req.OrderNo+" 共释放"+itoa(released), nil) ok(w, map[string]any{"released": released}) } } // checkStockHandler 校验库存是否满足需求(锁库前检查) func checkStockHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var req struct { Items []struct { MaterialCode string `json:"materialCode"` Qty int `json:"qty"` } `json:"items"` } if err := parseJSON(r, &req); err != nil { fail(w, http.StatusBadRequest, "参数错误") return } results := make([]map[string]any, 0, len(req.Items)) allOk := true for _, item := range req.Items { // 汇总可用量:序列号=否 quantity-locked_qty;序列号=是 在库数量(2026-09-30 改按 sn_mode 判定) rows, _ := ctx.EntClient.Inventory.Query(). Where(inventory.MaterialCodeEQ(item.MaterialCode)).All(ctx0()) availBatch := 0 availSerial := 0 for _, row := range rows { if row.SnMode == snModeBatch { availBatch += row.Quantity - row.LockedQty } else if row.Status == "在库" { availSerial++ } } enough := availBatch+availSerial >= item.Qty if !enough { allOk = false } results = append(results, map[string]any{ "materialCode": item.MaterialCode, "requireQty": item.Qty, "availQty": availBatch + availSerial, "batchAvail": availBatch, "serialAvail": availSerial, "enough": enough, }) } ok(w, map[string]any{"allOk": allOk, "items": results}) } } func itoa(n int) string { if n == 0 { return "0" } neg := n < 0 if neg { n = -n } var b [20]byte i := len(b) for n > 0 { i-- b[i] = byte('0' + n%10) n /= 10 } if neg { i-- b[i] = '-' } return string(b[i:]) } // shortageRow 缺货预警行(安全库存 > 0 且可用量 < 安全库存) type shortageRow struct { ID int64 `json:"id"` // 物料主表 ID MaterialCode string `json:"materialCode"` MaterialName string `json:"materialName"` Spec string `json:"spec"` Unit string `json:"unit"` SafetyStock int `json:"safetyStock"` AvailQty int `json:"availQty"` ShortQty int `json:"shortQty"` } // shortageHandler 缺货预警:安全库存 > 0 且可用量低于安全库存的物料。 // 客户诉求《问题记录》L473「安全库存/缺货预警进 WMS 首页」。 // 可用量口径与出库门禁一致:在库/锁定 且质量状态=合格(未检/不合格/待退不计可用)。 func shortageHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { // 缺货预警只统计纳入库存体系的物料类别:半成品为自产中间品、不参与常规库存统计,故排除。 mats, err := ctx.EntClient.Material.Query(). Where(material.SafetyStockGT(0), material.IsActiveEQ(true), material.ItemTypeNEQ(2)). All(ctx0()) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } rows := make([]*shortageRow, 0) for _, m := range mats { invRows, err := ctx.EntClient.Inventory.Query(). Where( inventory.MaterialCodeEQ(m.Code), inventory.StatusIn("在库", "锁定"), inventory.QualityStatusIn(QStatusPass), ).All(ctx0()) if err != nil { continue } avail := 0 for _, inv := range invRows { if inv.SnMode == snModeBatch { avail += inv.Quantity - inv.LockedQty } else if inv.Status == "在库" { avail++ } } if avail < m.SafetyStock { name := m.Name if name == "" { name = m.Code } rows = append(rows, &shortageRow{ ID: int64(m.ID), MaterialCode: m.Code, MaterialName: name, Spec: m.Spec, Unit: m.Unit, SafetyStock: m.SafetyStock, AvailQty: avail, ShortQty: m.SafetyStock - avail, }) } } ok(w, map[string]any{"list": rows, "total": len(rows)}) } } // materialDemandRow 缺料补货行(方案 §A3/§D2):安全库存补货量 与 排产缺料量 分两列,不合并。 type materialDemandRow struct { MaterialCode string `json:"materialCode"` MaterialName string `json:"materialName"` Spec string `json:"spec"` Unit string `json:"unit"` SafetyStock int `json:"safetyStock"` AvailQty int `json:"availQty"` PlanDemand int `json:"planDemand"` // 排产需求(未来 N 天,来自 MES) PlanShort int `json:"planShort"` // 排产缺料量 = max(0, planDemand - avail) SafetyReplenish int `json:"safetyReplenish"` // 安全库存补货量 = max(0, safetyStock - avail) InTransit string `json:"inTransit"` // 在途量(暂无数据源,留空显示"—",不臆造) PlanStart string `json:"planStart"` PlanEnd string `json:"planEnd"` } // availableQty 计算物料的合格可用量(口径同出库门禁 QStatusPass;半成品不纳入常规库存)。 // 序列号=否 = Σ(quantity - locked_qty);序列号=是 = 在库 SN 行数(2026-09-30 改按 sn_mode 判定)。 func availableQty(ctx *svc.ServiceContext, materialCode string) int { invRows, err := ctx.EntClient.Inventory.Query(). Where( inventory.MaterialCodeEQ(materialCode), inventory.StatusIn("在库", "锁定"), inventory.QualityStatusIn(QStatusPass), ).All(ctx0()) if err != nil { return 0 } avail := 0 for _, inv := range invRows { if inv.SnMode == snModeBatch { avail += inv.Quantity - inv.LockedQty } else if inv.Status == "在库" { avail++ } } return avail } // materialDemandHandler 缺料补货(方案 §A3):拉 MES 排产需求,对比本地可用库存, // 给出「安全库存补货量」与「排产缺料量」两列(§D2:两列不合并,合并会掩盖两种不同性质的缺料)。 // 在途量当前无数据源,列留空显示"—"(§D2:不臆造)。 // 打开页面实时拉一次(同旧 producible 口径),不做定时同步,保持 WMS/MES 两系统无定时耦合。 // GET /api/stock/material-demand func materialDemandHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { // 1) 拉 MES 排产需求(若不可达则需求为空,仅展示安全库存补货) demandMap := map[string]int{} var planStart, planEnd string if ctx.Mes != nil { rows, err := ctx.Mes.FetchMaterialDemand(ctx0(), 5) if err == nil { for _, d := range rows { demandMap[d.MaterialCode] += d.DemandQty if planStart == "" || d.StartDate < planStart { planStart = d.StartDate } if planEnd == "" || d.EndDate > planEnd { planEnd = d.EndDate } } // 回写 material_demand(全量覆盖,语义同已下线的 queryProducibleHandler): // 备料四态“预警”档(misc.go ledgerState)依赖本表 future5_qty;旧快照写入口删除后, // 必须由本处专职喂数,否则“预警”永久静默失效(客户诉求 问题记录 L256)。 // best-effort:回写失败不影响本页视图(demandMap 已在内存算好)。 if tx, terr := ctx.EntClient.Tx(ctx0()); terr == nil { now := time.Now().Unix() done := false if _, derr := tx.MaterialDemand.Delete().Exec(ctx0()); derr == nil { done = true for code, qty := range demandMap { if code == "" { continue } if _, cerr := tx.MaterialDemand.Create(). SetMaterialCode(code). SetFuture5Qty(qty). SetUpdatedAt(now). Save(ctx0()); cerr != nil { done = false break } } } if done { _ = tx.Commit() } else { _ = tx.Rollback() } } } } // 2) 本地可用量对比(只统计纳入库存体系的物料类别,半成品/成品单独处理不并入) mats, err := ctx.EntClient.Material.Query(). Where(material.IsActiveEQ(true), material.ItemTypeNEQ(2)).All(ctx0()) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } out := make([]*materialDemandRow, 0) for _, m := range mats { avail := availableQty(ctx, m.Code) planDemand := demandMap[m.Code] planShort := planDemand - avail if planShort < 0 { planShort = 0 } safetyReplenish := m.SafetyStock - avail if safetyReplenish < 0 { safetyReplenish = 0 } // 仅列有缺口的物料(安全库存缺货 或 排产缺料),无缺口不展示 if planShort == 0 && safetyReplenish == 0 { continue } name := m.Name if name == "" { name = m.Code } out = append(out, &materialDemandRow{ MaterialCode: m.Code, MaterialName: name, Spec: m.Spec, Unit: m.Unit, SafetyStock: m.SafetyStock, AvailQty: avail, PlanDemand: planDemand, PlanShort: planShort, SafetyReplenish: safetyReplenish, InTransit: "", PlanStart: planStart, PlanEnd: planEnd, }) } // 排序:排产缺料优先,其次安全库存补货量 sort.Slice(out, func(i, j int) bool { if out[i].PlanShort != out[j].PlanShort { return out[i].PlanShort > out[j].PlanShort } return out[i].SafetyReplenish > out[j].SafetyReplenish }) ok(w, map[string]any{"list": out, "planStart": planStart, "planEnd": planEnd, "syncedAt": time.Now().Unix()}) } } // listStockBatchesInternalHandler GET /api/internal/stock/batches?materialCode=&zoneCode= // 供 MES「工单备料自动出库」分配批次用:返回该物料可出库的批次明细(结构件)与可用 SN 列表(电气件)。 // 结构件按批次号升序(FIFO);统一质量门禁:仅「合格」库存可出库,未检/不合格/待退不返回。 func listStockBatchesInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { materialCode := strings.TrimSpace(r.URL.Query().Get("materialCode")) if materialCode == "" { fail(w, http.StatusBadRequest, "materialCode 必填") return } q := ctx.EntClient.Inventory.Query(). Where( inventory.MaterialCodeEQ(materialCode), inventory.QuantityGT(0), inventory.QualityStatusIn(QStatusPass), // 仅「在库」可出库:SN 行出库走状态机(status 置「出库」)而 quantity 仍为 1, // 缺此过滤会把已出库 SN 误返回,MES 自动备料逐颗尝试时第一颗即失败(AITEST 闭环实测缺陷)。 // 盘点冻结(锁定)行也不返回:与 stock/deduct 的冻结守卫口径一致,避免 MES 撞拦截。 inventory.StatusEQ("在库"), ) if zc := strings.TrimSpace(r.URL.Query().Get("zoneCode")); zc != "" { q = q.Where(inventory.ZoneCodeEQ(zc)) } rows, err := q.Order(ent.Asc("batch_no"), ent.Asc("created_at")).All(ctx0()) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } batches := make([]map[string]any, 0, len(rows)) sns := make([]string, 0, len(rows)) for _, inv := range rows { avail := inv.Quantity - inv.LockedQty if avail <= 0 { continue } if inv.SnMode == snModeSN { if inv.SnCode != "" { sns = append(sns, inv.SnCode) } continue } batches = append(batches, map[string]any{ "batchNo": inv.BatchNo, "quantity": inv.Quantity, "lockedQty": inv.LockedQty, "avail": avail, "zoneCode": inv.ZoneCode, "qualityStatus": inv.QualityStatus, }) } ok(w, map[string]any{"batches": batches, "snList": sns}) } }