// 检验模块路由总览(本文件实现): // // 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": // 2026-11-17 拍板:检验页「处置」与库存查询页「处置」统一扣减口径—— // 退货不再只翻「待退」状态,而是自动生成退供应商出库单并真实扣减库存, // 与 inventoryDisposeHandler RETURN 分支走同一个 createSupplierReturnOutbound, // 保证无论从检验页还是库存页发起退货,批次/SN 明细与汇总账都一致。 // 守卫:合格行不在检验页直接退(避免误扣合格库存);已待退/已出库拒绝重复退货。 if inv.QualityStatus == "合格" { fail(w, http.StatusBadRequest, "该库存行已是合格状态,不能在检验页直接退货;请到「库存管理 → 库存查询 → 批次/序列号明细」按实际库存处置") return } if inv.Status == "出库" || inv.QualityStatus == "待退" { fail(w, http.StatusConflict, "该物料已处置或已出库,请勿重复退货") return } if _, err = tx.Inventory.UpdateOneID(inv.ID).SetQualityStatus("待退").Save(ctx0()); err != nil { fail(w, http.StatusInternalServerError, "更新库存状态失败: "+err.Error()) return } operator := r.Header.Get("X-Username") if operator == "" { operator = req.Operator } if _, err = createSupplierReturnOutbound(ctx, tx, inv, req.DisposalRemark, operator); 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 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}) } }