Files
bj_power/bj_power_wms/internal/handler/misc.go
T

369 lines
14 KiB
Go
Raw Normal View History

2026-08-28 15:06:01 +08:00
package handler
import (
"net/http"
"strings"
"time"
2026-08-28 15:06:01 +08:00
"bj_power_wms/ent"
"bj_power_wms/ent/inventory"
"bj_power_wms/ent/material"
2026-08-28 15:06:01 +08:00
"bj_power_wms/internal/svc"
)
// 库存物料类别(与 schema/inventory.go 保持一致):1=原材料 2=半成品 3=成品
const (
invCatRaw = 1
invCatSemi = 2
invCatFinished = 3
)
// 半成品 / 台账 相关(盘点见 stocktake.go)
//
// 【统一库存主表收编 2026-09-07】半成品不再写独立 semi_finisheds 表,
// 全部落 inventories(sn_mode=1 序列号=是SN单件, category=2 半成品)。
// 三个 semi 接口签名与响应结构保持不变,MES / 前端零改造平滑切换。
2026-08-28 15:06:01 +08:00
// semiInboundHandler 半成品/成品入库(携带「已完成至工位」展示快照)
// 与 MES 闭环:MES 工位报工暂存退库 / 完工回流时调用本接口,把 SN 入 WMS 库
// (inventories,category=2 半成品 / 3 成品,客户诉求 问题记录 L222 半成品与成品要区分)。
// 成品入库 9 字段(L218):SN/图号/归属/产品状态/相关标准/试验记录单号/记录员/记录日期/工单号。
// 契约(2026-09-22 定稿):废除 completedProcess/doneProcessCodes 字段,改为 completedText
// ——人类可读展示快照(如"已完成至工位5",空=未报工)。WMS 只原样存入
// inventories.completed_process 展示,不解析、不参与任何逻辑。
// 为保持两系统解耦,materialCode 不强制要求——优先用请求传入,都没有则留空(SN 本身即追溯锚点)。
2026-08-28 15:06:01 +08:00
func semiInboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
Sn string `json:"sn"`
MaterialCode string `json:"materialCode"`
CompletedText string `json:"completedText"` // 已完成至工位(展示快照,空=未报工)
ZoneCode string `json:"zoneCode"`
OrderNo string `json:"orderNo"`
ProductWorkNo string `json:"productWorkNo"` // 产品工号(A1 五页带出;MES 回流可顺带传)
Operator string `json:"operator"`
Category int `json:"category"` // 2=半成品 3=成品(默认 2)
OwnershipType string `json:"ownershipType"`
OwnershipNo string `json:"ownershipNo"`
ProductStatus string `json:"productStatus"` // 已通过/部分通过/返修(成品用)
RelatedStandard string `json:"relatedStandard"` // 相关标准(试验方案号)
TestRecordNo string `json:"testRecordNo"` // 试验记录单号
RecordedBy string `json:"recordedBy"` // 记录员
RecordedAt int64 `json:"recordedAt"` // 记录日期(unix 秒)
2026-08-28 15:06:01 +08:00
}
if err := parseJSON(r, &req); err != nil {
fail(w, http.StatusBadRequest, "参数错误")
return
}
if req.Sn == "" {
fail(w, http.StatusBadRequest, "sn 必填")
2026-08-28 15:06:01 +08:00
return
}
category := req.Category
if category != invCatFinished {
category = invCatSemi
}
catLabel := "半成品"
if category == invCatFinished {
catLabel = "成品"
}
2026-08-28 15:06:01 +08:00
// SN 防重:同一物料类别下同一 SN 只允许一条库存行(含已出库历史,避免重复回流)
exists, err := ctx.EntClient.Inventory.Query().
Where(inventory.CategoryEQ(category), inventory.SnCodeEQ(req.Sn)).
2026-08-28 15:06:01 +08:00
Exist(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
if exists {
fail(w, http.StatusConflict, catLabel+"已存在: "+req.Sn)
2026-08-28 15:06:01 +08:00
return
}
// 已完成至工位:MES 传人类可读快照,WMS 原样存展示(不解析、不参与任何逻辑)
completed := req.CompletedText
// 物料编码:以请求传入为准;名称/类型从物料档案补齐(档案缺失则用编码兜底、类型默认结构件)
materialCode := req.MaterialCode
materialName := materialCode
matType := 1
if materialCode != "" {
if m, err := ctx.EntClient.Material.Query().Where(material.CodeEQ(materialCode)).First(ctx0()); err == nil && m != nil {
materialName = m.Name
matType = m.ManageMode
}
}
// A2 半成品入库归属:请求体已带 ownershipType(workorder=合同号/project=科技项目号/other=其他)
// 时以请求体为准,ownershipNo 同样保留原值,不再按 contractNo 强制覆盖
// (2026-09-30:科技项目号半成品回流不再被误标为「合同号」)。
// 兜底:ownershipType 为空且填了工单号时,沿用原推断——按工单带出合同号作为归属。
if req.OwnershipType == "" && req.OrderNo != "" && ctx.Mes != nil {
if wo, e := ctx.Mes.GetWorkOrder(ctx0(), req.OrderNo); e == nil && wo != nil && wo.ContractNo != "" {
req.OwnershipType = "workorder"
req.OwnershipNo = wo.ContractNo
}
}
rec, err := ctx.EntClient.Inventory.Create().
SetManageMode(matType).
SetSnMode(snModeSN).
SetCategory(category).
SetSnCode(req.Sn).
SetMaterialCode(materialCode).
SetMaterialName(materialName).
SetQuantity(1).
SetQualityStatus("未检").
2026-08-28 15:06:01 +08:00
SetNillableZoneCode(strPtr(req.ZoneCode)).
SetStatus("在库").
SetNillableInboundNo(strPtr(req.OrderNo)).
SetOrderNo(req.OrderNo).
SetNillableProductWorkNo(strPtr(req.ProductWorkNo)).
SetCompletedProcess(completed).
SetNillableOwnershipType(strPtr(ownershipTypeOrNone(req.OwnershipType))).
SetNillableOwnershipNo(strPtr(req.OwnershipNo)).
SetNillableProductStatus(strPtr(req.ProductStatus)).
SetNillableRelatedStandard(strPtr(req.RelatedStandard)).
SetNillableTestRecordNo(strPtr(req.TestRecordNo)).
SetNillableRecordedBy(strPtr(req.RecordedBy)).
SetNillableRecordedAt(int64Ptr(req.RecordedAt)).
SetRemark(catLabel + "完工暂存回流").
2026-08-28 15:06:01 +08:00
Save(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
ctx.EventLog.Write(ctx0(), "semi.inbound", r.Header.Get("X-Username"), "semi", req.Sn,
catLabel+"入库 "+req.Sn, map[string]any{"materialCode": materialCode, "category": category})
ok(w, semiView(rec))
2026-08-28 15:06:01 +08:00
}
}
// workOrderContractHandler GET /api/workorder/contract?orderNo=
// 供前端半成品入库表单只读带出归属(A2 半成品入库继承产线工单):凭工单号解析合同号/工程编号。
func workOrderContractHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
orderNo := r.URL.Query().Get("orderNo")
if orderNo == "" {
fail(w, http.StatusBadRequest, "工单号必填")
return
}
if ctx.Mes == nil {
fail(w, http.StatusInternalServerError, "MES 客户端未配置")
return
}
wo, err := ctx.Mes.GetWorkOrder(ctx0(), orderNo)
if err != nil {
fail(w, http.StatusInternalServerError, "解析工单归属失败:"+err.Error())
return
}
if wo == nil {
fail(w, http.StatusNotFound, "工单不存在或无合同号")
return
}
ok(w, map[string]any{
"workOrderNo": wo.WorkOrderNo,
"contractNo": wo.ContractNo,
"projectNo": wo.ProjectNo,
})
}
}
2026-10-26 16:32:35 +08:00
// workOrderExistsHandler GET /api/workorder/exists?orderNo=
// 入库「产品工号」软校验(B1):只判工单是否存在(不要求有合同号)。
// 红字提示由前端出、不阻断保存;404=查不到,5xx=MES 不可达。
func workOrderExistsHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
orderNo := r.URL.Query().Get("orderNo")
if orderNo == "" {
fail(w, http.StatusBadRequest, "工单号必填")
return
}
if ctx.Mes == nil {
fail(w, http.StatusInternalServerError, "MES 客户端未配置")
return
}
wo, err := ctx.Mes.GetWorkOrder(ctx0(), orderNo)
if err != nil {
fail(w, http.StatusBadGateway, "MES 不可达:"+err.Error())
return
}
if wo == nil {
fail(w, http.StatusNotFound, "工单不存在")
return
}
ok(w, map[string]any{"exists": true, "workOrderNo": wo.WorkOrderNo})
}
}
// semiOutboundHandler 半成品/成品出库(重上线/发货等):更新 inventories 状态
// 客户诉求 L224:出库原因必选(包装/继续生产/检验试验/其他),写入 outbound_reason 留痕。
2026-08-28 15:06:01 +08:00
func semiOutboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
Sn string `json:"sn"`
ZoneCode string `json:"zoneCode"`
Operator string `json:"operator"`
Reason string `json:"reason"` // 出库原因:包装/继续生产/检验试验/其他
Category int `json:"category"` // 2=半成品 3=成品(默认 2)
2026-08-28 15:06:01 +08:00
}
if err := parseJSON(r, &req); err != nil {
fail(w, http.StatusBadRequest, "参数错误")
return
}
if req.Sn == "" {
fail(w, http.StatusBadRequest, "sn 必填")
return
}
if strings.TrimSpace(req.Reason) == "" {
fail(w, http.StatusBadRequest, "出库原因必选(包装/继续生产/检验试验/其他)")
return
}
category := req.Category
if category != invCatFinished {
category = invCatSemi
}
catLabel := "半成品"
if category == invCatFinished {
catLabel = "成品"
}
2026-08-28 15:06:01 +08:00
rec, err := ctx.EntClient.Inventory.Query().
Where(inventory.CategoryEQ(category), inventory.SnCodeEQ(req.Sn)).
2026-08-28 15:06:01 +08:00
Only(ctx0())
if err != nil {
fail(w, http.StatusNotFound, catLabel+"不存在: "+req.Sn)
2026-08-28 15:06:01 +08:00
return
}
if rec.Status != "在库" {
fail(w, http.StatusConflict, catLabel+"不在库: "+rec.Status)
2026-08-28 15:06:01 +08:00
return
}
// 盘点冻结守卫(问题2):盘点期间库存量冻结,禁止半成品/成品出库。
if rec.StocktakeNo != "" {
fail(w, http.StatusConflict, catLabel+" "+req.Sn+" 正在盘点单 "+rec.StocktakeNo+" 中冻结,盘点期间禁止出库")
return
}
2026-08-28 15:06:01 +08:00
ctx.EntClient.Inventory.UpdateOneID(rec.ID).
2026-08-28 15:06:01 +08:00
SetStatus("出库").
SetNillableOutboundReason(strPtr(req.Reason)).
SetUpdatedAt(time.Now().Unix()).
2026-08-28 15:06:01 +08:00
ExecX(ctx0())
ctx.EventLog.Write(ctx0(), "semi.outbound", r.Header.Get("X-Username"), "semi", req.Sn,
catLabel+"出库 "+req.Sn, map[string]any{"reason": req.Reason})
2026-08-28 15:06:01 +08:00
ok(w, map[string]any{"sn": req.Sn, "status": "出库"})
}
}
// semiView 把统一库存行映射为半成品/成品视图(保持原 /api/semi/query 响应结构,前端零改造)
type semiViewRow struct {
ID int `json:"id"`
Sn string `json:"sn"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Category int `json:"category"` // 2=半成品 3=成品
CompletedProcess string `json:"completedProcess"`
Quantity int `json:"quantity"`
ZoneCode string `json:"zoneCode"`
Status string `json:"status"`
QualityStatus string `json:"qualityStatus"` // 质量状态(成品入库记录表展示;新增字段,semi 页不受影响)
OrderNo string `json:"orderNo"`
OwnershipNo string `json:"ownershipNo"`
ProductWorkNo string `json:"productWorkNo"`
ProductStatus string `json:"productStatus"`
RelatedStandard string `json:"relatedStandard"`
TestRecordNo string `json:"testRecordNo"`
RecordedBy string `json:"recordedBy"`
RecordedAt int64 `json:"recordedAt"`
OutboundReason string `json:"outboundReason"`
Remark string `json:"remark"` // 备注(成品入库记录表区分来源:手工成品入库 / 成品完工回流)
CreatedAt int64 `json:"createdAt"`
UpdatedAt int64 `json:"updatedAt"`
}
func semiView(inv *ent.Inventory) *semiViewRow {
return &semiViewRow{
ID: inv.ID,
Sn: inv.SnCode,
MaterialCode: inv.MaterialCode,
MaterialName: inv.MaterialName,
Category: inv.Category,
CompletedProcess: inv.CompletedProcess,
Quantity: inv.Quantity,
ZoneCode: inv.ZoneCode,
Status: inv.Status,
QualityStatus: inv.QualityStatus,
OrderNo: inv.OrderNo,
OwnershipNo: inv.OwnershipNo,
ProductWorkNo: inv.ProductWorkNo,
ProductStatus: inv.ProductStatus,
RelatedStandard: inv.RelatedStandard,
TestRecordNo: inv.TestRecordNo,
RecordedBy: inv.RecordedBy,
RecordedAt: inv.RecordedAt,
OutboundReason: inv.OutboundReason,
Remark: inv.Remark,
CreatedAt: inv.CreatedAt,
UpdatedAt: inv.UpdatedAt,
}
}
// querySemiHandler 半成品查询(读统一库存主表 category=2 半成品)。
// 半成品管理页只处理半成品;成品由 MES 完工回流入库、经 WMS 完工检验,在「库存查询」页按物料类别查看,不在本页手工出入库。
2026-08-28 15:06:01 +08:00
func querySemiHandler(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")
status := r.URL.Query().Get("status")
sn := r.URL.Query().Get("sn")
ownershipNo := r.URL.Query().Get("ownershipNo")
productWorkNo := r.URL.Query().Get("productWorkNo")
2026-08-28 15:06:01 +08:00
q := ctx.EntClient.Inventory.Query().Where(inventory.CategoryEQ(invCatSemi))
2026-08-28 15:06:01 +08:00
if materialCode != "" {
q = q.Where(inventory.MaterialCodeEqualFold(materialCode))
2026-08-28 15:06:01 +08:00
}
if status != "" {
q = q.Where(inventory.StatusEQ(status))
2026-08-28 15:06:01 +08:00
}
if sn != "" {
q = q.Where(inventory.SnCodeContainsFold(sn))
}
if ownershipNo != "" {
q = q.Where(inventory.OwnershipNoContainsFold(ownershipNo))
}
if productWorkNo != "" {
q = q.Where(inventory.ProductWorkNoContainsFold(productWorkNo))
}
2026-08-28 15:06:01 +08:00
total, err := q.Count(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
2026-09-03 18:13:59 +08:00
list, err := q.Order(ent.Desc("created_at"), ent.Desc("id")).
2026-08-28 15:06:01 +08:00
Offset((page - 1) * pageSize).Limit(pageSize).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
rows := make([]*semiViewRow, 0, len(list))
for _, inv := range list {
rows = append(rows, semiView(inv))
}
2026-08-28 15:06:01 +08:00
ok(w, map[string]any{
"total": total,
"list": rows,
2026-08-28 15:06:01 +08:00
"page": page,
"pageSize": pageSize,
})
}
}