Files
bj_power/bj_power_mes/internal/wmsclient/client.go
T
SunYF 1d1dc1bdd8 按模块说明
一、MES — 叫料单扩展(schema + 逻辑)​

material_request 新增字段:packageNo(叫料包号,一次提交=一包)、callDate(叫料日,默认当天)、planBreakdown(jsonb,工单×排产日明细 []CallPlanBreakdown);targetDock 语义降级为"期望接驳台(可空,配送时 WMS 确定实际台)"。
新增 internal/logic/call_plan.go:实时计算「叫料需求明细(工单×排产日×物料)」,派生两类提示(当日剩余未叫 / 跨日量明细),不落库、不拦提交;接驳台空台校验 EnsureStationDocksEmpty、托盘回库 DispatchPalletReturnManual、人工清台 ClearDockLedger、配送单派车 DispatchDeliveryAgv、工位物料明细 StationMaterialDetail。
新增 internal/handler/production/call_pkg.go:8 个 MES 内部端点(X-API-TOKEN 网关),供 WMS 调用——叫料需求明细、按包查单、接驳台状态、托盘回库、人工清台、配送单派车、叫料池原始行、工位物料明细、WMS 代叫料。
internal/handler/production/call.go、internal/logic/call.go、agv.go、qty_report.go、routes_production.go、wmsclient/client.go、db.go 同步接入上述逻辑。
二、WMS — 配送单(新功能,叫料与送料彻底拆开)​

新增 schema/delivery_order.go + delivery_order_item.go 及 ent 生成代码:delivery_order(PENDING→DISPATCHED→DONE / CANCELLED,一单=一次托盘配送)、delivery_order_item(配送物料明细快照:工单/工艺/排产日)。
新增 internal/handler/delivery.go + 路由 + DeliveryOrders.vue 页面(仓储作业 → 配送单)。
mesclient/client.go 扩展:MES 叫料单结构补 packageNo/callDate/workOrderNo/planBreakdown,新增 PoolRow/DockPalletState/DeliveryAgvItem/getJSON 等。
CallQueue.vue:按叫料包展示,新增「代叫料」「建配送单」按钮与对话框;出库单回写所属配送单号(outbound_order 加字段);AGV 派送改由配送单驱动。
三、工位终端 — 叫料体验升级

MaterialPanel.vue:新增「本工位物料明细」卡(工艺物料全集×工位账四数,量为 0 也显示);叫料改为「叫料包」模式(默认当天、可勾选分批、可选其他排产日、期望接驳台可空),新增叫料日选择器、两条提示横幅(当日剩余未叫 / 跨日量明细)、托盘回库按钮。
InspectPanel.vue/Main.vue/OnlinePanel.vue/OfflinePanel.vue/WorkPanel.vue/SyncQueueDialog.vue/api/index.js/internal/handler/line.go/routes.go 同步接入接驳台状态、托盘回库、下班双台空台校验等。
web/static/index.html 构建刷新。
四、文档

案例.md:重写第 5/6/8/9 节与新「配送单」流程,补「模拟模式跳过接驳台校验」说明,库管员菜单加「配送单」;并修正"本单箱体"等措辞歧义。
客户问题.md:同步本轮拍板口径。
五、构建产物 / 同步

多个 MES 前端页面(.vue)随本次改动统一重新构建刷新;ent 生成代码(MES material_request、WMS delivery_order/outbound_order 相关)随 schema 更新重新生成。
2026-11-05 19:18:18 +08:00

