Files
bj_power/bj_power_wms/internal/handler/inspection.go
T
SunYF d92ca803d5 feat: 来料检处置项实体与复检、日排产达成对比、PLC/WMS 传输日志
- WMS 新增「检验处置项」实体(schema + ent 生成码),配套检验记录实体调整与复检接口,完善来料检/不良退货/入库检验前端
- MES 日排产:新增达成率统计与计划对比逻辑,调整日排产前端与流程卡/工序流
- 日志与传输:MES 新增 PLC 日志与 WMS 客户端传输日志,WMS 新增 MES 客户端传输日志
- MES 其他:扫码、工单/工件、AGV 客户端与告警、产品导入等逻辑完善及前端调整
- 工位终端:上线面板/作业面板、工件 handler 与 MES 客户端调整
- 配置与文档:更新 mes-api.yaml、三端构建产物与问题记录文档
2026-11-16 16:42:44 +08:00

1495 lines
57 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.
// 检验模块路由总览(本文件实现):
//
// POST /api/inspection/batch-flip 批量判定翻转(来料检)
// POST /api/inspection/dispose 不合格品处置(按检验记录发起,来料检处置)
// POST /api/inspection/inventory-dispose 在库处置:从在库库存行直接发起不合格处置
// (合格入库后的物料在使用中发现不合格,无需绕道补录检验记录)
// POST /api/internal/inventory/dispose MES 判不合格联动 WMS 在库处置(X-API-TOKEN 内部接口)
// GET /api/inspection/query 检验记录查询
// GET /api/inspection/export 检验记录导出
// GET /api/inspection/stats 检验统计
// GET /api/inspection/pending[/details] 待检清单
package handler
import (
"encoding/json"
"fmt"
"net/http"
"strconv"
"strings"
"time"
"bj_power_wms/ent"
"bj_power_wms/ent/inboundorder"
"bj_power_wms/ent/inspectiondisposalitem"
"bj_power_wms/ent/inspectionrecord"
"bj_power_wms/ent/inventory"
"bj_power_wms/ent/material"
"bj_power_wms/internal/svc"
)
// resolveInspectionTarget 通过编号(批次号或 SN)定位唯一库存行。
// 检验必须落在真实存在的库存记录上,才能同步质量状态——杜绝"提示成功但库存未更新"的假闭环。
// 返回错误或定位到的库存行(含物料编码与序列号方式,供后续写入检验记录与翻状态使用)。
func resolveInspectionTarget(ctx *svc.ServiceContext, targetId string) (*ent.Inventory, error) {
// 优先按批次号(序列号=否)
if inv, err := ctx.EntClient.Inventory.Query().
Where(inventory.SnModeEQ(snModeBatch), inventory.BatchNoEQ(targetId)).Only(ctx0()); err == nil {
return inv, nil
}
// 再按 SN(序列号=是)
if inv, err := ctx.EntClient.Inventory.Query().
Where(inventory.SnModeEQ(snModeSN), inventory.SnCodeEQ(targetId)).Only(ctx0()); err == nil {
return inv, nil
}
return nil, fmt.Errorf("未找到对应库存记录(批次号/SN):%s,请确认编号是否已入库、或该记录是否已出库", targetId)
}
// batchFlipInspectionHandler 逐个判定批量翻转检验状态(问题记录 L150 三问题之三)
// body: { items: [ { targetId, status, inspectQty, passQty, disposals: [{type, qty, remark}],
//
// ownershipType, ownershipNo, relatedStandard, manufacturer, checkDesc, inspector,
// reportNo, inspectionNo, batchSeq, batchTotal } ] }
//
// 每个对象按自身数量写记录、按自身结论翻库存状态(修复旧版"所有记录同数量"的 bug)。
// reject_qty 后端复核 = inspectQty - passQty,不信任前端传入值。
// 2026-11-16 拍板:处置方式下放明细子表——不合格项必须带 disposals 明细行
// (退货/返修/报废按数量拆分,Σqty=不合格数;备注非必填,退货物流信息也填备注),
// 提交时写子表并按行执行库存动作。运单号概念废除。
func batchFlipInspectionHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
Items []struct {
TargetId string `json:"targetId"`
Status string `json:"status"` // 合格/不合格
InspectQty int `json:"inspectQty"`
PassQty int `json:"passQty"`
Disposals []struct {
Type string `json:"type"` // RETURN/REWORK/SCRAP
Qty int `json:"qty"` // >0
Remark string `json:"remark"` // 非必填(退货物流信息也填此处)
} `json:"disposals"`
OwnershipType string `json:"ownershipType"`
OwnershipNo string `json:"ownershipNo"`
RelatedStandard string `json:"relatedStandard"`
Manufacturer string `json:"manufacturer"`
CheckDesc string `json:"checkDesc"`
Inspector string `json:"inspector"`
ReportNo string `json:"reportNo"`
InspectionNo string `json:"inspectionNo"`
BatchSeq int `json:"batchSeq"`
BatchTotal int `json:"batchTotal"`
} `json:"items"`
}
if err := parseJSON(r, &req); err != nil {
fail(w, http.StatusBadRequest, "参数错误")
return
}
if len(req.Items) == 0 {
fail(w, http.StatusBadRequest, "items 必填")
return
}
// 预校验:每条必须含 targetId 且结论合法、能定位到库存行;任意一条失败整体拒绝(避免部分成功假闭环)
type disposalLine struct {
dt string
qty int
remark string
}
type item struct {
id string
inv *ent.Inventory
targetType string
material string
status string
inspectQty int
passQty int
rejectQty int
disposals []disposalLine
ownType string
ownNo string
relStd string
mfr string
checkDesc string
inspector string
reportNo string
inspNo string
batchSeq int // 第几批(序列号=否必填≥1;序列号=是恒 0=未填)
batchTotal int // 共几件(序列号=否必填≥1;序列号=是恒 0=未填)
pw string // 产品工号:从源库存(入库单)带出,五页带出展示/筛选
}
items := make([]item, 0, len(req.Items))
codes := make([]string, 0, len(req.Items))
seenCode := map[string]bool{}
for _, it := range req.Items {
if it.TargetId == "" || (it.Status != "合格" && it.Status != "不合格") {
fail(w, http.StatusBadRequest, "每条必须含 targetId 与 status(合格/不合格): "+it.TargetId)
return
}
inv, err := resolveInspectionTarget(ctx, it.TargetId)
if err != nil {
fail(w, http.StatusBadRequest, err.Error())
return
}
// 强校验:只有「未检」行可送检,防止手输编号绕过前端下拉把已检(合格/不合格/待退)对象重复送检。
// 不合格品重新判定走独立「复检」入口(/api/inspection/reinspect),不经过本 handler,互不影响。
if qs := inv.QualityStatus; qs != QStatusPending {
fail(w, http.StatusConflict, fmt.Sprintf("批次/SN「%s」当前质量状态为「%s」,不可重复送检;如需重新判定请走「复检」入口", it.TargetId, qs))
return
}
tt := "BATCH"
if inv.SnMode == snModeSN {
tt = "SN"
}
inspectQty := it.InspectQty
passQty := it.PassQty
if inspectQty <= 0 {
inspectQty = 1 // 序列号=是:单件判定默认检验数=1
}
if passQty < 0 || passQty > inspectQty {
fail(w, http.StatusBadRequest, "合格数必须在 0~检验数 之间: "+it.TargetId)
return
}
// 后端复核不合格数 = 检验数 - 合格数(不信任前端)
rejectQty := inspectQty - passQty
// 2026-11-16 拍板:不合格必须有处置明细行,Σqty = 不合格数,逐行归一化校验
disposals := make([]disposalLine, 0, len(it.Disposals))
if rejectQty > 0 {
sum := 0
for _, d := range it.Disposals {
dt := disposalTypeOrNone(d.Type)
if dt == "NONE" {
fail(w, http.StatusBadRequest, fmt.Sprintf("「%s」处置明细行方式无效(仅 退货/返修/报废): %s", it.TargetId, d.Type))
return
}
if d.Qty <= 0 {
fail(w, http.StatusBadRequest, fmt.Sprintf("「%s」处置明细行数量必须大于 0", it.TargetId))
return
}
sum += d.Qty
disposals = append(disposals, disposalLine{dt: dt, qty: d.Qty, remark: strings.TrimSpace(d.Remark)})
}
if sum != rejectQty {
fail(w, http.StatusBadRequest, fmt.Sprintf("「%s」处置明细数量合计(%d)必须等于不合格数量(%d):按数量分别填退货/返修/报废", it.TargetId, sum, rejectQty))
return
}
}
// 第几批/共几件已下线(2026-11-08):前端不再采集,字段保留落库 0(schema Default(0) 不动)
batchSeq, batchTotal := 0, 0
items = append(items, item{
id: it.TargetId, inv: inv, targetType: tt, material: inv.MaterialCode,
status: it.Status, inspectQty: inspectQty, passQty: passQty, rejectQty: rejectQty,
disposals: disposals,
ownType: it.OwnershipType, ownNo: it.OwnershipNo, relStd: it.RelatedStandard, mfr: it.Manufacturer,
checkDesc: it.CheckDesc, inspector: it.Inspector, reportNo: it.ReportNo, inspNo: it.InspectionNo,
batchSeq: batchSeq, batchTotal: batchTotal, pw: inv.ProductWorkNo,
})
if inv.MaterialCode != "" && !seenCode[inv.MaterialCode] {
seenCode[inv.MaterialCode] = true
codes = append(codes, inv.MaterialCode)
}
}
// 「其他」类物料(类型 manage_mode=3)单独记对象类型 OTHER(§B1:其他类此前混在批次(结构件)里无法单独识别)
if len(codes) > 0 {
if mats, e := ctx.EntClient.Material.Query().Where(material.CodeIn(codes...)).All(ctx0()); e == nil {
otherSet := map[string]bool{}
for _, m := range mats {
if m.ManageMode == invManageOther {
otherSet[m.Code] = true
}
}
for i := range items {
if items[i].targetType == "BATCH" && otherSet[items[i].material] {
items[i].targetType = "OTHER"
}
}
}
}
tx, err := ctx.EntClient.Tx(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, "开启事务失败: "+err.Error())
return
}
committed := false
defer func() {
if !committed {
_ = tx.Rollback()
}
}()
// 同库存行被多条记录引用的极端情况:批量送检若勾选了同一批次多行,按 id 去重取首条,
// 避免重复写记录(正常待检清单按入库单分组,行级唯一,此去重仅为防御)。
seen := map[string]bool{}
flipped := 0
for _, it := range items {
if seen[it.id] {
continue
}
seen[it.id] = true
matName := it.inv.MaterialName
if matName == "" {
if m, merr := tx.Material.Query().Where(material.CodeEQ(it.material)).First(ctx0()); merr == nil && m != nil {
matName = m.Name
}
}
// 2026-11-13 拍板「来料检验三维度正交重构」:
// ① 检验结论 inspection_conclusion(只答判定成什么)
// ② 数量拆分(inspectQty/passQty/rejectQty)——提交时【自动拆库存行】,不再等人工二次点处置
// ③ 不合格品处置:2026-11-16 拍板下放明细子表,提交时写处置行并按行执行库存动作
dispStatus := ""
if it.rejectQty > 0 {
dispStatus = "已处置"
}
rec, err := tx.InspectionRecord.Create().
SetTargetType(it.targetType).
SetTargetID(it.id).
SetMaterialCode(it.material).
SetNillableMaterialName(strPtr(matName)).
SetNillableOwnershipType(strPtr(ownershipTypeOrNone(it.ownType))).
SetNillableOwnershipNo(strPtr(it.ownNo)).
SetNillableRelatedStandard(strPtr(it.relStd)).
SetNillableManufacturer(strPtr(it.mfr)).
SetStatus(it.status).
SetInspectionConclusion(it.status).
SetDisposalStatus(dispStatus).
SetParentRecordID(0).
SetInspectQty(it.inspectQty).
SetPassQty(it.passQty).
SetRejectQty(it.rejectQty).
SetBatchSeq(it.batchSeq).
SetBatchTotal(it.batchTotal).
SetNillableCheckDesc(strPtr(it.checkDesc)).
SetNillableInspector(strPtr(it.inspector)).
SetNillableReportNo(strPtr(it.reportNo)).
SetNillableInspectionNo(strPtr(it.inspNo)).
SetNillableProductWorkNo(strPtr(it.pw)).
Save(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, "创建检验记录失败: "+err.Error())
return
}
// 处置明细行:逐行写子表(qty 按行、备注非必填)
for _, d := range it.disposals {
if _, err = tx.InspectionDisposalItem.Create().
SetRecordID(int64(rec.ID)).SetDisposeType(d.dt).SetQty(d.qty).
SetNillableRemark(strPtr(d.remark)).
SetNillableOperator(strPtr(it.inspector)).
Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "创建处置明细失败: "+err.Error())
return
}
}
// 库存动作:自动拆分。原行保留「合格数 + 未检数」;不合格数按处置明细行拆分——
// 批次行按处置生成多条 -NG 隔离行(退货=待退/返修=不合格在库/报废=不合格报废);
// SN/其他类单件行按唯一处置行直接翻状态。处置明细行存在时一律不再挂「待处置」。
if it.rejectQty > 0 && it.inv.SnMode == snModeBatch && !strings.HasSuffix(it.inv.BatchNo, "-NG") {
kept := it.passQty + (it.inv.Quantity - it.inspectQty)
if kept < 0 {
kept = 0
}
keptQuality := "未检"
if it.passQty > 0 {
keptQuality = "合格"
}
if _, err = tx.Inventory.UpdateOneID(it.inv.ID).
SetQuantity(kept).SetQualityStatus(keptQuality).Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "拆分合格/未检数量失败: "+err.Error())
return
}
// 按处置行拆 -NG 隔离行:批次号 -NG、-NG-2、-NG-3…(处置动作不同、物理同隔离区)
for di, d := range it.disposals {
ngBatch := it.inv.BatchNo + "-NG"
if di > 0 {
ngBatch = fmt.Sprintf("%s-NG-%d", it.inv.BatchNo, di+1)
}
ngQuality, ngStatus := "不合格", "在库"
ngLabel := ""
switch d.dt {
case "RETURN":
ngQuality, ngStatus = "待退", "待处置"
ngLabel = "退货处置"
case "SCRAP":
ngQuality, ngStatus = "不合格", "报废"
ngLabel = "报废处置"
case "REWORK":
ngQuality, ngStatus = "不合格", "在库"
ngLabel = "返修处置"
}
remark := fmt.Sprintf("检验自动拆分:%s×%d", ngLabel, d.qty)
if d.remark != "" {
remark += ";" + d.remark
}
if _, err = tx.Inventory.Create().
SetManageMode(it.inv.ManageMode).SetSnMode(it.inv.SnMode).SetCategory(it.inv.Category).
SetMaterialCode(it.inv.MaterialCode).
SetNillableMaterialName(strPtr(it.inv.MaterialName)).
SetBatchNo(ngBatch).
SetQuantity(d.qty).SetLockedQty(0).
SetQualityStatus(ngQuality).SetStatus(ngStatus).
SetNillableZoneCode(strPtr(it.inv.ZoneCode)).
SetNillableInboundNo(strPtr(it.inv.InboundNo)).
SetRemark(remark).
Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "生成不合格隔离行失败: "+err.Error())
return
}
}
} else if it.rejectQty > 0 {
// SN / 其他类单件行:处置明细只有一行(qty=1),直接翻库存行状态
d := it.disposals[0]
upd := tx.Inventory.UpdateOneID(it.inv.ID).SetQualityStatus(qualityAfterInspection(it.status, d.dt))
if d.dt == "SCRAP" {
upd = upd.SetStatus("报废")
}
if _, err = upd.Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "同步库存检验状态失败: "+err.Error())
return
}
} else if _, err = tx.Inventory.UpdateOneID(it.inv.ID).
SetQualityStatus(qualityAfterInspection(it.status, "NONE")).Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "同步库存检验状态失败: "+err.Error())
return
}
flipped++
}
if err = tx.Commit(); err != nil {
fail(w, http.StatusInternalServerError, "提交事务失败: "+err.Error())
return
}
committed = true
ok(w, map[string]any{"flipped": flipped})
}
}
// queryInspectionHandler 检验记录查询
func queryInspectionHandler(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)
targetId := r.URL.Query().Get("targetId")
materialCode := r.URL.Query().Get("materialCode")
inspectionType := r.URL.Query().Get("inspectionType")
status := r.URL.Query().Get("status")
inspector := r.URL.Query().Get("inspector")
// 时间筛选:起止两端各自独立生效(只填一端合法,另一端不限制),**不做导出那套归一化校验**。
// 注意:normalizeExportRange(默认近3个月 / 只传一端即报错 / 间隔≤1年)是**导出**专用硬规则,
// 列表查询套用会导致进入「检测记录」Tab(默认只带 startDate)立即 400
// 「导出必须同时提供起始时间与结束时间」。口径与 statsInspectionHandler 保持一致。
startDate := r.URL.Query().Get("startDate")
endDate := r.URL.Query().Get("endDate")
q := ctx.EntClient.InspectionRecord.Query()
if targetId != "" {
q = q.Where(inspectionrecord.TargetIDContainsFold(targetId))
}
if materialCode != "" {
q = q.Where(inspectionrecord.MaterialCodeContainsFold(materialCode))
}
// 名称模糊 / 归属单号(客户诉求 L507-510 三框制:图号/名称/型号,每框内模糊、多框取交集;L149 增加归属筛选)
if v := r.URL.Query().Get("materialName"); v != "" {
q = q.Where(inspectionrecord.MaterialNameContainsFold(v))
}
if v := r.URL.Query().Get("ownershipNo"); v != "" {
q = q.Where(inspectionrecord.OwnershipNoContainsFold(v))
}
if v := r.URL.Query().Get("productWorkNo"); v != "" {
q = q.Where(inspectionrecord.ProductWorkNoContainsFold(v))
}
if v := r.URL.Query().Get("itemType"); v != "" {
// 按物料类别(itemType)过滤:先取对应物料编码集再 IN(避免逐行 join,同 materialCodesBySpec 套路)
if code := atoi(v, 0); code > 0 {
codes := materialCodesByItemType(ctx, code)
if len(codes) == 0 {
ok(w, map[string]any{"total": 0, "list": []any{}, "page": page, "pageSize": pageSize})
return
}
q = q.Where(inspectionrecord.MaterialCodeIn(codes...))
}
}
if v := r.URL.Query().Get("spec"); v != "" {
// 型号=物料档案规格型号,需 join 物料表取编码集合
codes := materialCodesBySpec(ctx, v)
if len(codes) == 0 {
ok(w, map[string]any{"total": 0, "list": []any{}, "page": page, "pageSize": pageSize})
return
}
q = q.Where(inspectionrecord.MaterialCodeIn(codes...))
}
if inspectionType != "" {
q = q.Where(inspectionrecord.InspectionTypeEQ(inspectionType))
}
if status != "" {
q = q.Where(inspectionrecord.StatusEQ(status))
}
if inspector != "" {
q = q.Where(inspectionrecord.InspectorContainsFold(inspector))
}
// 时间筛选(默认近3个月由前端传入;兼容两端口径)
if startDate != "" {
if t, err := time.ParseInLocation("2006-01-02", startDate, time.Local); err == nil {
q = q.Where(inspectionrecord.CreatedAtGTE(t.Unix()))
}
}
if endDate != "" {
if t, err := time.ParseInLocation("2006-01-02", endDate, time.Local); err == nil {
q = q.Where(inspectionrecord.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
}
// 处置明细汇总(2026-11-16 处置下放明细子表):列表/历史直接展示,前端无需二次查询
dispMap := inspectionDisposalTextMap(ctx, list)
rows := make([]map[string]any, 0, len(list))
for _, rec := range list {
b, _ := json.Marshal(rec)
m := map[string]any{}
_ = json.Unmarshal(b, &m)
m["disposalLines"] = dispMap[rec.ID]
rows = append(rows, m)
}
ok(w, map[string]any{
"total": total,
"list": rows,
"page": page,
"pageSize": pageSize,
})
}
}
// exportInspectionHandler 检验记录全量导出(按条件返回全部 JSON,前端转 CSV/Excel)
// GET /api/inspection/export?targetId=&materialCode=&inspectionType=&status=&inspector=&startDate=&endDate=
func exportInspectionHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
targetId := r.URL.Query().Get("targetId")
materialCode := r.URL.Query().Get("materialCode")
inspectionType := r.URL.Query().Get("inspectionType")
status := r.URL.Query().Get("status")
inspector := r.URL.Query().Get("inspector")
startDate := r.URL.Query().Get("startDate")
endDate := r.URL.Query().Get("endDate")
startDate, endDate, rerr := normalizeExportRange(startDate, endDate)
if rerr != nil {
fail(w, http.StatusBadRequest, rerr.Error())
return
}
q := ctx.EntClient.InspectionRecord.Query()
if targetId != "" {
q = q.Where(inspectionrecord.TargetIDContainsFold(targetId))
}
if materialCode != "" {
q = q.Where(inspectionrecord.MaterialCodeContainsFold(materialCode))
}
if v := r.URL.Query().Get("materialName"); v != "" {
q = q.Where(inspectionrecord.MaterialNameContainsFold(v))
}
if v := r.URL.Query().Get("ownershipNo"); v != "" {
q = q.Where(inspectionrecord.OwnershipNoContainsFold(v))
}
if v := r.URL.Query().Get("productWorkNo"); v != "" {
q = q.Where(inspectionrecord.ProductWorkNoContainsFold(v))
}
if v := r.URL.Query().Get("itemType"); v != "" {
// 按物料类别(itemType)过滤:先取对应物料编码集再 IN(避免逐行 join,同 materialCodesBySpec 套路)
if code := atoi(v, 0); code > 0 {
codes := materialCodesByItemType(ctx, code)
if len(codes) == 0 {
ok(w, map[string]any{"list": []any{}})
return
}
q = q.Where(inspectionrecord.MaterialCodeIn(codes...))
}
}
if v := r.URL.Query().Get("spec"); v != "" {
codes := materialCodesBySpec(ctx, v)
if len(codes) == 0 {
ok(w, map[string]any{"list": []any{}})
return
}
q = q.Where(inspectionrecord.MaterialCodeIn(codes...))
}
if inspectionType != "" {
q = q.Where(inspectionrecord.InspectionTypeEQ(inspectionType))
}
if status != "" {
q = q.Where(inspectionrecord.StatusEQ(status))
}
if inspector != "" {
q = q.Where(inspectionrecord.InspectorContainsFold(inspector))
}
if startDate != "" {
if t, err := time.ParseInLocation("2006-01-02", startDate, time.Local); err == nil {
q = q.Where(inspectionrecord.CreatedAtGTE(t.Unix()))
}
}
if endDate != "" {
if t, err := time.ParseInLocation("2006-01-02", endDate, time.Local); err == nil {
q = q.Where(inspectionrecord.CreatedAtLTE(t.Add(24 * time.Hour).Unix()))
}
}
list, err := q.Order(ent.Desc("created_at"), ent.Desc("id")).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
// xlsx 导出
if r.URL.Query().Get("format") == "xlsx" {
// 列名按客户口径(问题记录 L150):检验说明→相关标准、检验员→记录人、检验日期→记录日期、增加归属;
// 图号=物料编码(L18 合并裁决)。2026-11-08 移除「第几批/共几件」两列(字段仍落库 0)。
// 2026-11-16 增加「处置明细」列(处置下放明细子表,按行汇总退货/返修/报废数量与备注)。
headers := []string{"ID", "对象", "批次/SN", "图号", "名称", "检验类型", "结论", "检验数", "合格数", "不合格数", "相关标准", "报检单号", "检测单号", "归属单号", "生产厂家", "记录人", "备注", "记录日期", "处置明细"}
dispMap := inspectionDisposalTextMap(ctx, list)
matrix := make([][]any, 0, len(list))
for _, rec := range list {
obj := rec.TargetType
if obj == "BATCH" {
obj = "批次"
} else if obj == "SN" {
obj = "SN"
}
matrix = append(matrix, []any{
rec.ID, obj, rec.TargetID, rec.MaterialCode, rec.MaterialName,
inspectionTypeLabel(rec.InspectionType), rec.Status,
rec.InspectQty, rec.PassQty, rec.RejectQty, rec.RelatedStandard, rec.ReportNo,
rec.InspectionNo, rec.OwnershipNo, rec.Manufacturer, rec.Inspector, rec.Remark,
unixFmt(rec.CreatedAt), dispMap[rec.ID],
})
}
sendExcel(w, xlsxFilename("检验记录"), headers, matrix)
return
}
ok(w, map[string]any{"list": list})
}
}
// materialCodesBySpec 按规格型号模糊匹配物料编码集合(检验查询「型号」框用,L507-510)
func materialCodesBySpec(ctx *svc.ServiceContext, spec string) []string {
mats, err := ctx.EntClient.Material.Query().Where(material.SpecContainsFold(spec)).All(ctx0())
if err != nil {
return nil
}
codes := make([]string, 0, len(mats))
for _, m := range mats {
codes = append(codes, m.Code)
}
return codes
}
// disposalTypeOrNone 处置方式归一化(2026-11-16 拍板:处置下放明细子表,仅 退货/返修/报废 三种;
// 「部分入库」由送检判定即拆行自动完成,不再作为人工处置选项)
func disposalTypeOrNone(v string) string {
switch v {
case "RETURN", "SCRAP", "REWORK":
return v
default:
return "NONE"
}
}
// inspectionDisposalTextMap 处置明细汇总文本(2026-11-16 处置下放明细子表):
// 每条检验记录拼接「退货×5;返修×5」,供列表/历史/导出直接展示,无需前端二次查询。
func inspectionDisposalTextMap(ctx *svc.ServiceContext, list []*ent.InspectionRecord) map[int]string {
out := map[int]string{}
if len(list) == 0 {
return out
}
ids := make([]int64, 0, len(list))
for _, r := range list {
ids = append(ids, int64(r.ID))
}
lines, err := ctx.EntClient.InspectionDisposalItem.Query().
Where(inspectiondisposalitem.RecordIDIn(ids...)).All(ctx0())
if err != nil {
return out
}
typeName := map[string]string{"RETURN": "退货", "REWORK": "返修", "SCRAP": "报废"}
byRec := map[int][]*ent.InspectionDisposalItem{}
for _, l := range lines {
byRec[int(l.RecordID)] = append(byRec[int(l.RecordID)], l)
}
for _, r := range list {
parts := make([]string, 0, 3)
for _, l := range byRec[r.ID] {
seg := typeName[l.DisposeType] + "×" + strconv.Itoa(l.Qty)
if l.Remark != "" {
seg += "(" + l.Remark + ")"
}
parts = append(parts, seg)
}
if len(parts) > 0 {
out[r.ID] = strings.Join(parts, ";")
}
}
return out
}
// qualityAfterInspection 检验后的库存质量状态:
// 合格 → 合格(可出库);
// 退货(RETURN) → 待退(隔离);返修(REWORK)/报废/其余不合格 → 不合格(隔离,禁止上线)。
func qualityAfterInspection(status, disposalType string) string {
if status == "合格" {
return "合格"
}
switch disposalTypeOrNone(disposalType) {
case "RETURN":
return "待退"
}
return "不合格"
}
// disposeInspectionHandler 不合格品处置(退货 / 返修 / 报废)——历史「待处置」记录的补处置入口。
// POST /api/inspection/dispose body: { recordId, disposalType, disposalRemark, operator }
//
// RETURN 退货 → 库存置「待退」隔离(保持数量,等待退货运单确认后出库)
// REWORK 返修 → 库存置「不合格」隔离,备注标返修,返修后走复检入口
// SCRAP 报废 → 库存置「不合格」且生命周期「报废」,退出可用库存
//
// 2026-11-16 拍板:处置写明细子表 inspection_disposal_items(qty=记录不合格数、备注非必填,
// 运单号概念废除、物流信息统一填备注);单头不再存处置方式(列已 DROP)。
func disposeInspectionHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
RecordID int `json:"recordId"`
DisposalType string `json:"disposalType"`
DisposalRemark string `json:"disposalRemark"`
Operator string `json:"operator"`
}
if err := parseJSON(r, &req); err != nil || req.RecordID <= 0 {
fail(w, http.StatusBadRequest, "参数错误:recordId 必填")
return
}
dt := disposalTypeOrNone(req.DisposalType)
if dt == "NONE" {
fail(w, http.StatusBadRequest, "请选择处置方式(退货/返修/报废)")
return
}
rec, err := ctx.EntClient.InspectionRecord.Get(ctx0(), req.RecordID)
if err != nil {
fail(w, http.StatusNotFound, "检验记录不存在")
return
}
if rec.Status != "不合格" {
fail(w, http.StatusBadRequest, "仅「不合格」记录可执行处置")
return
}
inv, err := resolveInspectionTarget(ctx, rec.TargetID)
if err != nil {
fail(w, http.StatusBadRequest, err.Error())
return
}
tx, err := ctx.EntClient.Tx(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, "开启事务失败: "+err.Error())
return
}
committed := false
defer func() {
if !committed {
_ = tx.Rollback()
}
}()
// 2026-11-13 拍板:三维度正交——处置状态与检验结论、数量拆分互不混用。
// 2026-11-16 拍板:处置方式/备注下放明细子表,单头只推进处置状态。
if _, err = tx.InspectionRecord.UpdateOneID(rec.ID).
SetDisposalStatus("已处置").
Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "更新处置信息失败: "+err.Error())
return
}
// 处置明细行(qty=记录不合格数;SN 单件时不合格数=1)
dispQty := rec.RejectQty
if dispQty <= 0 {
dispQty = 1
}
if _, err = tx.InspectionDisposalItem.Create().
SetRecordID(int64(rec.ID)).SetDisposeType(dt).SetQty(dispQty).
SetNillableRemark(strPtr(req.DisposalRemark)).
SetNillableOperator(strPtr(req.Operator)).
Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "创建处置明细失败: "+err.Error())
return
}
switch dt {
case "RETURN":
if _, err = tx.Inventory.UpdateOneID(inv.ID).SetQualityStatus("待退").Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "更新库存状态失败: "+err.Error())
return
}
case "REWORK":
// 换修/返修:隔离为不合格,备注标返修,等待返修后重新报检(不上线、不发货)
if _, err = tx.Inventory.UpdateOneID(inv.ID).SetQualityStatus("不合格").Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "更新库存状态失败: "+err.Error())
return
}
case "SCRAP":
if _, err = tx.Inventory.UpdateOneID(inv.ID).SetQualityStatus("不合格").SetStatus("报废").Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "更新库存状态失败: "+err.Error())
return
}
}
if err = tx.Commit(); err != nil {
fail(w, http.StatusInternalServerError, "提交事务失败: "+err.Error())
return
}
committed = true
ctx.EventLog.Write(ctx0(), "inspection.dispose", r.Header.Get("X-Username"), "inspection", rec.TargetID,
"不合格处置 "+rec.TargetID+" → "+dt, map[string]any{"recordId": rec.ID, "disposalType": dt})
ok(w, map[string]any{"recordId": rec.ID, "disposalType": dt})
}
}
// applyInventoryDispose 按处置语义翻转一行库存(在库处置 / 内部接口共用):
//
// RETURN 退货 → 质量状态「待退」隔离(保持数量,等待退货运单确认后出库)
// REWORK 换修/返修 → 质量状态「不合格」隔离,返修后重新报检(不上线、不发货)
// SCRAP 报废 → 质量状态「不合格」且生命周期「报废」,退出可用库存
func applyInventoryDispose(tx *ent.Tx, inv *ent.Inventory, dt string) error {
switch dt {
case "RETURN":
_, err := tx.Inventory.UpdateOneID(inv.ID).SetQualityStatus("待退").Save(ctx0())
return err
case "REWORK":
_, err := tx.Inventory.UpdateOneID(inv.ID).SetQualityStatus("不合格").Save(ctx0())
return err
case "SCRAP":
_, err := tx.Inventory.UpdateOneID(inv.ID).SetQualityStatus("不合格").SetStatus("报废").Save(ctx0())
return err
}
return fmt.Errorf("不支持的处置方式: %s", dt)
}
// createDisposeTraceRecord 处置留痕:自动生成一条「不合格」检验记录 + 处置明细子表行
// (复用 batchFlipInspectionHandler 的创建模式:targetId=库存行编号、后端复核不合格数)。
// source 写入 remark 标记留痕来源(在库处置 / MES 联动),便于与来料检记录区分。
// 2026-11-16 拍板:处置方式/备注下放明细子表,运单号概念废除(退货物流信息填备注)。
func createDisposeTraceRecord(tx *ent.Tx, inv *ent.Inventory, dt, remark, operator, source string) error {
targetType := "BATCH"
targetId := inv.BatchNo
qty := inv.Quantity
if inv.SnMode == snModeSN {
targetType = "SN"
targetId = inv.SnCode
qty = 1
}
if qty <= 0 {
qty = 1
}
rec, err := tx.InspectionRecord.Create().
SetTargetType(targetType).
SetTargetID(targetId).
SetMaterialCode(inv.MaterialCode).
SetNillableMaterialName(strPtr(inv.MaterialName)).
SetStatus("不合格").
SetInspectQty(qty).
SetPassQty(0).
SetRejectQty(qty).
SetDisposalStatus("已处置").
SetNillableInspector(strPtr(operator)).
SetNillableRemark(strPtr(source)).
Save(ctx0())
if err != nil {
return err
}
_, err = tx.InspectionDisposalItem.Create().
SetRecordID(int64(rec.ID)).SetDisposeType(dt).SetQty(qty).
SetNillableRemark(strPtr(remark)).
SetNillableOperator(strPtr(operator)).
Save(ctx0())
return err
}
// inventoryDisposeHandler 在库处置:合格入库后的物料在使用中发现不合格,
// 直接从在库库存行发起处置,不再绕道补录检验记录(缺口 A)。
// POST /api/inspection/inventory-dispose body: { inventoryId, disposalType, disposalRemark, operator, qty }
//
// 仅接受 RETURN/REWORK/SCRAP
// qty 缺省 0=整行处置(向后兼容);序列号=否 0<qty<行数量 走部分处置:
// 原行扣减余量继续在库 + 拆出处置隔离行(qty==行数量 按整行处置,避免零数量行)
// 校验:库存行存在、生命周期「在库」、数量不超行
// 事务内:①自动生成「不合格」检验记录留痕+处置明细子表行 ②按处置语义翻该库存行/拆行 ③退货自动出库 ④写事件日志
// 2026-11-16 拍板:运单号概念废除,退货物流信息统一填 disposalRemark(非必填)
func inventoryDisposeHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
InventoryID int `json:"inventoryId"`
DisposalType string `json:"disposalType"`
DisposalRemark string `json:"disposalRemark"`
Operator string `json:"operator"`
Qty int `json:"qty"` // 处置数量:0=整行处置(默认,向后兼容)
}
if err := parseJSON(r, &req); err != nil || req.InventoryID <= 0 {
fail(w, http.StatusBadRequest, "参数错误:inventoryId 必填")
return
}
dt := disposalTypeOrNone(req.DisposalType)
switch dt {
case "RETURN", "REWORK", "SCRAP":
default:
fail(w, http.StatusBadRequest, "请选择处置方式(退货/返修/报废)")
return
}
inv, err := ctx.EntClient.Inventory.Get(ctx0(), req.InventoryID)
if err != nil {
fail(w, http.StatusNotFound, "库存行不存在")
return
}
if inv.Status != "在库" {
fail(w, http.StatusBadRequest, "仅「在库」库存行可发起处置,当前状态:"+inv.Status)
return
}
if req.Qty < 0 || req.Qty > inv.Quantity {
fail(w, http.StatusBadRequest, "处置数量不能超过该行库存数量")
return
}
if inv.SnMode == snModeSN && req.Qty > 1 {
fail(w, http.StatusBadRequest, "序列号=是请按 SN 行处置")
return
}
// 部分处置:仅序列号=否、数量严格小于行数量(qty==行数量 按整行处置,避免产生零数量行)
partial := inv.SnMode == snModeBatch && req.Qty > 0 && req.Qty < inv.Quantity
operator := r.Header.Get("X-Username")
if operator == "" {
operator = req.Operator
}
tx, err := ctx.EntClient.Tx(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, "开启事务失败: "+err.Error())
return
}
committed := false
defer func() {
if !committed {
_ = tx.Rollback()
}
}()
splitID := 0
if partial {
// 盘点冻结守卫:盘点期间库存量冻结,禁止部分处置拆行
if inv.StocktakeNo != "" {
fail(w, http.StatusConflict, "批次 "+inv.BatchNo+" 正在盘点单 "+inv.StocktakeNo+" 中冻结,禁止部分处置")
return
}
partialTag := fmt.Sprintf("部分处置 %d/%d", req.Qty, inv.Quantity)
dtName := map[string]string{"RETURN": "退货", "REWORK": "返修", "SCRAP": "报废"}[dt]
traceRemark := req.DisposalRemark
if traceRemark != "" {
traceRemark += ";" + partialTag
} else {
traceRemark = partialTag
}
// 原行扣减处置数量,剩余数量继续在库
if _, err = tx.Inventory.UpdateOneID(inv.ID).
AddQuantity(-req.Qty).SetUpdatedAt(time.Now().Unix()).Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "扣减原库存行失败: "+err.Error())
return
}
// 拆出处置隔离行:同物料/批次/四级库位/入库单号,质量状态按处置语义隔离
splitQuality := "不合格"
if dt == "RETURN" {
splitQuality = "待退"
}
split, e := tx.Inventory.Create().
SetManageMode(inv.ManageMode).
SetSnMode(inv.SnMode).
SetCategory(inv.Category).
SetMaterialCode(inv.MaterialCode).
SetNillableMaterialName(strPtr(inv.MaterialName)).
SetBatchNo(inv.BatchNo).
SetQuantity(req.Qty).SetLockedQty(0).
SetQualityStatus(splitQuality).
SetNillableZoneCode(strPtr(inv.ZoneCode)).
SetNillableShelfNo(strPtr(inv.ShelfNo)).
SetNillableLayerNo(strPtr(inv.LayerNo)).
SetNillablePositionNo(strPtr(inv.PositionNo)).
SetStatus("在库").
SetNillableInboundNo(strPtr(inv.InboundNo)).
SetRemark("在库处置部分隔离:" + dtName + "," + partialTag).
Save(ctx0())
if e != nil {
fail(w, http.StatusInternalServerError, "创建处置拆分行失败: "+e.Error())
return
}
splitID = split.ID
// 留痕/单据以拆分行为数量载体(按 qty 口径,inventoryId 关联拆分行)
splitInv := *split
if err = createDisposeTraceRecord(tx, &splitInv, dt, traceRemark, operator, "在库处置留痕"); err != nil {
fail(w, http.StatusInternalServerError, "创建留痕检验记录失败: "+err.Error())
return
}
// 退货闭环:对拆分行自动生成退供应商出库单并真实扣减(数量=qty)
if dt == "RETURN" {
if _, err = createSupplierReturnOutbound(ctx, tx, &splitInv, traceRemark, operator); err != nil {
fail(w, http.StatusInternalServerError, "自动退供应商出库失败: "+err.Error())
return
}
}
} else {
if err = createDisposeTraceRecord(tx, inv, dt, req.DisposalRemark, operator, "在库处置留痕"); err != nil {
fail(w, http.StatusInternalServerError, "创建留痕检验记录失败: "+err.Error())
return
}
if err = applyInventoryDispose(tx, inv, dt); err != nil {
fail(w, http.StatusInternalServerError, "更新库存状态失败: "+err.Error())
return
}
// 退货闭环:自动生成退供应商出库单并真实扣减库存(一步完成"置待退 + 实物出库 + 库存减少")
if dt == "RETURN" {
if _, err = createSupplierReturnOutbound(ctx, tx, inv, req.DisposalRemark, operator); err != nil {
fail(w, http.StatusInternalServerError, "自动退供应商出库失败: "+err.Error())
return
}
}
}
if err = tx.Commit(); err != nil {
fail(w, http.StatusInternalServerError, "提交事务失败: "+err.Error())
return
}
committed = true
targetId := inv.BatchNo
if inv.SnMode == snModeSN {
targetId = inv.SnCode
}
if partial {
ctx.EventLog.Write(ctx0(), "inspection.inventory.dispose", operator, "inventory", targetId,
fmt.Sprintf("在库处置(部分) %s %d/%d → %s", targetId, req.Qty, inv.Quantity, dt),
map[string]any{"inventoryId": splitID, "originalInventoryId": inv.ID, "disposalType": dt,
"materialCode": inv.MaterialCode, "qty": req.Qty, "total": inv.Quantity})
ok(w, map[string]any{"inventoryId": splitID, "originalInventoryId": inv.ID, "disposalType": dt, "qty": req.Qty, "total": inv.Quantity})
return
}
ctx.EventLog.Write(ctx0(), "inspection.inventory.dispose", operator, "inventory", targetId,
"在库处置 "+targetId+" → "+dt, map[string]any{"inventoryId": inv.ID, "disposalType": dt, "materialCode": inv.MaterialCode})
ok(w, map[string]any{"inventoryId": inv.ID, "disposalType": dt})
}
}
// internalInventoryDisposeHandler MES 质量检验(过程检/完工检)判不合格 → 联动 WMS 在库处置
// (X-API-TOKEN 内部接口,缺口 B;路由经 /api/internal/ 前缀注册,免 JWT、靠写死 token 保护)。
// POST /api/internal/inventory/dispose
// body: { materialCode, sn, batchNo, disposalType(RETURN/REWORK/SCRAP), remark, operator }
//
// 定位:SN 料(序列号=是 sn_mode=1)按 material_code+序列号精确唯一;批次料(序列号=否 sn_mode=2)按
// material_code+批次号定位(同批次可能多行,全部置状态)。仅操作「在库」行,0 行返回明确错误。
// 动作与在库处置同语义:RETURN→待退、REWORK→不合格、SCRAP→不合格+报废,
// 并同样生成留痕检验记录+处置明细子表行 + 事件日志。2026-11-16:运单号概念废除。
func internalInventoryDisposeHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
MaterialCode string `json:"materialCode"`
Sn string `json:"sn"`
BatchNo string `json:"batchNo"`
DisposalType string `json:"disposalType"`
Remark string `json:"remark"`
Operator string `json:"operator"`
}
if err := parseJSON(r, &req); err != nil {
fail(w, http.StatusBadRequest, "参数错误: "+err.Error())
return
}
if req.MaterialCode == "" {
fail(w, http.StatusBadRequest, "materialCode 必填")
return
}
if req.Sn == "" && req.BatchNo == "" {
fail(w, http.StatusBadRequest, "sn 与 batchNo 至少传一个")
return
}
dt := disposalTypeOrNone(req.DisposalType)
switch dt {
case "RETURN", "REWORK", "SCRAP":
default:
fail(w, http.StatusBadRequest, "处置方式仅支持 RETURN/REWORK/SCRAP")
return
}
// 定位在库库存行:sn 优先(序列号=是单件),否则按批次(序列号=否,可多行)
var rows []*ent.Inventory
var err error
desc := ""
if req.Sn != "" {
rows, err = ctx.EntClient.Inventory.Query().
Where(inventory.SnModeEQ(snModeSN), inventory.MaterialCodeEQ(req.MaterialCode),
inventory.SnCodeEQ(req.Sn), inventory.StatusEQ("在库")).All(ctx0())
desc = "SN " + req.Sn
} else {
rows, err = ctx.EntClient.Inventory.Query().
Where(inventory.SnModeEQ(snModeBatch), inventory.MaterialCodeEQ(req.MaterialCode),
inventory.BatchNoEQ(req.BatchNo), inventory.StatusEQ("在库")).All(ctx0())
desc = "批次 " + req.BatchNo
}
if err != nil {
fail(w, http.StatusInternalServerError, "查询库存失败: "+err.Error())
return
}
if len(rows) == 0 {
fail(w, http.StatusNotFound, "未找到在库库存行: "+req.MaterialCode+" "+desc+"(可能已出库、已处置或编号不符)")
return
}
tx, err := ctx.EntClient.Tx(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, "开启事务失败: "+err.Error())
return
}
committed := false
defer func() {
if !committed {
_ = tx.Rollback()
}
}()
for _, inv := range rows {
if err = createDisposeTraceRecord(tx, inv, dt, req.Remark, req.Operator, "MES检验联动留痕"); err != nil {
fail(w, http.StatusInternalServerError, "创建留痕检验记录失败: "+err.Error())
return
}
if err = applyInventoryDispose(tx, inv, dt); err != nil {
fail(w, http.StatusInternalServerError, "更新库存状态失败: "+err.Error())
return
}
}
if err = tx.Commit(); err != nil {
fail(w, http.StatusInternalServerError, "提交事务失败: "+err.Error())
return
}
committed = true
ctx.EventLog.Write(ctx0(), "inspection.inventory.dispose.internal", req.Operator, "inventory", req.MaterialCode,
"在库处置(内部) "+req.MaterialCode+" "+desc+" → "+dt, map[string]any{"disposalType": dt, "rows": len(rows)})
ok(w, map[string]any{"rows": len(rows), "disposalType": dt})
}
}
// statsInspectionHandler 检验统计:按物料汇总检验次数/合格数/不合格数/合格率
// 对应《问题记录》附二9 的替代方案(不合并记录,另出统计视图)
func statsInspectionHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
inspectionType := r.URL.Query().Get("inspectionType")
materialCode := r.URL.Query().Get("materialCode") // 需求13:统计先选物料,按物料聚焦
startDate := r.URL.Query().Get("startDate")
endDate := r.URL.Query().Get("endDate")
q := ctx.EntClient.InspectionRecord.Query()
if inspectionType != "" {
q = q.Where(inspectionrecord.InspectionTypeEQ(inspectionType))
}
if materialCode != "" {
q = q.Where(inspectionrecord.MaterialCodeContainsFold(materialCode))
}
if startDate != "" {
if t, err := time.ParseInLocation("2006-01-02", startDate, time.Local); err == nil {
q = q.Where(inspectionrecord.CreatedAtGTE(t.Unix()))
}
}
if endDate != "" {
if t, err := time.ParseInLocation("2006-01-02", endDate, time.Local); err == nil {
q = q.Where(inspectionrecord.CreatedAtLTE(t.Add(24 * time.Hour).Unix()))
}
}
recs, err := q.All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
type statRow struct {
MaterialCode string `json:"materialCode"`
Total int `json:"total"`
Pass int `json:"pass"`
Fail int `json:"fail"`
PassRate float64 `json:"passRate"`
}
agg := map[string]*statRow{}
order := []string{}
for _, rec := range recs {
r, found := agg[rec.MaterialCode]
if !found {
r = &statRow{MaterialCode: rec.MaterialCode}
agg[rec.MaterialCode] = r
order = append(order, rec.MaterialCode)
}
r.Total++
if rec.Status == "合格" {
r.Pass++
} else if rec.Status == "不合格" {
r.Fail++
}
}
list := make([]*statRow, 0, len(agg))
for _, code := range order {
r := agg[code]
if r.Total > 0 {
r.PassRate = float64(int(float64(r.Pass)/float64(r.Total)*10000)) / 100
}
list = append(list, r)
}
ok(w, map[string]any{"list": list})
}
}
// materialCodesByItemType 按物料类别(itemType)取物料编码集合。
// 先查 material 取编码集,再 IN 查 inventory/inspection_record,避免逐行 join(同 materialCodesBySpec 套路)。
func materialCodesByItemType(ctx *svc.ServiceContext, itemType int) []string {
mats, err := ctx.EntClient.Material.Query().Where(material.ItemTypeEQ(itemType)).All(ctx0())
if err != nil {
return nil
}
codes := make([]string, 0, len(mats))
for _, m := range mats {
codes = append(codes, m.Code)
}
return codes
}
// materialCodesByManageMode 按类型(manageMode=1结构件/2电气件/3其他)取物料编码集合(来料检验/库存「其他」类过滤用)。
// 纯类型语境过滤(2026-09-30 解耦后 manage_mode 仅作分类,不再承载 SN 行为)。
func materialCodesByManageMode(ctx *svc.ServiceContext, manageMode int) []string {
mats, err := ctx.EntClient.Material.Query().Where(material.ManageModeEQ(manageMode)).All(ctx0())
if err != nil {
return nil
}
codes := make([]string, 0, len(mats))
for _, m := range mats {
codes = append(codes, m.Code)
}
return codes
}
// inboundNosByType 取符合入库类型/入库时间范围的入库单号集合(待检清单按入库类型/时间过滤用,B1)。
// inboundType 为空表示不限类型;dateFrom/dateTo 为 YYYY-MM-DD,空表示不限(含止日当天)。
func inboundNosByType(ctx *svc.ServiceContext, inboundType, dateFrom, dateTo string) ([]string, error) {
oq := ctx.EntClient.InboundOrder.Query()
if inboundType != "" {
oq = oq.Where(inboundorder.InboundTypeEQ(inboundType))
}
if dateFrom != "" {
if t, err := time.ParseInLocation("2006-01-02", dateFrom, time.Local); err == nil {
oq = oq.Where(inboundorder.CreatedAtGTE(t.Unix()))
}
}
if dateTo != "" {
if t, err := time.ParseInLocation("2006-01-02", dateTo, time.Local); err == nil {
oq = oq.Where(inboundorder.CreatedAtLTE(t.Add(24 * time.Hour).Unix()))
}
}
orders, err := oq.All(ctx0())
if err != nil {
return nil, err
}
nos := make([]string, 0, len(orders))
for _, o := range orders {
if o.InboundNo != "" {
nos = append(nos, o.InboundNo)
}
}
return nos, nil
}
// pendingInspectionRow 待检清单主行(按 入库单 + 物料 分组,§E2)
// 详情明细改为按需分页加载(右侧抽屉),主行只带总数不塞 details 数组,避免 3000 SN 一次进内存
type pendingInspectionRow struct {
InboundNo string `json:"inboundNo"`
InboundType string `json:"inboundType"`
OwnershipType string `json:"ownershipType"`
OwnershipNo string `json:"ownershipNo"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
MatManageMode int `json:"matManageMode"` // 物料档案类型(1结构件/2电气件/3其他)
SnMode int `json:"snMode"` // 物料序列号设置(1=是/2=否/0未选择),待检清单展示用
UnInspectedQty int `json:"unInspectedQty"` // 未检数量(结构件=数量求和;电气件=SN 行数)
DetailsTotal int `json:"detailsTotal"` // 未检批次数/SN 总数(抽屉分页拉明细)
InboundTime int64 `json:"inboundTime"`
InspectionNo string `json:"inspectionNo"` // 入库单检测单号(送检时由检验页继承,互通)
}
// pendingInspectionHandler 待检清单(来料检验问题2):列出 quality_status=未检 的库存行,
// 按入库单为主行分组(展开看该单下批次/SN 明细),支持 物料/入库类型/目标类型(targetType=sn_mode 维度)/类型(manageMode) 筛选。
// targetType 仍按物料 sn_mode 落 BATCH/SN/OTHER(兼容旧参数);manageMode 按物料 manage_mode 维度(1结构件/2电气件/3其他)过滤,两者正交可叠加。
// 勾选带入录入页时,归属/入库类型/物料一并从入库单与库存行回填(§E1/E2)。
// GET /api/inspection/pending?materialCode=&inboundNo=&materialName=&inboundType=&dateFrom=&dateTo=&targetType=&manageMode=&page=&pageSize=
func pendingInspectionHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
materialCode := r.URL.Query().Get("materialCode")
inboundNo := r.URL.Query().Get("inboundNo") // 入库单号(模糊)
materialName := r.URL.Query().Get("materialName") // 物料名称(模糊)
inboundType := r.URL.Query().Get("inboundType") // purchase/semi/finished/return/other
dateFrom := r.URL.Query().Get("dateFrom") // 入库时间起 YYYY-MM-DD
dateTo := r.URL.Query().Get("dateTo") // 入库时间止 YYYY-MM-DD
targetType := r.URL.Query().Get("targetType") // BATCH(序列号=否)/SN(序列号=是)/OTHER(其他),按物料 sn_mode 维度
manageMode := r.URL.Query().Get("manageMode") // 1结构件/2电气件/3其他,按物料 manage_mode 维度(类型维度,与 targetType 正交,可叠加)
page := atoi(r.URL.Query().Get("page"), 1)
pageSize := atoi(r.URL.Query().Get("pageSize"), 20)
q := ctx.EntClient.Inventory.Query().
Where(inventory.StatusIn("在库", "锁定"), inventory.QualityStatusEQ("未检"))
if materialCode != "" {
q = q.Where(inventory.MaterialCodeContainsFold(materialCode))
}
if inboundNo != "" {
q = q.Where(inventory.InboundNoContainsFold(inboundNo))
}
if materialName != "" {
// 物料名称在 material 表:先按名称取编码集再 IN,避免逐行 join
mats, err := ctx.EntClient.Material.Query().Where(material.NameContainsFold(materialName)).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
if len(mats) == 0 {
ok(w, map[string]any{"list": []any{}, "total": 0})
return
}
codes := make([]string, 0, len(mats))
for _, m := range mats {
codes = append(codes, m.Code)
}
q = q.Where(inventory.MaterialCodeIn(codes...))
}
switch targetType {
case "BATCH":
q = q.Where(inventory.SnModeEQ(snModeBatch))
case "SN":
q = q.Where(inventory.SnModeEQ(snModeSN))
case "OTHER":
// 其他入库物料:类型 manage_mode=3(先取编码集再 IN,避免逐行 join)
codes := materialCodesByManageMode(ctx, invManageOther)
if len(codes) == 0 {
ok(w, map[string]any{"list": []any{}, "total": 0})
return
}
q = q.Where(inventory.MaterialCodeIn(codes...))
}
// 按类型(manage_mode)维度过滤待检项:值为 "1"/"2"/"3" 时,取对应物料编码集再 IN。
// 不改变已存储 target_type 字段语义(仍按物料 sn_mode 落 BATCH/SN/OTHER,供台账/盘点使用)。
if mm := atoi(manageMode, 0); mm == 1 || mm == 2 || mm == invManageOther {
codes := materialCodesByManageMode(ctx, mm)
if len(codes) == 0 {
ok(w, map[string]any{"list": []any{}, "total": 0})
return
}
q = q.Where(inventory.MaterialCodeIn(codes...))
}
if inboundType != "" || dateFrom != "" || dateTo != "" {
// 入库类型/入库时间都在 inbound_orders 表,合并为一次查询取单号集再 IN
nos, err := inboundNosByType(ctx, inboundType, dateFrom, dateTo)
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
if len(nos) == 0 {
ok(w, map[string]any{"list": []any{}, "total": 0})
return
}
q = q.Where(inventory.InboundNoIn(nos...))
}
all, err := q.Order(ent.Desc("created_at"), ent.Desc("id")).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
// 入库单维度信息(类型/归属/入库时间)map
inboundNos := []string{}
seenNo := map[string]bool{}
for _, inv := range all {
if inv.InboundNo != "" && !seenNo[inv.InboundNo] {
seenNo[inv.InboundNo] = true
inboundNos = append(inboundNos, inv.InboundNo)
}
}
inboundMap := map[string]*ent.InboundOrder{}
if len(inboundNos) > 0 {
if orders, e := ctx.EntClient.InboundOrder.Query().Where(inboundorder.InboundNoIn(inboundNos...)).All(ctx0()); e == nil {
for _, o := range orders {
inboundMap[o.InboundNo] = o
}
}
}
// 物料名称 / 类型 map
matName := map[string]string{}
matManageMode := map[string]int{}
codeSet := []string{}
seenC := map[string]bool{}
for _, inv := range all {
if !seenC[inv.MaterialCode] {
seenC[inv.MaterialCode] = true
codeSet = append(codeSet, inv.MaterialCode)
}
}
if len(codeSet) > 0 {
if mats, e := ctx.EntClient.Material.Query().Where(material.CodeIn(codeSet...)).All(ctx0()); e == nil {
for _, m := range mats {
matName[m.Code] = m.Name
matManageMode[m.Code] = m.ManageMode
}
}
}
// 分组:主行 = (入库单号, 物料编码)
group := map[string]*pendingInspectionRow{}
order := []string{}
for _, inv := range all {
o := inboundMap[inv.InboundNo]
key := inv.InboundNo + "|" + inv.MaterialCode
g, ok := group[key]
if !ok {
ownType, ownNo := "", ""
if o != nil {
ownType = o.OwnershipType
ownNo = o.OwnershipNo
}
g = &pendingInspectionRow{
InboundNo: inv.InboundNo,
InboundType: strOrEmpty(o),
OwnershipType: ownershipTypeOrNone(ownType),
OwnershipNo: ownNo,
MaterialCode: inv.MaterialCode,
MaterialName: matName[inv.MaterialCode],
MatManageMode: matManageMode[inv.MaterialCode],
SnMode: inv.SnMode,
InspectionNo: strOrEmptyInspectionNo(o),
}
group[key] = g
order = append(order, key)
}
qty := 1
if inv.SnMode == snModeBatch {
qty = inv.Quantity
}
g.UnInspectedQty += qty
g.DetailsTotal++
if o != nil && o.CreatedAt > g.InboundTime {
g.InboundTime = o.CreatedAt
}
}
total := len(order)
start := (page - 1) * pageSize
if start < 0 {
start = 0
}
end := start + pageSize
if end > total {
end = total
}
rows := make([]*pendingInspectionRow, 0, end-start)
for i := start; i < end; i++ {
rows = append(rows, group[order[i]])
}
ok(w, map[string]any{"list": rows, "total": total, "page": page, "pageSize": pageSize})
}
}
// strOrEmpty 取入库单的入库类型(nil 安全)
func strOrEmpty(o *ent.InboundOrder) string {
if o == nil {
return ""
}
return o.InboundType
}
// strOrEmptyInspectionNo 取入库单的检测单号(nil 安全)
func strOrEmptyInspectionNo(o *ent.InboundOrder) string {
if o == nil {
return ""
}
return o.InspectionNo
}
// pendingDetailsInspectionHandler GET /api/inspection/pending/details
// 待检清单主行抽屉里的明细分页(右侧抽屉懒加载,不再主行带 details 数组)。
// 入参:inboundNo + materialCode + page + pageSize(默认 20)。
func pendingDetailsInspectionHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
q := r.URL.Query()
inboundNo := q.Get("inboundNo")
materialCode := q.Get("materialCode")
if inboundNo == "" || materialCode == "" {
fail(w, http.StatusBadRequest, "inboundNo 和 materialCode 不能为空")
return
}
page, _ := strconv.Atoi(q.Get("page"))
pageSize, _ := strconv.Atoi(q.Get("pageSize"))
if page < 1 {
page = 1
}
if pageSize < 1 || pageSize > 500 {
pageSize = 20
}
qry := svcCtx.EntClient.Inventory.Query().
Where(
inventory.InboundNoEQ(inboundNo),
inventory.MaterialCodeEQ(materialCode),
inventory.QualityStatusEQ("未检"),
)
total, err := qry.Count(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
start := (page - 1) * pageSize
list, err := qry.
Order(inventory.ByID()).
Offset(start).
Limit(pageSize).
All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
// itemType / 类型 从物料档案补查(一个 materialCode 唯一)
itemType := 0
matManageMode := 0
if m, e := svcCtx.EntClient.Material.Query().Where(material.CodeEQ(materialCode)).Only(ctx0()); e == nil {
itemType = m.ItemType
matManageMode = m.ManageMode
}
rows := make([]map[string]any, 0, len(list))
for _, inv := range list {
tid := inv.BatchNo
if inv.SnMode == snModeSN {
tid = inv.SnCode
}
rows = append(rows, map[string]any{
"targetId": tid,
"snMode": inv.SnMode,
"matManageMode": matManageMode,
"itemType": itemType,
"quantity": inv.Quantity,
"zoneCode": inv.ZoneCode,
"id": inv.ID,
})
}
ok(w, map[string]any{"list": rows, "total": total, "page": page, "pageSize": pageSize})
}
}