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

1069 lines
39 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"`
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)
}
}
// materialTypesHandler 内部接口:批量查询物料类别(item_type)。
// body: {"codes":["A","B"]} → data: {"types":{"A":1,"B":3}}(1原材料/3成品/4其他)。
// 供 MES 递归展开产品物料清单使用:成品子项(item_type=3)需继续展开到原材料。
func materialTypesHandler(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)
}
types := map[string]int{}
if len(codes) > 0 {
list, err := ctx.EntClient.Material.Query().
Where(material.CodeIn(codes...)).
Select(material.FieldCode, material.FieldItemType).
All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, "查询物料类别失败: "+err.Error())
return
}
for _, m := range list {
types[m.Code] = m.ItemType
}
}
ok(w, map[string]any{"types": types})
}
}
// materialManageModesHandler 内部接口:批量查询物料「类型」(manage_mode: 1结构件/2电气件/3其他)。
// 与 materialTypesHandler(物料类别 item_type)相互独立:物料类别=成品/组件类,类型=结构件/电气件/其他。
// 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{}})
}
}