oms/backend/app/service/externalSendSync.js
liufumingren 3b1c13492c fix(send): 发货回传用取号记录的分区,别用模板记录的 dbname
线上「意洁」整批回传失败固定报 `店管家发货同步失败:12;ErrorCode=500`。对同一单、同一
fxdd 域名、同一模板只改 dbname 做对照(该单平台侧已发货,正确报文只会回「不是待发货」):

- dbname=y/2wUDWCZOk=(模板记录 external_print_express_interfaces.dbname)→ 12 / ErrorCode=500
- dbname=''(host 默认区)                                    → 「存在不是待发货的商品」(业务类,正常)
- dbname=dzh93a8…(取号记录 dbname)                          → 同上,正常

根因:resolveTarget 把模板记录的 dbname 当成订单分区去发 OnlineSend / 回读订单行,
而那个值是「模板接口」的区(同账号所有模板相同),平台在错的区里解析 Orders → 抛 500,
Message 只回一串数字,看起来像报文缺字段(连带 §9f067c1 的实时行重试也拿不到行)。

- resolveTarget:dbname 改取 waybill_fetch_records.dbname(取号就在那一区成功),无取号记录时 ''
- 模板同步/查询仍用模板记录的 dbname,两者不混用
- recordFailure:报文类失败的备注里附平台原始返回(先 500 字内),订单页即可看到真实返回
- 报文类失败但回读不到实时订单行时,备注里明确写出来(原来静默按首次错误落库)
- 单测 externalSendDbname.test.js 2 例;文档补 §2.1.2(对照表 + 口径表)

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

