Files
bj_power/bj_power_wms/internal/handler/material.go
T
SunYF 1e92b2a596 feat: 核心业务实体扩充(混产模板/产品BOM/试制记录)、WMS 库存检验增强与前端通用能力
- MES 新增实体:混产模板、产品BOM、产品工艺物料、试制记录(schema + ent 生成码 + logic/handler/前端页)
- WMS 实体增强:检验记录、库存、半成品重构;新增序列号库存与短缺代报
- AGV 与产能:AGV 手动点位与链路、物料守卫、短缺预测、原因字典
- 前端通用能力:新增下一步引导组件 NextStepBar,统一帮助文档/布局/请求拦截与操作列
- 工位终端:界面与各 handler 调整(api/store/绑定/PLC/拧紧/上报等)
- 配置与文档:更新 mes-api.yaml、WMS README 及案例/产线API/问题记录/项目说明/流程说明
2026-11-15 12:17:39 +08:00

1101 lines
42 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.
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": <material 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"`
MaterialCode string `json:"materialCode"` // 物料编码(普通字段,不参与必填校验)
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).
SetMaterialCode(strings.TrimSpace(req.MaterialCode)).
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"`
MaterialCode string `json:"materialCode"` // 物料编码(普通字段,不参与必填校验)
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).
SetMaterialCode(strings.TrimSpace(req.MaterialCode)).
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
MaterialCode 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, MaterialCode: m.MaterialCode, 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" {
// 图号列沿用业务主键名;问题12 新增「物料编码」普通字段列(与导入模板一致)
// 「简称」已按 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.MaterialCode, 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 批量导入
// 模板(2026-11-10 与 MES 模板统一,10 列同序):图号 | 物料编码 | 名称 | 规格 | 单位 | 类型 | 类别 | 序列号 | 启用 | 说明
// 「物料编码」为选填普通字段;「类别」兼容旧列名「物料类别」;「序列号/启用」为 MES 业务差异列,WMS 导入忽略(按类型派生序列号、默认启用)。
// 强约束:全成功或全失败(一次性全导入 or 全失败,禁止部分成功)。
// 阶段1 逐行解析+校验(图号必填且唯一 / 名称、规格、单位必填 / 类型合法) → 任一错则整体拒绝并列出错误行;
// 阶段2 全部通过 → 开启单事务整体提交,任一步失败整体回滚。
// excelMaterialImportTemplateHandler 物料档案导入模板下载:
// 第1行表头 + 第2/3行示例数据(导入前请删除)+「填写说明」页逐列字段说明。
func excelMaterialImportTemplateHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
headers := []string{"图号", "物料编码", "名称", "规格", "单位", "类型", "类别", "序列号", "启用", "说明"}
rows := [][]any{
{"DX100-001", "WL-0001", "示例成品", "300x200x150", "台", "结构件", "成品", "是", "是", "示例行,导入前请删除"},
{"M-BEARING-6204", "WL-0002", "示例原材料-轴承6204", "6204-RS", "个", "结构件", "原材料", "否", "是", "示例行,导入前请删除"},
}
guides := []string{
"【列顺序】图号 | 物料编码 | 名称 | 规格 | 单位 | 类型 | 类别 | 序列号 | 启用 | 说明(与 MES 模板一致,按表头名识别,请勿改动表头文字)",
"1. 仅保留第一个「Sheet1」数据页,「填写说明」页请勿删除或填入数据;第2/3行是示例,正式导入前请删除。",
"2. 图号:必填且唯一,物料唯一标识(两库同步业务键);已有相同图号的行会被拒绝。",
"3. 物料编码:选填,普通档案字段(如 WL-0001),不参与业务与必填校验。",
"4. 名称 / 规格 / 单位:必填,不可为空。",
"5. 类型:填「结构件」「电气件」「其他」或数字 1/2/3(决定按批次还是按序列号记账)。",
"6. 类别:填「原材料」或「成品」,留空默认原材料(兼容旧列名「物料类别」;在制品不是物料类别)。",
"7. 序列号:MES 模板字段,WMS 导入忽略(本端按类型自动派生,成品强制序列号=是)。",
"8. 启用:MES 模板字段,WMS 导入忽略(本端默认启用)。",
"9. 说明:可空,备注信息。",
"10. 首行为表头,从第二行开始为数据;整批校验,任一行出错则一行不写(导入前可先点「预检」看错误明细)。",
}
sendExcelWithGuide(w, "物料档案导入模板.xlsx", headers, rows, guides)
}
}
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
}
// 阶段1:解析 + 逐行校验(不落库)——与预检端点 excelMaterialImportPreviewHandler 共用同一函数,规则同源
plans, errs := parseMaterialImportPlan(ctx, rows)
// 阶段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).
SetMaterialCode(pr.materialCode).
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{}})
}
}
// materialImportPlan 物料档案导入单行写入计划(预检与写入共用同一解析/校验,规则同源不漂移)。
type materialImportPlan struct {
row int
code string
materialCode string // 物料编码(普通字段,不参与必填校验)
name string
spec string
unit string
manageMode int
snMode int // 序列号=是/否:按类型默认联动派生(电气件→1,其余→2)
itemType int
description string
}
// parseMaterialImportPlan 阶段1:解析 + 逐行校验(只读不落库):图号必填且库内唯一 /
// 名称、规格、单位必填 / 类型、物料类别合法。返回通过校验的行计划与逐行错误。
func parseMaterialImportPlan(ctx *svc.ServiceContext, rows [][]string) ([]materialImportPlan, []importErr) {
plans := make([]materialImportPlan, 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)
materialCodeCol := colOf([]string{"物料编码"}, -1)
nameCol := colOf([]string{"名称", "物料名称"}, 1)
specCol := colOf([]string{"规格", "规格型号"}, 2)
unitCol := colOf([]string{"单位"}, 3)
typeCol := colOf([]string{"类型", "管理类型", "管理粒度"}, 4)
catCol := colOf([]string{"物料类别", "品类", "类别"}, -1)
descCol := colOf([]string{"说明", "备注", "描述"}, 5)
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 := materialImportPlan{row: i + 1}
pr.code = cell(codeCol)
pr.materialCode = cell(materialCodeCol)
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)
}
return plans, errs
}
// excelMaterialImportPreviewHandler POST /api/material/import/preview 物料档案导入预检(只读):
// 复用写入端点的阶段1校验(parseMaterialImportPlan,同一函数保证规则同源),不写任何数据。
// 返回 {total 总行数, success 将成功行数, failed 失败行数, errors 逐行失败原因(行号+图号+原因)}。
func excelMaterialImportPreviewHandler(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
}
plans, errs := parseMaterialImportPlan(ctx, rows)
if errs == nil {
errs = []importErr{}
}
ok(w, map[string]any{"total": len(rows) - 1, "success": len(plans), "failed": len(errs), "errors": errs})
}
}