liufumingren 498543b9d7 perf(external-send): 控制回传平台的请求量,避免被判刷单
全部回读订单行在批量场景会被平台当成高频访问,补齐三处节流:

- syncPending:同批相邻两单之间留 EXTERNAL_SEND_INTERVAL_MS(默认 300ms)
- resolveTraceId:按账号缓存,批量内只调一次 getUserInfo(原来每单一次)
- dgj.resolveTraceId():实例级缓存 5 分钟的 traceId,
  取号(fetchWaybillNo)与重打(waybillPrintData)改用它,批量取号不再逐单 getUserInfo

配合上一版的「快照拼报文」,发货每单只有 1 次 POST,不再回读订单行。

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-07 08:14:12 +08:00

3159 lines
130 KiB
JavaScript
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.

'use strict';
const PrintPlatformService = require('./base');
const { resolvePlatform } = require('../platformCode');
/** 店管家商家门户站点 */
const PORTAL_ORIGIN = 'https://tfxportal.dgjapp.com';
/** 门户登录页入口(用于登录前建立会话 cookie;未登录时访问会停在登录页) */
const PORTAL_URL = `${PORTAL_ORIGIN}/ffaccount`;
/** 登录前置接口:判断是否需要提示绑定微信 */
const BIND_WECHAT_PROMPT_URL = `${PORTAL_ORIGIN}/FFAccount/BindWeChatPrompt`;
/** 登录接口:返回 Token 与跳转地址,并通过 set-cookie 下发登录态 */
const LOGIN_URL = `${PORTAL_ORIGIN}/FFAccount/LoginPortal`;
/** 登录后的工作台域名(需同时带 token 与 cookie 才能打开) */
const WORKBENCH_HOST = 'fxali.dgjapp.com';
/** 工作台入口:?token=<登录接口返回的 Token> */
const WORKBENCH_URL = `https://${WORKBENCH_HOST}/GeneralizeIndex/`;
/** 工作台用户信息接口:返回当前登录账号的店铺/昵称等信息(需 token + cookie) */
const USER_INFO_URL = `https://${WORKBENCH_HOST}/api/user/GetUserInfo`;
/** 工作台分区信息接口:商家列表需要其中的 dbname;商品查询需要逐个分区(区)查询 */
const AREAS_INFO_PATH = '/api/user/GetAreasInfo';
/** 商家(即店管家侧的店铺)列表接口 */
const AGENT_LIST_URL = `https://${WORKBENCH_HOST}/Partner/LoadMyAgentList`;
/** 商品列表接口(按分区域名请求,路径固定) */
const PRODUCT_LIST_PATH = '/Product/LoadList';
/** 订单列表接口(按分区域名请求,路径固定) */
const ORDER_LIST_PATH = '/NewOrder/List';
/** 面单模板(快递接口)列表接口:按平台域名请求,返回当前分区下可用的快递面单模板 */
const TEMPLATE_LIST_PATH = '/TemplateSet/LoadTemplateListInOrderList';
/** 面单账号明细接口:查看单个模板对应的电子面单账号 / 网点明细 */
const TEMPLATE_DETAIL_PATH = '/TemplateSet/LoadWaybillAccountDetailInfo';
/** 取号前校验模板可用性 / 面单余额(只读,不消耗面单) */
const TEMPLATE_AVAILABLE_PATH = '/TemplateSet/CheckTemplateAvaliable';
/**
* 取号接口:一次调用即返回运单号与打印数据,**会真实消耗面单**。
* 默认开启;需要临时停用时把环境变量 DGJ_WAYBILL_ENABLE 置为 0/false/off。
*/
const EXPRESS_PRINT_PATH = '/NewOrder/ExpressPrint';
/**
* 通知平台发货接口(`POST /NewOrder/OnlineSend`,**不消耗面单**)。
*/
const ONLINE_SEND_PATH = '/NewOrder/OnlineSend';
/**
* 按打印记录重新拉取面单打印数据(**只读,不消耗面单**)。
*
* 取号返回的打印数据(params)只有 10 分钟有效期,WMS 真正打印前要再取一次:
* `POST /PrintHistory/LoadPrintData?dbname=...`,表单 `printHistoryIds[]=...&IsCustomerOrder=false&FxPageType=1`。
*/
const PRINT_HISTORY_DATA_PATH = '/PrintHistory/LoadPrintData';
/**
* 是否允许调用真实取号(默认开启)
*
* 平台配置 `fetch_waybill_no=1` 即表示要回打单平台取号,这里默认放行;
* 仅在需要「只读联调、绝不下单」时用 DGJ_WAYBILL_ENABLE=0 显式关闭。
* @return {boolean} 是否允许调用 ExpressPrint
*/
function isWaybillEnabled() {
const value = String(process.env.DGJ_WAYBILL_ENABLE == null ? '' : process.env.DGJ_WAYBILL_ENABLE).trim().toLowerCase();
return !(value === '0' || value === 'false' || value === 'off' || value === 'no');
}
/**
* 构造带平台原始返回的错误(供上层写入取号记录留痕)
* @param {string} message 错误提示
* @param {{status: number, json: Object|null, text: string}} res 平台响应
* @return {Error} 附带 rawResponse 的错误
*/
function buildPlatformError(message, res) {
const error = new Error(message);
error.rawResponse = res && res.json ? res.json : { httpStatus: res && res.status, text: res && res.text };
return error;
}
/**
* 提取发货回传的逐单失败(平台是「整包 Success + Data.Orders[] 逐单结果」)
* @param {Object} json 平台响应
* @return {Array<{logicOrderId: string, message: string}>} 逐单失败
*/
function extractSendOrderFailures(json) {
const list = json && json.Data && Array.isArray(json.Data.Orders) ? json.Data.Orders : [];
const out = [];
for (const item of list) {
if (!item || typeof item !== 'object') continue;
if (item.IsSuccess === true || Number(item.IsSuccess) === 1) continue;
out.push({
logicOrderId: String(item.LogicOrderId || item.OrderCode || ''),
message: String(item.ErrorMessage || item.ErrorMsg || '平台未返回原因'),
});
}
return out;
}
/**
* 组装发货回传的单条订单报文(对齐平台「待打订单 → 发货」实际请求,2026-11-07 抓包)
* @param {Object} row 平台订单行(findPlatformOrderRow 的返回)
* @param {number} index 序号(0 基)
* @param {string} [expressCode] 快递编码兜底
* @return {Object} Orders[i]
*/
function buildSendOrder(row, index, expressCode = '') {
const subOrders = Array.isArray(row.SubOrders) ? row.SubOrders : [];
const waybills = Array.isArray(row.WaybillCodes) ? row.WaybillCodes : [];
const firstWaybill = waybills.find(code => code && code.WaybillCode) || {};
const items = subOrders.map(sub => ({
OrderItemId: sub.OrderItemId,
OrderItemCode: sub.OrderItemCode,
Quantity: '1',
SkuCode: sub.SkuCode,
ProductCode: sub.ProductID,
OrderItemIdStr: String(sub.OrderItemId == null ? '' : sub.OrderItemId),
}));
const orderItems = subOrders.map(sub => sub.OrderItemId);
return {
Id: row.Id,
Index: index + 1,
LogicOrderId: row.LogicOrderId,
PlatformOrderId: row.LogicOrderId,
PathFlowCode: row.PathFlowCode,
CustomerOrderId: row.PlatformOrderId,
ExpressPrintTime: row.ExpressPrintTime || '',
ShopId: row.ShopId,
ShopName: row.ShopName || '',
PlatformTypeName: row.PlatformTypeName || '',
PlatformType: row.PlatformType,
PlatformStatus: 'waitsellersend',
RefunStatus: '',
FxUserId: row.FxUserId,
BuyerRemark: row.BuyerRemark || '',
SellerRemark: row.SellerRemark || '',
NewSellerRemark: '',
NewPrintRemark: '',
// 分销场景 UpFxUserId(上游厂家)≠ FxUserId,直接透传平台值,别用 FxUserId 顶替
UpFxUserId: row.UpFxUserId,
IsPddCrossBorderOrder: row.IsPddCrossBorderOrder === true,
IsPddCourierDoorToDoorCollect: row.IsPddCourierDoorToDoorCollect === true,
ReceiverIsChange: row.ReceiverIsChange === true,
DataFlag: row.DataFlag,
PrintState: row.PrintState,
IsOfflineOrder: row.IsOfflineOrder === true,
OrderTags: Array.isArray(row.OrderTags) ? row.OrderTags : [],
PayTime: row.PayTime || '',
MergeredType: row.MergeredType == null ? 0 : row.MergeredType,
// 平台页面会把订单行里这个加密串原样带回,缺了可能被判报文不合法
ShippingType: row.ShippingType || '',
LogisticStatus: row.LogisticStatus == null ? 0 : row.LogisticStatus,
ExtField1: row.ExtField1 || '',
ExtField2: row.ExtField2 || '',
SellerRemarkFlagTag: row.SellerRemarkFlagTag || '',
IsSelectAllNotPrintedItem: 1,
WaybillCode: row.LastWaybillCode || firstWaybill.WaybillCode || '',
ExpressCompanyCode: firstWaybill.ExpressCpCode || expressCode || '',
weight: 0,
WaybillCodeUniqueKey: firstWaybill.UniqueKey || '',
SubOrders: subOrders,
WaybillCodes: waybills,
Items: items,
OrderItems: orderItems,
OrderItemStrList: orderItems,
Receiver: {
ToProvince: row.ToProvince,
ToCity: row.ToCity,
ToCounty: row.ToCounty,
ToMaskAddress: `${row.ToTown || ''}${row.ToAddress || ''}`,
ToName: row.ToName,
ToMobile: row.ToPhone,
ToAddress: row.ToFullAddress,
toFullName: row.ToName,
toArea: row.ToFullAddress,
},
Sender: { SenderCompany: '', CompanyName: '' },
ReceiverIsEmpty: 0,
PrintInfo: '',
NoPrintFlag: 'false',
};
}
/**
* 收集发货回传响应里的逐单错误(各平台结构不统一,这里按常见字段兜底)
* @param {Object} json 平台响应
* @return {string[]} 可读错误文案
*/
function describeSendErrors(json) {
const out = [];
const data = json && json.Data;
const list = Array.isArray(data) ? data : (data && Array.isArray(data.List) ? data.List : []);
for (const item of list) {
if (!item || typeof item !== 'object') continue;
const isError = item.IsError === true || Number(item.IsError) === 1;
const message = item.ErrorMsg || item.ErrMsg || item.Message || (isError ? '平台返回失败' : '');
if (!message) continue;
const code = item.LogicOrderId || item.OrderCode || item.PlatformOrderId || '';
out.push(code ? `${code}: ${message}` : message);
}
// 去重但保留顺序
return [ ...new Set(out) ].slice(0, 3);
}
/** 订单列表单页条数(平台允许 500) */
const ORDER_PAGE_SIZE = 500;
/** 订单查询的最大翻页数,防御平台分页异常 */
const ORDER_MAX_PAGES = 200;
/**
* 拉单时固定下发的订单状态过滤(平台订单页同口径:Filters ErpState == waitsellersend)。
* 不加这个条件会把窗口内历史已发货/已完成单全部拉回来再本地丢弃,请求量放大十几倍。
*/
const ORDER_ERP_STATE_PENDING = 'waitsellersend';
/**
* 老分区(不支持状态/商家过滤)退化拉取时的最大回看天数。
* 老分区只能按时间窗全量拉,「全部待处理」这类超大窗口会翻很多页,这里统一封顶(与平台页面默认 15 天一致),
* 用 DGJ_FALLBACK_MAX_DAYS 可覆盖。
*/
const ORDER_FALLBACK_MAX_DAYS = Number(process.env.DGJ_FALLBACK_MAX_DAYS || 15);
/** 分区是否支持「状态/商家」过滤的进程内缓存:key = host|dbname,避免每次都撞一次「服务器繁忙」 */
const AREA_FILTER_SUPPORT = new Map();
const AREA_FILTER_SUPPORT_TTL_MS = 60 * 60 * 1000;
/** 商家的分区 DbName -> 商品接口域名(toutiao=抖店、pinduoduo=拼多多、alibaba=精选、jingdong=京东) */
const AREA_PRODUCT_HOSTS = {
toutiao: 'fxdd.dgjapp.com',
pinduoduo: 'fxpdd.dgjapp.com',
alibaba: 'fxali.dgjapp.com',
jingdong: 'fxjd.dgjapp.com',
taobao: 'fxali.dgjapp.com',
kuaishou: 'fxali.dgjapp.com',
};
/** 商家没有可识别的分区时兜底查询的域名:宁可多查,避免漏商品 */
const FALLBACK_PRODUCT_HOSTS = [
'fxali.dgjapp.com',
'fxdd.dgjapp.com',
'fxpdd.dgjapp.com',
'fxjd.dgjapp.com',
'fxtk.dgjapp.com',
];
/**
* 面单模板(快递接口)接口按平台域名部署:分区 DbName → 模板接口域名 + PlatformType 写法。
* 平台新增分区时在此补充;未收录的分区按商品域名的同类映射兜底。
*/
const TEMPLATE_PLATFORMS = {
pinduoduo: { host: 'fxpdd.dgjapp.com', type: 'Pinduoduo' },
toutiao: { host: 'fxdd.dgjapp.com', type: 'TouTiao' },
douyin: { host: 'fxdd.dgjapp.com', type: 'TouTiao' },
doudian: { host: 'fxdd.dgjapp.com', type: 'TouTiao' },
wxvideo: { host: 'fxdd.dgjapp.com', type: 'WxVideo' },
alibaba: { host: 'fxali.dgjapp.com', type: 'Alibaba' },
taobao: { host: 'fxali.dgjapp.com', type: 'Taobao' },
tmall: { host: 'fxali.dgjapp.com', type: 'Tmall' },
jingdong: { host: 'fxjd.dgjapp.com', type: 'JingDong' },
kuaishou: { host: 'fxtk.dgjapp.com', type: 'KuaiShou' },
};
/** 只能识别出域名时的兜底 PlatformType(每个域名取一个代表平台) */
const TEMPLATE_HOST_TYPES = {
'fxpdd.dgjapp.com': [ 'Pinduoduo' ],
'fxdd.dgjapp.com': [ 'TouTiao' ],
'fxali.dgjapp.com': [ 'Alibaba' ],
'fxjd.dgjapp.com': [ 'JingDong' ],
'fxtk.dgjapp.com': [ 'KuaiShou' ],
};
/**
* 订单/取号接口域名:与模板域名不同!旧系统 `$this->pingtais` 的口径是
* 淘宝/1688/视频号/小红书/快手都走 fxali,抖店走 fxdd,拼多多走 fxpdd,京东走 fxjd。
* 取错域名会查不到订单(实测:视频号订单只在 fxali 能查到)。
*/
const ORDER_HOSTS = {
pinduoduo: 'fxpdd.dgjapp.com',
toutiao: 'fxdd.dgjapp.com',
douyin: 'fxdd.dgjapp.com',
doudian: 'fxdd.dgjapp.com',
jingdong: 'fxjd.dgjapp.com',
jd: 'fxjd.dgjapp.com',
};
/** 未命中映射时的订单域名兜底(淘宝/视频号/小红书/快手/1688 等) */
const ORDER_HOST_FALLBACK = 'fxali.dgjapp.com';
/** 商品列表单页条数(平台允许 200) */
const PRODUCT_PAGE_SIZE = 200;
/**
* 店管家 PlatformType -> 系统预设平台编码(硬编码,新增平台时在此补充)。
* 系统预设见 app/lib/platformCode.js;未收录的统一落到 OTHER(其他)。
*/
const PLATFORM_TYPE_PRESETS = {
pinduoduo: 'PDD',
toutiao: 'DYXD',
douyin: 'DYXD',
doudian: 'DYXD',
wxvideo: 'SPH',
alibaba: '1688',
1688: '1688',
taobao: 'TB',
tmall: 'TM',
jingdong: 'JD',
jd: 'JD',
kuaishou: 'KS',
xiaohongshu: 'XHS',
dewu: 'DW',
meituan: 'MTYYJK',
offline: 'OFFLINE',
};
/**
* 把店管家的 PlatformType 转成系统预设平台(编码 + 名称)
* @param {*} platformType 店管家 PlatformType(如 Pinduoduo / TouTiao / WxVideo)
* @return {{code: string, name: string}} 预设平台
*/
function resolveOrderPlatform(platformType) {
const key = String(platformType == null ? '' : platformType).trim().toLowerCase();
const presetCode = PLATFORM_TYPE_PRESETS[key];
return resolvePlatform(presetCode || platformType);
}
/**
* 按 PlatformType 反查面单模板接口域名(未收录时返回空字符串)
* @param {*} platformType 店管家 PlatformType(如 Pinduoduo)
* @return {string} 模板接口域名
*/
function resolveTemplateHost(platformType) {
const key = String(platformType == null ? '' : platformType).trim().toLowerCase();
for (const preset of Object.values(TEMPLATE_PLATFORMS)) {
if (preset.type.toLowerCase() === key) return preset.host;
}
return '';
}
/**
* 按 PlatformType 取订单 / 取号接口域名(与模板域名不同,见 ORDER_HOSTS 说明)
* @param {*} platformType 店管家 PlatformType(如 WxVideo)
* @return {string} 订单接口域名
*/
function resolveOrderHost(platformType) {
const key = String(platformType == null ? '' : platformType).trim().toLowerCase();
return ORDER_HOSTS[key] || ORDER_HOST_FALLBACK;
}
/**
* 平台侧「已发货 / 已终结」的订单状态(ErpState):
* sended=已发货、success=交易成功、close=交易关闭,其余为各平台交易状态的等价写法。
* 这些订单平台已自行处理完毕,不需要进本系统的待审核,拉取时直接跳过。
*/
const FINISHED_ORDER_STATES = [
'sended',
'sendsuccess',
'success',
'tradeclosed',
'close',
'closed',
'finished',
'delivered',
'refundsuccess',
'refunded',
];
/**
* 订单是否已在平台侧发货或已终结(不需要本系统再处理)。
* 判断依据(任一命中即为已处理):
* - ErpState 属于已发货/已终结状态
* - 有 OnlineSendTime(平台发货时间)
* - 面单里存在 IsSended=true 的包裹
* - LogisticStatus > 0(已进入物流流程)
* 注意:PrintState / ExpressPrintTime 只表示面单已打印,未发货的订单仍需要处理,故不作为判定依据。
* @param {Object} row 店管家订单原始结构
* @return {boolean} 是否已发货/已终结
*/
function isOrderFinished(row) {
return describeFinishedOrder(row).finished;
}
/**
* 平台是否拒绝了「状态/商家」过滤条件(旧系统分区不支持,统一返回「服务器繁忙」)
* @param {Error} err 请求异常
* @return {boolean} 是否需要退化为只按时间窗查询
*/
function isFilterUnsupportedError(err) {
return /服务器繁忙|系统繁忙|Server is busy/i.test(String((err && err.message) || ''));
}
/**
* 判定平台侧是否已发货/已终结,并给出**可读原因**(用于自动作废备注,便于区分具体依据)
* @param {Object} row 店管家订单原始结构
* @return {{finished: boolean, reason: string}} finished=是否已处理,reason=命中的具体依据
*/
function describeFinishedOrder(row) {
const data = row || {};
const state = String(data.ErpState || data.Status || '').trim();
const signals = [];
if (state && FINISHED_ORDER_STATES.includes(state.toLowerCase())) {
signals.push(`平台订单状态 ErpState=${state}`);
}
const sendTime = String(data.OnlineSendTime || '').trim();
if (sendTime) signals.push(`平台已有发货时间 ${sendTime}`);
const waybills = Array.isArray(data.WaybillCodes) ? data.WaybillCodes : [];
const sentCount = waybills.filter(code => code && code.IsSended === true).length;
if (sentCount > 0) signals.push(`${sentCount} 个面单包裹已发货`);
const logistic = Number(data.LogisticStatus);
if (logistic > 0) signals.push(`物流状态已推进(LogisticStatus=${logistic})`);
if (!signals.length) return { finished: false, reason: '' };
return { finished: true, reason: signals.join('、') };
}
/**
* 商品状态是否为在售:平台不同分区返回的状态值不统一(published / 1 / db_del / jdp_delete 等)
* @param {string|number|null} status 平台商品状态
* @return {boolean} 是否在售
*/
function isProductOnSale(status) {
const value = String(status == null ? '' : status).trim().toLowerCase();
return value === '1' || value === 'published' || value === 'online' || value === 'onsale' || value === 'on_sale';
}
/**
* 转数字,非法值按 0 处理
* @param {*} value 原始值
* @return {number} 数字
*/
function toNumber(value) {
const num = Number(value);
return Number.isFinite(num) ? num : 0;
}
/**
* 截断字符串,避免超出表字段长度
* @param {*} value 原始值
* @param {number} max 最大长度
* @return {string} 截断后的字符串
*/
function truncate(value, max) {
return String(value == null ? '' : value).slice(0, max);
}
/** 单次请求超时(毫秒) */
const REQUEST_TIMEOUT_MS = 15000;
/**
* 模拟 Chrome 访问 html 页面的请求头(取自真实抓包)。
* 说明:HTTP/2 伪头(:authority / :method / :path / :scheme)由客户端按 URL 自动生成,不能手动设置;
* accept-encoding 交给 fetch 自动协商并解压,手动声明会导致响应不解压。
*/
const BROWSER_HEADERS = {
accept:
'text/html,application/xhtml+xml,application/xml;q=0.9,image/jxl,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
'accept-language': 'zh-CN,zh;q=0.9',
'cache-control': 'max-age=0',
priority: 'u=0, i',
'sec-ch-ua': '"Not:A-Brand";v="8", "Chromium";v="156", "Google Chrome";v="156"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"Windows"',
'sec-fetch-dest': 'document',
'sec-fetch-mode': 'navigate',
'sec-fetch-site': 'none',
'sec-fetch-user': '?1',
'upgrade-insecure-requests': '1',
'user-agent':
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36',
};
/** 模拟浏览器 ajax 表单提交的请求头(登录接口为同源 XHR) */
const AJAX_HEADERS = {
accept: 'application/json, text/javascript, */*; q=0.01',
'accept-language': 'zh-CN,zh;q=0.9',
'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
origin: PORTAL_ORIGIN,
referer: PORTAL_URL,
'sec-ch-ua': '"Not:A-Brand";v="8", "Chromium";v="156", "Google Chrome";v="156"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"Windows"',
'sec-fetch-dest': 'empty',
'sec-fetch-mode': 'cors',
'sec-fetch-site': 'same-origin',
'user-agent':
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36',
'x-requested-with': 'XMLHttpRequest',
};
/** 模拟工作台 ajax(GET 接口)的请求头,Referer 指向工作台 */
const WORKBENCH_AJAX_HEADERS = {
accept: 'application/json, text/javascript, */*; q=0.01',
'accept-language': 'zh-CN,zh;q=0.9',
referer: WORKBENCH_URL,
'sec-ch-ua': '"Not:A-Brand";v="8", "Chromium";v="156", "Google Chrome";v="156"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"Windows"',
'user-agent':
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36',
'x-requested-with': 'XMLHttpRequest',
};
/**
* 登录表单字段加密:店管家要求 IsEnc=1 时字段值做 base64(URLSearchParams 会再对 = 等字符做 URL 编码)
* @param {string} value 原始值
* @return {string} base64 值
*/
function encodeField(value) {
return Buffer.from(String(value), 'utf8').toString('base64');
}
/**
* 读取响应里的 set-cookie(兼容没有 getSetCookie 的运行时)
* @param {Response} res fetch 响应
* @return {string[]} set-cookie 列表
*/
function getSetCookies(res) {
if (typeof res.headers.getSetCookie === 'function') return res.headers.getSetCookie();
const raw = res.headers.get('set-cookie');
return raw ? [ raw ] : [];
}
/**
* 合并 set-cookie 到已有 cookie:同名覆盖,其余保留
* @param {string} cookie 已有 cookie
* @param {string[]} setCookies 响应头 set-cookie
* @return {string} 合并后的 cookie
*/
function mergeCookie(cookie, setCookies) {
const jar = new Map();
for (const item of String(cookie || '').split(';')) {
const kv = item.trim();
const idx = kv.indexOf('=');
if (idx > 0) jar.set(kv.slice(0, idx), kv.slice(idx + 1));
}
for (const raw of setCookies) {
const kv = String(raw).split(';')[0].trim();
const idx = kv.indexOf('=');
if (idx > 0) jar.set(kv.slice(0, idx), kv.slice(idx + 1));
}
return Array.from(jar, ([ key, value ]) => `${key}=${value}`).join('; ');
}
/**
* 组装登录失败提示
* @param {{status: number, json: Object|null}} res 接口响应
* @return {string} 失败原因
*/
function describeFailure(res) {
const json = (res && res.json) || {};
const message = json.Message || json.ErrorCode || '未知错误';
return `${message}(HTTP ${res ? res.status : '-'})`;
}
/**
* 日期格式化为店管家订单查询使用的时间字符串(yyyy-MM-dd HH:mm:ss)
* @param {Date|string} value 时间
* @return {string} 时间字符串
*/
function formatOrderTime(value) {
const date = value instanceof Date ? value : new Date(value);
if (Number.isNaN(date.getTime())) return '';
const pad = num => String(num).padStart(2, '0');
return (
`${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ` +
`${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
);
}
/**
* 解析平台时间字符串(店管家返回 yyyy-MM-dd HH:mm:ss),非法值返回 null
* @param {*} value 平台时间
* @return {Date|null} 时间
*/
function parseOrderTime(value) {
const text = String(value == null ? '' : value).trim();
if (!text) return null;
const date = new Date(text.replace(' ', 'T'));
return Number.isNaN(date.getTime()) ? null : date;
}
/**
* 订单明细的平台规格ID:不同平台字段口径不一致
* (抖店/淘宝用 SkuId 存规格ID,视频号则用 SkuCode 存规格ID、SkuId 存规格名称)
* @param {Object} data 明细原始结构
* @return {string} 平台规格ID,取不到时返回空字符串
*/
function resolveOrderSkuId(data) {
const looksLikeId = value => /^[0-9A-Za-z_-]{4,64}$/.test(value);
const candidates = [ data.SkuId, data.SkuCode ];
for (const item of candidates) {
const value = String(item == null ? '' : item).trim();
if (value && looksLikeId(value)) return value;
}
return '';
}
/**
* 递归收集打印数据里的运单号(旧系统口径:PrintDataList.task.documents[].documentID)
* @param {*} value 已解析的打印数据对象/数组
* @param {string[]} out 收集结果
* @return {void}
*/
function collectDocumentIds(value, out) {
if (!value || typeof value !== 'object') return;
if (Array.isArray(value)) {
for (const item of value) collectDocumentIds(item, out);
return;
}
for (const [ key, item ] of Object.entries(value)) {
if ((key === 'documentID' || key === 'DocumentID') && (typeof item === 'string' || typeof item === 'number')) {
const text = String(item).trim();
if (text) out.push(text);
continue;
}
collectDocumentIds(item, out);
}
}
/**
* 解析打印数据(字符串或对象),提取运单号
* @param {*} printInfo 打印数据
* @return {string[]} 运单号列表
*/
function extractWaybillsFromPrintInfo(printInfo) {
if (!printInfo) return [];
let parsed = printInfo;
if (typeof printInfo === 'string') {
try {
parsed = JSON.parse(printInfo);
} catch {
return [];
}
}
const out = [];
collectDocumentIds(parsed, out);
return out;
}
/**
* 从 ExpressPrint 响应的 Data.WaybillCode[] 里提取运单号
* 兼容:WaybillCode / LogisticCode / MailNo 字段、OrderInfo 嵌套、PrintInfo 里的 documentID
* @param {Array} items Data.WaybillCode 数组
* @return {string[]} 去重后的运单号
*/
function extractWaybillCodes(items) {
const out = [];
for (const item of Array.isArray(items) ? items : []) {
if (!item || typeof item !== 'object') continue;
for (const key of [ 'WaybillCode', 'LogisticCode', 'MailNo', 'WaybillNo' ]) {
const value = item[key];
if (typeof value === 'string' && value.trim()) out.push(value.trim());
}
const nested = item.OrderInfo && item.OrderInfo.OrderInfo;
if (nested && typeof nested === 'object') {
for (const key of [ 'WaybillCode', 'LastWaybillCode' ]) {
const value = nested[key];
if (typeof value === 'string' && value.trim()) out.push(value.trim());
}
}
for (const key of [ 'PrintInfo', 'PrintData' ]) {
out.push(...extractWaybillsFromPrintInfo(item[key]));
}
}
return [ ...new Set(out) ];
}
/**
* 从 ExpressPrint 响应的 Data.PrintHistoryIds[] 里提取打印记录
*
* 平台每打印一张面单就新增一条打印历史,`Id` 即打印记录ID(printHistoryId),
* 重打/作废/查打印记录(`PrintHistory/LoadPrintData`)都要用它。多包裹时数组长度 = 张数。
* @param {Object} printed ExpressPrint 响应
* @return {Array<{id: string, pid: string, waybill_code: string, batch_index: number|null}>} 打印记录
*/
function extractPrintHistoryIds(printed) {
const list = printed && printed.Data && printed.Data.PrintHistoryIds;
const out = [];
for (const item of Array.isArray(list) ? list : []) {
if (!item || typeof item !== 'object') continue;
const id = String(item.Id == null ? '' : item.Id).trim();
if (!id) continue;
out.push({
id,
pid: String(item.Pid == null ? '' : item.Pid).trim(),
waybill_code: String(item.WaybillCode == null ? '' : item.WaybillCode).trim(),
batch_index: item.BatchIndex == null ? null : Number(item.BatchIndex),
});
}
return out;
}
/**
* 取平台返回的打印单据(`Data.PrintDataList.task.documents[]`)
*
* 店管家的 `ExpressPrint` 返回里,运单号在 `Data.WaybillCode[]`,而**面单打印数据在
* `Data.PrintDataList.task.documents[]`**(`documentID` = 运单号,`printInfo` = 打印数据,
* `contents[]` = 需要加密打印的场景下的 encryptedData / signature / ver)。
* 一次请求可能返回多个 document(多包裹),这里按运单号匹配,匹配不到取第一个。
* @param {Object} printed ExpressPrint 响应
* @param {string} waybillCode 本次运单号
* @return {Object|null} document 对象,未找到为 null
*/
function firstPrintDocument(printed, waybillCode) {
const documents = printed && printed.Data && printed.Data.PrintDataList &&
printed.Data.PrintDataList.task && printed.Data.PrintDataList.task.documents;
const list = Array.isArray(documents) ? documents.filter(doc => doc && typeof doc === 'object') : [];
if (!list.length) return null;
const matched = waybillCode ? list.find(doc => String(doc.documentID || '').trim() === String(waybillCode).trim()) : null;
return matched || list[0];
}
/**
* 取第一条打印数据(字符串化,便于原样回传给打印端)
*
* 顺序:`Data.PrintDataList.task.documents[].printInfo`(店管家实际下发的打印数据,
* base64 编码的 URL-encoded JSON,WMS 打印端按原样塞进 `task.printInfo`)→
* `Data.WaybillCode[].PrintInfo / PrintData / PrintDataJson`(其它平台/旧版返回)。
* @param {Array} items Data.WaybillCode 数组
* @param {Object} printed ExpressPrint 响应
* @param {string} waybillCode 本次运单号
* @return {string} 打印数据,未找到为空串
*/
function firstPrintInfo(items, printed, waybillCode) {
const document = firstPrintDocument(printed, waybillCode);
if (document && document.printInfo) {
return typeof document.printInfo === 'string' ? document.printInfo : JSON.stringify(document.printInfo);
}
for (const item of Array.isArray(items) ? items : []) {
const value = item && (item.PrintInfo || item.PrintData || item.PrintDataJson);
if (!value) continue;
return typeof value === 'string' ? value : JSON.stringify(value);
}
return '';
}
/**
* 从 document 的 contents[0] 取打印附加信息(旧系统同口径)
*
* 旧系统 `Dianguanjia.php` 取的是
* `PrintDataList.task.documents[0].contents[0]` 的 `signature` / `encryptedData` / `ver`;
* 视频号等自定义模板场景平台不返回 `contents`,此时三个值都为空串。
* @param {Object} document 打印单据
* @return {{signature: string, encryptprintinfo: string, ver: string}} 签名、加密打印数据、版本
*/
function extractDocumentContents(document) {
const empty = { signature: '', encryptprintinfo: '', ver: '' };
const contents = document && document.contents;
const first = Array.isArray(contents) ? contents[0] : null;
if (!first || typeof first !== 'object') return empty;
return {
signature: typeof first.signature === 'string' ? first.signature : '',
encryptprintinfo: typeof first.encryptedData === 'string' ? first.encryptedData : '',
ver: first.ver == null ? '' : String(first.ver),
};
}
/**
* 构造 `Orders[0][WaybillCodes][]`(平台「新单号打印」请求里带的当前号清单)
*
* 平台前端在重新取号时会把这个订单已有的运单号(含 `WaybillCodeId` / `Pid`)一起回传,
* 平台据此分配**下一个**号(`WaybillCodePid` 的第二段自增)。不传时平台容易直接复用旧号。
* @param {Object} row 平台订单行(含 WaybillCodes / SubOrders)
* @param {string} templateId 面单模板ID
* @param {string} expressCode 快递编码
* @return {Array|string} 运单号清单;没有历史号时返回空串(表单里表现为空值)
*/
function buildWaybillCodesBlock(row, templateId, expressCode) {
const list = Array.isArray(row.WaybillCodes) ? row.WaybillCodes.filter(item => item && item.WaybillCode) : [];
if (!list.length) return '';
const subs = Array.isArray(row.SubOrders) ? row.SubOrders : [];
return list.map(entry => ({
TemplateId: String(entry.TemplateId || templateId || ''),
TemplateType: entry.TemplateType == null ? '' : entry.TemplateType,
ExpressCpCode: entry.ExpressCpCode || expressCode || '',
ExpressName: entry.ExpressName || '',
WaybillCode: entry.WaybillCode,
ChildWaybillCode: '',
ChildWaybillCodes: '',
CompanyCode: entry.CompanyCode || entry.ExpressCpCode || expressCode || '',
WaybillCodeId: entry.WaybillCodeId == null ? '' : entry.WaybillCodeId,
CreateDate: entry.CreateDate || '',
IsSended: entry.IsSended === true,
TotalWeight: 0,
SendType: 0,
Status: entry.Status == null ? 1 : entry.Status,
Pid: entry.Pid || '',
WaybillCodeOrderProducts: subs.map(sub => ({
MasterId: `${row.Id}_${entry.WaybillCode}_iD`,
OrderItemId: sub.OrderItemId,
OrderItemIdStr: sub.OrderItemId,
Quantity: 1,
OrderItemCode: sub.OrderItemCode,
WaybillCodeId: entry.WaybillCodeId == null ? '' : entry.WaybillCodeId,
})),
}));
}
/**
* 按 PHP `http_build_query` 口径把对象展开成表单
*
* 店管家(ASP.NET MVC)按 PHP 风格的嵌套键解析表单:数组元素是
* `orders[0][SourceShopId]=...`,**不是** `orders[0]={"SourceShopId":...}`。
* 用 JSON 字符串提交会被平台判为参数缺失(表现为「打印校验失败,系统异常」)。
*
* 取值口径与 PHP 一致:`null/undefined` → 空串;`true` → `1`;`false` → 空串;
* 空数组/空对象 → 空串;数字/字符串 → 原样。
* @param {Object} data 表单数据(可含嵌套对象/数组)
* @return {URLSearchParams} 可直接作为 x-www-form-urlencoded body
*/
function buildPhpForm(data) {
const form = new URLSearchParams();
/**
* 递归写入一个值
* @param {*} value 值
* @param {string} key 字段名(含嵌套括号)
* @return {void}
*/
const walk = (value, key) => {
if (value === null || value === undefined) {
form.append(key, '');
return;
}
if (typeof value === 'boolean') {
form.append(key, value ? '1' : '');
return;
}
if (Array.isArray(value)) {
if (!value.length) {
form.append(key, '');
return;
}
value.forEach((item, index) => walk(item, `${key}[${index}]`));
return;
}
if (typeof value === 'object') {
const keys = Object.keys(value);
if (!keys.length) {
form.append(key, '');
return;
}
for (const childKey of keys) walk(value[childKey], `${key}[${childKey}]`);
return;
}
form.append(key, String(value));
};
for (const [ key, value ] of Object.entries(data || {})) walk(value, key);
return form;
}
/**
* 店管家(dgj)外部打单平台服务。
*
* 平台记录:external_print_platforms.code = 'dgj'(名称「店管家」,fetch_waybill_no = 0 即不回平台取号)。
* 该平台的全部处理逻辑(登录、打单、取号等)都写在本文件里,不要散落到别处;
* 新增平台时同样新建 `<平台 code>.js`,并把 static code 改成对应平台标识。
*
* 登录流程(与浏览器一致):
* 1. GET /ffaccount 建立会话(拿到 WAF/ASP.NET 基础 cookie)
* 2. POST /FFAccount/BindWeChatPrompt(是否需要提示绑定微信)
* 3. POST /FFAccount/LoginPortal(返回 Token / RedirectUrl,并通过 set-cookie 下发登录态)
* 4. GET /api/user/GetUserInfo?token=<Token>(需同时带 cookie)确认登录态并拿账号信息
* 成功后把 token 与 cookie 一并写回账号表,后续检查/调用复用。
*
* 注意:店管家工作台同时依赖 token 与 cookie,仅保存 cookie 无法获取账号信息(返回 401)。
* 登录态检查走 GetUserInfo(轻量 JSON,避免每次拉取 500KB 的工作台页面)。
*/
class DgjService extends PrintPlatformService {
static get code() {
return 'dgj';
}
/**
* 店管家站点根地址(平台配置的链接未带协议时补 https://)
* @return {string} 站点根地址
*/
get siteUrl() {
const url = String(this.platform.url || '').trim();
if (!url) throw new Error('店管家平台未配置链接地址(external_print_platforms.url)');
return /^https?:\/\//i.test(url) ? url : `https://${url}`;
}
/**
* 统一平台请求入口(请求拦截器)。
* 平台接口返回 401 表示登录已失效,这里统一把账号登录状态记为 0;
* 其余状态交由调用方按业务判断。
* @param {string} url 完整请求地址
* @param {Object} [options] fetch 选项(method / headers / body 等)
* @return {Promise<{status: number, json: Object|null, text: string, setCookies: string[]}>} 响应
*/
async request(url, options = {}) {
const res = await fetch(url, {
redirect: 'follow',
...options,
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
const text = await res.text();
let json = null;
try {
json = JSON.parse(text);
} catch {
json = null;
}
if (res.status === 401) {
await this.saveLoginStatus(0);
}
return { status: res.status, json, text, setCookies: getSetCookies(res) };
}
/**
* 拉取工作台当前登录账号信息(需 token + cookie,缺一不可)
* @param {string} [token] 登录 token,默认取账号已保存的 token
* @param {string} [cookie] 会话 cookie,默认取账号已保存的 cookie
* @return {Promise<{success: boolean, status: number, message: string, data: Object|null, setCookies: string[]}>} 账号信息
*/
async getUserInfo(token = this.token, cookie = this.cookie) {
const tk = String(token || '').trim();
if (!tk) throw new Error('店管家账号未保存登录 token,无法获取账号信息');
const query = new URLSearchParams({
traceId: '',
dbname: '',
dataFlag: '',
IsCustomerOrder: 'false',
FxPageType: '1',
_: String(Date.now()),
token: tk,
});
const headers = { ...WORKBENCH_AJAX_HEADERS };
if (cookie) headers.cookie = cookie;
const res = await this.request(`${USER_INFO_URL}?${query.toString()}`, { method: 'GET', headers });
const success = res.status === 200 && !!res.json && res.json.Success === true;
if (success) await this.saveLoginStatus(1);
return {
success,
status: res.status,
message: (res.json && res.json.Message) || '',
data: success && res.json.Data ? res.json.Data : null,
setCookies: res.setCookies,
};
}
/**
* 拉取工作台分区信息(商家列表接口需要其中的 DbName;商品接口需要按分区逐个查询)
* @param {string} [token] 登录 token,默认取账号已保存的 token
* @param {string} [cookie] 会话 cookie,默认取账号已保存的 cookie
* @param {string} [host] 分区信息所属域名,默认工作台域名
* @return {Promise<{success: boolean, status: number, message: string, data: Object|null}>} 分区信息
*/
async getAreasInfo(token = this.token, cookie = this.cookie, host = WORKBENCH_HOST) {
const tk = String(token || '').trim();
if (!tk) return { success: false, status: 0, message: '账号未保存登录 token', data: null };
const query = new URLSearchParams({ token: tk, dbname: '' });
const headers = { ...WORKBENCH_AJAX_HEADERS, referer: `https://${host}/` };
if (cookie) headers.cookie = cookie;
const res = await this.request(`https://${host}${AREAS_INFO_PATH}?${query.toString()}`, { method: 'GET', headers });
const success = res.status === 200 && !!res.json && res.json.Success === true;
return {
success,
status: res.status,
message: (res.json && res.json.Message) || '',
data: success && res.json.Data ? res.json.Data : null,
};
}
/**
* 拉取当前账号的商家列表(店管家的「商家」即 OMS 的店铺)。
* 返回统一结构,上层(控制器/前端)不直接依赖店管家字段。
* @param {Object} [options] 查询参数
* @param {number} [options.pageIndex] 页码,从 1 开始
* @param {number} [options.pageSize] 每页条数(最大 200)
* @param {string} [options.keyword] 关键词(商家名称/手机号)
* @return {Promise<{total: number, list: Array}>} 统一的店铺列表
*/
async listShops(options = {}) {
if (!this.token || !this.cookie) {
throw new Error('账号未登录:缺少 token 或 cookie,请先登录');
}
const pageIndex = Math.max(1, Number.parseInt(options.pageIndex, 10) || 1);
const pageSize = Math.min(200, Math.max(1, Number.parseInt(options.pageSize, 10) || 20));
const keyword = String(options.keyword || '');
// 商家列表接口需要 traceId 与 dbname,取不到时按空值请求
let traceId = '';
let dbName = '';
try {
const info = await this.getUserInfo();
traceId = (info.data && info.data.TraceId) || '';
const areas = await this.getAreasInfo();
dbName = (areas.data && areas.data.DbName) || '';
} catch {
// 忽略:上下文参数缺失不阻断列表查询
}
const query = new URLSearchParams({
token: this.token,
traceId,
dbname: dbName,
dataFlag: '',
key: keyword,
status: '0s',
pageIndex: String(pageIndex),
pageSize: String(pageSize),
IsCustomerOrder: 'false',
FxPageType: '1',
});
const headers = { ...WORKBENCH_AJAX_HEADERS };
if (this.cookie) headers.cookie = this.cookie;
const res = await this.request(`${AGENT_LIST_URL}?${query.toString()}`, { method: 'GET', headers });
if (res.status === 401) {
throw new Error(`店管家登录已失效:${(res.json && res.json.Message) || 'token is invalid'}`);
}
if (!res.json || res.json.Success !== true) {
const reason = (res.json && (res.json.Message || res.json.ErrorCode)) || `HTTP ${res.status}`;
throw new Error(`拉取店管家商家列表失败:${reason}`);
}
const data = res.json.Data || {};
const list = Array.isArray(data.List) ? data.List.map(item => this.normalizeShop(item)) : [];
return { total: Number(data.Total) || list.length, list };
}
/**
* 把店管家商家结构转换为统一的店铺结构(其他平台按同样结构返回即可)
* @param {Object} item 店管家商家原始结构
* @return {Object} 统一店铺结构
*/
normalizeShop(item) {
const data = item || {};
return {
external_id: String(data.Id == null ? '' : data.Id),
name: data.Remark || data.UserName || data.NickName || data.RemarkName || '',
contact_name: data.SenderName || data.Remark || '',
contact_phone: data.SenderMobile || data.Mobile || '',
status: Number(data.Status) === 0 ? 0 : 1,
remark: data.RemarkName || '',
raw: data,
};
}
/**
* 根据商家的分区信息确定要查询的商品域名。
* 商家在店管家的 DbAreas 里记录了所在分区(抖店/拼多多/精选/京东),
* 商品接口按分区域名部署;识别不出分区时兜底查询全部域名,避免漏商品。
* @param {Object} externalData 商家原始结构(shops.external_data)
* @return {string[]} 商品接口域名列表
*/
resolveProductHosts(externalData) {
const areas = Array.isArray(externalData && externalData.DbAreas) ? externalData.DbAreas : [];
const hosts = [];
for (const area of areas) {
const host = AREA_PRODUCT_HOSTS[String((area && area.DbName) || '').toLowerCase()];
if (host && !hosts.includes(host)) hosts.push(host);
}
return hosts.length ? hosts : FALLBACK_PRODUCT_HOSTS.slice();
}
/**
* 归纳商家的分区声明:每个平台域名下是否声明了「新系统分区 / 老分区」
*
* 商家结构里的 `DbAreas[]` 带 `IsNewSystem` 标志(如 toutiao 抖店-二区 true、toutiao 抖店 false),
* 平台页面的「所在区」就是它的 NickName。老分区只用来存放迁移前的历史单,
* 因此店铺没声明老分区时可以直接跳过该平台的老分区,不必每次都白拉一遍历史数据。
* @param {Object} externalData 商家原始结构(shops.external_data)
* @return {Object} host → { hasNew, hasLegacy }
*/
resolveAreaFlags(externalData) {
const areas = Array.isArray(externalData && externalData.DbAreas) ? externalData.DbAreas : [];
const flags = {};
for (const area of areas) {
const host = AREA_PRODUCT_HOSTS[String((area && area.DbName) || '').toLowerCase()];
if (!host) continue;
if (!flags[host]) flags[host] = { hasNew: false, hasLegacy: false };
if (area.IsNewSystem) flags[host].hasNew = true;
else flags[host].hasLegacy = true;
}
return flags;
}
/**
* 该分区是否支持「状态/商家」过滤(进程内缓存,避免每次同步都去撞一次「服务器繁忙」)
* @param {string} host 接口域名
* @param {string} dbname 分区库名
* @return {boolean|null} true=支持 false=不支持 null=未知
*/
filterSupported(host, dbname) {
const cached = AREA_FILTER_SUPPORT.get(`${host}|${dbname}`);
if (!cached) return null;
if (Date.now() - cached.at > AREA_FILTER_SUPPORT_TTL_MS) {
AREA_FILTER_SUPPORT.delete(`${host}|${dbname}`);
return null;
}
return cached.ok;
}
/**
* 记录分区是否支持「状态/商家」过滤
* @param {string} host 接口域名
* @param {string} dbname 分区库名
* @param {boolean} ok 是否支持
* @return {void} 无返回值
*/
rememberFilterSupport(host, dbname, ok) {
AREA_FILTER_SUPPORT.set(`${host}|${dbname}`, { ok, at: Date.now() });
}
/**
* 解析店铺需要拉取面单模板的目标(模板接口域名 + PlatformType + 分区库名)。
* 优先级:商家分区 DbAreas/DbArea 里的 DbName(如 pinduoduo)→ 展开该分区的全部库;
* 识别不出分区时按商品域名兜底,每个域名取一个代表 PlatformType。
* @param {Object} shop OMS 店铺记录(type=2,external_data 为商家原始结构)
* @return {Promise<Array<{host: string, platformType: string, dbname: string, areaName: string}>>} 目标列表
*/
async resolveTemplateTargets(shop) {
const data = (shop && shop.external_data) || {};
const areaRows = [
...(Array.isArray(data.DbAreas) ? data.DbAreas : []),
...(Array.isArray(data.DbArea) ? data.DbArea : []),
];
const presets = [];
for (const row of areaRows) {
const key = String((row && (row.DbName || row.Name)) || '').toLowerCase();
const preset = TEMPLATE_PLATFORMS[key];
if (!preset) continue;
if (!presets.some(item => item.host === preset.host && item.type === preset.type)) presets.push(preset);
}
if (!presets.length) {
for (const host of this.resolveProductHosts(data)) {
for (const type of TEMPLATE_HOST_TYPES[host] || []) {
if (!presets.some(item => item.host === host && item.type === type)) presets.push({ host, type });
}
}
}
const targets = [];
for (const preset of presets) {
const areas = await this.listProductAreas(preset.host);
for (const area of areas) {
targets.push({ host: preset.host, platformType: preset.type, dbname: area.dbname, areaName: area.name });
}
}
return targets;
}
/**
* 拉取一个平台域名 / 分区下的面单模板(快递接口)列表
* @param {string} host 模板接口域名
* @param {Object} options 查询参数
* @param {string} options.traceId 登录上下文 traceId
* @param {string} options.dbname 分区库名
* @param {string} options.platformType 店管家 PlatformType(如 Pinduoduo)
* @return {Promise<Array>} 平台原始模板列表
*/
async fetchTemplateList(host, { traceId, dbname, platformType }) {
const query = new URLSearchParams({
token: this.token,
traceId: traceId || '',
dbname: dbname || '',
dataFlag: '',
});
const form = new URLSearchParams({
platformType: platformType || '',
isDefault: 'false',
IsCustomerOrder: 'false',
FxPageType: '2',
});
const headers = {
accept: 'application/json, text/javascript, */*; q=0.01',
'accept-language': 'zh-CN,zh;q=0.9',
'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
referer: `https://${host}/NewOrder/WaitOrder`,
'user-agent': BROWSER_HEADERS['user-agent'],
'x-requested-with': 'XMLHttpRequest',
};
if (this.cookie) headers.cookie = this.cookie;
const res = await this.request(`https://${host}${TEMPLATE_LIST_PATH}?${query.toString()}`, {
method: 'POST',
headers,
body: form.toString(),
});
if (res.status === 401) {
throw new Error(`店管家登录已失效:${(res.json && res.json.Message) || 'token is invalid'}`);
}
if (!res.json || res.json.Success !== true) {
const reason = (res.json && (res.json.Message || res.json.ErrorCode)) || `HTTP ${res.status}`;
throw new Error(reason);
}
if (Array.isArray(res.json.Data)) return res.json.Data;
return Array.isArray(res.json.Data && res.json.Data.List) ? res.json.Data.List : [];
}
/**
* 把平台模板结构转换为统一结构(上层不直接依赖店管家字段)
* @param {Object} item 平台模板原始结构
* @param {Object} target 拉取目标(host / platformType / dbname)
* @return {Object} 统一模板结构
*/
normalizeExpressTemplate(item, target) {
const data = item || {};
// 平台归属优先取模板自身的 TemplateTypeShort(如小红书模板挂在抖店分区下,
// CloudPlatform / 分区 PlatformType 仍是 TouTiao),其次才用云端平台与分区类型兜底
const platformType = String(
data.TemplateTypeShort || data.CloudPlatform || data.PlatformType || target.platformType || ''
).trim();
const platform = resolveOrderPlatform(platformType);
return {
template_id: String(data.Id == null ? '' : data.Id),
template_name: truncate(data.TemplateName, 128),
platform_type: truncate(platformType, 32),
platform_code: platform.code,
platform_name: platform.name,
express_company_id: toNumber(data.ExpressCompanyId),
express_company_code: truncate(data.ExpressCompanyCode, 50),
express_company_name: truncate(data.ExpressCompanyName, 100),
shop_id: toNumber(data.ShopId),
shop_name: truncate(data.ShopName, 128),
dbname: truncate(target.dbname, 128),
// 菜鸟授权网点ID:同平台下不同授权网点取值不同,取号时随结果回给 WMS 便于分店/多网点归集
cai_niao_auth_info_id: toNumber(data.CaiNiaoAuthInfoId),
platform_updated_at: parseOrderTime(data.UpdateDate),
raw: data,
};
}
/**
* 拉取店铺关联的全部面单模板(快递接口):逐平台域名 / 分区查询后按模板ID去重。
* 单个分区失败不影响其它分区,错误随结果返回,供上层提示。
* @param {Object} shop OMS 店铺记录(type=2)
* @return {Promise<{list: Array, errors: Array<string>, targets: Array<string>}>} 模板列表与逐项错误
*/
async listExpressTemplates(shop) {
if (!this.token || !this.cookie) {
throw new Error('账号未登录:缺少 token 或 cookie,请先登录');
}
let traceId = '';
try {
const info = await this.getUserInfo();
traceId = (info.data && info.data.TraceId) || '';
} catch {
// 忽略:traceId 缺失不阻断模板查询
}
const targets = await this.resolveTemplateTargets(shop);
if (!targets.length) {
throw new Error('店铺缺少可识别的平台分区(DbAreas),无法确定快递接口所属平台');
}
const rows = new Map();
const errors = [];
const hitTargets = [];
for (const target of targets) {
const label = `${target.host} / ${target.platformType}${target.areaName ? `(${target.areaName})` : ''}`;
try {
const list = await this.fetchTemplateList(target.host, {
traceId,
dbname: target.dbname,
platformType: target.platformType,
});
for (const item of list) {
if (!item || !item.Id) continue;
// 平台标记为已删除的模板不落库:历史记录会在全量扫描后被标记失效
if (item.IsDeleted === true) continue;
rows.set(String(item.Id), this.normalizeExpressTemplate(item, target));
}
hitTargets.push(label);
} catch (err) {
errors.push(`${label}:${err.message}`);
}
}
return { list: [ ...rows.values() ], errors, targets: hitTargets };
}
/**
* 查看单个模板的电子面单账号 / 网点明细(平台单独接口)
* @param {Object} template 已落库的模板(template_id / platform_type / shop_id / dbname 等)
* @return {Promise<Object|null>} 平台返回的明细数据
*/
async fetchWaybillAccountDetail(template) {
const item = template || {};
const platformType = String(item.platform_type || '').trim();
const host = resolveTemplateHost(platformType);
if (!host) throw new Error(`暂不支持该平台类型的快递接口明细:${platformType || '-'}`);
let traceId = '';
try {
const info = await this.getUserInfo();
traceId = (info.data && info.data.TraceId) || '';
} catch {
// 忽略:traceId 缺失不阻断明细查询
}
const raw = item.raw && typeof item.raw === 'object' ? item.raw : {};
const query = new URLSearchParams({
token: this.token,
traceId,
dbname: item.dbname || '',
dataFlag: '',
});
const form = new URLSearchParams({
Id: String(item.template_id || ''),
TemplateId: String(item.template_id || ''),
ShopId: String(item.shop_id == null ? '' : item.shop_id),
ExpressCompanyId: String(item.express_company_id == null ? '' : item.express_company_id),
CaiNiaoAuthInfoId: String(raw.CaiNiaoAuthInfoId || (item.cai_niao_auth_info_id || '')),
platformType,
FxPageType: '2',
});
const headers = {
accept: 'application/json, text/javascript, */*; q=0.01',
'accept-language': 'zh-CN,zh;q=0.9',
'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
referer: `https://${host}/NewOrder/WaitOrder`,
'user-agent': BROWSER_HEADERS['user-agent'],
'x-requested-with': 'XMLHttpRequest',
};
if (this.cookie) headers.cookie = this.cookie;
const res = await this.request(`https://${host}${TEMPLATE_DETAIL_PATH}?${query.toString()}`, {
method: 'POST',
headers,
body: form.toString(),
});
if (res.status === 401) {
throw new Error(`店管家登录已失效:${(res.json && res.json.Message) || 'token is invalid'}`);
}
if (!res.json || res.json.Success !== true) {
const reason = (res.json && (res.json.Message || res.json.ErrorCode)) || `HTTP ${res.status}`;
throw new Error(reason);
}
return res.json.Data || null;
}
/**
* 组装商品列表查询表单(字段口径与店管家工作台一致)
* @param {string} agentId 商家 FxUserId(注意不是商家 Id);为空表示不限商家
* @param {number} pageIndex 页码,从 1 开始
* @param {number} pageSize 每页条数
* @param {Object} [filters] 单品查询条件
* @param {string} [filters.productId] 平台商品ID
* @param {string} [filters.skuId] 平台规格ID
* @return {URLSearchParams} 表单
*/
buildProductForm(agentId, pageIndex, pageSize, filters = {}) {
return new URLSearchParams({
PageIndex: String(pageIndex),
PageSize: String(pageSize),
SelectShopId: '',
SelectSupplierId: '',
SelectAgentId: agentId ? String(agentId) : '',
SelectPlatformType: '',
InputProductName: '',
ProductType: 'all',
ProductStatus: '0',
ProductCargoNumber: '',
ProductSkuName: '',
ProductShortTitle: '',
ProductSkuShortTitle: '',
IsSetShortTitle: '',
IsSetSkuShortTitle: '',
IsSetWeight: '',
IsSkuSetWeight: '',
ProductId: filters.productId || '',
SkuId: filters.skuId || '',
SkuCargoNumber: '',
IsDeleted: 'false',
IsRelationBaseProduct: '',
ActiveTimeDay: '-1',
StockCode: '',
IsExistStockCode: '',
IsCustomerOrder: 'false',
FxPageType: '1',
});
}
/**
* 列出某个域名下账号可访问的分区(区)。
* 同一域名可能存在多个物理库(如「精选平台四区」「新系统区」),dbname 为空表示默认区;
* 商品必须逐区查询,否则会漏掉其它区的商品。
* @param {string} host 商品接口域名
* @return {Promise<Array<{dbname: string, name: string}>>} 分区列表(含默认区)
*/
async listProductAreas(host) {
const areas = await this.getAreasInfo(this.token, this.cookie, host);
const data = areas.data || {};
const list = [];
const push = (dbname, name) => {
const value = String(dbname || '');
if (!value || list.some(item => item.dbname === value)) return;
list.push({ dbname: value, name: name || '' });
};
// 当前分区 + 其它分区;dbname 为空等价于当前分区,这里统一用显式库名查询
const names = new Map();
for (const area of data.DbArea || []) {
if (area && area.DbName) names.set(String(area.DbName), area.NickName || '');
}
push(data.DbName, names.get(String(data.DbName || '')) || '当前分区');
for (const area of data.DbArea || []) push(area && area.DbName, area && area.NickName);
return list.length ? list : [{ dbname: '', name: '默认区' }];
}
/**
* 拉取一页商品
* @param {string} host 商品接口域名
* @param {Object} options 查询参数
* @param {string} [options.agentId] 商家 FxUserId,为空表示不限商家
* @param {string} options.traceId 登录上下文 traceId
* @param {string} [options.dbname] 分区库名,为空表示默认区
* @param {string} [options.productId] 平台商品ID(单品查询)
* @param {string} [options.skuId] 平台规格ID(单品查询)
* @param {number} options.pageIndex 页码
* @param {number} options.pageSize 每页条数
* @return {Promise<{rows: Array, total: number}>} 当页商品与总数
*/
async fetchProductPage(host, { agentId, traceId, dbname, productId, skuId, pageIndex, pageSize }) {
const query = new URLSearchParams({
token: this.token,
traceId: traceId || '',
dbname: dbname || '',
dataFlag: '',
});
const headers = {
accept: 'application/json, text/javascript, */*; q=0.01',
'accept-language': 'zh-CN,zh;q=0.9',
'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
referer: `https://${host}/`,
'user-agent': BROWSER_HEADERS['user-agent'],
'x-requested-with': 'XMLHttpRequest',
};
if (this.cookie) headers.cookie = this.cookie;
const res = await this.request(`https://${host}${PRODUCT_LIST_PATH}?${query.toString()}`, {
method: 'POST',
headers,
body: this.buildProductForm(agentId, pageIndex, pageSize, { productId, skuId }).toString(),
});
if (res.status === 401) {
throw new Error(`店管家登录已失效:${(res.json && res.json.Message) || 'token is invalid'}`);
}
if (!res.json || res.json.Success !== true) {
const reason = (res.json && (res.json.Message || res.json.ErrorCode)) || `HTTP ${res.status}`;
throw new Error(`拉取店管家商品列表失败(${host}):${reason}`);
}
const data = res.json.Data || {};
return {
rows: Array.isArray(data.Rows) ? data.Rows : [],
total: Number(data.Total) || 0,
};
}
/**
* 拉取某个域名下单个分区的全量商品快照。
* 逐页拉取并校验「去重后的商品数 = Total」,不一致时重试一次,
* 避免平台在分页过程中新增/删除商品导致漏拉或重复。
* @param {string} host 商品接口域名
* @param {Object} options 查询参数
* @param {string} options.agentId 商家 FxUserId
* @param {string} options.traceId 登录上下文 traceId
* @param {string} [options.dbname] 分区库名,为空表示默认区
* @param {string} [options.name] 分区名称
* @return {Promise<Object>} 分区商品快照
*/
async fetchAreaSnapshot(host, { agentId, traceId, dbname, name }) {
const maxAttempts = 2;
let snapshot = null;
for (let attempt = 1; attempt <= maxAttempts; attempt++) {
const rows = [];
let total = 0;
let pages = 0;
// 上限 1000 页:防御平台分页异常(Total 与实际不符)时死循环
for (let pageIndex = 1; pageIndex <= 1000; pageIndex++) {
const page = await this.fetchProductPage(host, {
agentId,
traceId,
dbname,
pageIndex,
pageSize: PRODUCT_PAGE_SIZE,
});
pages++;
if (pages === 1) total = page.total;
rows.push(...page.rows);
if (!page.rows.length || rows.length >= total) break;
}
const unique = new Map();
for (const item of rows) {
const key = String((item && (item.Id != null ? item.Id : item.PlatformId)) || '');
if (key && !unique.has(key)) unique.set(key, item);
}
const candidate = {
host,
dbname: dbname || '',
name: name || '',
total,
uniqueCount: unique.size,
pages,
rows: Array.from(unique.values()),
verified: unique.size === total,
};
// 重试结果更差(例如瞬时返回空列表)时保留上一次快照,避免把商品误判为下架
if (!snapshot || candidate.verified || candidate.uniqueCount > snapshot.uniqueCount) {
snapshot = candidate;
}
if (snapshot.verified) break;
}
return snapshot;
}
/**
* 拉取某个域名下所有分区的商品快照并合并。
* 同一域名下可能有多个物理库(默认区 / 新系统区等),只查默认区会漏掉其它区的商品。
* @param {string} host 商品接口域名
* @param {Object} options 查询参数
* @param {string} options.agentId 商家 FxUserId
* @param {string} options.traceId 登录上下文 traceId
* @return {Promise<Object>} 域名商品快照(含各分区明细)
*/
async fetchProductSnapshot(host, { agentId, traceId }) {
const areas = await this.listProductAreas(host);
const snapshots = [];
for (const area of areas) {
snapshots.push(await this.fetchAreaSnapshot(host, {
agentId,
traceId,
dbname: area.dbname,
name: area.name,
}));
}
// 不同分区是独立库,正常不会重复;仍按商品ID去重,避免同一商品被写入两次
const rows = new Map();
for (const snapshot of snapshots) {
for (const item of snapshot.rows) {
const key = String((item && (item.Id != null ? item.Id : item.PlatformId)) || '');
if (key && !rows.has(key)) rows.set(key, item);
}
}
return {
host,
total: snapshots.reduce((sum, snapshot) => sum + snapshot.total, 0),
uniqueCount: rows.size,
pages: snapshots.reduce((sum, snapshot) => sum + snapshot.pages, 0),
rows: Array.from(rows.values()),
verified: snapshots.every(snapshot => snapshot.verified),
areas: snapshots.map(snapshot => ({
dbname: snapshot.dbname,
name: snapshot.name,
total: snapshot.total,
unique: snapshot.uniqueCount,
pages: snapshot.pages,
verified: snapshot.verified,
})),
};
}
/**
* 拉取店铺商品全量快照:商家可能同时经营多个平台,
* 按其分区逐个域名拉取后合并,按「平台类型 + 平台商品ID + 平台规格ID」去重。
* @param {Object} shop OMS 店铺记录(type=2,external_data 为商家原始结构)
* @return {Promise<{total: number, verified: boolean, hosts: Array, list: Array}>} 商品快照
*/
async listProducts(shop) {
if (!this.token || !this.cookie) {
throw new Error('账号未登录:缺少 token 或 cookie,请先登录');
}
const data = (shop && shop.external_data) || {};
const agentId = String(data.FxUserId || '').trim();
if (!agentId) throw new Error('店铺缺少商家 FxUserId,无法拉取平台商品');
const hosts = this.resolveProductHosts(data);
let traceId = '';
try {
const info = await this.getUserInfo();
traceId = (info.data && info.data.TraceId) || '';
} catch {
// 忽略:traceId 缺失不阻断商品查询
}
const snapshots = [];
for (const host of hosts) {
snapshots.push(await this.fetchProductSnapshot(host, { agentId, traceId }));
}
const merged = new Map();
for (const snapshot of snapshots) {
for (const item of snapshot.rows) {
for (const row of this.normalizeProduct(item)) {
merged.set(`${row.platform_type}|${row.outer_item_id}|${row.outer_sku_id}`, row);
}
}
}
return {
total: snapshots.reduce((sum, snapshot) => sum + snapshot.total, 0),
verified: snapshots.every(snapshot => snapshot.verified),
hosts: snapshots.map(snapshot => ({
host: snapshot.host,
total: snapshot.total,
unique: snapshot.uniqueCount,
pages: snapshot.pages,
verified: snapshot.verified,
areas: snapshot.areas,
})),
list: Array.from(merged.values()),
};
}
/**
* 按平台商品ID(可选规格ID)单独拉取商品,用于订单明细匹配不到店铺商品时按需补拉。
* 单品查询不传 SelectAgentId:商品可能属于同一账号下的其它商家,按商品ID更容易命中;
* 域名与分区按「店铺所属分区优先、其余域名兜底」的顺序逐个尝试,命中即停止。
* @param {Object} shop OMS 店铺记录(type=2,external_data 为商家原始结构)
* @param {Array<{outer_item_id: string, outer_sku_id?: string}>} items 待补拉的商品
* @return {Promise<{list: Array, missing: Array, hosts: Array}>} 命中的店铺商品行与未命中的商品
*/
async listProductsByIds(shop, items = []) {
if (!this.token || !this.cookie) {
throw new Error('账号未登录:缺少 token 或 cookie,请先登录');
}
const data = (shop && shop.external_data) || {};
const hosts = [];
for (const host of [ ...this.resolveProductHosts(data), ...FALLBACK_PRODUCT_HOSTS ]) {
if (!hosts.includes(host)) hosts.push(host);
}
let traceId = '';
try {
const info = await this.getUserInfo();
traceId = (info.data && info.data.TraceId) || '';
} catch {
// 忽略:traceId 缺失不阻断单品查询
}
const areaCache = new Map();
const list = [];
const missing = [];
const hitHosts = new Set();
for (const item of items) {
const productId = String((item && item.outer_item_id) || '').trim();
const skuId = String((item && item.outer_sku_id) || '').trim();
if (!productId) {
missing.push({ outer_item_id: productId, outer_sku_id: skuId, reason: '缺少平台商品ID' });
continue;
}
let matched = [];
for (const host of hosts) {
if (!areaCache.has(host)) areaCache.set(host, await this.listProductAreas(host));
for (const area of areaCache.get(host)) {
const page = await this.fetchProductPage(host, {
traceId,
dbname: area.dbname,
productId,
skuId,
pageIndex: 1,
pageSize: 20,
});
if (!page.rows.length) continue;
for (const product of page.rows) {
const rows = this.normalizeProduct(product);
// 带规格ID时只保留该规格(平台可能返回整个商品的全部规格)
const picked = skuId ? rows.filter(row => row.outer_sku_id === skuId) : rows;
matched = matched.concat(picked);
}
if (matched.length) {
hitHosts.add(`${host}(${area.name || area.dbname})`);
break;
}
}
if (matched.length) break;
}
if (matched.length) list.push(...matched);
else missing.push({ outer_item_id: productId, outer_sku_id: skuId, reason: '平台未查询到该商品' });
}
return { list, missing, hosts: Array.from(hitHosts) };
}
/**
* 把店管家商品(含 SKU 列表)转换为店铺商品行的统一结构。
* 平台商品ID取商品级 PlatformId;平台规格ID取 SKU 的 SpecId/SkuId
* (注意 SKU.PlatformId 是商品级平台ID,不能当作规格ID),缺失时退化为店管家内部ID。
* 原样保留商品与 SKU 结构供后续使用。
* @param {Object} product 店管家商品原始结构
* @return {Array<Object>} 店铺商品行(一个 SKU 一行)
*/
normalizeProduct(product) {
const data = product || {};
const skus = Array.isArray(data.Skus) && data.Skus.length ? data.Skus : [ null ];
const productRaw = { ...data };
delete productRaw.Skus;
const platformType = resolveOrderPlatform(data.PlatformType).code;
const externalShopId = data.ShopId == null ? '' : truncate(data.ShopId, 64);
const status = isProductOnSale(data.Status) ? 1 : 0;
return skus.map(sku => {
const item = sku || {};
const ptInfo = item.PtProductInfo || {};
const attrs = [ item.AttributeValue1, item.AttributeValue2 ].filter(Boolean).join(' ');
return {
outer_item_id: String(data.PlatformId || ptInfo.PrductId || data.Id || ''),
outer_sku_id: String(item.SpecId || item.SkuId || item.Id || ''),
title: truncate(data.Subject, 255),
outer_code: String(item.CargoNumber || item.SkuSelfCode || data.CargoNumber || data.ProductSelfCode || ''),
spec: truncate(item.Name || attrs, 255),
image: truncate(data.ImageUrl || item.ImgUrl, 255),
price: toNumber(item.SalePrice),
stock: Math.max(0, Math.trunc(toNumber(item.AvailableCount))),
status,
platform_type: platformType,
external_shop_id: externalShopId,
raw: { product: productRaw, sku: sku || null },
};
});
}
/**
* 拉取店铺订单(按「待发货 + 商家」过滤,只返回仍需本系统处理的未发货订单)。
*
* 查询策略:
* 1. 新系统分区支持 `ErpState == waitsellersend` 与 `UpFxUserId in <FxUserId>` 过滤,带上过滤后单量极小;
* 2. 老分区(旧系统库)对这两个过滤返回「服务器繁忙」,只能按时间窗全量拉,窗口封顶最近 N 天;
* 3. 分区是否支持过滤用 AREA_FILTER_SUPPORT 缓存(1 小时),避免每次都先撞一次「服务器繁忙」;
* 4. 商家分区声明(external_data.DbAreas[].IsNewSystem)里没有老分区时,跳过该平台的老分区,
* 那些是迁移前遗留数据,避免每次白拉一遍历史单。
* 拉回来的行仍做两步本地校验:按 UpFxUserId 归属店铺、丢弃平台侧已发货/已终结的订单。
* 被丢弃的订单会通过 finished 返回,供上层把本地仍处于待审核的副本作废。
* @param {Object} shop OMS 店铺记录(type=2,external_data 为商家原始结构)
* @param {Object} [options] 查询参数
* @param {Date|string} [options.startTime] 平台下单时间起(含)
* @param {Date|string} [options.endTime] 平台下单时间止(含)
* @return {Promise<{total: number, list: Array, hosts: Array, skipped: number, finished: Array, fallbackHosts: Array, skippedLegacy: Array}>} 订单列表
*/
async listOrders(shop, options = {}) {
if (!this.token || !this.cookie) {
throw new Error('账号未登录:缺少 token 或 cookie,请先登录');
}
const data = (shop && shop.external_data) || {};
const merchantFxUserId = String(data.FxUserId || '').trim();
if (!merchantFxUserId) throw new Error('店铺缺少商家 FxUserId,无法拉取平台订单');
const end = options.endTime ? new Date(options.endTime) : new Date();
const start = options.startTime
? new Date(options.startTime)
// 未指定时间窗时按平台「待发货订单」页的默认范围(15 天)兜底
: new Date(end.getTime() - 15 * 24 * 3600 * 1000);
const hosts = this.resolveProductHosts(data);
let traceId = '';
try {
const info = await this.getUserInfo();
traceId = (info.data && info.data.TraceId) || '';
} catch {
// 忽略:traceId 缺失不阻断订单查询
}
const orders = new Map();
const finished = new Map();
const hitHosts = [];
// 不支持状态/商家过滤的老分区(旧系统库):退化为只按时间窗拉全量,本地过滤
const fallbackHosts = [];
// 店铺没有声明该平台的老分区(只有新系统分区)时,该平台的老分区属于迁移前遗留数据,跳过不拉
const skippedLegacy = [];
const areaFlags = this.resolveAreaFlags(data);
for (const host of hosts) {
// 商家分区声明里没有该平台的记录时,按「新旧分区都要查」处理,宁可多查也不漏单
const flags = areaFlags[host] || { hasNew: true, hasLegacy: true };
const areas = await this.listProductAreas(host);
for (const area of areas) {
const areaLabel = `${host}(${area.name || area.dbname})`;
let fetched = null;
// 新系统分区支持「待发货 + 商家」过滤;已知不支持的老分区直接走下面的兜底分支
if (this.filterSupported(host, area.dbname) !== false) {
try {
fetched = await this.fetchOrderPages(host, {
traceId,
dbname: area.dbname,
startTime: start,
endTime: end,
erpState: ORDER_ERP_STATE_PENDING,
merchantFxUserId,
});
this.rememberFilterSupport(host, area.dbname, true);
} catch (err) {
if (!isFilterUnsupportedError(err)) throw err;
// 旧系统分区不支持 ErpState/UpFxUserId 过滤(平台返回「服务器繁忙」)
this.rememberFilterSupport(host, area.dbname, false);
fetched = null;
}
}
if (fetched === null) {
// 老分区:店铺没声明老分区时跳过(迁移前遗留数据,避免每次白拉一遍历史单)
if (!flags.hasLegacy) {
skippedLegacy.push(areaLabel);
continue;
}
fallbackHosts.push(areaLabel);
// 老分区只能全量拉:超大窗口(「全部待处理」)会翻很多页,统一封顶到最近 N 天
const fallbackStart = new Date(Math.max(
start.getTime(),
end.getTime() - Math.max(1, ORDER_FALLBACK_MAX_DAYS) * 24 * 3600 * 1000
));
fetched = await this.fetchOrderPages(host, {
traceId,
dbname: area.dbname,
startTime: fallbackStart,
endTime: end,
});
}
if (!fetched.length) continue;
hitHosts.push(`${host}(${area.name || area.dbname})`);
for (const row of fetched) {
// 订单列表按账号维度返回,这里只保留当前商家的订单
if (String(row.UpFxUserId || '') !== merchantFxUserId) continue;
const order = this.normalizeOrder(row);
if (!order.external_order_id) continue;
// 平台已发货/已终结:不进待审核,只登记给上层用于作废本地未处理的副本
// (带上命中的具体依据,作废备注里直接写明「平台订单状态 ErpState=sended」之类)
const finishedDetail = describeFinishedOrder(row);
if (finishedDetail.finished) {
finished.set(order.external_order_id, {
external_order_id: order.external_order_id,
platform_order_no: order.platform_order_no,
platform_status: order.platform_status,
place_order_time: order.external_created_at,
reason: finishedDetail.reason,
});
continue;
}
orders.set(order.external_order_id, order);
}
}
}
return {
total: orders.size,
list: Array.from(orders.values()),
hosts: hitHosts,
fallbackHosts,
skippedLegacy,
skipped: finished.size,
finished: Array.from(finished.values()),
// 供上层做「按订单号精确核对」时复用本次登录上下文
traceId,
};
}
/**
* 按系统编号批量回读订单行(只做只读核对,不做归属过滤)
*
* 平台支持 `Filters[0][Name]=LogicOrderId & Contract=in & Value=id1,id2` 一次命中多单(实测有效),
* 用于核对本地待审核订单在平台的最新状态(是否已发货/已终结/已不存在)。
* @param {string} host 接口域名
* @param {Object} options 查询参数
* @param {string} [options.traceId] 登录上下文 traceId
* @param {string} [options.dbname] 分区库名
* @param {Array<string>} options.ids 系统编号(LogicOrderId)列表
* @return {Promise<Array>} 订单原始结构列表
*/
async fetchOrdersByIds(host, { traceId, dbname, ids }) {
const list = (ids || []).map(value => String(value || '').trim()).filter(Boolean);
if (!list.length) return [];
if (!this.token || !this.cookie) {
throw new Error('账号未登录:缺少 token 或 cookie,请先登录');
}
const query = new URLSearchParams({
token: this.token,
traceId: traceId || '',
dbname: dbname || '',
dataFlag: '',
});
const form = new URLSearchParams();
const fields = {
TableAlias: 'o',
FieldType: 'string',
TableName: 'LogicOrder',
Name: 'LogicOrderId',
Value: list.join(','),
Contract: 'in',
};
for (const [ key, value ] of Object.entries(fields)) form.append(`Filters[0][${key}]`, value);
form.set('IsOrderDesc', 'true');
form.set('OrderByField', 'o.CreateTime');
form.set('IsPdd', 'false');
form.set('PageSize', String(Math.max(50, list.length)));
form.set('PageIndex', '1');
form.set('isFilterDangerChar', 'false');
form.set('TarType', '');
form.set('requestUrl', `https://${host}/NewOrder/WaitOrder`);
form.set('IsCustomerOrder', 'false');
form.set('FxPageType', '2');
const headers = {
accept: 'application/json, text/javascript, */*; q=0.01',
'accept-language': 'zh-CN,zh;q=0.9',
'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
referer: `https://${host}/NewOrder/WaitOrder`,
'user-agent': BROWSER_HEADERS['user-agent'],
'x-requested-with': 'XMLHttpRequest',
};
if (this.cookie) headers.cookie = this.cookie;
const res = await this.request(`https://${host}${ORDER_LIST_PATH}?${query.toString()}`, {
method: 'POST',
headers,
body: form.toString(),
});
if (res.status === 401) {
throw new Error(`店管家登录已失效:${(res.json && res.json.Message) || 'token is invalid'}`);
}
if (!res.json || res.json.Success !== true) {
const reason = (res.json && (res.json.Message || res.json.ErrorCode)) || `HTTP ${res.status}`;
throw new Error(`核对店管家订单失败(${host}):${reason}`);
}
const data = res.json.Data || {};
return Array.isArray(data.Rows) ? data.Rows : [];
}
/**
* 按分页拉取订单列表(不归属过滤,交由调用方按商家过滤)
* @param {string} host 接口域名
* @param {Object} options 查询参数
* @param {string} options.traceId 登录上下文 traceId
* @param {string} options.dbname 分区库名
* @param {Date} options.startTime 下单时间起
* @param {Date} options.endTime 下单时间止
* @param {string} [options.erpState] 订单状态过滤(如 waitsellersend;不传则不限状态)
* @param {string} [options.merchantFxUserId] 商家 FxUserId(按商家过滤,不传则整账号)
* @return {Promise<Array>} 订单原始结构列表
*/
async fetchOrderPages(host, { traceId, dbname, startTime, endTime, erpState, merchantFxUserId }) {
const rows = [];
// 平台不保证返回 PageCount(实测多为 null),因此以 Total 和「本页是否满页」判断结束,
// 只依赖 PageCount 会在超过 500 条时静默截断
let total = Infinity;
for (let pageIndex = 1; pageIndex <= ORDER_MAX_PAGES; pageIndex++) {
const page = await this.fetchOrderPage(host, {
traceId,
dbname,
startTime,
endTime,
pageIndex,
erpState,
merchantFxUserId,
});
if (!page.rows.length) break;
rows.push(...page.rows);
if (Number(page.total) > 0) total = Number(page.total);
if (rows.length >= total) break;
if (page.rows.length < ORDER_PAGE_SIZE) break;
}
return rows;
}
/**
* 拉取一页订单
* @param {string} host 接口域名
* @param {Object} options 查询参数
* @param {string} options.traceId 登录上下文 traceId
* @param {string} options.dbname 分区库名
* @param {Date} options.startTime 下单时间起
* @param {Date} options.endTime 下单时间止
* @param {number} options.pageIndex 页码
* @param {string} [options.erpState] 订单状态过滤(如 waitsellersend;不传则不限状态)
* @param {string} [options.merchantFxUserId] 商家 FxUserId(按商家过滤,不传则整账号)
* @return {Promise<{rows: Array, total: number, pageCount: number}>} 当页订单
*/
async fetchOrderPage(host, { traceId, dbname, startTime, endTime, pageIndex, erpState, merchantFxUserId }) {
const query = new URLSearchParams({
token: this.token,
traceId: traceId || '',
dbname: dbname || '',
dataFlag: '',
});
const form = new URLSearchParams();
const filters = [
{
TableAlias: 'o',
FieldType: 'DateTime',
TableName: 'LogicOrder',
Name: 'CreateTime',
Value: formatOrderTime(startTime),
ExtValue: formatOrderTime(endTime),
Contract: 'between',
},
];
// 状态过滤:与平台「待发货订单」页同口径(ErpState == waitsellersend)
if (erpState) {
filters.push({
TableAlias: 'o',
FieldType: 'string',
TableName: 'LogicOrder',
Name: 'ErpState',
Value: String(erpState),
Contract: '==',
});
}
// 商家过滤:平台按 PathFlowNode.UpFxUserId 过滤(实测有效,一次只回该商家的单)
if (merchantFxUserId) {
filters.push({
TableAlias: 'pfn',
FieldType: 'int',
TableName: 'PathFlowNode',
Name: 'UpFxUserId',
Value: String(merchantFxUserId),
Contract: 'in',
});
}
filters.forEach((fields, index) => {
for (const [ key, value ] of Object.entries(fields)) form.append(`Filters[${index}][${key}]`, value);
});
form.set('IsOrderDesc', 'true');
form.set('OrderByField', 'o.CreateTime');
form.set('IsPdd', 'false');
form.set('PageSize', String(ORDER_PAGE_SIZE));
form.set('PageIndex', String(pageIndex));
form.set('isFilterDangerChar', 'false');
form.set('TarType', '');
form.set('requestUrl', `https://${host}/NewOrder/WaitOrder`);
form.set('IsCustomerOrder', 'false');
form.set('FxPageType', '2');
const headers = {
accept: 'application/json, text/javascript, */*; q=0.01',
'accept-language': 'zh-CN,zh;q=0.9',
'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
referer: `https://${host}/NewOrder/WaitOrder`,
'user-agent': BROWSER_HEADERS['user-agent'],
'x-requested-with': 'XMLHttpRequest',
};
if (this.cookie) headers.cookie = this.cookie;
const res = await this.request(`https://${host}${ORDER_LIST_PATH}?${query.toString()}`, {
method: 'POST',
headers,
body: form.toString(),
});
if (res.status === 401) {
throw new Error(`店管家登录已失效:${(res.json && res.json.Message) || 'token is invalid'}`);
}
if (!res.json || res.json.Success !== true) {
const reason = (res.json && (res.json.Message || res.json.ErrorCode)) || `HTTP ${res.status}`;
throw new Error(`拉取店管家订单失败(${host}):${reason}`);
}
const data = res.json.Data || {};
return {
rows: Array.isArray(data.Rows) ? data.Rows : [],
total: Number(data.Total) || 0,
pageCount: Number(data.PageCount) || 1,
};
}
/**
* 把店管家订单结构转换为统一结构(明细保留平台商品快照,不在此处做系统商品匹配)
* @param {Object} row 店管家订单原始结构
* @return {Object} 统一订单结构
*/
normalizeOrder(row) {
const data = row || {};
const subOrders = Array.isArray(data.SubOrders) ? data.SubOrders : [];
// 店管家「系统编号」LogicOrderId 全局唯一,作为来源订单号与去重键;
// 「订单编号」PlatformOrderId 是平台单号,可能存在重复(如同一平台单被拆成多条逻辑单),不能作为唯一标识
const logicOrderId = String(data.LogicOrderId || '').trim();
const platformOrderId = String(data.PlatformOrderId || '').trim();
const externalOrderId = logicOrderId || platformOrderId;
// 平台类型转系统预设编码(PDD / DYXD / SPH…),订单表与推 WMS 都用这一套
const platform = resolveOrderPlatform(data.PlatformType);
const distributeChannel = this.resolveOrderDistributeChannel(data);
// 硬规则(分销代发业务口径):1688 单不按 1688 出号,统一换算成实际取号渠道
// - 抖音分销单(OutChannel=douyin)→ 抖音小店(DYXD)
// - 其它分销渠道(OutChannel=未知值)→ 其他(OTHER),原始报文与渠道留痕,等待后续映射
// - 非分销单(无 OutChannel 标签)→ 淘宝(TB)
// 否则按 1688 永远匹配不到面单模板,取号必失败
let platformCode = platform.code;
let platformName = platform.name;
if (platform.code === '1688') {
let targetCode = 'TB';
if (distributeChannel === 'douyin') targetCode = 'DYXD';
else if (distributeChannel) targetCode = 'OTHER';
const target = resolvePlatform(targetCode);
platformCode = target.code;
platformName = target.name;
}
return {
external_order_id: externalOrderId,
// 平台单号保留下来展示/查询用(与外部环境对账时需要)
platform_order_no: platformOrderId || null,
external_shop_id: data.ShopId == null ? '' : String(data.ShopId),
external_shop_name: truncate(data.ShopName || data.AgentShopName || data.SelfShopName, 128),
// 原始值仅作留痕;落库用 platform_code / platform_name
platform_type: truncate(data.PlatformType, 32),
platform_code: platformCode,
platform_name: platformName,
// 分销渠道与原始平台:换算后仍可追溯「这单其实是 1688 分销到哪个渠道的」
distribute_channel: distributeChannel || null,
original_platform_code: platform.code,
original_platform_name: platform.name,
platform_status: truncate(data.ErpState || data.Status, 32),
order_no: externalOrderId,
total_amount: toNumber(data.TotalAmount),
pay_amount: toNumber(data.SumTotalAmount || data.TotalAmount),
// 店管家对收件人脱敏(明文仅打印组件可取):这里保留可用的省市区与脱敏明细地址
receiver: {
name: data.ToName || '',
phone: data.ToPhone || '',
address: data.ToAddress || '',
full_address: data.ToFullAddress || '',
province: data.ToProvince || '',
city: data.ToCity || '',
area: data.ToCounty || '',
town: data.ToTown || '',
masked: !!(data.ToName && /\*/.test(String(data.ToName))) || !!(data.ToAddress && /\*/.test(String(data.ToAddress))),
},
remark: truncate(data.BuyerRemark || data.SellerRemark, 255),
external_created_at: parseOrderTime(data.CreateTime),
external_updated_at: parseOrderTime(data.UpdateTime),
raw: data,
items: subOrders.map(item => this.normalizeOrderItem(item)),
};
}
/**
* 取订单的分销渠道(Tags/OrderTags 里 `Tag=OutChannel` 的 `TagValue`)
*
* 1688 分销/代发采购单会带这个标签,值是对下游渠道的标识(实测 `douyin`、
* `chaoshibianli_plaintext`、`thyny_plaintext` 等)。分销单必须用下游渠道的电子面单,
* 所以「平台」要按下游渠道算,不能按 1688 算,否则取号永远匹配不到模板。
* @param {Object} data 店管家订单原始结构
* @return {string} 分销渠道标识(小写),无则空串
*/
resolveOrderDistributeChannel(data) {
const tags = [
...(Array.isArray(data && data.Tags) ? data.Tags : []),
...(Array.isArray(data && data.OrderTags) ? data.OrderTags : []),
];
for (const tag of tags) {
if (!tag || String(tag.Tag || '') !== 'OutChannel') continue;
const value = String(tag.TagValue || '').trim().toLowerCase();
if (value) return value;
}
return '';
}
/**
* 把店管家订单明细转换为统一结构:平台商品快照原样保留,
* 系统商品关联由上层按店铺商品绑定关系决定(未绑定时保持原样)
* @param {Object} item 店管家明细原始结构
* @return {Object} 统一明细结构
*/
normalizeOrderItem(item) {
const data = item || {};
const ptInfo = data.PtProductInfo || {};
const spec = data.Color || data.Size || ptInfo.PrductSpecs || '';
return {
external_item_id: data.OrderItemId == null ? '' : truncate(data.OrderItemId, 64),
outer_item_id: String(data.ProductID || ptInfo.PrductId || ''),
outer_sku_id: resolveOrderSkuId(data),
sku_code: truncate(data.CargoNumber || data.productCargoNumber || ptInfo.CargoNumber, 100),
name: truncate(data.ProductSubject || ptInfo.ProductSubject, 255),
spec: truncate(spec, 255),
image: truncate(data.ProductImgUrl || ptInfo.ProductImgUrl, 255),
quantity: toNumber(data.Count),
price: toNumber(data.Price),
total_amount: toNumber(data.ItemAmount),
// 店管家基准商品的关联状态(IsRelationBaseProduct=true 表示该明细已关联平台基础商品)
relation_base_product: !!data.IsRelationBaseProduct,
base_product: data.BaseProductInfo || null,
raw: data,
};
}
/**
* 登录:token + cookie 有效时直接复用;否则用账号密码登录,
* 成功后把 token 与 cookie 写回账号表,避免上下文丢失
* @return {Promise<{cookie: string, token: string|null, redirectUrl: string|null, reused: boolean}>} 登录结果
*/
async login() {
if (this.cookie && this.token) {
const status = await this.checkSession();
if (status.loggedIn) {
return { cookie: this.cookie, token: this.token, redirectUrl: null, reused: true, shopName: status.shopName || '' };
}
}
return this.loginByPassword();
}
/**
* 检查当前账号登录态:token/cookie 缺失视为未登录;
* 都有则打开工作台校验(未登录会被重定向回门户登录页)
* @return {Promise<{loggedIn: boolean, message: string, url: string}>} 登录态检查结果
*/
async checkSession() {
if (!this.token) {
await this.saveLoginStatus(0);
return { loggedIn: false, message: '账号未保存登录 token,尚未登录', url: USER_INFO_URL };
}
if (!this.cookie) {
await this.saveLoginStatus(0);
return { loggedIn: false, message: '账号未保存会话 cookie,尚未登录', url: USER_INFO_URL };
}
const info = await this.getUserInfo(this.token, this.cookie);
const loggedIn = info.success;
if (!loggedIn) await this.saveLoginStatus(0);
return {
loggedIn,
message: loggedIn ? '登录态有效' : `登录态已失效${info.message ? `(${info.message})` : ''}`,
url: USER_INFO_URL,
nickname: info.data ? info.data.FxUserNickName || info.data.NickName || '' : '',
shopName: info.data ? info.data.ShopName || '' : '',
};
}
/**
* 账号密码登录(两次 POST:BindWeChatPrompt → LoginPortal)
* @return {Promise<{cookie: string, token: string|null, redirectUrl: string|null, reused: boolean}>} 登录结果
*/
async loginByPassword() {
const { account, password } = this.getCredentials();
let cookie = await this.bootstrapSession();
const prompt = await this.postForm(BIND_WECHAT_PROMPT_URL, this.buildLoginForm(account, password, false), cookie);
cookie = mergeCookie(cookie, prompt.setCookies);
if (!this.isSuccess(prompt)) {
throw new Error(`店管家登录前置校验失败:${describeFailure(prompt)}`);
}
const result = await this.postForm(LOGIN_URL, this.buildLoginForm(account, password, true), cookie);
cookie = mergeCookie(cookie, result.setCookies);
const data = result.json && result.json.Data;
if (!this.isSuccess(result) || !data || !data.Token) {
throw new Error(`店管家登录失败:${describeFailure(result)}`);
}
// 用登录返回的 token + cookie 拉取账号信息,确认登录态真正可用后再落库
const info = await this.getUserInfo(data.Token, cookie);
if (!info.success) {
throw new Error(`店管家登录后校验失败:${info.message || '获取账号信息失败'}`);
}
await this.saveCookie(cookie);
await this.saveToken(data.Token);
return {
cookie,
token: data.Token,
redirectUrl: data.RedirectUrl || null,
reused: false,
shopName: info.data ? info.data.ShopName || '' : '',
};
}
/**
* 访问门户建立会话,拿到 WAF / ASP.NET 基础 cookie
* @return {Promise<string>} 新建的 cookie
*/
async bootstrapSession() {
const res = await fetch(PORTAL_URL, {
method: 'GET',
headers: BROWSER_HEADERS,
redirect: 'follow',
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
// 只需要响应头里的 set-cookie,正文丢弃
await res.arrayBuffer().catch(() => {});
return mergeCookie('', getSetCookies(res));
}
/**
* 组装登录表单(IsEnc=1:Mobile/Password 做 base64;LoginPortal 额外带空参数)
* @param {string} account 登录账号
* @param {string} password 登录密码
* @param {boolean} forPortal 是否为 LoginPortal 接口
* @return {URLSearchParams} 表单
*/
buildLoginForm(account, password, forPortal) {
const form = new URLSearchParams();
form.set('Mobile', encodeField(account));
form.set('Password', encodeField(password));
form.set('ValidCode', '');
form.set('IsEnc', '1');
form.set('NotUseAliyunCaptcha', 'true');
if (forPortal) {
form.set('ShopId', '');
form.set('From', '');
form.set('PlatformType', '');
}
return form;
}
/**
* 以浏览器 ajax 方式提交登录表单
* @param {string} url 接口地址
* @param {URLSearchParams} form 表单
* @param {string} cookie 会话 cookie
* @return {Promise<{status: number, json: Object|null, text: string, setCookies: string[]}>} 接口响应
*/
async postForm(url, form, cookie) {
const headers = { ...AJAX_HEADERS };
if (cookie) headers.cookie = cookie;
return this.request(url, {
method: 'POST',
headers,
body: form.toString(),
});
}
/**
* 接口是否返回 Success = true
* @param {{json: Object|null}} res 接口响应
* @return {boolean} 是否成功
*/
isSuccess(res) {
return !!(res && res.json && res.json.Success === true);
}
/**
* 把订单推送到店管家打印
* @param {Object} order 订单数据(字段口径由店管家协议决定)
* @return {Promise<Object>} 平台响应
*/
async print(order) {
throw new Error(`店管家未实现 print(),订单:${order && order.id}`);
}
/**
* 店管家取号(Old 系统 Dianguanjia.php#ExpressPrint 同口径)
*
* 流程:回读平台订单行 → 已发货/已终结拦截 →
* CheckTemplateAvaliable(模板/余额)→ ExpressPrint(取号 + 打印数据)。
*
* **不做「平台已有运单号就复用」的判断**:是否算重复调用只由幂等表
* (`openapi_request_idempotency`,按 request_id)决定;平台订单行上的 `LastWaybillCode`
* 只用于诊断(判断是否真换了号),不参与取号决策。
* ⚠️ ExpressPrint 会真实消耗面单:默认开启,需要「只读联调」时用 DGJ_WAYBILL_ENABLE=0 关闭。
* @param {Object} order OMS 订单(order_no / parent_order_no / oaid_order_source_code / place_order_time)
* @param {Object} options 取号上下文
* @param {Object} options.template 已绑定的快递接口记录(template_id / platform_type / dbname / raw)
* @param {number} [options.packageIndex] 包裹序号(0 基):>0 目前不支持,会直接报错(见下)
* @param {number} [options.packageCount] 包裹张数(默认 1):>1 时同一次请求取多张面单
* @return {Promise<{waybill_code: string, waybill_codes: string[], printinfo: string, signature: string, previous_code: string, raw: Object}>} 取号结果
*/
async fetchWaybillNo(order, options = {}) {
if (!this.token || !this.cookie) throw new Error('店管家账号未登录:缺少 token 或 cookie,请先登录');
const template = options.template || {};
const templateId = String(template.template_id || (template.raw && template.raw.Id) || '').trim();
if (!templateId) throw new Error('取号缺少面单模板ID:请先在「外部打单平台 → 快递接口」为编码绑定模板');
// 订单/取号走「订单域名」,与模板域名不同(视频号订单只在 fxali 能查到)。
// 1688 分销单在 OMS 里被换算成抖音小店/淘宝(为了选对模板),但订单行仍在 Alibaba 分区,
// 域名必须按「订单原始平台」算,否则回读订单行会查错域名
const originalCode = String(options.originalPlatformCode || '').trim();
const originalPlatformType = originalCode ? DgjService.resolvePlatformType(originalCode) : '';
const host = resolveOrderHost(originalPlatformType || template.platform_type);
const traceId = await this.resolveTraceId();
// 分区:模板记录的分区优先,订单不一定同区(模板按账号同步、店铺可能迁区),命中会改写
let dbname = String(template.dbname || '').trim();
const logicalOrderId = String(order.parent_order_no || String(order.order_no || '').replace(/^[^-]+-/, '')).trim();
const platformOrderId = String((order.extend_props && order.extend_props.platform_order_no) || order.oaid_order_source_code || '').trim();
if (!logicalOrderId) throw new Error('订单缺少店管家系统编号(parent_order_no),无法取号');
const placeOrderTime = order.place_order_time || order.pay_time || order.created_at;
let row = await this.findPlatformOrderRow(host, { traceId, dbname, logicalOrderId, platformOrderId, placeOrderTime });
if (!row) {
// 模板分区里查不到时逐个分区回读(取号要用平台的订单行,分区不对就会「未找到订单」)
let areas = [];
try {
areas = await this.listProductAreas(host);
} catch {
areas = [];
}
for (const area of areas) {
const candidate = String((area && area.dbname) || '').trim();
if (!candidate || candidate === dbname) continue;
try {
row = await this.findPlatformOrderRow(host, {
traceId, dbname: candidate, logicalOrderId, platformOrderId, placeOrderTime,
});
} catch {
row = null;
}
if (row) {
dbname = candidate;
break;
}
}
}
if (!row) throw new Error(`店管家未找到订单:系统编号 ${logicalOrderId}(域名 ${host},分区 ${dbname || '-'})`);
// 平台侧已发货/已终结:不能再取号,也不能把旧运单号当成取号成功(该单应作废/取消)
if (isOrderFinished(row)) {
const codeText = row.LastWaybillCode ? `,平台运单号 ${row.LastWaybillCode}` : '';
throw new Error(`订单在店管家已发货或已终结(ErpState=${row.ErpState || '-'}${codeText}),取号失败:请作废或取消该单,不要再发货`);
}
// 平台已取号但未发货:不再复用。重复调用是否要拦,由幂等表(request_id)负责;
// 这里只在结果里带上原来的号码,便于判断这次到底有没有换号。
const previousCode = String(row.LastWaybillCode || '').trim();
// 多包裹 / 子单:每次调用都走「新单号打印」,平台会分配一个新号,
// 所以 WMS 按包裹各调一次即可(packageIndex 无需下发给平台)。
if (!isWaybillEnabled()) {
throw new Error('店管家真实取号已关闭(DGJ_WAYBILL_ENABLE=0):当前只做只读校验,不会调用平台取号;需要真实取号请去掉该环境变量或置为 1');
}
const runPrint = async () => {
const check = await this.checkTemplateAvailable(host, { traceId, dbname, templateId, rows: [ row ] });
const balance = Number(check && check.Data && check.Data.Balance);
const needCount = Number(check && check.Data && check.Data.PrintCount);
if (Number.isFinite(balance) && Number.isFinite(needCount) && balance < needCount) {
throw new Error('店管家面单余额不足,请充值后再取号');
}
return await this.expressPrint(host, {
traceId,
dbname,
templateId,
rows: [ row ],
checkData: check && check.Data,
packageCount: Number(options.packageCount || 1),
expressCode: String(options.expressCode || '').trim(),
});
};
let printed;
try {
printed = await runPrint();
} catch (err) {
// 账号在别处重新登录会把这里的 token 顶掉(平台返回 401):重新登录后重试一次
if (!/登录已失效|登录信息过期/.test(String(err && err.message))) throw err;
await this.loginByPassword();
printed = await runPrint();
}
const items = Array.isArray(printed && printed.Data && printed.Data.WaybillCode) ? printed.Data.WaybillCode : [];
const errorItem = items.find(item => item && (item.IsError === true || Number(item.IsError) === 1));
if (errorItem) {
const reason = errorItem.ErrorMsg || errorItem.Message || (errorItem.OrderInfo && errorItem.OrderInfo.ErrorMsg) || '平台返回取号失败';
throw buildPlatformError(`店管家取号失败:${reason}`, { status: 200, json: printed, text: '' });
}
const waybillCodes = extractWaybillCodes(items);
if (!waybillCodes.length) {
throw buildPlatformError('店管家未返回运单号:请检查模板与订单状态,或查看原始响应', { status: 200, json: printed, text: '' });
}
const document = firstPrintDocument(printed, waybillCodes[0]);
const contents = extractDocumentContents(document);
return {
waybill_code: waybillCodes[0],
waybill_codes: waybillCodes,
// 打印记录ID(平台 PrintHistoryIds):重打/作废/查打印记录时平台按它回捞,仅本地留痕
print_history_ids: extractPrintHistoryIds(printed),
// 实际命中的分区库名:重取打印数据(PrintHistory/LoadPrintData)要带上同一个 dbname
dbname,
// 实际命中的订单域名:重取打印数据要发到同一个域名
host,
// 面单打印数据:原样透传(WMS 打印端直接塞进 task.printInfo)
printinfo: firstPrintInfo(items, printed, waybillCodes[0]),
signature: contents.signature,
encryptprintinfo: contents.encryptprintinfo,
ver: contents.ver,
// 取号前后对比用的旧号码(不参与判断,只用于提示「平台仍返回原运单号」)
previous_code: previousCode,
raw: printed,
};
}
/**
* 按系统编号 / 平台单号回读店管家订单行(取号请求需要完整的订单结构)
*
* 优先按字段精确过滤(实测 `LogicOrderId` 可直接命中),失败时按订单创建时间窗扫描
* (`NewOrder/List` 的 Filters 依赖平台内部查询实现,时间窗是更稳的兜底)。
* @param {string} host 订单接口域名
* @param {Object} options 查询参数
* @param {string} options.traceId 登录上下文 traceId
* @param {string} options.dbname 分区库名
* @param {string} options.logicalOrderId 店管家系统编号
* @param {string} [options.platformOrderId] 店管家订单编号
* @param {Date|string} [options.placeOrderTime] 订单下单时间(兜底扫描的时间窗基准)
* @return {Promise<Object|null>} 订单行,未找到为 null
*/
async findPlatformOrderRow(host, { traceId, dbname, logicalOrderId, platformOrderId, placeOrderTime }) {
const candidates = [];
if (logicalOrderId) candidates.push([ 'LogicOrderId', logicalOrderId, false ]);
if (platformOrderId && platformOrderId !== logicalOrderId) candidates.push([ 'PlatformOrderId', platformOrderId, true ]);
for (const [ field, value, customQuery ] of candidates) {
const rows = await this.fetchOrderRows(host, { traceId, dbname, field, value, customQuery });
if (!rows.length) continue;
const hit = rows.find(row => String(row.LogicOrderId || '') === String(logicalOrderId)) || rows[0];
return hit;
}
// 兜底:按下单时间窗口扫描(±2 天),再按系统编号匹配
const base = placeOrderTime ? new Date(placeOrderTime) : new Date();
if (Number.isNaN(base.getTime())) return null;
const startTime = new Date(base.getTime() - 2 * 24 * 3600 * 1000);
const endTime = new Date(base.getTime() + 2 * 24 * 3600 * 1000);
const rows = await this.fetchOrderPages(host, { traceId, dbname, startTime, endTime });
return rows.find(row => String(row.LogicOrderId || '') === String(logicalOrderId)) || null;
}
/**
* 按单个字段精确过滤订单列表
* @param {string} host 平台域名
* @param {Object} options 查询参数
* @param {string} options.traceId 登录上下文 traceId
* @param {string} options.dbname 分区库名
* @param {string} options.field 过滤字段(LogicOrderId / PlatformOrderId)
* @param {string} options.value 过滤值
* @param {boolean} [options.customQuery] 是否附加平台自定义查询(PlatformOrderId 需要)
* @return {Promise<Array>} 订单行
*/
async fetchOrderRows(host, { traceId, dbname, field, value, customQuery = false }) {
const query = new URLSearchParams({
token: this.token,
traceId: traceId || '',
dbname: dbname || '',
dataFlag: '',
});
const form = new URLSearchParams();
form.append('Filters[0][TableAlias]', 'o');
form.append('Filters[0][FieldType]', 'string');
form.append('Filters[0][TableName]', 'LogicOrder');
form.append('Filters[0][Name]', field);
form.append('Filters[0][Value]', String(value));
form.append('Filters[0][Contract]', 'in');
if (customQuery) form.append('Filters[0][CustomQuery]', 'PlatformOrderIdSearch');
form.set('IsOrderDesc', 'true');
form.set('OrderByField', 'o.CreateTime');
form.set('IsPdd', 'false');
form.set('PageSize', '20');
form.set('PageIndex', '1');
form.set('isFilterDangerChar', 'false');
form.set('TarType', '');
form.set('requestUrl', `https://${host}/NewOrder/WaitOrder`);
form.set('IsCustomerOrder', 'false');
form.set('FxPageType', '2');
const headers = {
accept: 'application/json, text/javascript, */*; q=0.01',
'accept-language': 'zh-CN,zh;q=0.9',
'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
referer: `https://${host}/NewOrder/WaitOrder`,
'user-agent': BROWSER_HEADERS['user-agent'],
'x-requested-with': 'XMLHttpRequest',
};
if (this.cookie) headers.cookie = this.cookie;
const res = await this.request(`https://${host}${ORDER_LIST_PATH}?${query.toString()}`, {
method: 'POST',
headers,
body: form.toString(),
});
if (res.status === 401) {
throw new Error(`店管家登录已失效:${(res.json && res.json.Message) || 'token is invalid'}`);
}
if (!res.json || res.json.Success !== true) {
const reason = (res.json && (res.json.Message || res.json.ErrorCode)) || `HTTP ${res.status}`;
throw new Error(`查询店管家订单失败:${reason}`);
}
const data = res.json.Data || {};
return Array.isArray(data.Rows) ? data.Rows : [];
}
/**
* 取登录上下文 traceId(实例级缓存)
*
* `getUserInfo` 也是一次平台请求,批量取号/重打时逐单调用会把请求量翻几倍,
* 容易被平台判成高频访问;同一实例内缓存 5 分钟足够(traceId 只用于串联日志)。
* @param {Object} [options] 参数
* @param {number} [options.ttlMs] 缓存时长(毫秒)
* @return {Promise<string>} traceId,取不到为空串
*/
async resolveTraceId({ ttlMs = 5 * 60 * 1000 } = {}) {
const now = Date.now();
if (this._traceCache && now - this._traceCache.at < ttlMs) return this._traceCache.value;
let value = '';
try {
const info = await this.getUserInfo();
value = (info.data && info.data.TraceId) || '';
} catch {
value = '';
}
this._traceCache = { value, at: now };
return value;
}
/**
* 取号前校验模板可用性与面单余额(只读,与旧系统 TemplateSet/CheckTemplateAvaliable 同口径)
* @param {string} host 平台域名
* @param {Object} options 参数
* @param {string} options.traceId 登录上下文 traceId
* @param {string} options.dbname 分区库名
* @param {string} options.templateId 面单模板ID
* @param {Array} options.rows 平台订单行
* @return {Promise<Object>} 平台响应(Data.DateNow / DayPrintBatchNumber / Branches / Balance / PrintCount)
*/
async checkTemplateAvailable(host, { traceId, dbname, templateId, rows }) {
const items = (rows || []).map(row => ({
SourceShopId: row.ShopId,
UpFxUserId: row.FxUserId,
SourceFxUserId: row.FxUserId,
LogicOrderId: row.LogicOrderId,
PlatformOrderId: row.LogicOrderId,
IsAllowNegativeStock: 'false',
SendType: row.SendState,
DataFlag: row.IsCold,
Items: (Array.isArray(row.SubOrders) ? row.SubOrders : []).map(sub => ({
OrderItemCode: sub.OrderItemCode,
LogicOrderItemId: sub.OrderItemId,
Quantity: '1',
})),
}));
const form = buildPhpForm({
templateId: String(templateId),
printCount: String(items.length),
needCheck: 'true',
orders: items,
isResend: '',
pirntMethod: 'Normal',
IsContinueForStock: 'false',
IsCustomerOrder: 'false',
FxPageType: '2',
});
const res = await this.postPlatformForm(host, TEMPLATE_AVAILABLE_PATH, form, traceId, dbname);
if (!res.json || res.json.Success !== true) {
const reason = (res.json && (res.json.Message || res.json.ErrorCode)) || `HTTP ${res.status}`;
// 附带平台原始返回,便于取号记录留痕与排错
throw buildPlatformError(`店管家模板校验失败:${reason}`, res);
}
return res.json;
}
/**
* 取号(同时返回打印数据):**真实消耗面单**,仅供 fetchWaybillNo 在开关打开后调用
* @param {string} host 平台域名
* @param {Object} options 参数
* @param {string} options.traceId 登录上下文 traceId
* @param {string} options.dbname 分区库名
* @param {string} options.templateId 面单模板ID
* @param {Array} options.rows 平台订单行
* @param {Object} [options.checkData] CheckTemplateAvaliable 返回的 Data(DateNow / DayPrintBatchNumber / Branches)
* @param {number} [options.packageCount] 包裹张数(默认 1):>1 时把同一订单行重复 N 份
* @param {string} [options.expressCode] 快递编码(仅用于回传 WaybillCodes 时补 ExpressCpCode)
* @param {boolean} [options.reuseWaybill] 复用平台已有运单号、只拉取打印数据(不分配新面单);拉 params 时用
* @return {Promise<Object>} 平台响应(Data.WaybillCode[] 含运单号与打印数据)
*/
async expressPrint(host, { traceId, dbname, templateId, rows, checkData, packageCount = 1, expressCode = '', reuseWaybill = false }) {
const data = checkData || {};
const repeat = Number.isFinite(Number(packageCount)) && Number(packageCount) > 1 ? Math.floor(Number(packageCount)) : 1;
const currentWaybillCode = (() => {
const row = (rows || [])[0] || {};
const list = Array.isArray(row.WaybillCodes) ? row.WaybillCodes.filter(item => item && item.WaybillCode) : [];
return String(row.LastWaybillCode || (list[list.length - 1] || {}).WaybillCode || '').trim();
})();
const branches = Array.isArray(data.Branches) ? data.Branches.map(branch => {
const copy = { ...branch };
for (const key of Object.keys(copy)) {
if (copy[key] === null) copy[key] = '';
else if (copy[key] === false) copy[key] = 'false';
else if (copy[key] === true) copy[key] = 'true';
}
return copy;
}) : '';
// 多包裹:同一订单行重复 N 份,Index 依次 1..N(平台按包裹各分配一个运单号)
const sourceRows = [];
for (let i = 0; i < repeat; i += 1) sourceRows.push(...(rows || []));
const orders = sourceRows.map((row, index) => {
const items = [];
const orderItems = [];
for (const sub of Array.isArray(row.SubOrders) ? row.SubOrders : []) {
items.push({
OrderItemId: sub.OrderItemId,
OrderItemCode: sub.OrderItemCode,
Quantity: '1',
ShortTitle: sub.ShortTitle,
SkuCode: sub.SkuCode,
ProductCode: sub.ProductCode,
});
orderItems.push(sub.OrderItemId);
}
return {
WaybillCodeId: '',
Index: index + 1,
Id: row.Id,
IdStr: row.Id,
PlatformOrderId: row.LogicOrderId,
LogicOrderId: row.LogicOrderId,
PathFlowCode: row.PathFlowCode,
CustomerOrderId: row.PlatformOrderId,
ShopId: row.ShopId,
// 与平台前端一致:PrintInfo 传 `[1];\n`(第 1 份)
PrintInfo: '[1];\n',
OrderItems: orderItems,
Items: items,
OrderItemStrList: orderItems,
// 新单号打印:把当前号(含 Pid/WaybillCodeId)带给平台,平台据此分配下一个号
WaybillCode: currentWaybillCode,
WaybillCodes: buildWaybillCodesBlock(row, templateId, expressCode),
NewSellerRemark: '',
PrintRemark: '',
NewPrintRemark: '',
SellerRemark: row.SellerRemark,
BuyerRemark: row.BuyerRemark,
FxUserId: row.FxUserId,
IsSelectAllNotPrintedItem: '1',
SendType: '0',
DataFlag: row.IsCold,
Receiver: {
toFullName: row.ToName,
toMobile: row.ToPhone,
toArea: row.ToFullAddress,
toProvince: row.ToProvince,
toCity: row.ToCity,
toCounty: row.ToCounty,
toMaskAddress: `${row.ToTown || ''}${row.ToAddress || ''}`,
},
Sender: { CompanyName: '' },
Buyer: { BuyerWangWang: row.ToName },
};
});
const form = buildPhpForm({
TemplateId: String(templateId),
PackageCount: String(repeat),
PackageDesc: '',
GoodsDesc: '',
// 「复用已有运单号」拉取打印数据:PrintMethod=Normal + IsIgnoreWaybillRepeat=true,
// 平台不再分配新面单,只把打印数据(抖店是 params)重新下发
PrintMethod: reuseWaybill ? 'Normal' : 'NewPrint',
IsIgnoreWaybillRepeat: reuseWaybill ? 'true' : 'false',
PrinterName: '默认打印机',
IsPreview: 'false',
IsContinueForStock: 'false',
PackageLength: '',
PackageWidth: '',
PackageHeight: '',
PackageType: '1',
ExpressSustenance: { name: '', desc: '' },
Branches: Array.isArray(branches) ? branches : '',
Orders: orders,
RequestBatchNumber: `1/1/${data.DateNow || ''}${data.DayPrintBatchNumber || ''}`,
IsCustomerOrder: 'false',
FxPageType: '2',
});
const res = await this.postPlatformForm(host, EXPRESS_PRINT_PATH, form, traceId, dbname);
if (!res.json || res.json.Success !== true) {
const reason = (res.json && (res.json.Message || res.json.ErrorCode)) || `HTTP ${res.status}`;
// 附带平台原始返回(含 PrintInfo / WaybillCode 等),便于取号记录留痕与排错
throw buildPlatformError(`店管家取号请求失败:${reason}`, res);
}
return res.json;
}
/**
* 拉取面单打印参数(抖店等需要 `params` 的平台;复用已有运单号,**不分配新面单**)
*
* 背景:抖店面单打印走的是一串带签名的 `params`
* (`access_token=…&method=logistics.getShopKey&timestamp=…&sign=…`),**10 分钟过期**;
* 而 `PrintHistory/LoadPrintData` 只回放历史签名(实测不重签),拿不到新鲜串。
* 平台侧唯一能重新下发的入口是 `ExpressPrint`:
* `PrintMethod=Normal + IsIgnoreWaybillRepeat=true` → 复用订单已有运单号、只重新下发打印数据。
* 注意:这不是「重打」,只是把打印数据(params)重新取一次;真正的打印在打印端做。
* @param {string} host 平台域名
* @param {Object} options 参数
* @param {string} options.traceId 登录上下文 traceId
* @param {string} options.dbname 分区库名
* @param {string} options.templateId 面单模板ID
* @param {Object} options.row 平台订单行(findPlatformOrderRow 的返回)
* @param {string} [options.expressCode] 快递编码
* @return {Promise<{waybill_codes: string[], documents: Array<{documentID: string, params: string, template_url: string}>, raw: Object}>} 打印数据
*/
async fetchPrintParams(host, { traceId = '', dbname = '', templateId, row, expressCode = '' }) {
if (!row) throw new Error('拉取打印参数需要平台订单行');
const printed = await this.expressPrint(host, {
traceId,
dbname,
templateId,
rows: [ row ],
checkData: {},
expressCode,
reuseWaybill: true,
});
const errorItem = (Array.isArray(printed && printed.Data && printed.Data.WaybillCode) ? printed.Data.WaybillCode : [])
.find(item => item && (item.IsError === true || Number(item.IsError) === 1));
if (errorItem) {
const reason = errorItem.ErrMsg || errorItem.ErrorMsg || '平台返回失败';
throw buildPlatformError(`店管家拉取打印参数失败:${reason}`, { status: 200, json: printed, text: '' });
}
const documents = [];
const docs = printed && printed.Data && printed.Data.PrintDataList && printed.Data.PrintDataList.task &&
printed.Data.PrintDataList.task.documents;
for (const doc of Array.isArray(docs) ? docs : []) {
const contents = Array.isArray(doc && doc.contents) ? doc.contents : [];
const content = contents.find(item => item && String(item.params || '').trim()) || contents[0] || {};
documents.push({
documentID: String((doc && doc.documentID) || ''),
params: String(content.params || ''),
template_url: String(content.templateURL || ''),
});
}
return {
waybill_codes: extractWaybillCodes(printed.Data && printed.Data.WaybillCode),
documents,
raw: printed,
};
}
/**
* 按打印记录重新拉取面单打印数据(只读,不消耗面单)
*
* 取号返回的打印数据(params)**只有 10 分钟有效期**,WMS 真正打印前要再用一次本接口换新的;
* 平台入参为打印记录ID(`PrintHistoryIds[].Id`)数组 + 分区 dbname。
* @param {string} host 平台域名
* @param {Object} options 参数
* @param {string} options.traceId 登录上下文 traceId
* @param {string} options.dbname 分区库名(取号时命中的那个)
* @param {Array<string|number>} options.printHistoryIds 打印记录ID数组
* @return {Promise<Array<{print_history_id: string, waybill_code: string, template_id: string, print_data: string, raw: Object}>>} 打印数据
*/
async loadPrintData(host, { traceId = '', dbname = '', printHistoryIds = [] }) {
const ids = (printHistoryIds || [])
.map(value => String(value == null ? '' : value).trim())
.filter(Boolean);
if (!ids.length) throw new Error('重新获取打印数据需要打印记录ID(printHistoryIds)');
if (!this.token || !this.cookie) {
throw new Error('店管家账号未登录:缺少 token 或 cookie,请先登录');
}
const form = buildPhpForm({
printHistoryIds: ids,
IsCustomerOrder: 'false',
FxPageType: '1',
});
const res = await this.postPlatformForm(host, PRINT_HISTORY_DATA_PATH, form, traceId, dbname);
if (!res.json || res.json.Success !== true) {
const reason = (res.json && (res.json.Message || res.json.ErrorCode)) || `HTTP ${res.status}`;
throw buildPlatformError(`店管家读取打印记录失败:${reason}`, res);
}
const rows = Array.isArray(res.json.Data) ? res.json.Data : [];
return rows.map(row => ({
print_history_id: String(row && row.ID == null ? '' : row.ID),
waybill_code: String((row && row.ExpressWaybillCode) || ''),
template_id: row && row.TemplateId == null ? '' : String(row.TemplateId),
// 平台原样返回的打印数据(params):WMS 打印端直接使用
print_data: String((row && row.PrintDataJson) || ''),
raw: row,
}));
}
/**
* 通知平台发货(对齐平台「待打订单 → 发货」的 `POST /NewOrder/OnlineSend`,2026-11-07 抓包)
*
* WMS 回传 `deliveryorder.confirm`、OMS 流转到「配送」后,需要把发货结果同步回店管家,
* 平台才会把订单状态推进为「已发货」。走**订单域名**(`fxali` / `fxdd` / `fxpdd` / `fxjd`)。
* @param {string} host 订单接口域名
* @param {Object} options 参数
* @param {string} options.traceId 登录上下文 traceId
* @param {string} options.dbname 分区库名
* @param {Array} options.rows 平台订单行(含 SubOrders / LastWaybillCode / WaybillCodes / ShippingType)
* @param {string} [options.templateId] 面单模板ID(平台页面会带上,缺了会被判「请先勾选要发货的订单」)
* @param {string|number} [options.expressCompanyId] 快递公司ID(同模板记录)
* @param {string} [options.expressCode] 快递编码兜底
* @return {Promise<Object>} 平台响应
*/
async sendOrders(host, { traceId, dbname, rows, templateId = '', expressCompanyId = '', expressCode = '' }) {
const orders = (rows || []).map((row, index) => buildSendOrder(row, index, expressCode));
const now = new Date();
const pad = value => String(value).padStart(2, '0');
const batchNo = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}${pad(now.getHours())}${pad(now.getMinutes())}` +
String(Date.now()).slice(-9) + Math.floor(Math.random() * 100000);
// 顶层参数按平台「待打订单 → 发货」实际请求对齐(2026-11-07 抓包):
// 少了 TemplateId / ExpressCompanyId 时平台会回「请先勾选要发货的订单」
const form = buildPhpForm({
Orders: orders,
TemplateId: String(templateId || (rows && rows[0] && rows[0].LastExpressPrintTemplateId) || ''),
ExpressCompanyId: String(expressCompanyId || ''),
ExcludeOrders: { productItemCount: 0, productCount: 0 },
NoLogisticsInfoModel: '',
IsSendPreCheck: 'true',
IsContinueForStock: 'false',
RequestBatchNumber: `1/1/${batchNo}`,
IsCustomerOrder: 'false',
FxPageType: '2',
});
const res = await this.postPlatformForm(host, ONLINE_SEND_PATH, form, traceId, dbname);
if (res.status === 401) {
throw buildPlatformError(`店管家登录已失效:${(res.json && res.json.Message) || 'token is invalid'}`, res);
}
if (!res.json || res.json.Success !== true) {
const json = res.json || {};
const hints = [];
if (json.ErrorCode !== undefined && json.ErrorCode !== null && String(json.ErrorCode) !== '') {
hints.push(`ErrorCode=${json.ErrorCode}`);
}
hints.push(...describeSendErrors(json));
// 平台对「这一单还没运单号」只回一句「请先…」,补一句本地判断,避免只看到半句话
const missingWaybill = orders.filter(item => !String(item.WaybillCode || '').trim()).length;
if (missingWaybill) {
hints.push(`其中 ${missingWaybill} 单在店管家还没有运单号(可能未取号/未打印面单)`);
}
const reason = [
json.Message || `HTTP ${res.status}`,
...hints,
].filter(Boolean).join(';');
// 「请先勾选要发货的订单」= 平台没把提交的 Orders 当成有效选中项,
// 属于报文口径问题(不是业务状态问题),补一句指向文档的提示便于排查
const notSelected = /勾选/.test(String(json.Message || ''));
throw buildPlatformError(
`店管家发货同步失败:${reason}${notSelected ? '(平台未识别提交的订单报文,需核对 OnlineSendBatch 报文口径)' : ''}`,
res
);
}
// 平台是「整包 Success + 逐单结果」:逐单失败要单独判,否则会把没发成功的单标成已同步。
// 例外:单子已经是已发货状态(平台早于我们手工/别处发货)视为幂等成功。
const failed = extractSendOrderFailures(res.json);
const realFailures = failed.filter(item => !/不是待发货状态|已发货|已取消|已关闭/.test(item.message));
if (realFailures.length) {
throw buildPlatformError(
`店管家发货同步失败:${realFailures.map(item => `${item.logicOrderId}: ${item.message}`).join(';')}`,
res
);
}
if (failed.length && this.logger && typeof this.logger.info === 'function') {
for (const item of failed) {
this.logger.info('[dgj.sendOrders] 平台侧该单无需再发货:%s %s', item.logicOrderId, item.message);
}
}
return res.json;
}
/**
* 统一提交平台表单(token/traceId/dbname 走 query,表单走 body)
* @param {string} host 平台域名
* @param {string} path 接口路径
* @param {URLSearchParams} form 表单
* @param {string} traceId 登录上下文 traceId
* @param {string} dbname 分区库名
* @return {Promise<{status: number, json: Object|null, text: string}>} 响应
*/
async postPlatformForm(host, path, form, traceId, dbname) {
const query = new URLSearchParams({
token: this.token,
traceId: traceId || '',
dbname: dbname || '',
dataFlag: '',
});
const headers = {
accept: 'application/json, text/javascript, */*; q=0.01',
'accept-language': 'zh-CN,zh;q=0.9',
'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
referer: `https://${host}/NewOrder/WaitOrder`,
'user-agent': BROWSER_HEADERS['user-agent'],
'x-requested-with': 'XMLHttpRequest',
};
if (this.cookie) headers.cookie = this.cookie;
const res = await this.request(`https://${host}${path}?${query.toString()}`, {
method: 'POST',
headers,
body: form.toString(),
});
if (res.status === 401) {
throw new Error(`店管家登录已失效:${(res.json && res.json.Message) || 'token is invalid'}`);
}
return res;
}
/**
* 订单是否已在平台侧发货或已终结(供脚本/上层按落库的平台原始结构复用同一口径)
* @param {Object} row 店管家订单原始结构
* @return {boolean} 是否已发货/已终结
*/
static isOrderFinished(row) {
return isOrderFinished(row);
}
/**
* 店管家 PlatformType 转系统预设平台(供脚本迁移历史数据复用同一口径)
* @param {string} platformType 店管家 PlatformType
* @return {{code: string, name: string}} 预设平台
*/
static resolveOrderPlatform(platformType) {
return resolveOrderPlatform(platformType);
}
/**
* 判定平台订单是否已发货/已终结,并给出可读依据(供上层拼接自动作废备注)
* @param {Object} row 店管家订单原始结构
* @return {{finished: boolean, reason: string}} 判定结果与依据
*/
static describeFinishedOrder(row) {
return describeFinishedOrder(row);
}
/**
* 只读查询平台订单状态(审核前校验「平台是否已发货/已终结」、取号前回读订单行)
* @param {Object} params 参数
* @param {string} params.platformType 店管家 PlatformType(如 WxVideo)
* @param {string} [params.dbname] 分区库名,缺省按分区接口解析
* @param {string} params.logicalOrderId 店管家系统编号
* @param {string} [params.platformOrderId] 店管家订单编号
* @param {Date|string} [params.placeOrderTime] 下单时间(兜底扫描窗口)
* @return {Promise<Object|null>} 平台订单行
*/
async fetchPlatformOrder({ platformType, dbname, logicalOrderId, platformOrderId, placeOrderTime }) {
if (!logicalOrderId) return null;
const host = resolveOrderHost(platformType);
let traceId = '';
try {
const info = await this.getUserInfo();
traceId = (info.data && info.data.TraceId) || '';
} catch {
// 忽略:traceId 缺失不阻断查询
}
let area = String(dbname || '').trim();
if (!area) {
const areas = await this.listProductAreas(host);
area = (areas.find(item => item && item.dbname) || {}).dbname || '';
}
return await this.findPlatformOrderRow(host, { traceId, dbname: area, logicalOrderId, platformOrderId, placeOrderTime });
}
/**
* 按系统预设平台编码(SPH/TB/...)推断店管家 PlatformType
* @param {string} platformCode 系统预设平台编码
* @return {string} 店管家 PlatformType,未知返回空串
*/
static resolvePlatformType(platformCode) {
const map = {
SPH: 'WxVideo',
TB: 'Taobao',
TM: 'Tmall',
DYXD: 'TouTiao',
PDD: 'Pinduoduo',
JD: 'JingDong',
KS: 'KuaiShou',
XHS: 'XiaoHongShu',
1688: 'Alibaba',
};
return map[ String(platformCode || '').trim().toUpperCase() ] || '';
}
/**
* 店管家 PlatformType 对应的接口域名(供脚本/调试工具复用)
* @param {string} platformType 店管家 PlatformType(如 WxVideo / TouTiao)
* @return {string} 域名,未知返回空串
*/
static resolveTemplateHost(platformType) {
return resolveTemplateHost(platformType);
}
/**
* 店管家 PlatformType 对应的订单/取号域名(与模板域名不同)
* @param {string} platformType 店管家 PlatformType(如 WxVideo)
* @return {string} 域名
*/
static resolveOrderHost(platformType) {
return resolveOrderHost(platformType);
}
/**
* 是否允许真实取号(默认开启,DGJ_WAYBILL_ENABLE=0 关闭)
* @return {boolean} 是否允许
*/
static isWaybillEnabled() {
return isWaybillEnabled();
}
/**
* 从 ExpressPrint 响应里解析打印记录(`Data.PrintHistoryIds`)
* @param {Object} printed ExpressPrint 响应
* @return {Array<{id: string, pid: string, waybill_code: string, batch_index: number|null}>} 打印记录
*/
static extractPrintHistoryIds(printed) {
return extractPrintHistoryIds(printed);
}
/**
* 组装发货回传单体报文(`Orders[i]`),供脚本/单测复用同一口径
* @param {Object} row 订单行(平台行或本地快照拼装结果)
* @param {number} index 序号(0 基)
* @param {string} [expressCode] 快递编码兜底
* @return {Object} Orders[i]
*/
static buildSendOrder(row, index, expressCode = '') {
return buildSendOrder(row, index, expressCode);
}
/**
* 构造店管家表单(PHP http_build_query 口径,嵌套用括号)
* @param {Object} data 表单数据
* @return {URLSearchParams} 表单
*/
static buildForm(data) {
return buildPhpForm(data);
}
}
module.exports = DgjService;