700 lines
30 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 Service = require('egg').Service;
const { buildSendRow, parseOrderWaybills, parseJson } = require('../lib/dgjSendRow');
const { isPayloadRejected } = require('../lib/platformError');
/** 外部发货同步状态 */
const SEND_STATUS = {
PENDING: 0,
SYNCED: 1,
RETRY: 2,
EXCEPTION: 3,
};
/** 状态文案 */
const SEND_STATUS_LABELS = {
0: '待同步',
1: '已同步',
2: '同步失败待重试',
3: '同步异常',
};
/** 失败重试上限:达到后流转为「异常」,等人工批量重试 */
const MAX_SEND_TIMES = 3;
/**
* 同批逐单同步的间隔(毫秒)
*
* 店管家对高频请求会判成刷单/攻击,批量回传时逐单之间留一点间隔;
* 现在发货不再回读订单行(用本地快照拼报文),每单只有 1 次 POST。
*/
const SEND_INTERVAL_MS = Number(process.env.EXTERNAL_SEND_INTERVAL_MS || 300);
/**
* 简单等待
* @param {number} ms 毫秒
* @return {Promise<void>} 无返回值
*/
function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
/**
* 截断字符串,避免超出表字段长度
* @param {*} value 原始值
* @param {number} max 最大长度
* @return {string} 截断后的字符串
*/
function truncateText(value, max) {
return String(value == null ? '' : value).slice(0, max);
}
/**
* 转义 LIKE 里的通配符(订单号可能含 `_`,如 `FH_2_1`)
* @param {string} value 原始值
* @return {string} 转义后的值
*/
function escapeLike(value) {
return String(value == null ? '' : value).replace(/([\\%_])/g, '\\$1');
}
/**
* 取号记录里是否包含指定运单号
* @param {Object} record 取号记录
* @param {string} waybill 运单号
* @return {boolean} 是否命中
*/
function fetchRecordHasWaybill(record, waybill) {
const wanted = String(waybill == null ? '' : waybill).trim();
if (!wanted || !record) return false;
if (String(record.waybill_code || '').trim() === wanted) return true;
const raw = record.waybill_codes;
const parsed = parseJson(raw);
const codes = Array.isArray(parsed) ? parsed : (raw ? String(raw).split(',') : []);
return codes.some(code => String(code).trim() === wanted);
}
/**
* 是否为平台登录态失效类错误(分区接口统一返回「登录信息过期,请重新登录」)
* @param {Error} err 异常
* @return {boolean} 是否需要重新登录
*/
function isSessionExpiredError(err) {
const message = String((err && err.message) || '');
return /登录信息过期|登录已失效|token is invalid|未登录|缺少 token/i.test(message);
}
/**
* 同步外部打单平台发货(店管家 `NewOrder/OnlineSendBatch`)
*
* 触发链路:
* - WMS 回传 `deliveryorder.confirm` → 订单流转到「配送」时把状态置为「待同步」(`markPending`);
* - 定时任务 `externalSendSyncWorker` 扫描「待同步 / 失败待重试」的配送单,逐单调平台发货接口;
* - 失败累加次数,达到 3 次转「异常」;人工在列表里批量重试(`retry`)会把次数清零重新排队。
*/
class ExternalSendSyncService extends Service {
/**
* 订单流转到配送后标记「待同步」
*
* 非外部打单订单(店铺不是 type=2 / 没有打单账号)直接标记为「已同步」,避免污染异常统计。
* @param {number[]} ids 订单ID(order_index.id)
* @param {number} principalId 主体ID
* @return {Promise<void>} 无返回值
*/
async markPending(ids, principalId) {
const { ctx } = this;
const idList = (Array.isArray(ids) ? ids : [ ids ]).map(Number).filter(Boolean);
if (!idList.length) return;
const Op = ctx.app.Sequelize.Op;
const rows = await ctx.model.OrderStatusDelivery.findAll({
where: { principal_id: principalId, id: { [Op.in]: idList } },
});
for (const row of rows) {
const applicable = await this.isExternalPrintOrder(row);
await row.update(applicable
? { external_send_status: SEND_STATUS.PENDING, external_send_times: 0, external_send_error: '' }
: {
external_send_status: SEND_STATUS.SYNCED,
external_send_times: 0,
external_send_error: '',
external_send_at: new Date(),
external_sent_at: new Date(),
});
}
}
/**
* 是否外部打单平台订单(店铺 type=2 且挂了打单账号)
* @param {Object} order 配送表订单行
* @return {Promise<boolean>} 是否需要同步
*/
async isExternalPrintOrder(order) {
const { ctx } = this;
if (!order || !order.shop_id) return false;
const shop = await ctx.model.Shop.findByPk(order.shop_id, {
attributes: [ 'id', 'type', 'external_print_account_id' ],
});
return !!(shop && Number(shop.type) === 2 && shop.external_print_account_id);
}
/**
* 同步单个订单的发货结果到外部打单平台
* @param {Object} order 配送表订单行(Sequelize 实例)
* @param {Object} [options] 参数
* @param {string} [options.trigger] 触发来源(schedule / manual)
* @return {Promise<{ok: boolean, message: string, skipped?: boolean}>} 同步结果
*/
async syncOrder(order, { trigger = 'schedule' } = {}) {
const { ctx } = this;
const now = new Date();
try {
const target = await this.resolveTarget(order);
if (!target) {
await order.update({
external_send_status: SEND_STATUS.SYNCED,
external_send_error: '',
external_send_at: now,
external_sent_at: now,
});
return { ok: true, skipped: true, message: '非外部打单订单,无需同步' };
}
const { service, platformType, dbname, platformCode, template, fetchRecord } = target;
const host = service.constructor.resolveOrderHost(platformType);
const row = await this.resolveSendRow(order, { service, host, dbname, platformCode, template, fetchRecord });
if (!row) {
throw new Error(`外部打单平台未找到该订单(平台 ${platformCode},系统编号 ${order.parent_order_no || order.order_no})`);
}
await service.sendOrders(host, {
traceId: await this.resolveTraceId(service),
dbname,
rows: [ row ],
templateId: template ? template.template_id : '',
expressCompanyId: template ? template.express_company_id : '',
expressCode: template ? template.express_company_code : '',
});
await order.update({
external_send_status: SEND_STATUS.SYNCED,
external_send_error: '',
external_send_at: now,
external_sent_at: now,
});
ctx.logger.info('[external-send] 同步外部发货成功 %s(%s)', order.order_no, trigger);
return { ok: true, message: 'ok' };
} catch (err) {
// 登录态失效:重新登录后重试一次
if (isSessionExpiredError(err)) {
try {
const target = await this.resolveTarget(order);
if (target) {
await target.service.loginByPassword();
const host = target.service.constructor.resolveOrderHost(target.platformType);
const row = await this.resolveSendRow(order, {
service: target.service,
host,
dbname: target.dbname,
platformCode: target.platformCode,
template: target.template,
fetchRecord: target.fetchRecord,
});
if (!row) throw new Error('外部打单平台未找到该订单');
await target.service.sendOrders(host, {
traceId: await this.resolveTraceId(target.service),
dbname: target.dbname,
rows: [ row ],
templateId: target.template ? target.template.template_id : '',
expressCompanyId: target.template ? target.template.express_company_id : '',
expressCode: target.template ? target.template.express_company_code : '',
});
await order.update({
external_send_status: SEND_STATUS.SYNCED,
external_send_error: '',
external_send_at: now,
external_sent_at: now,
});
ctx.logger.info('[external-send] 重新登录后同步成功 %s', order.order_no);
return { ok: true, message: 'ok' };
}
} catch (retryErr) {
return await this.recordFailure(order, retryErr, now);
}
}
// 平台判「报文不被接受」(5xx / 服务器繁忙 / 只回一串数字):本地快照拼的报文平台解析不了,
// 直接用平台实时订单行重发一次(实测同一单换成实时行后能正常发货)
const rejectedPayload = this.isPayloadRejectedError(err);
if (rejectedPayload) {
let retryErr = null;
let liveRowMissing = false;
try {
const target = await this.resolveTarget(order);
if (target) {
const host = target.service.constructor.resolveOrderHost(target.platformType);
const liveRow = await this.resolveSendRow(order, {
service: target.service,
host,
dbname: target.dbname,
platformCode: target.platformCode,
template: target.template,
fetchRecord: target.fetchRecord,
forceRemote: true,
});
if (liveRow) {
await target.service.sendOrders(host, {
traceId: await this.resolveTraceId(target.service),
dbname: target.dbname,
rows: [ liveRow ],
templateId: target.template ? target.template.template_id : '',
expressCompanyId: target.template ? target.template.express_company_id : '',
expressCode: target.template ? target.template.express_company_code : '',
});
await order.update({
external_send_status: SEND_STATUS.SYNCED,
external_send_error: '',
external_send_at: now,
external_sent_at: now,
});
ctx.logger.info('[external-send] 改用平台实时订单行后同步成功 %s', order.order_no);
return { ok: true, message: 'ok' };
}
liveRowMissing = true;
ctx.logger.warn('[external-send] %s 回读平台订单行失败(订单可能已不在待发货),无法用实时行重试', order.order_no);
}
} catch (retryErr2) {
retryErr = retryErr2;
ctx.logger.warn('[external-send] %s 用平台实时订单行重试仍失败:%s', order.order_no, retryErr.message);
}
if (retryErr) return await this.recordFailure(order, retryErr, now);
if (liveRowMissing) {
return await this.recordFailure(
order,
Object.assign(new Error(`${err.message}(回读平台订单行失败,未能用实时行重试)`), {
rawResponse: err.rawResponse,
}),
now
);
}
}
return await this.recordFailure(order, err, now);
}
}
/**
* 平台返回是否为「报文不被接受」类失败(判定口径见 lib/platformError)
* @param {Error} err 平台异常(buildPlatformError 会带 rawResponse)
* @return {boolean} 是否需要改用实时订单行重发
*/
isPayloadRejectedError(err) {
return isPayloadRejected(err && err.rawResponse, err && err.message);
}
/**
* 组装发货回传用的订单行:优先用本地快照(不访问平台),快照缺失才回读平台
* @param {Object} order 配送状态行
* @param {Object} ctxInfo 上下文
* @param {Object} ctxInfo.service 打单平台服务
* @param {string} ctxInfo.host 订单域名
* @param {string} ctxInfo.dbname 分区库名
* @param {Object} [ctxInfo.template] 快递接口记录
* @param {Object} [ctxInfo.fetchRecord] 最近一次成功取号记录(已在 resolveTarget 查过就不再查)
* @param {boolean} [ctxInfo.forceRemote] 强制回读平台订单行(平台判报文无效时重试用)
* @return {Promise<Object|null>} 订单行
*/
async resolveSendRow(order, { service, host, dbname, template, fetchRecord, forceRemote = false }) {
const { ctx } = this;
const logicalOrderId = String(order.parent_order_no || order.order_no || '');
// 1) 拉单快照:老表 orders.external_data(平台整行,含 PathFlowCode / ShippingType / SubOrders)
let snapshot = null;
if (!forceRemote) {
try {
const legacy = await ctx.model.Order.findOne({
where: { principal_id: order.principal_id, order_no: order.order_no },
attributes: [ 'id', 'external_data' ],
});
snapshot = legacy && legacy.external_data ? legacy.external_data : null;
} catch {
snapshot = null;
}
}
// 2) 最近一次成功取号记录:拿最新面单信息(WaybillCodeId / Pid / 快递编码)
if (!fetchRecord) fetchRecord = await this.findLatestFetchRecord(order);
const localRow = buildSendRow({ order, snapshot, fetchRecord, template });
// 平台按 SubOrders 校验收件人与商品明细,缺了会直接回 500「服务器繁忙」;
// 这种快照(老化/只存了归一化数据)不能用,退回回读平台订单行
if (localRow && Array.isArray(localRow.SubOrders) && localRow.SubOrders.length) {
// 报文里 WaybillCodes 是平台校验运单渠道的依据(WaybillCodeId / Pid / 快递编码),缺失时要能查到
const waybills = Array.isArray(localRow.WaybillCodes) ? localRow.WaybillCodes : [];
if (!waybills.length) {
ctx.logger.warn(
'[external-send] %s 没有带平台面单标识(取号记录 %s),WaybillCodes 为空,运单号 %s',
order.order_no,
fetchRecord ? `#${fetchRecord.id}` : '缺失',
localRow.LastWaybillCode || order.express_code || '-'
);
}
return localRow;
}
if (localRow) {
ctx.logger.warn('[external-send] %s 本地快照缺少 SubOrders,回读平台订单行拼报文', order.order_no);
} else {
ctx.logger.info('[external-send] %s 没有本地快照,回读平台订单行', order.order_no);
}
// 3) 没有可用快照(历史单/非平台单/快照不完整):退回回读平台订单行
return await service.findPlatformOrderRow(host, {
traceId: await this.resolveTraceId(service),
dbname,
logicalOrderId,
platformOrderId: String((order.extend_props && order.extend_props.platform_order_no) || order.oaid_order_source_code || ''),
placeOrderTime: order.place_order_time || order.pay_time || order.created_at,
});
}
/**
* 记录一次失败:累加次数,达到上限转「异常」
* @param {Object} order 配送表订单行
* @param {Error} err 异常
* @param {Date} now 当前时间
* @return {Promise<{ok: boolean, message: string}>} 结果
*/
async recordFailure(order, err, now) {
const { ctx } = this;
const rawMessage = truncateText(err && err.message ? err.message : '同步失败', 500);
// 平台限流(服务商级 QPS 超限)不是这单的问题:不计入重试次数,等下一轮调度再试,
// 否则批量重试时容易一批单被限流打成「异常」,还得人工再清
const rateLimited = /isv\.request-limited|请求太频繁|访问QPS|接口限流/i.test(rawMessage);
// 报文类失败把平台原始返回摘一段拼进备注:订单页能直接看到「12」背后到底是什么,
// 不用再去翻日志(完整原始返回仍写日志)
const raw = err && err.rawResponse;
const message = raw && isPayloadRejected(raw, rawMessage)
? truncateText(`${rawMessage}|平台原始返回:${JSON.stringify(raw)}`, 500)
: rawMessage;
if (rateLimited) {
await order.update({
external_send_status: SEND_STATUS.RETRY,
external_send_error: message,
external_send_at: now,
});
ctx.logger.warn('[external-send] %s 被平台限流,本轮跳过、不计重试次数:%s', order.order_no, message);
return { ok: false, message };
}
const times = Number(order.external_send_times || 0) + 1;
const exception = times >= MAX_SEND_TIMES;
await order.update({
external_send_status: exception ? SEND_STATUS.EXCEPTION : SEND_STATUS.RETRY,
external_send_times: times,
external_send_error: message,
external_send_at: now,
});
ctx.logger.warn('[external-send] 同步外部发货失败 %s(第 %d 次%s):%s',
order.order_no, times, exception ? ',转异常' : '', message);
// 平台原始返回只进日志(订单页只展示可读文案):报文类失败靠它定位缺了哪个字段
if (err && err.rawResponse) {
ctx.logger.warn('[external-send] %s 平台原始返回:%s', order.order_no, truncateText(JSON.stringify(err.rawResponse), 2000));
}
return { ok: false, message };
}
/**
* 最近一次**与本单运单号对得上**的成功取号记录(含运单号、快递编码、平台面单标识)
*
* 同一单可能取过多次号(每次分配新号),配送单上真正发出去的是 `express_codes` 里的号,
* 所以必须按运单号挑记录:拿别的号会让发货模板(快递)和面单标识都错位,
* 抖音这类平台会直接判「此运单号非抖音的运单号」。
*
* @param {Object} order 配送状态行
* @return {Promise<Object|null>} 取号记录;运单号对不上时返回 null
*/
async findLatestFetchRecord(order) {
const { ctx } = this;
if (!order || !order.order_no) return null;
const Op = ctx.app.Sequelize.Op;
const orderCode = String(order.order_no);
let records = [];
try {
records = await ctx.model.WaybillFetchRecord.findAll({
where: {
principal_id: order.principal_id,
status: 1,
// 本单本身 + 本单的拆包(`_1` / `_2`):order_no 里的下划线是字面量,需转义
[Op.or]: [
{ delivery_order_code: orderCode },
{ delivery_order_code: { [Op.like]: `${escapeLike(orderCode)}\\_%` } },
],
},
order: [[ 'id', 'DESC' ]],
limit: 20,
});
} catch {
return null;
}
if (!records.length) return null;
const waybills = parseOrderWaybills(order);
// 配送单还没有运单号(异常数据):保持原有行为,取最近一条
if (!waybills.length) return records[0];
for (const waybill of waybills) {
const hit = records.find(record => fetchRecordHasWaybill(record, waybill));
if (hit) return hit;
}
ctx.logger.warn(
'[external-send] %s 的运单号 %s 没有对应取号记录(最近 %d 条都不是),将不带平台面单标识',
orderCode,
waybills.join(','),
records.length
);
return null;
}
/**
* 定位发货用的快递接口(模板)
*
* 必须按**运单实际所属的快递**取模板:店管家把 TemplateId / ExpressCompanyId 透传给平台,
* 抖音/快手等平台会按模板的电子面单渠道校验运单号,模板与运单快递不一致会被判
* `风控拦截#NOT_MATCH_SEGMENT_CHANNEL#(此运单号非抖音的运单号)`。
* 取号就是按「账号 + 平台 + 快递编码」定位模板(`resolveByCode`),发货沿用同一口径。
*
* @param {Object} params 参数
* @param {Object} params.account 打单账号
* @param {string} params.platformCode OMS 平台编码
* @param {string} params.expressCode 运单实际使用的快递编码(取号记录优先)
* @param {number} params.principalId 主体ID
* @return {Promise<Object|null>} 快递接口记录(纯对象)
*/
async resolveSendTemplate({ account, platformCode, expressCode, principalId }) {
const { ctx } = this;
const code = String(expressCode || '').trim();
if (code && platformCode) {
// 1) 显式绑定关系(OMS 快递编码 → 模板)
const matched = await ctx.service.externalPrintExpressInterface.resolveByCode(
account.id,
{ platformCode, expressCode: code },
principalId
);
if (matched) return matched;
// 2) 没绑 custom_code 的历史数据:按模板自带的快递公司编码兜底匹配(如 STO / YUNDA / POSTB)
const byCompany = await ctx.model.ExternalPrintExpressInterface.findOne({
where: {
principal_id: principalId,
account_id: account.id,
platform_code: platformCode,
status: 1,
express_company_code: code.toUpperCase(),
},
order: [[ 'id', 'ASC' ]],
});
if (byCompany) return byCompany.get ? byCompany.get({ plain: true }) : byCompany;
}
// 3) 兜底(历史单没有取号记录 / 快递未绑定):退回该平台的第一条模板,保持原有行为
const row = await ctx.model.ExternalPrintExpressInterface.findOne({
where: { principal_id: principalId, account_id: account.id, platform_code: platformCode, status: 1 },
order: [[ 'id', 'ASC' ]],
});
if (!row) return null;
const fallback = row.get ? row.get({ plain: true }) : row;
if (code) {
// 运单快递没有对应模板时平台会按模板渠道校验运单号(风控/渠道不匹配),留痕便于排查
ctx.logger.warn(
'[external-send] 平台 %s 快递 %s 未绑定模板,退回 #%s(模板快递 %s)',
platformCode,
code,
fallback.id,
fallback.express_company_code || '-'
);
}
return fallback;
}
/**
* 定位发货目标(打单账号 / 发货域名 / 分区库名 / 快递接口)
* @param {Object} order 配送表订单行
* @return {Promise<Object|null>} 目标信息
*/
async resolveTarget(order) {
const { ctx } = this;
if (!order || !order.shop_id) return null;
const shop = await ctx.model.Shop.findByPk(order.shop_id, {
attributes: [ 'id', 'type', 'external_print_account_id' ],
});
if (!shop || Number(shop.type) !== 2 || !shop.external_print_account_id) return null;
const account = await ctx.model.ExternalPrintAccount.findByPk(shop.external_print_account_id, {
include: [{ model: ctx.model.ExternalPrintPlatform, as: 'platform' }],
});
if (!account || !account.platform) return null;
const platformCode = String(order.source_platform_code || '').trim();
const service = ctx.service.externalPrintOrder.createPlatformService(account);
const resolvePlatformType = service.constructor && service.constructor.resolvePlatformType;
// 运单实际用的快递:以最近一次成功取号记录为准(取号时按 WMS 传入的快递编码定位模板),
// 兜底用订单的物流公司编码;发货模板必须与之对齐,否则平台按模板渠道校验运单号会报风控
const fetchRecord = await this.findLatestFetchRecord(order);
const waybillExpressCode = String((fetchRecord && fetchRecord.express_code) || order.logistics_code || '').trim();
const template = await this.resolveSendTemplate({
account,
platformCode,
expressCode: waybillExpressCode,
principalId: order.principal_id,
});
// PlatformType(决定回传发货用哪个域名)优先按「订单原始平台」:1688 分销单在 OMS 里被换算成
// 抖音小店/淘宝(为了选对模板),但订单行仍在 Alibaba 分区(fxali),按换算后的平台会查错域名
const raw = order.extend_props && typeof order.extend_props === 'object' ? order.extend_props : {};
const originalCode = String(raw.original_platform_code || '').trim();
let platformType = '';
if (originalCode && typeof resolvePlatformType === 'function') {
platformType = resolvePlatformType(originalCode) || '';
}
if (!platformType) {
platformType = template ? template.platform_type : (typeof resolvePlatformType === 'function' ? resolvePlatformType(platformCode) : '');
}
if (!platformType) return null;
// 回传发货要发到**订单所在分区**:取号记录里的 dbname 就是取号当时命中的那个区
// (取号在那一区成功,说明订单就在那里)。
// ⚠️ 不能用模板记录的 dbname:那是模板接口用的区,实测拿它回传发货,同一单会返回
// `{"Success":false,"ErrorCode":"500","Message":"12"}`(平台在错的区里解析订单),见文档 §2.1.2。
const dbname = String((fetchRecord && fetchRecord.dbname) || '').trim();
return { service, account, platformType, dbname, platformCode, template, fetchRecord };
}
/**
* 取平台登录上下文 traceId(失败不阻断)
*
* 同一次批量同步里按账号缓存:`getUserInfo` 本身也是一次平台请求,
* 逐单重复取等于把请求量翻倍,容易被平台判成高频访问。
* @param {Object} service 平台服务实例
* @return {Promise<string>} traceId
*/
async resolveTraceId(service) {
const key = (service.account && service.account.id) || 'default';
if (!this.traceMemo) this.traceMemo = new Map();
if (this.traceMemo.has(key)) return this.traceMemo.get(key);
let traceId = '';
try {
const info = await service.getUserInfo();
traceId = (info.data && info.data.TraceId) || '';
} catch (err) {
traceId = '';
}
this.traceMemo.set(key, traceId);
return traceId;
}
/**
* 扫描并同步待同步 / 可重试的配送单(定时任务入口)
* @param {Object} [options] 参数
* @param {number} [options.limit] 单批上限
* @return {Promise<Object>} 统计结果
*/
async syncPending({ limit = 50 } = {}) {
const { ctx } = this;
const Op = ctx.app.Sequelize.Op;
// 主体停用后不再回传平台
const enabledPrincipalIds = await ctx.service.cache.getEnabledPrincipalIds();
if (!enabledPrincipalIds.length) return { total: 0, success: 0, failed: 0, exception: 0 };
const rows = await ctx.model.OrderStatusDelivery.findAll({
where: {
external_send_status: { [Op.in]: [ SEND_STATUS.PENDING, SEND_STATUS.RETRY ] },
external_send_times: { [Op.lt]: MAX_SEND_TIMES },
principal_id: { [Op.in]: enabledPrincipalIds },
},
order: [[ 'external_send_at', 'ASC' ]],
limit,
});
let success = 0;
let failed = 0;
let exception = 0;
for (let index = 0; index < rows.length; index += 1) {
const row = rows[index];
// 平台对高频请求会判成刷单/攻击:同批逐单之间留间隔(可按 SEND_INTERVAL_MS 调整)
if (index > 0) await sleep(SEND_INTERVAL_MS);
const result = await this.syncOrder(row, { trigger: 'schedule' });
if (result.ok) success += 1;
else if (row.external_send_status === SEND_STATUS.EXCEPTION) exception += 1;
else failed += 1;
}
return { total: rows.length, success, failed, exception };
}
/**
* 各状态数量(前端快速查看异常数量)
* @param {number} principalId 主体ID
* @return {Promise<Object>} { pending, retry, exception, synced, total }
*/
async counts(principalId) {
const { ctx } = this;
const Sequelize = ctx.app.Sequelize;
const rows = await ctx.model.OrderStatusDelivery.findAll({
where: { principal_id: principalId },
attributes: [ 'external_send_status', [ Sequelize.fn('COUNT', Sequelize.col('id')), 'cnt' ]],
group: [ 'external_send_status' ],
raw: true,
});
const result = { pending: 0, retry: 0, exception: 0, synced: 0, total: 0 };
for (const row of rows) {
const count = Number(row.cnt) || 0;
result.total += count;
if (Number(row.external_send_status) === SEND_STATUS.PENDING) result.pending += count;
else if (Number(row.external_send_status) === SEND_STATUS.RETRY) result.retry += count;
else if (Number(row.external_send_status) === SEND_STATUS.EXCEPTION) result.exception += count;
else if (Number(row.external_send_status) === SEND_STATUS.SYNCED) result.synced += count;
}
return result;
}
/**
* 批量重试同步(人工处理异常单)
*
* 把状态重置为「待同步」并把次数清零,随后立刻跑一批,避免等定时任务。
* 与定时任务同样逐单留间隔(平台会把高频请求判成刷单),超过 `limit` 的部分保持「待同步」,
* 下一轮定时任务会接着处理,不会丢。
* @param {Object} p 参数
* @param {number[]} [p.ids] 指定订单ID;为空时按状态筛选
* @param {number} [p.principalId] 主体ID
* @param {number[]} [p.statuses] 状态筛选(默认异常 + 待重试)
* @param {number} [p.limit] 本次立刻同步的上限
* @return {Promise<Object>} { reset, synced, success, failed, remaining }
*/
async retry({ ids, principalId, statuses = [ SEND_STATUS.EXCEPTION, SEND_STATUS.RETRY ], limit = 200 } = {}) {
const { ctx } = this;
const Op = ctx.app.Sequelize.Op;
const idList = (Array.isArray(ids) ? ids : []).map(Number).filter(Boolean);
const where = { principal_id: principalId };
if (idList.length) where.id = { [Op.in]: idList };
else where.external_send_status = { [Op.in]: statuses };
const rows = await ctx.model.OrderStatusDelivery.findAll({ where });
for (const row of rows) {
await row.update({
external_send_status: SEND_STATUS.PENDING,
external_send_times: 0,
external_send_error: '',
});
}
const batch = rows.slice(0, Math.max(0, Number(limit) || 0));
let success = 0;
let failed = 0;
for (let index = 0; index < batch.length; index += 1) {
if (index > 0) await sleep(SEND_INTERVAL_MS);
const result = await this.syncOrder(batch[index], { trigger: 'manual' });
if (result.ok) success += 1;
else failed += 1;
}
return { reset: rows.length, synced: batch.length, success, failed, remaining: rows.length - batch.length };
}
}
module.exports = ExternalSendSyncService;
module.exports.SEND_STATUS = SEND_STATUS;
module.exports.SEND_STATUS_LABELS = SEND_STATUS_LABELS;
module.exports.MAX_SEND_TIMES = MAX_SEND_TIMES;