Files
bj_power/bj_power_mes/internal/wmsclient/client.go
T

865 lines
31 KiB
Go
Raw Normal View History

package wmsclient
2026-08-28 15:06:01 +08:00
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
2026-08-28 15:06:01 +08:00
"net/http"
"net/url"
"strconv"
"strings"
"sync/atomic"
2026-08-28 15:06:01 +08:00
"time"
)
// Client WMS 内部接口客户端(半成品流转等)
// baseURL 支持运行时热切换(系统管理员「基础设置」页保存 WMS 地址后 SetBaseURL 即生效),
// 因此用 atomic.Value 存储,读侧无需加锁。
2026-08-28 15:06:01 +08:00
type Client struct {
baseURL atomic.Value // string
2026-08-28 15:06:01 +08:00
token string
hc *http.Client
}
// defaultBaseURL 未配置 WMS 地址时的兜底值
const defaultBaseURL = "http://127.0.0.1:9091"
2026-08-28 15:06:01 +08:00
func New(baseURL, token string) *Client {
c := &Client{
token: token,
hc: &http.Client{Timeout: 5 * time.Second},
}
c.SetBaseURL(baseURL)
return c
}
// SetBaseURL 热切换 WMS 地址;空串回退默认地址。
// 注意:所有请求路径都以 "/api/..." 开头,这里必须去掉尾斜杠,否则拼出 "//api" 404。
func (c *Client) SetBaseURL(u string) {
u = strings.TrimSpace(u)
if u == "" {
u = defaultBaseURL
2026-08-28 15:06:01 +08:00
}
u = strings.TrimRight(u, "/")
c.baseURL.Store(u)
}
// BaseURL 当前生效的 WMS 地址(不带尾斜杠,请求路径以 /api/... 开头直接拼接)
func (c *Client) BaseURL() string {
return c.baseURL.Load().(string)
2026-08-28 15:06:01 +08:00
}
// SemiPayload MES→WMS 半成品入库/出库载荷。
// 归属三字段(2026-09-30):半成品归属自动继承其产品工号的工单归属——
// ownershipType/ownershipNo 取自工单归属(workorder=合同号/project=科技项目号/other=其他),
// productWorkNo=产品工号(即工单号),均由 MES 从工单带出后传入,不做人工手选。
type SemiPayload struct {
Sn string
OrderNo string
CompletedText string
Operator string
OwnershipType string // 归属类型:workorder=合同号/project=科技项目号/other=其他
OwnershipNo string // 归属编号(合同号或科技项目号)
ProductWorkNo string // 产品工号(=所属工单号)
}
// SemiInbound 调 WMS /api/internal/semi/inbound 半成品入库。
// 统一契约:payload={sn,orderNo,completedText,operator,ownershipType,ownershipNo,productWorkNo},
// completedText 由 MES 生成("已完成至工位N",N=workpiece.currentStationNo;0/无记录传空串),
// 旧 doneProcessCodes 已废除。
func (c *Client) SemiInbound(ctx context.Context, p SemiPayload) error {
return c.postSemi(ctx, "/api/internal/semi/inbound", map[string]any{
"sn": p.Sn, "orderNo": p.OrderNo, "completedText": p.CompletedText, "operator": p.Operator,
"ownershipType": p.OwnershipType, "ownershipNo": p.OwnershipNo, "productWorkNo": p.ProductWorkNo,
2026-08-28 15:06:01 +08:00
})
}
// SemiOutbound 调 WMS /api/internal/semi/outbound 半成品出库(重上线),契约同 SemiInbound。
func (c *Client) SemiOutbound(ctx context.Context, p SemiPayload) error {
return c.postSemi(ctx, "/api/internal/semi/outbound", map[string]any{
"sn": p.Sn, "orderNo": p.OrderNo, "completedText": p.CompletedText, "operator": p.Operator,
"ownershipType": p.OwnershipType, "ownershipNo": p.OwnershipNo, "productWorkNo": p.ProductWorkNo,
2026-08-28 15:06:01 +08:00
})
}
// postSemi 调 WMS 半成品接口并解析业务响应 {code,message}:
// 网络/超时、非2xx、业务码非0 均返回 error,且优先携带 WMS 原文 message,
// 供上线登记重上线路径直接透出(WMS 出库失败必须阻断并让操作工看到原因)。
func (c *Client) postSemi(ctx context.Context, path string, body any) error {
b, err := json.Marshal(body)
if err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL()+path, bytes.NewReader(b))
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
raw, _ := io.ReadAll(resp.Body)
var br struct {
Code int `json:"code"`
Message string `json:"message"`
}
_ = json.Unmarshal(raw, &br)
if resp.StatusCode >= 300 || br.Code != 0 {
if br.Message != "" {
return errors.New(br.Message)
}
return &RespError{Status: resp.StatusCode}
}
return nil
}
// DisposeInventoryReq MES → WMS 在库不合格处置请求(调 /api/internal/inventory/dispose)
// 定位口径与 WMS 一致:sn 非空按 SN 料(material_code+序列号)精确定位;
// 否则按批次料(material_code+batch_no)定位(同批次多行全部置状态)。
// DisposalType 仅支持 RETURN/REWORK/SCRAP;RETURN 必填 ReturnTrackingNo。
type DisposeInventoryReq struct {
MaterialCode string `json:"materialCode"`
Sn string `json:"sn"`
BatchNo string `json:"batchNo"`
DisposalType string `json:"disposalType"`
ReturnTrackingNo string `json:"returnTrackingNo"`
Remark string `json:"remark"`
Operator string `json:"operator"`
}
// DisposeInventory 调 WMS /api/internal/inventory/dispose 执行在库处置(退货/返修/报废)。
// 网络/超时、非2xx、业务码非0 均返回 error 且优先携带 WMS 原文 message,
// 供质量检验保存链路透出「库存联动失败」原因(不阻断检验记录落库)。
func (c *Client) DisposeInventory(ctx context.Context, req DisposeInventoryReq) error {
b, err := json.Marshal(req)
if err != nil {
return err
}
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL()+"/api/internal/inventory/dispose", bytes.NewReader(b))
if err != nil {
return err
}
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(httpReq)
if err != nil {
return err
}
defer resp.Body.Close()
raw, _ := io.ReadAll(resp.Body)
var br struct {
Code int `json:"code"`
Message string `json:"message"`
}
_ = json.Unmarshal(raw, &br)
if resp.StatusCode >= 300 || br.Code != 0 {
if br.Message != "" {
return errors.New(br.Message)
}
return &RespError{Status: resp.StatusCode}
}
return nil
}
// FinishedPayload MES→WMS 成品回流入库载荷(完工检合格触发,调 /api/internal/finished/inbound)。
// 归属三字段照 semi.go 半成品归属继承模式取自工单:ownershipType/ownershipNo 取工单归属,
// productWorkNo=产品工号(即工单号),由 MES 自动带出,不做人工手选。
// productStatus=完工检结论(已通过/部分通过,WMS 侧映射 qualityStatus 合格);
// relatedStandard=相关标准、testRecordNo=试验记录单号(MES 完工检记录暂无专用字段时传空)。
type FinishedPayload struct {
ProductCode string
ProductName string
Sn string
OrderNo string
Operator string
ProductStatus string // 完工检结论:已通过 / 部分通过(不合格不触发本接口)
QualityStatus string // 质量状态:合格(默认)/让步接收(CONCESSION,可发货但标记)
RelatedStandard string // 相关标准(无则传空)
TestRecordNo string // 试验记录单号(无则传空)
OwnershipType string // 归属类型:workorder=合同号/project=科技项目号/other=其他
OwnershipNo string // 归属编号(合同号或科技项目号)
ProductWorkNo string // 产品工号(=所属工单号)
}
// FinishedInbound 成品回流入库:调 WMS /api/internal/finished/inbound,统一库存主表 category=3。
// WMS 对重复 SN 返回 HTTP 409 防重,此处转成 *RespError{Status:409} 供调用方
// 提示「已入库勿重复」(返修后复检再录合格的重复入库场景)。
func (c *Client) FinishedInbound(ctx context.Context, p FinishedPayload) error {
b, err := json.Marshal(map[string]any{
"productCode": p.ProductCode, "productName": p.ProductName, "sn": p.Sn,
"orderNo": p.OrderNo, "snSource": "AUTO", "operator": p.Operator,
"productStatus": p.ProductStatus, "qualityStatus": p.QualityStatus, "relatedStandard": p.RelatedStandard,
"testRecordNo": p.TestRecordNo, "ownershipType": p.OwnershipType,
"ownershipNo": p.OwnershipNo, "productWorkNo": p.ProductWorkNo,
})
if err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL()+"/api/internal/finished/inbound", bytes.NewReader(b))
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
raw, _ := io.ReadAll(resp.Body)
var br struct {
Code int `json:"code"`
Message string `json:"message"`
}
_ = json.Unmarshal(raw, &br)
if resp.StatusCode >= 300 || br.Code != 0 {
if resp.StatusCode == http.StatusConflict {
return &RespError{Status: resp.StatusCode, Message: br.Message}
}
if br.Message != "" {
return errors.New(br.Message)
}
return &RespError{Status: resp.StatusCode}
}
return nil
}
// MaterialExists 批量校验物料编码是否存在于 WMS 物料档案。
// 返回 WMS 中不存在的编码列表(全部存在则为空)。WMS 响应 {code,message,data:{missing:[]}}。
// 失败(网络/超时/非0响应)返回 err,由调用方决定降级策略。
func (c *Client) MaterialExists(ctx context.Context, codes []string) ([]string, error) {
b, err := json.Marshal(map[string]any{"codes": codes})
if err != nil {
return nil, err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL()+"/api/internal/material/exists", bytes.NewReader(b))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var body struct {
Code int `json:"code"`
Data struct {
Missing []string `json:"missing"`
} `json:"data"`
}
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
return nil, err
}
if resp.StatusCode >= 300 || body.Code != 0 {
return nil, &RespError{Status: resp.StatusCode}
}
return body.Data.Missing, nil
}
// ProductTypeRow 产品型号档案行(WMS materials item_type=3)
// 注:原「备注」随 WMS 物料档案「简称」一并删除(2026-09-19),
// 改为与 WMS 必填口径一致的「规格 / 单位」。
type ProductTypeRow struct {
ID int `json:"id"`
Code string `json:"code"`
Name string `json:"name"`
Spec string `json:"spec"`
Unit string `json:"unit"`
Category string `json:"category"`
ManageMode int `json:"manageMode"` // 类型 1结构件/2电气件/3其他
SnMode int `json:"snMode"` // 是否逐件SN管理 0未选择/1序列号件(录SN)/2批次件(不录SN)
IsActive bool `json:"isActive"`
// SyncPending 推送 WMS 失败标记(两库对等 M3):true=本地已落、WMS 待重推
SyncPending bool `json:"syncPending"`
CreatedAt int64 `json:"createdAt"`
UpdatedAt int64 `json:"updatedAt"`
}
// get 调 WMS GET 接口并解出 {code,data}
func (c *Client) get(ctx context.Context, path string, out any) error {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.BaseURL()+path, nil)
if err != nil {
return err
}
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode >= 300 {
return &RespError{Status: resp.StatusCode}
}
var body struct {
Code int `json:"code"`
Data any `json:"data"`
}
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
return err
}
if body.Code != 0 {
return &RespError{Status: resp.StatusCode}
}
if out != nil && body.Data != nil {
b, _ := json.Marshal(body.Data)
return json.Unmarshal(b, out)
}
return nil
}
// ExportProductTypes 拉取产品型号导出 xlsx 字节流(WMS 端执行统一导出时间规则)。
// 编码/名称各自独立模糊筛选(禁止关键字混搜)。
func (c *Client) ExportProductTypes(ctx context.Context, code, name, isActive, startDate, endDate string) ([]byte, error) {
q := "/api/internal/product-types/export?"
if code != "" {
q += "code=" + url.QueryEscape(code) + "&"
}
if name != "" {
q += "name=" + url.QueryEscape(name) + "&"
}
if isActive != "" {
q += "isActive=" + isActive + "&"
}
q += "startDate=" + startDate + "&endDate=" + endDate
req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.BaseURL()+q, nil)
if err != nil {
return nil, err
}
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode >= 300 {
return nil, &RespError{Status: resp.StatusCode}
}
buf := new(bytes.Buffer)
if _, err := buf.ReadFrom(resp.Body); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
2026-09-15 16:37:39 +08:00
// CreateReturnOrder 调 WMS /api/internal/return-order 预建退库单(工位退料回库房,待 WMS 确认收货)。
func (c *Client) CreateReturnOrder(ctx context.Context, orderNo, sn, materialCode, materialName, spec, reason, operator string, stationNo, qty int, unit string) error {
return c.post(ctx, "/api/internal/return-order", map[string]any{
"orderNo": orderNo, "sn": sn, "materialCode": materialCode, "materialName": materialName,
"spec": spec, "qty": qty, "unit": unit, "reason": reason, "operator": operator, "stationNo": stationNo,
})
}
// DisplayOverview 拉取 WMS 免登录看板总览 /api/display/overview。
// 用于看板「仓储动态」屏。WMS 不可达时返回 err,由调用方降级为空对象(看板其余屏不受影响)。
func (c *Client) DisplayOverview(ctx context.Context) (map[string]any, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.BaseURL()+"/api/display/overview", nil)
if err != nil {
return nil, err
}
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode >= 300 {
return nil, &RespError{Status: resp.StatusCode}
}
var body struct {
Code int `json:"code"`
Data map[string]any `json:"data"`
}
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
return nil, err
}
if body.Data == nil {
return map[string]any{}, nil
}
return body.Data, nil
}
// StockAvailable 批量查询物料可用量(调 WMS /api/internal/stock/check,qty 传 0 只取可用量)。
// 返回 materialCode → availQty。用于 MES 侧计算可生产数量(BOM 单台用量在 MES、库存可用量在 WMS)。
func (c *Client) StockAvailable(ctx context.Context, codes []string) (map[string]int, error) {
items := make([]map[string]any, 0, len(codes))
for _, code := range codes {
items = append(items, map[string]any{"materialCode": code, "qty": 0})
}
b, err := json.Marshal(map[string]any{"items": items})
if err != nil {
return nil, err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL()+"/api/internal/stock/check", bytes.NewReader(b))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var body struct {
Code int `json:"code"`
Data struct {
Items []struct {
MaterialCode string `json:"materialCode"`
AvailQty int `json:"availQty"`
} `json:"items"`
} `json:"data"`
}
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
return nil, err
}
if resp.StatusCode >= 300 || body.Code != 0 {
return nil, &RespError{Status: resp.StatusCode}
}
out := make(map[string]int, len(body.Data.Items))
for _, it := range body.Data.Items {
out[it.MaterialCode] = it.AvailQty
}
return out, nil
}
// ProducibleItem 可生产数量行(按工单维度,MES 实时计算;原定时推送/快照已下线)
type ProducibleItem struct {
OrderNo string `json:"orderNo"`
ProductCode string `json:"productCode"`
ProductName string `json:"productName"`
ProducibleQty int `json:"producibleQty"`
ShortText string `json:"shortText"`
ComputedAt int64 `json:"computedAt"`
}
// ProducibleDemand 未来5天物料需求行(推送 WMS,供备料四态「预警」判定)
type ProducibleDemand struct {
MaterialCode string `json:"materialCode"`
Future5Qty int `json:"future5Qty"`
}
// MaterialTypes 批量查询物料在 WMS 的品类(1原材料/2半成品/3成品/4其他)。
// 供产品物料清单递归展开使用:成品子项需继续向下展开到原材料/外购件。
// WMS 不可达返回 err,由调用方按"全部视为叶子物料"降级(不阻塞产线)。
func (c *Client) MaterialTypes(ctx context.Context, codes []string) (map[string]int, error) {
b, err := json.Marshal(map[string]any{"codes": codes})
if err != nil {
return nil, err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL()+"/api/internal/material/types", bytes.NewReader(b))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var body struct {
Code int `json:"code"`
Data struct {
Types map[string]int `json:"types"`
} `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
return nil, err
}
if body.Code != 0 {
if body.Msg != "" {
return nil, errors.New(body.Msg)
}
return nil, errors.New("WMS 查询物料品类失败")
}
if body.Data.Types == nil {
return map[string]int{}, nil
}
return body.Data.Types, nil
}
// MaterialManageModes 批量查询物料在 WMS 的「类型」(manage_mode: 1结构件/2电气件/3其他)。
// 与 MaterialTypes(品类 item_type)相互独立:品类=成品/组件类,类型=结构件/电气件/其他。
// WMS 不可达返回 err,由调用方降级(不阻塞产线)。
func (c *Client) MaterialManageModes(ctx context.Context, codes []string) (map[string]int, error) {
b, err := json.Marshal(map[string]any{"codes": codes})
if err != nil {
return nil, err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL()+"/api/internal/material/manage-modes", bytes.NewReader(b))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var body struct {
Code int `json:"code"`
Data struct {
ManageModes map[string]int `json:"manageModes"`
} `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
return nil, err
}
if body.Code != 0 {
if body.Msg != "" {
return nil, errors.New(body.Msg)
}
return nil, errors.New("WMS 查询物料类型失败")
}
if body.Data.ManageModes == nil {
return map[string]int{}, nil
}
return body.Data.ManageModes, nil
}
// BackflushItem 反冲单条物料(已含损耗的单件消耗 * 完成件数)
type BackflushItem struct {
MaterialCode string `json:"materialCode"`
Qty int `json:"qty"`
}
// Backflush 调 WMS /api/internal/material/backflush 反冲扣账。
// 物料在该道工序被消耗:报工完成时 MES 算好「工单产品BOM + 当前工序」消耗明细,
// WMS 负责 FIFO 扣库存 + 生成 backflush 出库单。失败返回 err,由调用方降级(仅记日志不阻塞产线)。
func (c *Client) Backflush(ctx context.Context, orderNo string, stationNo, processCode int, operator string, items []BackflushItem) error {
return c.post(ctx, "/api/internal/material/backflush", map[string]any{
"orderNo": orderNo,
"stationNo": stationNo,
"processCode": processCode,
"operator": operator,
"items": items,
})
}
// StockBatch WMS 可用批次(结构件)
type StockBatch struct {
BatchNo string `json:"batchNo"`
Quantity int `json:"quantity"`
LockedQty int `json:"lockedQty"`
Avail int `json:"avail"`
ZoneCode string `json:"zoneCode"`
QualityStatus string `json:"qualityStatus"`
}
// StockBatches 调 WMS /api/internal/stock/batches 取该物料可出库的批次(FIFO 升序)与可用 SN 列表。
// 供「工单备料自动出库」分配用;WMS 只返回「合格」且在库的库存。
func (c *Client) StockBatches(ctx context.Context, materialCode string) ([]StockBatch, []string, error) {
u := c.BaseURL() + "/api/internal/stock/batches?materialCode=" + url.QueryEscape(materialCode)
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
if err != nil {
return nil, nil, err
}
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return nil, nil, err
}
defer resp.Body.Close()
var body struct {
Code int `json:"code"`
Message string `json:"message"`
Data struct {
Batches []StockBatch `json:"batches"`
SnList []string `json:"snList"`
} `json:"data"`
}
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
return nil, nil, err
}
if resp.StatusCode >= 300 || body.Code != 0 {
return nil, nil, errors.New("查询 WMS 可用库存失败: " + body.Message)
}
return body.Data.Batches, body.Data.SnList, nil
}
// StockDeductOpts 备料出库可选参数(一个字段一个语义,避免位置参数越加越长)。
type StockDeductOpts struct {
BatchNo string // 批次出库(结构件),与 SnList 二选一
SnList []string // SN 出库(电气件),与 BatchNo 二选一
Qty int // 出库数量
Operator string
TargetDock string
ZoneCode string
OutboundType string // workorder(备料,默认) / refill(补料)
NeedAgv bool // 是否叫 AGV 配送到接驳台
OverReason string // 超出 BOM 需求时的超领原因(损耗/报废/返修/其他);空=超领将被 WMS 拦截
// IdempotencyKey 幂等键(安全审计 C2):同一键重复提交 WMS 返回首次结果,避免网络超时重试导致重复扣减
IdempotencyKey string
}
// StockDeduct 调 WMS /api/internal/stock/deduct 执行一笔备料出库(批次或 SN 二选一)。
// 返回该笔出库单号、工单台账状态(等于「领料完结」表示该物料已领完)、是否幂等复用(replayed)。
// replayed=true 表示 WMS 已存在相同幂等键的出库单、本次未实际扣减(网络超时重试场景),
// 调用方据此不要重复累加 sentQty,避免双计。失败返回 err(含 WMS 业务错误文案,
// 由调用方降级为保持待备料并预警)。
func (c *Client) StockDeduct(ctx context.Context, orderNo, materialCode string, o StockDeductOpts) (string, string, bool, error) {
payload := map[string]any{
"orderNo": orderNo, "materialCode": materialCode,
"qty": o.Qty, "operator": o.Operator,
"targetDock": o.TargetDock, "zoneCode": o.ZoneCode,
}
if o.BatchNo != "" {
payload["batchNo"] = o.BatchNo
}
if len(o.SnList) > 0 {
payload["snList"] = o.SnList
}
if o.OutboundType != "" {
payload["outboundType"] = o.OutboundType
}
if o.NeedAgv {
payload["needAgv"] = true
}
if o.OverReason != "" {
payload["overReason"] = o.OverReason
}
if o.IdempotencyKey != "" {
payload["idempotencyKey"] = o.IdempotencyKey
}
b, err := json.Marshal(payload)
if err != nil {
return "", "", false, err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL()+"/api/internal/stock/deduct", bytes.NewReader(b))
if err != nil {
return "", "", false, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return "", "", false, err
}
defer resp.Body.Close()
var body struct {
Code int `json:"code"`
Message string `json:"message"`
Data struct {
OutboundNo string `json:"outboundNo"`
Status string `json:"status"`
Replayed bool `json:"idempotent"`
} `json:"data"`
}
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
return "", "", false, err
}
if resp.StatusCode >= 300 || body.Code != 0 {
return "", "", false, errors.New(body.Message)
}
return body.Data.OutboundNo, body.Data.Status, body.Data.Replayed, nil
}
// LedgerProgressRow 工单台账配送进度行(WMS 侧四段量)。
// 在途 / 线边由 MES 用本地已接料量派生(在途 = outQty − receivedQty;线边 = receivedQty − consumedQty),
// WMS 不猜 MES 的接料量,避免跨系统重复记账。
type LedgerProgressRow struct {
OrderNo string `json:"orderNo"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
TargetStation string `json:"targetStation"`
TotalQty int `json:"totalQty"`
OutQty int `json:"outQty"`
ReturnedQty int `json:"returnedQty"`
ConsumedQty int `json:"consumedQty"`
NetOut int `json:"netOut"`
Gap int `json:"gap"`
Status string `json:"status"`
CompletedAt int64 `json:"completedAt"`
}
// LedgerProgress 拉取 WMS 工单物料台账配送进度(只读聚合,WMS 是台账唯一真源)。
func (c *Client) LedgerProgress(ctx context.Context, orderNo, materialCode string, page, pageSize int) ([]LedgerProgressRow, int, error) {
u := fmt.Sprintf("/api/internal/ledger/progress?orderNo=%s&materialCode=%s&page=%d&pageSize=%d",
url.QueryEscape(orderNo), url.QueryEscape(materialCode), page, pageSize)
var out struct {
Total int `json:"total"`
List []LedgerProgressRow `json:"list"`
}
if err := c.get(ctx, u, &out); err != nil {
return nil, 0, err
}
return out.List, out.Total, nil
}
// LedgerSyncItem 工单物料台账同步项(工单级需求量,一个物料一行)。
type LedgerSyncItem struct {
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
TotalQty int `json:"totalQty"`
}
// LedgerSync 向 WMS 下发「该工单每种物料总共要多少料」(工单级需求量)。
//
// 需求10根因修复:MES 生成备料单后必须把工单级需求量同步给 WMS,
// WMS 才知道 total_qty(台账需求量),否则出库/缺口/领料完结判定都无据可依。
// WMS 侧按 orderNo+materialCode 幂等 upsert total_qty(详见 ledgerSyncHandler)。
func (c *Client) LedgerSync(ctx context.Context, orderNo, productCode, operator string, items []LedgerSyncItem) error {
if orderNo == "" || len(items) == 0 {
return errors.New("orderNo 和 items 必填")
}
payload := map[string]any{
"orderNo": orderNo,
"productCode": productCode,
"operator": operator,
"items": items,
}
b, err := json.Marshal(payload)
if err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL()+"/api/internal/ledger/sync", bytes.NewReader(b))
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
var body struct {
Code int `json:"code"`
Message string `json:"message"`
}
_ = json.NewDecoder(resp.Body).Decode(&body)
if resp.StatusCode >= 300 || body.Code != 0 {
if body.Message != "" {
return errors.New(body.Message)
}
return &RespError{Status: resp.StatusCode}
}
return nil
}
2026-08-28 15:06:01 +08:00
func (c *Client) post(ctx context.Context, path string, body any) error {
b, err := json.Marshal(body)
if err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL()+path, bytes.NewReader(b))
2026-08-28 15:06:01 +08:00
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
raw, _ := io.ReadAll(resp.Body)
2026-08-28 15:06:01 +08:00
if resp.StatusCode >= 300 {
// 优先透出 WMS 业务错误原文(fail() 返回 {code:-1,message}),不吞真实失败原因
var br struct {
Code int `json:"code"`
Message string `json:"message"`
}
_ = json.Unmarshal(raw, &br)
if br.Message != "" {
return errors.New(br.Message)
}
2026-08-28 15:06:01 +08:00
return &RespError{Status: resp.StatusCode}
}
return nil
}
type RespError struct {
Status int
Message string // WMS 业务错误原文(可选;409 防重等场景透出,空则仅报状态码)
2026-08-28 15:06:01 +08:00
}
func (e *RespError) Error() string {
if e.Message != "" {
return "wms call failed with status " + strconv.Itoa(e.Status) + ": " + e.Message
}
return "wms call failed with status " + strconv.Itoa(e.Status)
}
// MaterialRow WMS 物料档案行(代理 WMS materials 表)
type MaterialRow struct {
ID int `json:"id"`
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"` // 类型 1结构件/2电气件/3其他
SnMode int `json:"snMode"` // 是否逐件SN管理 0未选择/1序列号件/2批次件(WMS 侧未改造时缺省 0)
TemplateCode string `json:"templateCode"`
SafetyStock int `json:"safetyStock"`
IsActive bool `json:"isActive"`
CreatedAt int64 `json:"createdAt"`
UpdatedAt int64 `json:"updatedAt"`
}
// MaterialPage 分页查询 WMS 物料(GET /api/internal/materials)
func (c *Client) MaterialPage(ctx context.Context, code, name, spec string, itemType, manageMode, page, pageSize int) (int64, []MaterialRow, error) {
q := "/api/internal/materials?page=" + strconv.Itoa(page) + "&pageSize=" + strconv.Itoa(pageSize)
if code != "" {
q += "&materialCode=" + url.QueryEscape(code)
}
if name != "" {
q += "&name=" + url.QueryEscape(name)
}
if spec != "" {
q += "&spec=" + url.QueryEscape(spec)
}
if itemType > 0 {
q += "&itemType=" + strconv.Itoa(itemType)
}
if manageMode > 0 {
q += "&manageMode=" + strconv.Itoa(manageMode)
}
var out struct {
Total int64 `json:"total"`
List []MaterialRow `json:"list"`
}
if err := c.get(ctx, q, &out); err != nil {
return 0, nil, err
}
return out.Total, out.List, nil
}
// MaterialUpsert MES→WMS 物料推送载荷(POST WMS /api/internal/materials/upsert,按 code 幂等)。
type MaterialUpsert 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"` // 类型 1结构件/2电气件/3其他
SnMode int `json:"snMode"` // 是否逐件SN管理 1序列号件/2批次件(与 WMS 并行改造,字段契约一致)
TemplateCode string `json:"templateCode"`
SafetyStock int `json:"safetyStock"`
IsActive *bool `json:"isActive"`
}
// UpsertMaterialToWMS 推送物料到 WMS(需求一 M3/M5:MES 本地写入后同步推送;按 code 幂等 upsert)。
func (c *Client) UpsertMaterialToWMS(ctx context.Context, m MaterialUpsert) error {
return c.post(ctx, "/api/internal/materials/upsert", map[string]any{
"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": m.IsActive,
})
}