Files
bj_power/bj_power_wms/internal/handler/inspection.go
T
2026-10-26 16:32:35 +08:00

1363 lines
52 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 (
"fmt"
"net/http"
"strconv"
"time"
"bj_power_wms/ent"
"bj_power_wms/ent/inboundorder"
"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, disposalType,
//
// returnTrackingNo, disposalRemark, ownershipType, ownershipNo,
// relatedStandard, manufacturer, checkDesc, inspector, reportNo, inspectionNo,
// batchSeq, batchTotal } ] }
//
// 每个对象按自身数量写记录、按自身结论翻库存状态(修复旧版"所有记录同数量"的 bug)。
// reject_qty 后端复核 = inspectQty - passQty,不信任前端传入值。
// batchSeq/batchTotal(第几批/共几件):序列号=否(sn_mode=2)必填且均≥1;序列号=是忽略传值、落库 0=未填。
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"`
DisposalType string `json:"disposalType"`
ReturnTrackingNo string `json:"returnTrackingNo"`
DisposalRemark string `json:"disposalRemark"`
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 item struct {
id string
inv *ent.Inventory
targetType string
material string
status string
inspectQty int
passQty int
rejectQty int
disposal string
retTrack string
dispRemark string
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
// 第几批/共几件:序列号=否(sn_mode=2)必填且均≥1;序列号=是忽略前端传值、落库 0=未填
batchSeq, batchTotal := 0, 0
if inv.SnMode == snModeBatch {
if it.BatchSeq < 1 || it.BatchTotal < 1 {
fail(w, http.StatusBadRequest, "序列号=否来料检验需填写第几批与共几件: "+it.TargetId)
return
}
batchSeq, batchTotal = it.BatchSeq, it.BatchTotal
}
items = append(items, item{
id: it.TargetId, inv: inv, targetType: tt, material: inv.MaterialCode,
status: it.Status, inspectQty: inspectQty, passQty: passQty, rejectQty: rejectQty,
disposal: disposalTypeOrNone(it.DisposalType), retTrack: it.ReturnTrackingNo, dispRemark: it.DisposalRemark,
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
}
}
if _, 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).
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)).
SetDisposalType(it.disposal).
SetNillableDisposalRemark(strPtr(it.dispRemark)).
SetNillableReturnTrackingNo(strPtr(it.retTrack)).
SetNillableProductWorkNo(strPtr(it.pw)).
Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "创建检验记录失败: "+err.Error())
return
}
if _, err = tx.Inventory.UpdateOneID(it.inv.ID).
SetQualityStatus(qualityAfterInspection(it.status, it.disposal)).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
}
ok(w, map[string]any{
"total": total,
"list": list,
"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-10-04 客户需求)随批次/SN 列展示,0=未填显示 "-"
headers := []string{"ID", "对象", "批次/SN", "第几批", "共几件", "图号", "名称", "检验类型", "结论", "检验数", "合格数", "不合格数", "相关标准", "报检单号", "检测单号", "归属单号", "生产厂家", "记录人", "备注", "记录日期"}
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, intOrDash(rec.BatchSeq), intOrDash(rec.BatchTotal), 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),
})
}
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 处置方式归一化(需求23:不合格可转退货 / 换修(返修)/ 报废 / 部分入库)
func disposalTypeOrNone(v string) string {
switch v {
case "RETURN", "SCRAP", "PARTIAL", "REWORK":
return v
default:
return "NONE"
}
}
// 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, returnTrackingNo, operator }
//
// RETURN 退货 → 库存置「待退」隔离(保持数量,等待退货运单确认后出库)
// SCRAP 报废 → 库存置「不合格」且生命周期「报废」,退出可用库存
// PARTIAL 部分入库 → 仅批次管理:按合格数拆行(合格行入库 + 差额行隔离),数量守恒
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"`
ReturnTrackingNo string `json:"returnTrackingNo"`
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
}
if dt == "RETURN" && req.ReturnTrackingNo == "" {
fail(w, http.StatusBadRequest, "退货处置必须填写货运单号")
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()
}
}()
if _, err = tx.InspectionRecord.UpdateOneID(rec.ID).
SetDisposalType(dt).
SetNillableDisposalRemark(strPtr(req.DisposalRemark)).
SetNillableReturnTrackingNo(strPtr(req.ReturnTrackingNo)).
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
}
case "PARTIAL":
if inv.SnMode != snModeBatch {
fail(w, http.StatusBadRequest, "部分入库仅适用于序列号=否(按数量管理)")
return
}
total := inv.Quantity
if rec.PassQty <= 0 || rec.PassQty >= total {
fail(w, http.StatusBadRequest, fmt.Sprintf("部分入库:合格数须在 0 与批次数量(%d) 之间", total))
return
}
bad := total - rec.PassQty
if _, err = tx.Inventory.UpdateOneID(inv.ID).
SetQuantity(rec.PassQty).SetQualityStatus("合格").Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "拆分合格批次失败: "+err.Error())
return
}
if _, err = tx.Inventory.Create().
SetManageMode(inv.ManageMode).
SetSnMode(inv.SnMode).
SetCategory(inv.Category).
SetMaterialCode(inv.MaterialCode).
SetNillableMaterialName(strPtr(inv.MaterialName)).
SetBatchNo(inv.BatchNo + "-NG").
SetQuantity(bad).SetLockedQty(0).
SetQualityStatus("不合格").
SetNillableZoneCode(strPtr(inv.ZoneCode)).
SetStatus("在库").
SetNillableInboundNo(strPtr(inv.InboundNo)).
SetRemark("不合格隔离(部分入库差额)").
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 联动),便于与来料检记录区分。
func createDisposeTraceRecord(tx *ent.Tx, inv *ent.Inventory, dt, remark, trackNo, 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
}
_, err := tx.InspectionRecord.Create().
SetTargetType(targetType).
SetTargetID(targetId).
SetMaterialCode(inv.MaterialCode).
SetNillableMaterialName(strPtr(inv.MaterialName)).
SetStatus("不合格").
SetInspectQty(qty).
SetPassQty(0).
SetRejectQty(qty).
SetDisposalType(dt).
SetNillableDisposalRemark(strPtr(remark)).
SetNillableReturnTrackingNo(strPtr(trackNo)).
SetNillableInspector(strPtr(operator)).
SetNillableRemark(strPtr(source)).
Save(ctx0())
return err
}
// inventoryDisposeHandler 在库处置:合格入库后的物料在使用中发现不合格,
// 直接从在库库存行发起处置,不再绕道补录检验记录(缺口 A)。
// POST /api/inspection/inventory-dispose body: { inventoryId, disposalType, returnTrackingNo, disposalRemark, operator, qty }
//
// 仅接受 RETURN/REWORK/SCRAP;在库不存在部分入库场景,PARTIAL 直接报错
// qty 缺省 0=整行处置(向后兼容);序列号=否 0<qty<行数量 走部分处置:
// 原行扣减余量继续在库 + 拆出处置隔离行(qty==行数量 按整行处置,避免零数量行)
// 校验:库存行存在、生命周期「在库」、数量不超行、RETURN 必填退货运单号
// 事务内:①自动生成一条「不合格」检验记录留痕 ②按处置语义翻该库存行/拆行 ③退货自动出库 ④写事件日志
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"`
ReturnTrackingNo string `json:"returnTrackingNo"`
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
}
if req.DisposalType == "PARTIAL" {
fail(w, http.StatusBadRequest, "在库处置不支持部分入库")
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 dt == "RETURN" && req.ReturnTrackingNo == "" {
fail(w, http.StatusBadRequest, "退货处置必须填写退货运单号")
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, req.ReturnTrackingNo, 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, req.ReturnTrackingNo, 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), returnTrackingNo, remark, operator }
//
// 定位:SN 料(序列号=是 sn_mode=1)按 material_code+序列号精确唯一;批次料(序列号=否 sn_mode=2)按
// material_code+批次号定位(同批次可能多行,全部置状态)。仅操作「在库」行,0 行返回明确错误。
// 动作与在库处置同语义:RETURN→待退、REWORK→不合格、SCRAP→不合格+报废,
// 并同样生成留痕检验记录 + 事件日志。
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"`
ReturnTrackingNo string `json:"returnTrackingNo"`
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
}
if dt == "RETURN" && req.ReturnTrackingNo == "" {
fail(w, http.StatusBadRequest, "退货处置必须填写退货运单号")
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.ReturnTrackingNo, 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})
}
}