820 lines
30 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 wmsclient
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"strconv"
"strings"
"sync/atomic"
"time"
)
// Client WMS 内部接口客户端(半成品流转等)
// baseURL 支持运行时热切换(系统管理员「基础设置」页保存 WMS 地址后 SetBaseURL 即生效),
// 因此用 atomic.Value 存储,读侧无需加锁。
type Client struct {
baseURL atomic.Value // string
token string
hc *http.Client
}
// defaultBaseURL 未配置 WMS 地址时的兜底值
const defaultBaseURL = "http://127.0.0.1:9091"
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
}
u = strings.TrimRight(u, "/")
c.baseURL.Store(u)
}
// BaseURL 当前生效的 WMS 地址(不带尾斜杠,请求路径以 /api/... 开头直接拼接)
func (c *Client) BaseURL() string {
return c.baseURL.Load().(string)
}
// 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,
})
}
// 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,
})
}
// 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 // 质量状态:合格(默认)/不合格/未检/待退
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, spec, 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 spec != "" {
q += "spec=" + url.QueryEscape(spec) + "&"
}
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
}
// CreateReturnOrder 调 WMS /api/internal/return-order 预建退库单(工位退料/叫料单退库,待 WMS 确认收货)。
// refNo 非空 = 叫料单退库(B5):携带叫料单号,WMS 确认收回后凭此回调 MES /call/return-confirm。
// returnDock(2026-11-03 拍板):退料必须指定接驳台(退料托盘放置位置),WMS 退库单展示。
// lossReason(2026-11-04 拍板):损耗原因(巡检退料一律必填;转产退料实际<理论时必填),WMS 退库单落 loss_reason 可查。
// transportMode(2026-11-04 定稿):运输方式 agv/manual——agv=传感器检测到接驳台有托盘且库房有空位自动派车;manual=无 AGV。
func (c *Client) CreateReturnOrder(ctx context.Context, orderNo, sn, materialCode, materialName, spec, reason, operator string, stationNo, qty int, unit, refNo, returnDock, lossReason, transportMode 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,
"refNo": refNo, "returnDock": returnDock, "lossReason": lossReason, "transportMode": transportMode,
})
}
// StationReturnList 工位终端「我的退料单」列表(WMS internal 转发)。
func (c *Client) StationReturnList(ctx context.Context, stationNo int) ([]map[string]any, error) {
u := fmt.Sprintf("%s/api/internal/return-order/station-list?stationNo=%d", c.BaseURL(), stationNo)
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, 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()
var env struct {
Code int `json:"code"`
Data []map[string]any `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return nil, err
}
if env.Code != 0 {
return nil, fmt.Errorf("WMS 返回错误: %s", env.Msg)
}
if env.Data == nil {
return []map[string]any{}, nil
}
return env.Data, nil
}
// ---------- 退料 AGV 自动派车 / 工位取消退料 / 余量参考值(2026-11-04 口径定稿) ----------
// PendingReturnRow 待派车退料单行(WMS /api/internal/return-order/pending-agv 返回)。
type PendingReturnRow struct {
ReturnNo string `json:"returnNo"`
ReturnDock string `json:"returnDock"`
StationNo int `json:"stationNo"`
OrderNo string `json:"orderNo"`
}
// PendingAgvReturns 拉取待自动派车退料单(PENDING + 运输方式=AGV + 未派车)。
func (c *Client) PendingAgvReturns(ctx context.Context) ([]PendingReturnRow, error) {
u := c.BaseURL() + "/api/internal/return-order/pending-agv"
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, 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()
var env struct {
Code int `json:"code"`
Data []PendingReturnRow `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return nil, err
}
if env.Code != 0 {
return nil, fmt.Errorf("WMS 返回错误: %s", env.Msg)
}
if env.Data == nil {
return []PendingReturnRow{}, nil
}
return env.Data, nil
}
// MarkReturnDispatched 回写退料单「已派车」标记(自动派车成功后调用,防重复派车)。
func (c *Client) MarkReturnDispatched(ctx context.Context, returnNo string) error {
return c.post(ctx, "/api/internal/return-order/mark-dispatched", map[string]any{"returnNo": returnNo})
}
// CancelReturnOrder 工位取消自己发起的 PENDING 退料单(工位终端 → MES 转发 WMS)。
func (c *Client) CancelReturnOrder(ctx context.Context, returnNo string, stationNo int, operator, reason string) error {
return c.post(ctx, "/api/internal/return-order/cancel", map[string]any{
"returnNo": returnNo, "stationNo": stationNo, "operator": operator, "reason": reason,
})
}
// ReturnedSummaryRow 已退余量汇总行(WMS /api/internal/return-order/returned-summary 返回)。
type ReturnedSummaryRow struct {
OrderNo string `json:"orderNo"`
MaterialCode string `json:"materialCode"`
ReturnedQty float64 `json:"returnedQty"` // PENDING+RECEIVED 退料数量合计(已取消不计)
}
// FetchReturnedSummary 拉取某工位已退余量汇总(余量参考值=应剩余量−已退−损耗)。
func (c *Client) FetchReturnedSummary(ctx context.Context, stationNo int) ([]ReturnedSummaryRow, error) {
u := fmt.Sprintf("%s/api/internal/return-order/returned-summary?stationNo=%d", c.BaseURL(), stationNo)
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, 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()
var env struct {
Code int `json:"code"`
Data []ReturnedSummaryRow `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return nil, err
}
if env.Code != 0 {
return nil, fmt.Errorf("WMS 返回错误: %s", env.Msg)
}
if env.Data == nil {
return []ReturnedSummaryRow{}, nil
}
return env.Data, nil
}
// 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
}
// MaterialQuery 查询 WMS 物料档案 + 库存(看板物料追溯入口复用)。
// code 必填,batch 可选。返回 found(档案是否存在) + material(档案) + inventory(在库行)。
func (c *Client) MaterialQuery(ctx context.Context, code, batch string) (map[string]any, error) {
if code == "" {
return map[string]any{}, nil
}
u := c.BaseURL() + "/api/internal/material/query?code=" + url.QueryEscape(code)
if batch != "" {
u += "&batch=" + url.QueryEscape(batch)
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, 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 侧计算可生产数量(物料清单单台用量在 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"`
}
// MaterialManageModes 批量查询物料在 WMS 的「类型」(manage_mode: 1结构件/2电气件/3其他)。
// 物料类别(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
}
// 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
}
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))
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)
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)
}
return &RespError{Status: resp.StatusCode}
}
return nil
}
type RespError struct {
Status int
Message string // WMS 业务错误原文(可选;409 防重等场景透出,空则仅报状态码)
}
// DeliveredOutbound 调 WMS /api/internal/outbound/delivered:AGV 到位(任务结束)后
// 把关联出库单从「已出库」置「已送达」(幂等,已作废/已送达的跳过)。调用方 best-effort,失败仅记日志。
func (c *Client) DeliveredOutbound(ctx context.Context, outboundNos []string) error {
return c.post(ctx, "/api/internal/outbound/delivered", map[string]any{"outboundNos": outboundNos})
}
// DeliveryDelivered 调 WMS /api/internal/delivery/delivered:配送单驱动的 AGV 卸货放行后
// 把配送单置「已送达」(2026-11-05 拍板;WMS 端查不到配送单时忽略——兼容旧叫料单直派链路)。
func (c *Client) DeliveryDelivered(ctx context.Context, deliveryNo string) error {
return c.post(ctx, "/api/internal/delivery/delivered", map[string]any{"deliveryNo": deliveryNo})
}
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,
})
}