package handler import ( "context" "net/http" "strings" "time" "bj_power_wms/ent" "bj_power_wms/ent/inventory" "bj_power_wms/ent/material" "bj_power_wms/ent/ordermaterialledger" "bj_power_wms/internal/mesclient" "bj_power_wms/internal/svc" "bj_power_wms/internal/verr" "github.com/xuri/excelize/v2" "github.com/zeromicro/go-zero/core/logx" ) // pushMaterialToMESNow 物料两库对等(需求一 M4):把 WMS 物料档案同步推送 MES 本地副本(按 code 幂等)。 // 抽成同步函数,便于「异步推送」与「手动重推」复用同一份推送逻辑。ctx.Mes 为空(未配 MES)视为成功。 func pushMaterialToMESNow(ctx *svc.ServiceContext, m *ent.Material) error { if ctx.Mes == nil { return nil } c, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() active := m.IsActive return ctx.Mes.UpsertMaterial(c, mesclient.MaterialUpsert{ Code: m.Code, Name: m.Name, Spec: m.Spec, Unit: m.Unit, Description: m.Description, ItemType: m.ItemType, ManageMode: m.ManageMode, SnMode: m.SnMode, TemplateCode: m.TemplateCode, SafetyStock: m.SafetyStock, IsActive: &active, }) } // pushMaterialToMES 物料两库对等(需求一 M4):WMS 落库成功后异步推送 MES 本地副本(按 code 幂等)。 // C4 反向:推送失败置 sync_pending=true 并写 event_log 记原因;成功清位。不阻塞本请求。 func pushMaterialToMES(ctx *svc.ServiceContext, m *ent.Material) { go func() { if err := pushMaterialToMESNow(ctx, m); err != nil { _ = ctx.EntClient.Material.UpdateOneID(m.ID).SetSyncPending(true).Exec(context.Background()) ctx.EventLog.Write(context.Background(), "material.sync.failed", "system", "material", m.Code, "推送物料到 MES 失败", map[string]any{"error": err.Error()}) return } _ = ctx.EntClient.Material.UpdateOneID(m.ID).SetSyncPending(false).Exec(context.Background()) }() } // retryMaterialSyncHandler POST /api/material/retry-sync 手动重推单条(C4 反向,对齐 MES:不做自动重推)。 // body: {"id": };失败置 sync_pending=true + 写 event_log,返回 502 + 原因;成功清位返回 ok。 func retryMaterialSyncHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var req struct { ID int `json:"id"` } if err := parseJSON(r, &req); err != nil { fail(w, http.StatusBadRequest, "参数错误") return } if req.ID <= 0 { fail(w, http.StatusBadRequest, "id 必填") return } m, err := ctx.EntClient.Material.Get(ctx0(), req.ID) if err != nil { fail(w, http.StatusNotFound, "物料不存在") return } if err := pushMaterialToMESNow(ctx, m); err != nil { _ = ctx.EntClient.Material.UpdateOneID(m.ID).SetSyncPending(true).Exec(ctx0()) ctx.EventLog.Write(ctx0(), "material.sync.failed", "system", "material", m.Code, "手动重推物料到 MES 失败", map[string]any{"error": err.Error()}) fail(w, http.StatusBadGateway, "推送失败:"+err.Error()) return } _ = ctx.EntClient.Material.UpdateOneID(m.ID).SetSyncPending(false).Exec(ctx0()) ok(w, map[string]any{"ok": true, "code": m.Code}) } } // itemTypeLabel 物料类别标签:1原材料/3成品(「其他」类别已按 2026-10-19 裁决全项目移除, // 半成品类别早已下线,2 仅为历史存量数据防御性显示) func itemTypeLabel(t int) string { switch t { case invCatSemi: return "半成品" case invCatFinished: return "成品" default: return "原材料" } } // validateMaterialRequired 物料档案必填校验(2026-09-19 用户裁决: // 新增/编辑表单除「说明」外全部必填)。返回空串表示通过,否则返回中文错误文案。 // // 说明:图号 code 只在新增时必填(编辑不可改),由调用方单独校验; // 「类型」= 分类 1结构件/2电气件/3其他,与「物料类别」相互独立,均必填; // 「序列号」= sn_mode 1序列号=是/2序列号=否(2026-09-30 解耦定稿,0未选择不可保存)。 func validateMaterialRequired(name, spec, unit string, itemType, manageMode, snMode int) string { switch { case strings.TrimSpace(name) == "": return "名称为必填项" case strings.TrimSpace(spec) == "": return "规格型号为必填项" case strings.TrimSpace(unit) == "": return "单位为必填项" case itemType == invCatSemi: // 2026-09-22 定稿:半成品是工件状态(由库存 category=2 承载),不再是物料类别 return "半成品不再是物料类别,请选择成品档案并在库存中记录工序状态" case itemType != invCatRaw && itemType != invCatFinished: return "物料类别为必填项(原材料 / 成品)" case manageMode != 1 && manageMode != 2 && manageMode != invManageOther: return "类型为必填项(结构件 / 电气件 / 其他)" case snMode != snModeSN && snMode != snModeBatch: return "请选择是否有序列号(序列号=是 / 序列号=否)" } return "" } // snModeByType 类型默认联动(2026-09-30 解耦定稿):电气件→序列号=是(1),结构件/其他→序列号=否(2)。 // 用于 MES 同步/Excel 导入等无 sn_mode 入参的建档路径;WMS 表单端用户可手动改。 func snModeByType(manageMode int) int { if manageMode == 2 { return snModeSN } return snModeBatch } // collectMaterialRequired 物料档案必填校验·收集式(2026-10-20 报错规范): // 逐条收集不短路,仅物料表单保存(新增/编辑)路径使用;MES 同步/Excel 导入仍用 validateMaterialRequired。 // 必填口径(2026-09-19 用户裁决):除「说明」外全部必填;图号(code) 由调用方单独校验。 func collectMaterialRequired(ve *verr.ValidationError, name, spec, unit string, itemType, manageMode, snMode int) { if strings.TrimSpace(name) == "" { ve.Add("name", "名称为必填项", "请填写物料名称") } if strings.TrimSpace(spec) == "" { ve.Add("spec", "规格型号为必填项", "请填写规格型号") } if strings.TrimSpace(unit) == "" { ve.Add("unit", "单位为必填项", "请填写计量单位(如 件 / 个 / 米)") } if itemType == invCatSemi { // 2026-09-22 定稿:半成品是工件状态(由库存 category=2 承载),不再是物料类别 ve.Add("itemType", "半成品不再是物料类别", "请选择「成品」档案;半成品在库存中记录工序状态") } else if itemType != invCatRaw && itemType != invCatFinished { ve.Add("itemType", "物料类别为必填项", "在「物料类别」里选择 原材料 或 成品") } if manageMode != 1 && manageMode != 2 && manageMode != invManageOther { ve.Add("manageMode", "类型为必填项", "在「类型」里选择 结构件 / 电气件 / 其他") } if snMode != snModeSN && snMode != snModeBatch { ve.Add("snMode", "请选择是否有序列号", "在「序列号」里选择 序列号=是 或 序列号=否") } } // createMaterialHandler 创建物料档案 func createMaterialHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var req struct { Code string `json:"code"` Name string `json:"name"` Spec string `json:"spec"` Unit string `json:"unit"` Description string `json:"description"` ManageMode int `json:"manageMode"` // 类型 1结构件/2电气件/3其他 SnMode int `json:"snMode"` // 序列号 1序列号=是/2序列号=否(0未选择不可保存) TemplateCode string `json:"templateCode"` ItemType int `json:"itemType"` // 1原材料/3成品(半成品不是物料类别) SafetyStock int `json:"safetyStock"` // 安全库存(低于触发缺货预警) IsActive *bool `json:"isActive"` // 启用状态(nil 视为启用) } if err := parseJSON(r, &req); err != nil { fail(w, http.StatusBadRequest, "参数错误") return } // 必填口径(2026-09-19 用户裁决):除「说明」外全部必填 —— 收集式一次列全(2026-10-20 报错规范) ve := verr.New() if strings.TrimSpace(req.Code) == "" { ve.Add("code", "图号为必填项", "请填写物料图号(图号即物料编码)") } collectMaterialRequired(ve, req.Name, req.Spec, req.Unit, req.ItemType, req.ManageMode, req.SnMode) if req.ItemType == invCatFinished && req.SnMode != snModeSN { ve.Add("snMode", "成品物料的序列号必须为「是」", "成品逐件追溯、SN 由系统兜底生成;把序列号改为「序列号=是」") } // 校验编码唯一(与其他校验相互独立,一并收集) if strings.TrimSpace(req.Code) != "" { exists, err := ctx.EntClient.Material.Query(). Where(material.CodeEQ(req.Code)). Exist(ctx0()) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } if exists { ve.AddAction("code", "图号 "+req.Code+" 已存在", "改用其他图号;或到物料列表搜索该图号查看已有档案", "查看物料列表", "/material") } } if err := ve.OrNil(); err != nil { FailErr(w, err) return } // 物料类别/类型已在上方校验,原样落库(类型 1结构件/2电气件/3其他 相互独立,不再由物料类别收敛) manageMode := req.ManageMode itemType := req.ItemType // 成品(item_type=3)序列号强制「是」(2026-10-19 拍板:成品 SN 系统兜底生成、逐件追溯) snMode := req.SnMode if itemType == invCatFinished { snMode = snModeSN } m, err := ctx.EntClient.Material.Create(). SetCode(req.Code). SetName(req.Name). SetNillableSpec(strPtr(req.Spec)). SetNillableUnit(strPtr(req.Unit)). SetNillableDescription(strPtr(req.Description)). SetManageMode(manageMode). SetSnMode(snMode). SetIsBatchManaged(snMode == snModeBatch). SetIsSerialManaged(snMode == snModeSN). SetNillableTemplateCode(strPtr(req.TemplateCode)). SetItemType(itemType). SetSafetyStock(req.SafetyStock). SetIsActive(req.IsActive == nil || *req.IsActive). Save(ctx0()) if err != nil { logx.Errorf("create material failed: %v", err) fail(w, http.StatusInternalServerError, "创建物料失败: "+err.Error()) return } ctx.EventLog.Write(ctx0(), "material.create", r.Header.Get("X-Username"), "material", req.Code, "新增物料 "+req.Code+" "+req.Name, map[string]any{"manageMode": manageMode}) pushMaterialToMES(ctx, m) // 需求一 M4:异步推送 MES 本地副本 ok(w, m) } } // updateMaterialHandler 更新物料档案 func updateMaterialHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var req struct { ID int `json:"id"` Name string `json:"name"` Spec string `json:"spec"` Unit string `json:"unit"` Description string `json:"description"` ManageMode int `json:"manageMode"` // 类型 1结构件/2电气件/3其他 SnMode int `json:"snMode"` // 序列号 1序列号=是/2序列号=否(0未选择不可保存) ItemType int `json:"itemType"` SafetyStock int `json:"safetyStock"` IsActive *bool `json:"isActive"` } if err := parseJSON(r, &req); err != nil || req.ID <= 0 { fail(w, http.StatusBadRequest, "参数错误") return } // 必填口径(2026-09-19 用户裁决):除「说明」外全部必填 —— 收集式一次列全(2026-10-20 报错规范) ve := verr.New() collectMaterialRequired(ve, req.Name, req.Spec, req.Unit, req.ItemType, req.ManageMode, req.SnMode) cur, gerr := ctx.EntClient.Material.Get(ctx0(), req.ID) if gerr != nil { fail(w, http.StatusNotFound, "物料不存在") return } // ---------- 物料类别/序列号规则(2026-10-19 用户拍板;收集式并列校验 2026-10-20) ---------- // ① 成品(item_type=3)序列号强制为「是」且不可改(成品 SN 系统兜底生成、逐件追溯); // ② 已有工件引用(库存存在 SN 记账行=已有实物按件流转)→ 序列号锁死,禁止改; // ③ 已有工单引用(工单用料台账有该物料行)→ 物料类别锁死,禁止改; // ④ 类型(结构件/电气件/其他)已被库存引用 → 锁死(2026-10-20 拍板:三字段已使用不可修改)。 if req.ItemType == invCatFinished && req.SnMode != snModeSN { ve.Add("snMode", "成品物料的序列号必须为「是」,不可修改", "成品逐件追溯、SN 由系统兜底生成;把序列号改回「序列号=是」") } if req.SnMode != cur.SnMode { snRef, cerr := ctx.EntClient.Inventory.Query(). Where(inventory.MaterialCodeEQ(cur.Code), inventory.SnModeEQ(snModeSN)). Exist(ctx0()) if cerr == nil && snRef { ve.Add("snMode", "该物料已有工件按序列号引用,序列号不可修改", "已有库存实物按「序列号=是」流转;保持原序列号设置不变") } } if req.ItemType != cur.ItemType { woRef, werr := ctx.EntClient.OrderMaterialLedger.Query(). Where(ordermaterialledger.MaterialCodeEQ(cur.Code)). Exist(ctx0()) if werr == nil && woRef { ve.Add("itemType", "该物料已被工单用料引用,物料类别不可修改", "先清理相关工单用料记录;或保持原物料类别不变") } } if req.ManageMode != cur.ManageMode { invRef, ierr := ctx.EntClient.Inventory.Query(). Where(inventory.MaterialCodeEQ(cur.Code)). Exist(ctx0()) if ierr == nil && invRef { ve.Add("manageMode", "该物料已有库存记录,类型不可修改", "已有库存按原类型记账;保持原类型不变,或先处理完库存再调整") } } if err := ve.OrNil(); err != nil { FailErr(w, err) return } // 成品强制落「序列号=是」(防历史脏值经本接口翻案) snMode := req.SnMode if req.ItemType == invCatFinished { snMode = snModeSN } manageMode := req.ManageMode m, err := ctx.EntClient.Material.UpdateOneID(req.ID). SetName(req.Name). SetSpec(req.Spec). SetUnit(req.Unit). SetDescription(req.Description). SetItemType(req.ItemType). SetSafetyStock(req.SafetyStock). SetIsActive(req.IsActive == nil || *req.IsActive). SetManageMode(manageMode). SetSnMode(snMode). SetIsBatchManaged(snMode == snModeBatch). SetIsSerialManaged(snMode == snModeSN). Save(ctx0()) if err != nil { fail(w, http.StatusInternalServerError, "更新物料失败: "+err.Error()) return } ctx.EventLog.Write(ctx0(), "material.update", r.Header.Get("X-Username"), "material", cur.Code, "编辑物料 "+cur.Code+" "+cur.Name, nil) pushMaterialToMES(ctx, m) // 需求一 M4:异步推送 MES 本地副本(含停用) ok(w, m) } } // upsertMaterialInternalHandler POST /api/internal/materials/upsert // 物料两库对等(需求一 M3/M5 落点):MES→WMS 推送,按 code 幂等 upsert(存在→更新,不存在→校验必填后新建)。 // 两库均不物理删除:MES「删除」= isActive=false 停用,随本接口同步;本接口不回推 MES(改动源自 MES,防环)。 // toggleMaterialStatusHandler POST /api/material/toggle-status 物料启用/停用(操作列独立按钮,条11③) func toggleMaterialStatusHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var req struct { ID int `json:"id"` IsActive bool `json:"isActive"` } if err := parseJSON(r, &req); err != nil || req.ID <= 0 { fail(w, http.StatusBadRequest, "参数错误") return } m, err := ctx.EntClient.Material.UpdateOneID(req.ID).SetIsActive(req.IsActive).Save(ctx0()) if err != nil { fail(w, http.StatusInternalServerError, "更新物料状态失败: "+err.Error()) return } pushMaterialToMES(ctx, m) // 物料档案两库同步(立场A):启停状态同样互推 ok(w, map[string]any{"id": m.ID, "isActive": m.IsActive}) } } func upsertMaterialInternalHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var req struct { Code string `json:"code"` Name string `json:"name"` Spec string `json:"spec"` Unit string `json:"unit"` Description string `json:"description"` ItemType int `json:"itemType"` ManageMode int `json:"manageMode"` SnMode int `json:"snMode"` // 2026-09-30 与 MES 契约一致:0未选择/1序列号=是/2序列号=否;0=更新时保留现值、新建时按类型派生 TemplateCode string `json:"templateCode"` SafetyStock int `json:"safetyStock"` IsActive *bool `json:"isActive"` } if err := parseJSON(r, &req); err != nil || strings.TrimSpace(req.Code) == "" { fail(w, http.StatusBadRequest, "code(图号)为必填项") return } active := true if req.IsActive != nil { active = *req.IsActive } existing, gerr := ctx.EntClient.Material.Query().Where(material.CodeEQ(req.Code)).Only(ctx0()) if gerr == nil { // ---------- 类别/序列号规则(2026-10-19 拍板,与编辑接口同口径) ---------- // 成品(3)序列号强制「是」;已有工件引用(inventory SN 行)→序列号锁死; // 已有工单引用(order_material_ledgers)→类别锁死。 if req.ItemType == invCatFinished && req.SnMode != snModeSN && req.SnMode != 0 { fail(w, http.StatusBadRequest, "成品物料的序列号必须为「是」") return } if req.SnMode == snModeSN || req.SnMode == snModeBatch { if req.SnMode != existing.SnMode { snRef, cerr := ctx.EntClient.Inventory.Query(). Where(inventory.MaterialCodeEQ(existing.Code), inventory.SnModeEQ(snModeSN)). Exist(ctx0()) if cerr == nil && snRef { fail(w, http.StatusBadRequest, "该物料已有工件按序列号引用,序列号不可修改") return } } } if req.ItemType != existing.ItemType { woRef, werr := ctx.EntClient.OrderMaterialLedger.Query(). Where(ordermaterialledger.MaterialCodeEQ(existing.Code)). Exist(ctx0()) if werr == nil && woRef { fail(w, http.StatusBadRequest, "该物料已被工单用料引用,物料类别不可修改") return } } // 类型已被库存引用 → 锁死(与编辑接口同口径,2026-10-20) if req.ManageMode != existing.ManageMode { invRef, ierr := ctx.EntClient.Inventory.Query(). Where(inventory.MaterialCodeEQ(existing.Code)). Exist(ctx0()) if ierr == nil && invRef { fail(w, http.StatusBadRequest, "该物料已有库存记录,类型不可修改") return } } // sn_mode(2026-09-30 契约对齐):MES 传 1/2 时同步落库;传 0(未选择)保留现值防清零 upd := ctx.EntClient.Material.UpdateOneID(existing.ID). SetName(req.Name). SetSpec(req.Spec). SetUnit(req.Unit). SetDescription(req.Description). SetItemType(req.ItemType). SetManageMode(req.ManageMode). SetNillableTemplateCode(strPtr(req.TemplateCode)). SetSafetyStock(req.SafetyStock). SetIsActive(active) if req.ItemType == invCatFinished { // 成品强制「序列号=是」(防历史脏值经同步翻案) upd = upd.SetSnMode(snModeSN). SetIsBatchManaged(false). SetIsSerialManaged(true) } else if req.SnMode == snModeSN || req.SnMode == snModeBatch { upd = upd.SetSnMode(req.SnMode). SetIsBatchManaged(req.SnMode == snModeBatch). SetIsSerialManaged(req.SnMode == snModeSN) } m, uerr := upd.Save(ctx0()) if uerr != nil { fail(w, http.StatusInternalServerError, "更新物料失败: "+uerr.Error()) return } ctx.EventLog.Write(ctx0(), "material.sync", "MES", "material", req.Code, "MES 同步更新物料 "+req.Code, nil) ok(w, map[string]any{"created": false, "id": m.ID}) return } // sn_mode:MES 传 1/2 用 MES 值;未传(0)按类型默认联动派生(电气件→序列号=是,其余→序列号=否); // 成品(3)强制「序列号=是」(2026-10-19 拍板) newSnMode := req.SnMode if req.ItemType == invCatFinished { newSnMode = snModeSN } else if newSnMode != snModeSN && newSnMode != snModeBatch { newSnMode = snModeByType(req.ManageMode) } if msg := validateMaterialRequired(req.Name, req.Spec, req.Unit, req.ItemType, req.ManageMode, newSnMode); msg != "" { fail(w, http.StatusBadRequest, msg) return } m, cerr := ctx.EntClient.Material.Create(). SetCode(req.Code). SetName(req.Name). SetSpec(req.Spec). SetUnit(req.Unit). SetNillableDescription(strPtr(req.Description)). SetItemType(req.ItemType). SetManageMode(req.ManageMode). SetSnMode(newSnMode). SetIsBatchManaged(newSnMode == snModeBatch). SetIsSerialManaged(newSnMode == snModeSN). SetNillableTemplateCode(strPtr(req.TemplateCode)). SetSafetyStock(req.SafetyStock). SetIsActive(active). Save(ctx0()) if cerr != nil { fail(w, http.StatusInternalServerError, "创建物料失败: "+cerr.Error()) return } ctx.EventLog.Write(ctx0(), "material.sync", "MES", "material", req.Code, "MES 同步新建物料 "+req.Code+" "+req.Name, nil) ok(w, map[string]any{"created": true, "id": m.ID}) } } // queryMaterialsHandler 分页查询物料 func queryMaterialsHandler(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) materialCode := r.URL.Query().Get("materialCode") name := r.URL.Query().Get("name") spec := r.URL.Query().Get("spec") manageMode := atoi(r.URL.Query().Get("manageMode"), 0) itemType := atoi(r.URL.Query().Get("itemType"), 0) // 排除物料类别:入库各页签按管理粒度过滤时可按需排除指定物料类别, // 避免档案里某类别混进其他管理粒度的下拉。 excludeItemType := atoi(r.URL.Query().Get("excludeItemType"), 0) startDate := r.URL.Query().Get("startDate") endDate := r.URL.Query().Get("endDate") keyword := r.URL.Query().Get("keyword") // 仅供下拉选择框(MaterialSelect)远程搜索:编码/名称任一匹配;列表页禁用此混搜模式 q := ctx.EntClient.Material.Query() if materialCode != "" { q = q.Where(material.CodeContainsFold(materialCode)) } if name != "" { q = q.Where(material.NameContainsFold(name)) } if spec != "" { q = q.Where(material.SpecContainsFold(spec)) } if manageMode != 0 { q = q.Where(material.ManageModeEQ(manageMode)) } if itemType != 0 { q = q.Where(material.ItemTypeEQ(itemType)) } if excludeItemType != 0 { q = q.Where(material.ItemTypeNEQ(excludeItemType)) } if keyword != "" { q = q.Where( material.Or( material.CodeContainsFold(keyword), material.NameContainsFold(keyword), ), ) } // 启用过滤:下拉选择(新建入库/备料等)传 isActive=true 仅显示启用物料; // 物料档案管理页不传,显示全部以便重新启用。 if isActiveStr := r.URL.Query().Get("isActive"); isActiveStr != "" { q = q.Where(material.IsActiveEQ(isActiveStr == "true" || isActiveStr == "1")) } if startDate != "" { if t, err := time.ParseInLocation("2006-01-02", startDate, time.Local); err == nil { q = q.Where(material.CreatedAtGTE(t.Unix())) } } if endDate != "" { if t, err := time.ParseInLocation("2006-01-02", endDate, time.Local); err == nil { q = q.Where(material.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("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, }) } } // listMaterialsHandler 下拉框全量列表(不翻页) func listMaterialsHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { list, err := ctx.EntClient.Material.Query().Order(ent.Desc("created_at"), ent.Desc("id")).Limit(100).All(ctx0()) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } ok(w, list) } } // getMaterialHandler 物料详情 func getMaterialHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { id := atoi(r.URL.Query().Get("id"), 0) if id <= 0 { fail(w, http.StatusBadRequest, "id 必填") return } m, err := ctx.EntClient.Material.Get(ctx0(), id) if err != nil { fail(w, http.StatusNotFound, "物料不存在") return } ok(w, m) } } // materialManageModesHandler 内部接口:批量查询物料「类型」(manage_mode: 1结构件/2电气件/3其他)。 // 注意:物料类别(item_type=1原材料/2半成品/3成品/4其他,成品/组件类维度)与「类型」(结构件/电气件/其他)是两个独立维度,本接口只查后者。 // body: {"codes":["A","B"]} → data: {"manageModes": {"A":1}}(不存在的编码不返回)。 func materialManageModesHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var req struct { Codes []string `json:"codes"` } if err := parseJSON(r, &req); err != nil { fail(w, http.StatusBadRequest, "参数错误") return } seen := map[string]bool{} codes := []string{} for _, c := range req.Codes { c = strings.TrimSpace(c) if c == "" || seen[c] { continue } seen[c] = true codes = append(codes, c) } mm := map[string]int{} if len(codes) > 0 { list, err := ctx.EntClient.Material.Query(). Where(material.CodeIn(codes...)). Select(material.FieldCode, material.FieldManageMode). All(ctx0()) if err != nil { fail(w, http.StatusInternalServerError, "查询物料类型失败: "+err.Error()) return } for _, m := range list { mm[m.Code] = m.ManageMode } } ok(w, map[string]any{"manageModes": mm}) } } // materialExistsHandler 内部接口:批量校验物料编码是否存在于物料档案。 // body: {"codes":["A","B"]} → data: {"missing":["B"]}(不存在于档案的编码列表)。 // 供 MES 备料单生成前防呆使用(wrapInternal + X-API-TOKEN 保护)。 func materialExistsHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var req struct { Codes []string `json:"codes"` } if err := parseJSON(r, &req); err != nil { fail(w, http.StatusBadRequest, "参数错误") return } // 去重并过滤空串 seen := map[string]bool{} codes := []string{} for _, c := range req.Codes { c = strings.TrimSpace(c) if c == "" || seen[c] { continue } seen[c] = true codes = append(codes, c) } missing := []string{} if len(codes) > 0 { // 查存在的编码集合 exist, err := ctx.EntClient.Material.Query(). Where(material.CodeIn(codes...)). Select(material.FieldCode). All(ctx0()) if err == nil { have := map[string]bool{} for _, m := range exist { have[m.Code] = true } for _, c := range codes { if !have[c] { missing = append(missing, c) } } } } ok(w, map[string]any{"missing": missing}) } } // exportMaterialsHandler 物料档案全量导出(xlsx),按当前筛选条件导出 func exportMaterialsHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { materialCode := r.URL.Query().Get("materialCode") name := r.URL.Query().Get("name") startDate, endDate, rerr := normalizeExportRange(r.URL.Query().Get("startDate"), r.URL.Query().Get("endDate")) if rerr != nil { fail(w, http.StatusBadRequest, rerr.Error()) return } startUnix, endUnix := exportRangeUnix(startDate, endDate) spec := r.URL.Query().Get("spec") manageMode := atoi(r.URL.Query().Get("manageMode"), 0) itemType := atoi(r.URL.Query().Get("itemType"), 0) q := ctx.EntClient.Material.Query() q = q.Where(material.CreatedAtGTE(startUnix), material.CreatedAtLTE(endUnix)) if materialCode != "" { q = q.Where(material.CodeContainsFold(materialCode)) } if name != "" { q = q.Where(material.NameContainsFold(name)) } if spec != "" { q = q.Where(material.SpecContainsFold(spec)) } if manageMode != 0 { q = q.Where(material.ManageModeEQ(manageMode)) } if itemType != 0 { q = q.Where(material.ItemTypeEQ(itemType)) } if isActiveStr := r.URL.Query().Get("isActive"); isActiveStr != "" { q = q.Where(material.IsActiveEQ(isActiveStr == "true" || isActiveStr == "1")) } list, err := q.Order(ent.Desc("id")).All(ctx0()) if err != nil { fail(w, http.StatusInternalServerError, err.Error()) return } type exportRow struct { ID int Code string Name string Spec string Unit string ItemType int ManageMode int SnMode int Description string CreatedAt int64 } rows := make([]exportRow, 0, len(list)) for _, m := range list { rows = append(rows, exportRow{ ID: m.ID, Code: m.Code, Name: m.Name, Spec: m.Spec, Unit: m.Unit, ItemType: m.ItemType, ManageMode: m.ManageMode, SnMode: m.SnMode, Description: m.Description, CreatedAt: m.CreatedAt, }) } if r.URL.Query().Get("format") == "xlsx" { // 图号=物料编码(问题记录 L18 合并裁决):导出表头统一叫「图号」 // 「简称」已按 2026-09-19 用户裁决整体删除,导出列同步移除 headers := []string{"ID", "图号", "名称", "规格", "单位", "物料类别", "类型", "序列号", "说明", "创建时间"} matrix := make([][]any, 0, len(rows)) for _, rr := range rows { matrix = append(matrix, []any{ rr.ID, rr.Code, rr.Name, rr.Spec, rr.Unit, itemTypeLabel(rr.ItemType), manageModeLabel(rr.ManageMode), snModeLabel(rr.SnMode), rr.Description, unixFmt(rr.CreatedAt), }) } sendExcel(w, xlsxFilename("物料档案"), headers, matrix) return } ok(w, map[string]any{"total": len(rows), "list": rows}) } } // parseManageMode 解析导入模板"类型"列:支持中文(结构件/电气件/其他,含"(批次)/(SN)"后缀) // 与数字格式(1/2/3)双向兼容;无法识别返回 0。 func parseManageMode(s string) int { if s == "" { return 0 } if strings.Contains(s, "电气") || strings.EqualFold(s, "SN") { return 2 } if strings.Contains(s, "结构") || strings.Contains(s, "批次") { return 1 } if strings.Contains(s, "其他") { return invManageOther } if n := atoi(s, 0); n >= 1 && n <= 3 { return n } return 0 } // parseItemType 解析导入模板"物料类别"列(兼容旧模板"品类"列名):原材料/成品(兼容 1/3);无法识别返回 0。 // 注意:"半成品"不再是物料类别(2026-09-22),且含"成品"子串,必须先排除再判成品; // 「其他」类别已按 2026-10-19 裁决全项目移除,历史含"其他"的导入行按无法识别整体拒绝。 func parseItemType(s string) int { s = strings.TrimSpace(s) if s == "" { return 0 } switch { case strings.Contains(s, "原材料"): return 1 case strings.Contains(s, "半成品"): return 0 // 半成品已不是物料类别,导入该行按"物料类别无法识别"整体拒绝 case strings.Contains(s, "成品"): return 3 } if n := atoi(s, 0); n == 1 || n == 3 { return n } return 0 } // excelMaterialImportHandler 物料档案 Excel 批量导入 // 模板(首行忽略表头):图号 | 名称 | 规格 | 单位 | 类型(结构件/电气件) | 说明 // (图号=物料编码,问题记录 L18 合并裁决,不再单设图号列;「简称」列已按 2026-09-19 裁决移除) // 强约束:全成功或全失败(一次性全导入 or 全失败,禁止部分成功)。 // 阶段1 逐行解析+校验(图号必填且唯一 / 名称、规格、单位必填 / 类型合法) → 任一错则整体拒绝并列出错误行; // 阶段2 全部通过 → 开启单事务整体提交,任一步失败整体回滚。 // excelMaterialImportTemplateHandler 物料档案导入模板下载(2026-10-21): // 第1行表头 + 第2行示例数据(导入前请删除),列顺序与导入说明一致。 func excelMaterialImportTemplateHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { headers := []string{"图号", "名称", "规格", "单位", "类型", "物料类别", "说明"} rows := [][]any{ {"DX100-001", "示例物料名称", "300x200x150", "个", "结构件", "原材料", "示例行,导入前请删除"}, } sendExcel(w, "物料档案导入模板.xlsx", headers, rows) } } func excelMaterialImportHandler(ctx *svc.ServiceContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if err := r.ParseMultipartForm(20 << 20); err != nil { fail(w, http.StatusBadRequest, "文件上传失败: "+err.Error()) return } f, _, err := r.FormFile("file") if err != nil { fail(w, http.StatusBadRequest, "缺少 file 字段") return } defer f.Close() xl, err := excelize.OpenReader(f) if err != nil { fail(w, http.StatusBadRequest, "无法解析 Excel: "+err.Error()) return } defer xl.Close() sheet := xl.GetSheetList()[0] rows, err := xl.GetRows(sheet) if err != nil { fail(w, http.StatusBadRequest, "读取工作表失败: "+err.Error()) return } if len(rows) <= 1 { fail(w, http.StatusBadRequest, "文件无数据行(首行为表头,需至少一行数据)") return } type planRow struct { row int code string name string spec string unit string manageMode int snMode int // 序列号=是/否:按类型默认联动派生(电气件→1,其余→2) itemType int description string } plans := make([]planRow, 0, len(rows)-1) errs := make([]importErr, 0) // 表头→列下标映射:容忍列顺序变化与多余列(如「物料类别」/旧「品类」插在单位与类型之间)。 // 先按"去括号后的表头名"精确匹配,再按关键字包含兜底(顺序稳定),都找不到回退模板固定下标。 normHeader := func(s string) string { s = strings.TrimSpace(s) for _, op := range []string{"(", "("} { if i := strings.Index(s, op); i >= 0 { s = s[:i] } } return strings.TrimSpace(s) } headerNorm := make([]string, len(rows[0])) for j, h := range rows[0] { headerNorm[j] = normHeader(h) } colOf := func(names []string, fallback int) int { for _, n := range names { for j, hn := range headerNorm { if hn == n { return j } } } for _, n := range names { for j, hn := range headerNorm { if hn != "" && strings.Contains(hn, n) { return j } } } return fallback } codeCol := colOf([]string{"图号", "物料编码", "编码"}, 0) nameCol := colOf([]string{"名称", "物料名称"}, 1) specCol := colOf([]string{"规格", "规格型号"}, 2) unitCol := colOf([]string{"单位"}, 3) typeCol := colOf([]string{"类型", "管理类型", "管理粒度"}, 4) catCol := colOf([]string{"物料类别", "品类", "类别"}, -1) descCol := colOf([]string{"说明", "备注", "描述"}, 5) // 阶段1:解析 + 校验(不落库) for i, row := range rows { if i == 0 { continue // 表头 } cell := func(idx int) string { if idx < 0 || idx >= len(row) { return "" } return strings.TrimSpace(row[idx]) } pr := planRow{row: i + 1} pr.code = cell(codeCol) pr.name = cell(nameCol) pr.spec = cell(specCol) pr.unit = cell(unitCol) pr.manageMode = parseManageMode(cell(typeCol)) pr.itemType = parseItemType(cell(catCol)) pr.snMode = snModeByType(pr.manageMode) if pr.itemType == invCatFinished { pr.snMode = snModeSN // 成品强制「序列号=是」(与编辑/同步同口径,2026-10-19 拍板) } pr.description = cell(descCol) if pr.code == "" { errs = append(errs, importErr{pr.row, pr.code, "图号为空"}) continue } if pr.name == "" { errs = append(errs, importErr{pr.row, pr.code, "名称为空"}) continue } if pr.spec == "" { errs = append(errs, importErr{pr.row, pr.code, "规格型号为空"}) continue } if pr.unit == "" { errs = append(errs, importErr{pr.row, pr.code, "单位为空"}) continue } if pr.manageMode == 0 { errs = append(errs, importErr{pr.row, pr.code, "类型无法识别,请填写「结构件/电气件/其他」(兼容 1/2/3)"}) continue } if catCol >= 0 && cell(catCol) != "" && pr.itemType == 0 { errs = append(errs, importErr{pr.row, pr.code, "物料类别无法识别,请填写「原材料/成品」(兼容 1/3;半成品不是物料类别,「其他」已取消)"}) continue } exists, _ := ctx.EntClient.Material.Query(). Where(material.CodeEQ(pr.code)).Exist(ctx0()) if exists { errs = append(errs, importErr{pr.row, pr.code, "图号已存在: " + pr.code}) continue } plans = append(plans, pr) } // 阶段2:有错则整体拒绝,一行都不写 if len(errs) > 0 { ok(w, map[string]any{"success": 0, "failed": len(errs), "errors": errs}) return } // 阶段3:全部通过 → 单事务整体提交(原子,全成功或全失败) tx, e := ctx.EntClient.Tx(ctx0()) if e != nil { fail(w, http.StatusInternalServerError, "开启事务失败: "+e.Error()) return } committed := false defer func() { if !committed { _ = tx.Rollback() } }() imported := make([]*ent.Material, 0, len(plans)) for _, pr := range plans { mc := tx.Material.Create(). SetCode(pr.code). SetName(pr.name). SetNillableSpec(strPtr(pr.spec)). SetNillableUnit(strPtr(pr.unit)). SetNillableDescription(strPtr(pr.description)). SetManageMode(pr.manageMode). SetSnMode(pr.snMode). SetIsBatchManaged(pr.snMode == snModeBatch). SetIsSerialManaged(pr.snMode == snModeSN) if pr.itemType > 0 { mc = mc.SetItemType(pr.itemType) } m, e2 := mc.Save(ctx0()) if e2 != nil { fail(w, http.StatusInternalServerError, "创建物料失败: "+e2.Error()) return } imported = append(imported, m) } if e = tx.Commit(); e != nil { fail(w, http.StatusInternalServerError, "提交事务失败: "+e.Error()) return } committed = true for _, m := range imported { pushMaterialToMES(ctx, m) // 需求一 M4:导入行逐条异步推送 MES 本地副本 } ctx.EventLog.Write(ctx0(), "material.import", r.Header.Get("X-Username"), "material", "", "Excel 导入物料", map[string]any{"success": len(plans)}) ok(w, map[string]any{"success": len(plans), "failed": 0, "errors": []importErr{}}) } }