Files
bj_power/bj_power_wms/internal/mesclient/client.go
T
SunYF d92ca803d5 feat: 来料检处置项实体与复检、日排产达成对比、PLC/WMS 传输日志
- WMS 新增「检验处置项」实体(schema + ent 生成码),配套检验记录实体调整与复检接口,完善来料检/不良退货/入库检验前端
- MES 日排产:新增达成率统计与计划对比逻辑,调整日排产前端与流程卡/工序流
- 日志与传输:MES 新增 PLC 日志与 WMS 客户端传输日志,WMS 新增 MES 客户端传输日志
- MES 其他:扫码、工单/工件、AGV 客户端与告警、产品导入等逻辑完善及前端调整
- 工位终端:上线面板/作业面板、工件 handler 与 MES 客户端调整
- 配置与文档:更新 mes-api.yaml、三端构建产物与问题记录文档
2026-11-16 16:42:44 +08:00

980 lines
35 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 mesclient MES 内部接口客户端(备料单拉取 / 状态回写 / 接驳台与工单主数据只读)。
// AGV 配送真源已在 MES,2026-10-17 移除 WMS 侧 AGV 代理方法与 /api/agv/* 路由。
package mesclient
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net"
"net/http"
"net/url"
"strconv"
"strings"
"sync"
"time"
)
// Client MES 内部接口客户端
type Client struct {
mu sync.RWMutex
baseURL string
// initialBaseURL yaml 启动配置;页面把 MES 地址清空时回退到该值
initialBaseURL string
token string
hc *http.Client
}
func New(baseURL, token string) *Client {
if baseURL == "" {
baseURL = "http://127.0.0.1:8888"
}
return &Client{
baseURL: baseURL,
initialBaseURL: baseURL,
token: token,
hc: &http.Client{Timeout: 6 * time.Second, Transport: newLoggingTransport()},
}
}
// BaseURL 当前生效的 MES 地址(页面可热改,保存即生效)。
func (c *Client) BaseURL() string {
c.mu.RLock()
defer c.mu.RUnlock()
return c.baseURL
}
// SetBaseURL 热更新 MES 地址;传空串回退到 yaml 启动配置。
func (c *Client) SetBaseURL(u string) {
c.mu.Lock()
defer c.mu.Unlock()
u = strings.TrimRight(strings.TrimSpace(u), "/")
if u == "" {
u = c.initialBaseURL
}
c.baseURL = u
}
// Ping 连通性测试:调 MES 内部工单查询接口(轻量、无副作用),HTTP 200 即视为可达。
func (c *Client) Ping(ctx context.Context) error {
u := c.BaseURL() + "/api/internal/order/query?orderNo=__ping__"
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
if err != nil {
return err
}
req.Header.Set("X-API-TOKEN", c.token)
cli := &http.Client{Timeout: 4 * time.Second, Transport: newLoggingTransport()}
resp, err := cli.Do(req)
if err != nil {
return fmt.Errorf("无法连接 MES(%s):%v", c.BaseURL(), err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("MES 返回非 200(HTTP %d):请检查地址与 token", resp.StatusCode)
}
return nil
}
// 2026-11-13 拍板:成品入库扫 SN 反查 MES。WMS 必须区分「MES 不可达」与「SN 查不到」,
// 前者 502 硬拒、后者 404 硬拒,二者都禁止成品入库;物料入库链不调用本方法,绝不误伤。
var (
ErrMESUnreachable = errors.New("MES 不可达")
ErrMESTimeout = errors.New("MES 响应超时")
ErrFinishedSNNotFound = errors.New("SN 无对应工单")
)
// isTimeout 识别连接/读超时与 context deadline(http.Client Timeout=6s 会以 net.Error 形式返回)。
// 2026-11-13 拍板:MES 宕机时必须单独捕获超时,不能和「不可达」混成同一句提示。
func isTimeout(err error) bool {
if err == nil {
return false
}
if errors.Is(err, context.DeadlineExceeded) {
return true
}
var ne net.Error
if errors.As(err, &ne) && ne.Timeout() {
return true
}
s := strings.ToLower(err.Error())
return strings.Contains(s, "timeout") || strings.Contains(s, "deadline exceeded")
}
// FinishedLookup MES 透传的成品档案快照(WMS 只读展示,禁止前端改写)。
type FinishedLookup struct {
Sn string `json:"sn"`
OrderNo string `json:"orderNo"`
ProductCode string `json:"productCode"`
ProductName string `json:"productName"`
ProductStatus string `json:"productStatus"`
OwnershipType string `json:"ownershipType"`
OwnershipNo string `json:"ownershipNo"`
}
// LookupFinishedBySN 调 MES /api/internal/finished/lookup?sn= 反查工单与成品档案。
// 反查本身即「MES 在线」判据,省去额外一次 Ping(4s);业务错与网络错分开返回。
func (c *Client) LookupFinishedBySN(ctx context.Context, sn string) (*FinishedLookup, error) {
u := c.BaseURL() + "/api/internal/finished/lookup?sn=" + url.QueryEscape(sn)
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
if err != nil {
return nil, fmt.Errorf("%w: %v", ErrMESUnreachable, err)
}
req.Header.Set("X-API-TOKEN", c.token)
resp, err := c.hc.Do(req)
if err != nil {
if isTimeout(err) {
return nil, fmt.Errorf("%w: %v", ErrMESTimeout, err)
}
return nil, fmt.Errorf("%w: %v", ErrMESUnreachable, err)
}
defer resp.Body.Close()
if resp.StatusCode >= 400 {
return nil, fmt.Errorf("%w: HTTP %d(请检查 MES 地址与内部 token)", ErrMESUnreachable, resp.StatusCode)
}
var env struct {
Code int `json:"code"`
Data FinishedLookup `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return nil, fmt.Errorf("%w: 响应解析失败 %v", ErrMESUnreachable, err)
}
if env.Code != 0 {
return nil, fmt.Errorf("%w: %s", ErrFinishedSNNotFound, env.Msg)
}
return &env.Data, nil
}
// MaterialRequest MES 叫料单行(B5:不绑工单/不绑排产;七态状态机)
type MaterialRequest struct {
ID int `json:"id"`
RequestNo string `json:"requestNo"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Unit string `json:"unit"`
SnMode int `json:"snMode"`
ReqQty float64 `json:"reqQty"`
SentQty float64 `json:"sentQty"`
ReturnedQty float64 `json:"returnedQty"`
Status string `json:"status"`
TargetDock string `json:"targetDock"`
StationNo int `json:"stationNo"`
Source string `json:"source"`
RefReportNo string `json:"refReportNo"`
NeedAgv bool `json:"needAgv"`
CrossDay bool `json:"crossDay"`
OutboundNo string `json:"outboundNo"`
RejectReason string `json:"rejectReason"`
Operator string `json:"operator"`
CreatedAt string `json:"createdAt"` // RFC3339(MES ent 序列化),大屏叫料池显示 HH:MM 用
BorrowFrom map[string]int `json:"borrowFrom"` // 跨工位借料来源(MES 记账):stationNo→借用量;含本工位自取
// 2026-11-05 叫料包拍板:一次提交=一包;物料挂工单(工单×排产日明细)
PackageNo string `json:"packageNo"`
CallDate string `json:"callDate"`
WorkOrderNo string `json:"workOrderNo"`
PlanBreakdown []CallPlanBreakdown `json:"planBreakdown"`
}
// CallPlanBreakdown 叫料单的 工单×排产日 明细行(MES schema.CallPlanBreakdown 同构)
type CallPlanBreakdown struct {
OrderNo string `json:"orderNo"`
PlanDate string `json:"planDate"`
FlowID int `json:"flowId"`
FlowName string `json:"flowName"`
Qty float64 `json:"qty"`
}
// PoolRow 叫料池行(工位×物料 四数账;WMS 代叫料对话框数据源)
type PoolRow struct {
StationNo int `json:"stationNo"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Unit string `json:"unit"`
SnMode int `json:"snMode"`
ReqQty int `json:"reqQty"`
AdjQty int `json:"adjQty"`
SentQty int `json:"sentQty"`
ReservedQty int `json:"reservedQty"`
AvailQty int `json:"availQty"`
CrossDay bool `json:"crossDay"`
PlanDates string `json:"planDates"`
}
// DockPalletState 接驳台托盘状态(实时传感器为准;plcOk=false 为台账回退值)
type DockPalletState struct {
DockCode string `json:"dockCode"`
Name string `json:"name"`
Side string `json:"side"`
HasPallet bool `json:"hasPallet"`
LedgerPallet bool `json:"ledgerPallet"`
PlcOk bool `json:"plcOk"`
}
// DeliveryAgvItem 配送单派车物料行(转发 MES /api/internal/delivery/dispatch)
type DeliveryAgvItem struct {
RequestNo string `json:"requestNo"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Unit string `json:"unit"`
Qty float64 `json:"qty"`
}
// getJSON MES GET 通用(带 token;返回 body 的 data 字段)。
// 2026-11-09 缺陷修复:同 postJSON——HTTP 200 + 业务码≠0 也透出错误原文。
func (c *Client) getJSON(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()
raw, _ := io.ReadAll(resp.Body)
if resp.StatusCode >= 300 {
var br struct {
Message string `json:"message"`
}
_ = json.Unmarshal(raw, &br)
if br.Message != "" {
return errors.New(br.Message)
}
return fmt.Errorf("MES 返回 HTTP %d", resp.StatusCode)
}
var env struct {
Code int `json:"code"`
Message string `json:"message"`
Data json.RawMessage `json:"data"`
}
if err := json.Unmarshal(raw, &env); err != nil {
return err
}
if env.Code != 0 {
if env.Message != "" {
return fmt.Errorf("MES 业务错误(code=%d): %s", env.Code, env.Message)
}
return fmt.Errorf("MES 业务错误 code=%d", env.Code)
}
if out != nil && len(env.Data) > 0 {
return json.Unmarshal(env.Data, out)
}
return nil
}
// postJSON MES POST 通用(带 token)。
// 2026-11-09 缺陷修复:MES 业务失败 = HTTP 200 + code≠0(common/httpx.Fail),
// 此前只透出非 2xx,HTTP 200 的业务拒绝(如派车点位冲突)被当成功 → 上游假成功。
// 现统一解包 envelope:非 2xx 或业务码≠0 均透出错误原文。
func (c *Client) postJSON(ctx context.Context, path string, body any) error {
b, _ := json.Marshal(body)
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 {
var br struct {
Message string `json:"message"`
}
_ = json.Unmarshal(raw, &br)
if br.Message != "" {
return errors.New(br.Message)
}
return fmt.Errorf("MES 返回 HTTP %d", resp.StatusCode)
}
var env struct {
Code int `json:"code"`
Message string `json:"message"`
}
_ = json.Unmarshal(raw, &env)
if env.Code != 0 {
if env.Message != "" {
return fmt.Errorf("MES 业务错误(code=%d): %s", env.Code, env.Message)
}
return fmt.Errorf("MES 业务错误 code=%d", env.Code)
}
return nil
}
// ListMaterialRequestsByPackage 按叫料包号查叫料单(WMS 建配送单数据源,含工单×排产明细)
func (c *Client) ListMaterialRequestsByPackage(ctx context.Context, packageNo string) ([]MaterialRequest, error) {
out := []MaterialRequest{}
if err := c.getJSON(ctx, "/api/internal/call/package?packageNo="+url.QueryEscape(packageNo), &out); err != nil {
return nil, err
}
return out, nil
}
// StationPoolRaw 拉取叫料池原始行(WMS 代叫料对话框)
func (c *Client) StationPoolRaw(ctx context.Context, stationNo int) ([]PoolRow, error) {
out := []PoolRow{}
if err := c.getJSON(ctx, "/api/internal/call/pool-raw?stationNo="+strconv.Itoa(stationNo), &out); err != nil {
return nil, err
}
return out, nil
}
// StationDockPallets 按工位批量读左右接驳台实时传感器(配送空台校验)
func (c *Client) StationDockPallets(ctx context.Context, stationNo int) ([]DockPalletState, error) {
out := []DockPalletState{}
if err := c.getJSON(ctx, "/api/internal/dock/station-pallets?stationNo="+strconv.Itoa(stationNo), &out); err != nil {
return nil, err
}
return out, nil
}
// DispatchDelivery 配送单派车(转发 MES:AGV 派车改配送单驱动)
func (c *Client) DispatchDelivery(ctx context.Context, deliveryNo, targetDock, operator string, items []DeliveryAgvItem) error {
return c.postJSON(ctx, "/api/internal/delivery/dispatch", map[string]any{
"deliveryNo": deliveryNo, "targetDock": targetDock, "operator": operator, "items": items,
})
}
// CreateCall WMS 代叫料(与工位终端同一套 CreateCallOrders 逻辑)
func (c *Client) CreateCall(ctx context.Context, stationNo int, callDate string, force bool, items []map[string]any, operator string) error {
return c.postJSON(ctx, "/api/internal/call/create-internal", map[string]any{
"stationNo": stationNo, "callDate": callDate, "force": force, "items": items, "operator": operator, "source": "CALL",
})
}
// CreateShortageOnBehalf 库管代工位提交补料申请(转发 MES /api/internal/shortage/on-behalf)。
// 复用 MES 现有补料申请 logic 只生成待主管审批的补料单;WMS 不审批、不调增叫料池额度。
// 产品工号不作为独立字段下发(补料申请表无此列),由调用方附在补料原因里带过去。
func (c *Client) CreateShortageOnBehalf(ctx context.Context, stationNo int, materialCode, materialName, unit string, qty int, reason, operator string) error {
return c.postJSON(ctx, "/api/internal/shortage/on-behalf", map[string]any{
"stationNo": stationNo, "materialCode": materialCode,
"materialName": materialName, "unit": unit,
"qty": qty, "reason": reason, "operator": operator,
})
}
// DockClear 人工清台(托盘被人工卸走后台账卡死兜底)
func (c *Client) DockClear(ctx context.Context, dockCode, operator, reason string) error {
return c.postJSON(ctx, "/api/internal/dock/clear", map[string]any{
"dockCode": dockCode, "operator": operator, "reason": reason,
})
}
// ListMaterialRequests 拉取备料单(含 target_dock)
// status 空=全部;传 PENDING 可只取待发料。
func (c *Client) ListMaterialRequests(ctx context.Context, status string) ([]MaterialRequest, error) {
u := c.baseURL + "/api/internal/material-requests"
q := ""
if status != "" {
q = "?status=" + status
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u+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()
var env struct {
Code int `json:"code"`
Data []MaterialRequest `json:"data"`
Msg string `json:"message"`
}
dec := json.NewDecoder(resp.Body)
// MES 的 data 可能是 [object] 数组
if err := dec.Decode(&env); err != nil {
return nil, err
}
if env.Data == nil {
return []MaterialRequest{}, nil
}
return env.Data, nil
}
// MaterialDemandRow MES 排产物料需求行(按物料汇总,未来 N 天)
// WMS「缺料补货」视图拉此数据,对比本地可用库存得出排产缺料量。
type MaterialDemandRow struct {
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Unit string `json:"unit"`
DemandQty int `json:"demandQty"` // 未来 N 天排产总需求(台数×单台用量,向上取整)
StartDate string `json:"startDate"` // 需求窗口起(YYYY-MM-DD)
EndDate string `json:"endDate"` // 需求窗口止(YYYY-MM-DD)
}
// FetchMaterialDemand 实时向 MES 拉取「排产物料需求量」(供 WMS 缺料补货视图)。
// 两系统之间不做定时/批量同步:WMS 打开页面时按需拉一次,MES 现算现返。
// days 不传默认 5(与历史未来5天口径一致);MES 内部 /api/internal/material-demand 支持 ?days 覆盖。
func (c *Client) FetchMaterialDemand(ctx context.Context, days int) ([]MaterialDemandRow, error) {
u := c.baseURL + "/api/internal/material-demand"
if days > 0 {
u += "?days=" + strconv.Itoa(days)
}
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 []MaterialDemandRow `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return nil, err
}
if env.Code != 0 {
msg := env.Msg
if msg == "" {
msg = "MES 返回失败"
}
return nil, errors.New(msg)
}
if env.Data == nil {
return []MaterialDemandRow{}, nil
}
return env.Data, nil
}
// ---------- P1 备料清单(2026-11-04 用户拍板) ----------
// PreparationRow 备料清单行(MES 实时算返回):一行 = 某排产日 × 某工单 × 某工位 × 某物料。
type PreparationRow struct {
PlanDate string `json:"planDate"`
OrderNo string `json:"orderNo"`
ProductName string `json:"productName"`
StationNo int `json:"stationNo"`
StationQty int `json:"stationQty"` // 该工位分产量(台)
MaterialCode string `json:"materialCode"` // 物料编码(图号)
MaterialName string `json:"materialName"`
Spec string `json:"spec"`
Unit string `json:"unit"`
Qty int `json:"qty"` // 需求量 = ceil(分产量×单台用量)
UnitQty float64 `json:"unitQty"` // 单台用量
Status string `json:"status"` // 排产状态
}
// PreparationList 备料清单返回。
type PreparationList struct {
Rows []PreparationRow `json:"rows"`
Total int `json:"total"`
Range string `json:"range"`
PlanCnt int `json:"planCnt"`
}
// FetchPreparationList 实时向 MES 拉取备料清单(只读;MES 现算现返,工艺改动刷新即联动)。
func (c *Client) FetchPreparationList(ctx context.Context) (*PreparationList, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+"/api/internal/preparation-list", 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 *PreparationList `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return nil, err
}
if env.Code != 0 {
msg := env.Msg
if msg == "" {
msg = "MES 返回失败"
}
return nil, errors.New(msg)
}
if env.Data == nil {
return &PreparationList{Rows: []PreparationRow{}}, nil
}
return env.Data, nil
}
// ---------- E4 托盘余料明细(2026-11-04 拍板) ----------
// PalletResidualRow 接驳台托盘余料行(MES 从最近送达的 AGV 运输段 materials_json 解析)。
type PalletResidualRow struct {
RequestNo string `json:"requestNo"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Unit string `json:"unit"`
Qty float64 `json:"qty"`
}
// FetchPalletResidual 拉取指定接驳台托盘余料明细(供 WMS 托盘工作台代退料弹窗自动带出)。
func (c *Client) FetchPalletResidual(ctx context.Context, dock string) ([]PalletResidualRow, error) {
u := c.baseURL + "/api/internal/pallet/residual?dock=" + url.QueryEscape(dock)
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 []PalletResidualRow `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return nil, err
}
if env.Code != 0 {
msg := env.Msg
if msg == "" {
msg = "MES 返回失败"
}
return nil, errors.New(msg)
}
if env.Data == nil {
return []PalletResidualRow{}, nil
}
return env.Data, nil
}
// DockRow MES 接驳台主数据行(dock 真源已迁 MES,WMS 仅只读取用)。
type DockRow struct {
ID int64 `json:"id"`
DockCode string `json:"dockCode"`
Name string `json:"name"`
DockType string `json:"dockType"`
StationNo int `json:"stationNo"`
Side string `json:"side"`
Status string `json:"status"`
HasPallet bool `json:"hasPallet"`
PalletRef string `json:"palletRef"`
// Cleared 台面清空(R19 2026-11-03 拍板):= !HasPallet,转产退料确认收货闸门依据,
// 与 MES GuardTransferReroute(校验 Dock.HasPallet==false)同口径。
Cleared bool `json:"cleared"`
}
// ListDocks 拉取 MES 接驳台主数据(dock 真源在 MES)。
// WMS 出库目标工位下拉 / AGV 页接驳台列表均读此接口,仓库不再本地维护 dock 表。
func (c *Client) ListDocks(ctx context.Context) ([]DockRow, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+"/api/internal/docks", 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 struct {
List []DockRow `json:"list"`
} `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return nil, err
}
if env.Code != 0 {
msg := env.Msg
if msg == "" {
msg = "MES 返回失败"
}
return nil, errors.New(msg)
}
if env.Data.List == nil {
return []DockRow{}, nil
}
// Cleared 派生:无托盘即台面已清空(MES 侧不单独下发 cleared 字段)
for i := range env.Data.List {
env.Data.List[i].Cleared = !env.Data.List[i].HasPallet
}
return env.Data.List, nil
}
// AgvConfirm AGV 三段链确认(2026-11-03 三层机制):库管「确认装车并送货」等动作
// 经 MES internal /api/internal/agv/confirm;bizNo=叫料单号(MES 按 ARRIVED GO_LOAD 段定位)。
func (c *Client) AgvConfirm(ctx context.Context, bizNo, action, nextDock, operator string) error {
body, _ := json.Marshal(map[string]any{
"bizNo": bizNo, "action": action, "nextDock": nextDock, "operator": operator,
})
return c.postInternal(ctx, "/api/internal/agv/confirm", body, "AGV 确认动作失败")
}
// AgvDispatch 库管人工派车(2026-11-03 定论:废除备料完成自动派车):
// 叫料队列点「送货」→ MES internal /api/internal/agv/dispatch-call 下发空车去程段。
func (c *Client) AgvDispatch(ctx context.Context, requestNo, operator string) error {
body, _ := json.Marshal(map[string]any{"requestNo": requestNo, "operator": operator})
return c.postInternal(ctx, "/api/internal/agv/dispatch-call", body, "AGV 派车失败")
}
// PalletDispatch 托盘回收派车(WMS 托盘工作台):空车前往工位接驳台拉托盘(业务自动触发免弹窗)。
func (c *Client) PalletDispatch(ctx context.Context, dockCode, operator string) error {
body, _ := json.Marshal(map[string]any{"dockCode": dockCode, "operator": operator})
return c.postInternal(ctx, "/api/internal/agv/pallet-dispatch", body, "托盘回收派车失败")
}
// ---------- 退料 AGV 自动派车 / 取消联动 / 损耗落账 / 余量参考值(2026-11-04 口径定稿) ----------
// Jbt21Free 查询库房接驳台 JBT21 是否有空位(无空位不派车——托盘回收按钮禁用/自动派车等待)。
func (c *Client) Jbt21Free(ctx context.Context) (bool, string, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+"/api/internal/agv/jbt21-free", nil)
if err != nil {
return false, "", err
}
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 env struct {
Code int `json:"code"`
Data struct {
Free bool `json:"free"`
Reason string `json:"reason"`
} `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return false, "", err
}
if env.Code != 0 {
return false, "", errors.New(env.Msg)
}
return env.Data.Free, env.Data.Reason, nil
}
// CancelAgvByDock 按接驳台取消未终态 PALLET 回收任务(退料单取消联动:作废未完成 AGV 任务)。
// 返回 hasInTransit=true 表示该接驳台存在已装车运输中的段(调用方应拒绝取消退料单)。
func (c *Client) CancelAgvByDock(ctx context.Context, dockCode, reason string) (map[string]any, error) {
body, _ := json.Marshal(map[string]any{"dockCode": dockCode, "reason": reason})
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/api/internal/agv/cancel-by-dock", bytes.NewReader(body))
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 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, errors.New(env.Msg)
}
return env.Data, nil
}
// LossConfirm WMS 确认收货实收<应退时就地损耗落账(损耗确认移 WMS,MES 只读展示)。
func (c *Client) LossConfirm(ctx context.Context, returnNo, orderNo string, stationNo int,
materialCode, materialName string, theoryQty, actualQty, lossQty float64, reason, operator string) error {
body, _ := json.Marshal(map[string]any{
"returnNo": returnNo, "orderNo": orderNo, "stationNo": stationNo,
"materialCode": materialCode, "materialName": materialName,
"theoryQty": theoryQty, "actualQty": actualQty, "lossQty": lossQty,
"reason": reason, "operator": operator,
})
return c.postInternal(ctx, "/api/internal/loss/confirm", body, "损耗落账失败")
}
// ReturnRefRow 余量参考值行(MES 聚合返回,N4 定稿:应剩余量=实际备料量−已消耗−已退−已损耗)。
type ReturnRefRow struct {
OrderNo string `json:"orderNo"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Unit string `json:"unit"`
TheoryQty float64 `json:"theoryQty"`
PreparedQty float64 `json:"preparedQty"` // 实际备料量
ConsumedQty float64 `json:"consumedQty"` // 已消耗
LossQty float64 `json:"lossQty"`
ReturnedQty float64 `json:"returnedQty"`
RefLeft float64 `json:"refLeft"`
}
// StationReturnGuardResult WMS 代退料前置校验结果(拍板2 三态):
// Allowed=true 放行;NeedForce=true = PLC 离线(前端弹风险提示,ForceConfirm 重提);
// Allowed=false & NeedForce=false = 硬拒(Reason 为拒绝文案)。
type StationReturnGuardResult struct {
Allowed bool `json:"allowed"`
NeedForce bool `json:"needForce"`
Reason string `json:"reason"`
}
// StationReturnGuard WMS 代退料前置校验(N5 2026-11-04 拍板 + 拍板2):工位传感器无托盘
// (工件已完工离开工位)才允许退料;PLC 离线返回 NeedForce=true 供人工强行确认。
func (c *Client) StationReturnGuard(ctx context.Context, stationNo int) (*StationReturnGuardResult, error) {
u := fmt.Sprintf("%s/api/internal/station/return-guard?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 StationReturnGuardResult `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, errors.New(env.Msg)
}
return &env.Data, nil
}
// FetchReturnReference 拉取某工位余量参考值列表(WMS 代退料展示参考值)。
func (c *Client) FetchReturnReference(ctx context.Context, stationNo int) ([]ReturnRefRow, error) {
u := fmt.Sprintf("%s/api/internal/return-reference?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 struct {
Rows []ReturnRefRow `json:"rows"`
} `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, errors.New(env.Msg)
}
return env.Data.Rows, nil
}
// WorkOrderContract MES 工单归属解析结果(A2 在制品入库继承产线工单)
type WorkOrderContract struct {
WorkOrderNo string `json:"workOrderNo"`
ContractNo string `json:"contractNo"`
ProjectNo string `json:"projectNo"`
}
// GetWorkOrder 调 MES 内部接口解析工单归属(合同号/工程编号)。
// 找不到(工单不存在或 MES 不可达)返回 (nil, nil),调用方静默降级、不阻断入库。
func (c *Client) GetWorkOrder(ctx context.Context, orderNo string) (*WorkOrderContract, error) {
if orderNo == "" {
return nil, nil
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet,
c.baseURL+"/api/internal/work-orders/"+url.PathEscape(orderNo), 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 WorkOrderContract `json:"data"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return nil, err
}
if resp.StatusCode >= 400 {
return nil, fmt.Errorf("MES 工单查询失败(HTTP %d): %s", resp.StatusCode, env.Msg)
}
// 2026-11-13 修复:原来把 MES 的「任何」业务错都吞成 (nil,nil),上层一律误报 404「工单不存在」,
// 掩盖了 MES 不可达 / token 失效 / 网关异常。现只对「工单确实不存在」降级,其余原样上抛。
if env.Code != 0 {
if strings.Contains(env.Msg, "不存在") || strings.Contains(env.Msg, "未找到") || env.Code == 2003 {
return nil, nil
}
return nil, fmt.Errorf("MES 工单查询失败(%d): %s", env.Code, env.Msg)
}
return &env.Data, nil
}
// MaterialUpsert WMS→MES 物料推送载荷(需求一 M4:WMS 落库后异步推送 MES 本地副本;按 code 幂等)。
// SnMode(2026-09-30 与 MES 侧契约一致):0未选择/1序列号=是/2序列号=否。
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"`
SnMode int `json:"snMode"`
TemplateCode string `json:"templateCode"`
SafetyStock int `json:"safetyStock"`
IsActive *bool `json:"isActive"`
}
// UpsertMaterial 推送物料到 MES 本地副本(POST /api/internal/materials,按 code 幂等 upsert)。
// MES 业务错误为 HTTP 200 + code≠0,此处解包判断。
func (c *Client) UpsertMaterial(ctx context.Context, m MaterialUpsert) error {
b, _ := json.Marshal(m)
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/api/internal/materials", 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 env struct {
Code int `json:"code"`
Msg string `json:"message"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return err
}
if env.Code != 0 {
return fmt.Errorf("MES 返回错误: %s", env.Msg)
}
return nil
}
// CallStatus 查询 MES 叫料单状态(同步失败台账重试前判对端终态)。
// 已 SHIPPED/DONE 说明通知其实已成功,台账直接置 SUCCESS,不再重放。
func (c *Client) CallStatus(ctx context.Context, requestNo string) (string, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet,
c.BaseURL()+"/api/internal/call/status?requestNo="+url.QueryEscape(requestNo), 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 env struct {
Code int `json:"code"`
Message string `json:"message"`
Data struct {
Status string `json:"status"`
} `json:"data"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return "", err
}
if env.Code != 0 {
return "", errors.New(env.Message)
}
return env.Data.Status, nil
}
// CallComplete 通知 MES 仓库已完成备料(B5):实发量 + WMS 出库单号。
// MES 侧只做状态迁移(PENDING→SHIPPED)与四数账记账,不反向调 WMS 出库。
func (c *Client) CallComplete(ctx context.Context, requestNo string, sentQty float64, outboundNo, operator string) error {
b, _ := json.Marshal(map[string]any{
"requestNo": requestNo, "sentQty": sentQty, "outboundNo": outboundNo, "operator": operator,
})
return c.postInternal(ctx, "/api/internal/call/complete", b, "MES 叫料单完成备料回写失败")
}
// CallReject 通知 MES 仓库驳回叫料单(B5):带理由(异常标记:非当日等)。
func (c *Client) CallReject(ctx context.Context, requestNo, reason, operator string) error {
b, _ := json.Marshal(map[string]any{"requestNo": requestNo, "reason": reason, "operator": operator})
return c.postInternal(ctx, "/api/internal/call/reject", b, "MES 叫料单驳回回写失败")
}
// CallReturnConfirm 通知 MES 仓库已确认收回退库(B5 退库闭环终点):MES 关单并回补叫料池额度。
// 2026-11-03 拍板(R18):带回实收量/收货差异/备注,MES 落「待核」差异,不自动进损耗台账。
func (c *Client) CallReturnConfirm(ctx context.Context, requestNo, operator string, receiveQty, receiveDiff int, receiveNote string) error {
b, _ := json.Marshal(map[string]any{"requestNo": requestNo, "operator": operator,
"receiveQty": receiveQty, "receiveDiff": receiveDiff, "receiveNote": receiveNote})
return c.postInternal(ctx, "/api/internal/call/return-confirm", b, "MES 叫料单退库确认回写失败")
}
// PostRaw 同步失败台账人工重试:按 endpoint 原样重放通知请求体。
// 只重放通知,绝不重跑任何本地业务(如 doGeneralOutbound 出库扣减)。
func (c *Client) PostRaw(ctx context.Context, path string, payload map[string]any) error {
b, err := json.Marshal(payload)
if err != nil {
return err
}
return c.postInternal(ctx, path, b, "同步失败重试")
}
// postInternal 通用内部 POST:带 X-API-TOKEN;解析 MES 业务错误(HTTP 200 + body{code≠0} 必须判读)
func (c *Client) postInternal(ctx context.Context, path string, body []byte, errPrefix string) error {
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+path, bytes.NewReader(body))
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()
if resp.StatusCode >= 300 {
return &RespError{Status: resp.StatusCode}
}
var env struct {
Code int `json:"code"`
Msg string `json:"msg"`
}
if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
return err
}
if env.Code != 0 {
return fmt.Errorf("%s: %s", errPrefix, env.Msg)
}
return nil
}
type RespError struct {
Status int
}
func (e *RespError) Error() string {
return "mes call failed with status " + fmt.Sprintf("%d", e.Status)
}