- WMS 新增「检验处置项」实体(schema + ent 生成码),配套检验记录实体调整与复检接口,完善来料检/不良退货/入库检验前端 - MES 日排产:新增达成率统计与计划对比逻辑,调整日排产前端与流程卡/工序流 - 日志与传输:MES 新增 PLC 日志与 WMS 客户端传输日志,WMS 新增 MES 客户端传输日志 - MES 其他:扫码、工单/工件、AGV 客户端与告警、产品导入等逻辑完善及前端调整 - 工位终端:上线面板/作业面板、工件 handler 与 MES 客户端调整 - 配置与文档:更新 mes-api.yaml、三端构建产物与问题记录文档
980 lines
35 KiB
Go
980 lines
35 KiB
Go
// 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)
|
||
}
|