@reglow/reglow 0.12.0 → 0.13.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/reglow/core/config.js +1 -1
- package/dist/reglow/core/entities.d.ts +65 -0
- package/dist/reglow/core/models.d.ts +8 -0
- package/dist/reglow/core/models.js +4 -0
- package/dist/reglow/core/models.js.map +1 -1
- package/dist/reglow/core/payment.d.ts +93 -0
- package/dist/reglow/core/payment.js +1063 -11
- package/dist/reglow/core/payment.js.map +1 -1
- package/dist/reglow/modules/payment/controller.js +48 -1
- package/dist/reglow/modules/payment/controller.js.map +1 -1
- package/dist/reglow/modules/payment/events.d.ts +22 -0
- package/dist/reglow/modules/payment/events.js +60 -0
- package/dist/reglow/modules/payment/events.js.map +1 -0
- package/dist/reglow/modules/payment/schema.d.ts +89 -0
- package/dist/reglow/modules/payment/schema.js +85 -0
- package/dist/reglow/modules/payment/schema.js.map +1 -1
- package/dist/reglow/modules/payment/service.d.ts +90 -2
- package/dist/reglow/modules/payment/service.js +752 -3
- package/dist/reglow/modules/payment/service.js.map +1 -1
- package/dist/reglow/modules/photo/repository.d.ts +4 -0
- package/dist/reglow/modules/photo/repository.js +13 -0
- package/dist/reglow/modules/photo/repository.js.map +1 -1
- package/dist/reglow/modules/photo/service.d.ts +6 -1
- package/dist/reglow/modules/photo/service.js +13 -3
- package/dist/reglow/modules/photo/service.js.map +1 -1
- package/dist/reglow/modules/studio/mcp/client.js +2 -2
- package/dist/reglow/scripts/schema.js +81 -0
- package/dist/reglow/scripts/schema.js.map +1 -1
- package/package.json +1 -1
|
@@ -5,11 +5,16 @@
|
|
|
5
5
|
import { knex } from "../../core/database.js";
|
|
6
6
|
import { ModelRegistry } from "../../core/models.js";
|
|
7
7
|
import { logger } from "../../core/logging.js";
|
|
8
|
-
import { createPaymentProvider, getPaymentSettings, getActiveProvider, } from "../../core/payment.js";
|
|
8
|
+
import { createPaymentProvider, getPaymentSettings, getActiveProvider, getProviderCapabilities, } from "../../core/payment.js";
|
|
9
9
|
import { toIsoDate } from "../../common/serialize.js";
|
|
10
|
+
import * as events from "./events.js";
|
|
10
11
|
// 支付单支付有效期:超过该时长仍未支付自动关闭(cancelled),避免财务管理出现永久待支付流水
|
|
11
12
|
export const PAYMENT_EXPIRE_SECONDS = 30 * 60;
|
|
12
13
|
const TABLE = ModelRegistry.get("PaymentOrder");
|
|
14
|
+
const REFUND_TABLE = ModelRegistry.get("PaymentRefund");
|
|
15
|
+
const SPLIT_TABLE = ModelRegistry.get("PaymentSplit");
|
|
16
|
+
const SPLIT_RECEIVER_TABLE = ModelRegistry.get("PaymentSplitReceiver");
|
|
17
|
+
const SPLIT_RETURN_TABLE = ModelRegistry.get("PaymentSplitReturn");
|
|
13
18
|
function generateOutTradeNo() {
|
|
14
19
|
// 商户订单号: YYYYMMDDHHMMSS + 6位随机数字
|
|
15
20
|
const d = new Date();
|
|
@@ -83,9 +88,9 @@ export async function createOrder(input) {
|
|
|
83
88
|
}
|
|
84
89
|
// 按平台调用支付渠道下单
|
|
85
90
|
const result = await payProvider.createTradeByPlatform(outTradeNo, input.amountCents, input.subject, notifyUrl, input.platform ?? "web", input.openid ?? "", input.buyerId ?? "", input.payerIp ?? "");
|
|
86
|
-
// 支付宝电脑网站支付(page.pay)不直接返回 qr_code
|
|
91
|
+
// 支付宝电脑网站支付(page.pay)不直接返回 qr_code,从收银台页面提取(web/native 端;H5 直接返回跳转链接)
|
|
87
92
|
if (provider === "alipay" &&
|
|
88
|
-
(input.platform ?? "web")
|
|
93
|
+
["web", "native"].includes(input.platform ?? "web") &&
|
|
89
94
|
!result.qrCode) {
|
|
90
95
|
const redirectUrl = String((result.payParams || {}).redirect_url || "");
|
|
91
96
|
if (redirectUrl) {
|
|
@@ -171,6 +176,18 @@ export async function queryOrderStatus(orderId) {
|
|
|
171
176
|
trade_no: result.tradeNo || order.trade_no || null,
|
|
172
177
|
paid_at: new Date(),
|
|
173
178
|
});
|
|
179
|
+
const updated = (await knex(TABLE)
|
|
180
|
+
.where("id", order.id)
|
|
181
|
+
.first());
|
|
182
|
+
await events.dispatchPaymentEvent({
|
|
183
|
+
eventType: events.EVENT_PAYMENT_SUCCEEDED,
|
|
184
|
+
paymentOrder: updated,
|
|
185
|
+
payload: {
|
|
186
|
+
provider: order.provider,
|
|
187
|
+
tradeNo: result.tradeNo || "",
|
|
188
|
+
source: "query",
|
|
189
|
+
},
|
|
190
|
+
});
|
|
174
191
|
return { status: "paid", paid_at: new Date().toISOString() };
|
|
175
192
|
}
|
|
176
193
|
}
|
|
@@ -217,9 +234,741 @@ export async function processCallback(provider, headers, body) {
|
|
|
217
234
|
trade_no: callbackResult.tradeNo || order.trade_no || null,
|
|
218
235
|
paid_at: new Date(),
|
|
219
236
|
});
|
|
237
|
+
const updated = (await knex(TABLE)
|
|
238
|
+
.where("id", order.id)
|
|
239
|
+
.first());
|
|
220
240
|
logger.info(`支付成功: ${order.out_trade_no} (trade_no=${callbackResult.tradeNo})`);
|
|
241
|
+
await events.dispatchPaymentEvent({
|
|
242
|
+
eventType: events.EVENT_PAYMENT_SUCCEEDED,
|
|
243
|
+
paymentOrder: updated,
|
|
244
|
+
payload: { provider, tradeNo: callbackResult.tradeNo || "" },
|
|
245
|
+
});
|
|
221
246
|
return { success: true, response: payProvider.successResponse() };
|
|
222
247
|
}
|
|
223
248
|
return { success: false, response: "unexpected status" };
|
|
224
249
|
}
|
|
250
|
+
// ─── 退款 ───
|
|
251
|
+
export const REFUND_SOURCE_MANUAL = "manual";
|
|
252
|
+
export const REFUND_SOURCE_AUTO = "auto";
|
|
253
|
+
export const REFUND_STATUS_PROCESSING = "processing";
|
|
254
|
+
export const REFUND_STATUS_SUCCESS = "success";
|
|
255
|
+
export const REFUND_STATUS_FAILED = "failed";
|
|
256
|
+
// 渠道掉单对账:只回查最近 N 天内、尚未检查过的失败/取消支付单
|
|
257
|
+
export const RECONCILE_LOOKBACK_DAYS = 3;
|
|
258
|
+
function pad(n, len = 2) {
|
|
259
|
+
return String(n).padStart(len, "0");
|
|
260
|
+
}
|
|
261
|
+
/** 生成商户退款单号: R + YYYYMMDDHHMMSS + 6位随机数字 */
|
|
262
|
+
export function generateRefundNo() {
|
|
263
|
+
return `R${generateOutTradeNo()}`;
|
|
264
|
+
}
|
|
265
|
+
function toDbUtc(d) {
|
|
266
|
+
return (`${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())} ` +
|
|
267
|
+
`${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}`);
|
|
268
|
+
}
|
|
269
|
+
export async function getRefund(refundId) {
|
|
270
|
+
return (await knex(REFUND_TABLE)
|
|
271
|
+
.where("id", refundId)
|
|
272
|
+
.first());
|
|
273
|
+
}
|
|
274
|
+
export async function listRefunds(input = {}) {
|
|
275
|
+
const page = input.page ?? 1;
|
|
276
|
+
const size = input.size ?? 20;
|
|
277
|
+
const base = knex(REFUND_TABLE);
|
|
278
|
+
if (input.paymentOrderId !== null && input.paymentOrderId !== undefined) {
|
|
279
|
+
base.where("payment_order_id", input.paymentOrderId);
|
|
280
|
+
}
|
|
281
|
+
if (input.status)
|
|
282
|
+
base.where("status", input.status);
|
|
283
|
+
if (input.source)
|
|
284
|
+
base.where("source", input.source);
|
|
285
|
+
const totalRow = (await base.clone().count({ c: "*" }).first());
|
|
286
|
+
const total = Number(totalRow?.c ?? 0);
|
|
287
|
+
const rows = (await base
|
|
288
|
+
.clone()
|
|
289
|
+
.orderBy("id", "desc")
|
|
290
|
+
.offset((page - 1) * size)
|
|
291
|
+
.limit(size));
|
|
292
|
+
return { total, items: rows };
|
|
293
|
+
}
|
|
294
|
+
async function applyRefundResult(refund, order, result, amountCents, alreadyApplied) {
|
|
295
|
+
const patch = {
|
|
296
|
+
channel_refund_no: result.channelRefundNo || refund.channel_refund_no || null,
|
|
297
|
+
};
|
|
298
|
+
if (result.success) {
|
|
299
|
+
const isSuccess = result.status === REFUND_STATUS_SUCCESS;
|
|
300
|
+
patch["status"] = isSuccess
|
|
301
|
+
? REFUND_STATUS_SUCCESS
|
|
302
|
+
: REFUND_STATUS_PROCESSING;
|
|
303
|
+
patch["error_msg"] = null;
|
|
304
|
+
if (isSuccess)
|
|
305
|
+
patch["refunded_at"] = new Date();
|
|
306
|
+
await knex(REFUND_TABLE).where("id", refund.id).update(patch);
|
|
307
|
+
const refunded = (order.refunded_amount_cents || 0) + (alreadyApplied ? 0 : amountCents);
|
|
308
|
+
let status = order.status;
|
|
309
|
+
if (refunded >= order.amount_cents) {
|
|
310
|
+
status = isSuccess ? "refunded" : "refunding";
|
|
311
|
+
}
|
|
312
|
+
else if (order.status !== "refunded") {
|
|
313
|
+
status = isSuccess ? "paid" : "refunding";
|
|
314
|
+
}
|
|
315
|
+
await knex(TABLE)
|
|
316
|
+
.where("id", order.id)
|
|
317
|
+
.update({ refunded_amount_cents: refunded, status });
|
|
318
|
+
return;
|
|
319
|
+
}
|
|
320
|
+
patch["status"] = REFUND_STATUS_FAILED;
|
|
321
|
+
patch["error_msg"] = (result.msg || "退款失败").slice(0, 500);
|
|
322
|
+
await knex(REFUND_TABLE).where("id", refund.id).update(patch);
|
|
323
|
+
if (!alreadyApplied && order.status === "refunding") {
|
|
324
|
+
await knex(TABLE).where("id", order.id).update({ status: "paid" });
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
export async function createRefund(input) {
|
|
328
|
+
const order = await getOrder(input.paymentOrderId);
|
|
329
|
+
if (!order)
|
|
330
|
+
throw new Error("支付单不存在");
|
|
331
|
+
if (!["paid", "refunding"].includes(order.status)) {
|
|
332
|
+
throw new Error(`当前支付单状态不可退款: ${order.status}`);
|
|
333
|
+
}
|
|
334
|
+
const remaining = order.amount_cents - (order.refunded_amount_cents || 0);
|
|
335
|
+
if (remaining <= 0)
|
|
336
|
+
throw new Error("该支付单已全额退款");
|
|
337
|
+
const amountCents = input.amountCents ?? remaining;
|
|
338
|
+
if (amountCents <= 0 || amountCents > remaining) {
|
|
339
|
+
throw new Error(`退款金额不合法(剩余可退 ${remaining} 分)`);
|
|
340
|
+
}
|
|
341
|
+
// 幂等:已有处理中的退款直接返回,避免并发重复退款
|
|
342
|
+
const existing = (await knex(REFUND_TABLE)
|
|
343
|
+
.where({
|
|
344
|
+
payment_order_id: input.paymentOrderId,
|
|
345
|
+
status: REFUND_STATUS_PROCESSING,
|
|
346
|
+
})
|
|
347
|
+
.orderBy("id", "desc")
|
|
348
|
+
.first());
|
|
349
|
+
if (existing)
|
|
350
|
+
return existing;
|
|
351
|
+
const config = await getPaymentSettings();
|
|
352
|
+
const payProvider = createPaymentProvider(order.provider, config);
|
|
353
|
+
const now = new Date();
|
|
354
|
+
const [id] = await knex(REFUND_TABLE).insert({
|
|
355
|
+
refund_no: generateRefundNo(),
|
|
356
|
+
payment_order_id: order.id,
|
|
357
|
+
out_trade_no: order.out_trade_no,
|
|
358
|
+
provider: order.provider,
|
|
359
|
+
amount_cents: amountCents,
|
|
360
|
+
total_amount_cents: order.amount_cents,
|
|
361
|
+
reason: (input.reason || "").slice(0, 255),
|
|
362
|
+
source: input.source || REFUND_SOURCE_MANUAL,
|
|
363
|
+
status: REFUND_STATUS_PROCESSING,
|
|
364
|
+
operator_id: input.operatorId ?? null,
|
|
365
|
+
retry_count: 0,
|
|
366
|
+
created_at: now,
|
|
367
|
+
updated_at: now,
|
|
368
|
+
});
|
|
369
|
+
const refund = (await getRefund(Number(id)));
|
|
370
|
+
let result;
|
|
371
|
+
try {
|
|
372
|
+
result = await payProvider.refund(order.out_trade_no, refund.refund_no, amountCents, order.amount_cents, refund.reason || "");
|
|
373
|
+
}
|
|
374
|
+
catch (e) {
|
|
375
|
+
result = {
|
|
376
|
+
success: false,
|
|
377
|
+
msg: `退款请求异常: ${e.message}`,
|
|
378
|
+
refundNo: refund.refund_no,
|
|
379
|
+
outTradeNo: order.out_trade_no,
|
|
380
|
+
channelRefundNo: "",
|
|
381
|
+
status: REFUND_STATUS_FAILED,
|
|
382
|
+
raw: {},
|
|
383
|
+
};
|
|
384
|
+
}
|
|
385
|
+
await applyRefundResult(refund, order, result, amountCents, false);
|
|
386
|
+
const saved = (await getRefund(refund.id));
|
|
387
|
+
await dispatchRefundEvent(order, saved);
|
|
388
|
+
return saved;
|
|
389
|
+
}
|
|
390
|
+
async function dispatchRefundEvent(order, refund) {
|
|
391
|
+
const eventType = refund.status === REFUND_STATUS_SUCCESS
|
|
392
|
+
? events.EVENT_REFUND_SUCCEEDED
|
|
393
|
+
: refund.status === REFUND_STATUS_PROCESSING
|
|
394
|
+
? events.EVENT_REFUND_PROCESSING
|
|
395
|
+
: events.EVENT_REFUND_FAILED;
|
|
396
|
+
await events.dispatchPaymentEvent({
|
|
397
|
+
eventType,
|
|
398
|
+
paymentOrder: order,
|
|
399
|
+
refund: refund,
|
|
400
|
+
payload: { provider: refund.provider, amountCents: refund.amount_cents },
|
|
401
|
+
});
|
|
402
|
+
}
|
|
403
|
+
export async function retryRefund(refundId, operatorId) {
|
|
404
|
+
const refund = await getRefund(refundId);
|
|
405
|
+
if (!refund)
|
|
406
|
+
throw new Error("退款记录不存在");
|
|
407
|
+
if (refund.status === REFUND_STATUS_SUCCESS)
|
|
408
|
+
return refund;
|
|
409
|
+
const order = await getOrder(refund.payment_order_id);
|
|
410
|
+
if (!order)
|
|
411
|
+
throw new Error("支付单不存在");
|
|
412
|
+
const config = await getPaymentSettings();
|
|
413
|
+
const payProvider = createPaymentProvider(order.provider, config);
|
|
414
|
+
const alreadyApplied = refund.status === REFUND_STATUS_PROCESSING;
|
|
415
|
+
await knex(REFUND_TABLE)
|
|
416
|
+
.where("id", refund.id)
|
|
417
|
+
.update({
|
|
418
|
+
retry_count: (refund.retry_count || 0) + 1,
|
|
419
|
+
operator_id: operatorId ?? refund.operator_id ?? null,
|
|
420
|
+
updated_at: new Date(),
|
|
421
|
+
});
|
|
422
|
+
let result;
|
|
423
|
+
try {
|
|
424
|
+
result = await payProvider.refund(order.out_trade_no, refund.refund_no, refund.amount_cents, refund.total_amount_cents, refund.reason || "");
|
|
425
|
+
}
|
|
426
|
+
catch (e) {
|
|
427
|
+
result = {
|
|
428
|
+
success: false,
|
|
429
|
+
msg: `退款重试异常: ${e.message}`,
|
|
430
|
+
refundNo: refund.refund_no,
|
|
431
|
+
outTradeNo: order.out_trade_no,
|
|
432
|
+
channelRefundNo: "",
|
|
433
|
+
status: REFUND_STATUS_FAILED,
|
|
434
|
+
raw: {},
|
|
435
|
+
};
|
|
436
|
+
}
|
|
437
|
+
await applyRefundResult(refund, order, result, refund.amount_cents, alreadyApplied);
|
|
438
|
+
const saved = (await getRefund(refund.id));
|
|
439
|
+
await dispatchRefundEvent(order, saved);
|
|
440
|
+
return saved;
|
|
441
|
+
}
|
|
442
|
+
export async function autoRefundPayment(paymentOrderId, reason, operatorId) {
|
|
443
|
+
if (!paymentOrderId)
|
|
444
|
+
return null;
|
|
445
|
+
try {
|
|
446
|
+
const order = await getOrder(paymentOrderId);
|
|
447
|
+
if (!order || !["paid", "refunding"].includes(order.status))
|
|
448
|
+
return null;
|
|
449
|
+
return await createRefund({
|
|
450
|
+
paymentOrderId,
|
|
451
|
+
amountCents: null,
|
|
452
|
+
reason,
|
|
453
|
+
operatorId: operatorId ?? null,
|
|
454
|
+
source: REFUND_SOURCE_AUTO,
|
|
455
|
+
});
|
|
456
|
+
}
|
|
457
|
+
catch (e) {
|
|
458
|
+
logger.warning(`自动退款失败 payment_order=${paymentOrderId}: ${e.message}`);
|
|
459
|
+
return null;
|
|
460
|
+
}
|
|
461
|
+
}
|
|
462
|
+
export async function reconcileAbnormalPayments(limit = 20, lookbackDays = RECONCILE_LOOKBACK_DAYS) {
|
|
463
|
+
const cutoff = new Date(Date.now() - lookbackDays * 24 * 3600 * 1000);
|
|
464
|
+
const rows = (await knex(TABLE)
|
|
465
|
+
.whereIn("status", ["failed", "cancelled"])
|
|
466
|
+
.whereNot("provider", "mock")
|
|
467
|
+
.whereNotNull("created_at")
|
|
468
|
+
.where("created_at", ">=", toDbUtc(cutoff))
|
|
469
|
+
.whereNull("reconcile_checked_at")
|
|
470
|
+
.orderBy("id", "asc")
|
|
471
|
+
.limit(limit));
|
|
472
|
+
const refunds = [];
|
|
473
|
+
for (const order of rows) {
|
|
474
|
+
await knex(TABLE)
|
|
475
|
+
.where("id", order.id)
|
|
476
|
+
.update({ reconcile_checked_at: new Date() });
|
|
477
|
+
try {
|
|
478
|
+
const config = await getPaymentSettings();
|
|
479
|
+
const payProvider = createPaymentProvider(order.provider, config);
|
|
480
|
+
const result = await payProvider.queryTrade(order.out_trade_no);
|
|
481
|
+
if (!result.success)
|
|
482
|
+
continue;
|
|
483
|
+
await knex(TABLE)
|
|
484
|
+
.where("id", order.id)
|
|
485
|
+
.update({
|
|
486
|
+
status: "paid",
|
|
487
|
+
trade_no: result.tradeNo || order.trade_no || null,
|
|
488
|
+
paid_at: order.paid_at || new Date(),
|
|
489
|
+
});
|
|
490
|
+
refunds.push(await createRefund({
|
|
491
|
+
paymentOrderId: order.id,
|
|
492
|
+
amountCents: null,
|
|
493
|
+
reason: "渠道掉单自动退款",
|
|
494
|
+
source: REFUND_SOURCE_AUTO,
|
|
495
|
+
}));
|
|
496
|
+
}
|
|
497
|
+
catch (e) {
|
|
498
|
+
logger.warning(`渠道掉单对账失败 ${order.out_trade_no}: ${e.message}`);
|
|
499
|
+
}
|
|
500
|
+
}
|
|
501
|
+
logger.info(`渠道掉单对账完成: 检查 ${rows.length} 笔, 自动退款 ${refunds.length} 笔`);
|
|
502
|
+
return refunds;
|
|
503
|
+
}
|
|
504
|
+
export async function closeOrder(orderId) {
|
|
505
|
+
const order = await getOrder(orderId);
|
|
506
|
+
if (!order)
|
|
507
|
+
throw new Error("支付单不存在");
|
|
508
|
+
if (order.status === "paid")
|
|
509
|
+
throw new Error("已支付订单不可关单,请发起退款");
|
|
510
|
+
if (order.status === "cancelled")
|
|
511
|
+
return order;
|
|
512
|
+
const config = await getPaymentSettings();
|
|
513
|
+
const payProvider = createPaymentProvider(order.provider, config);
|
|
514
|
+
try {
|
|
515
|
+
const result = await payProvider.closeTrade(order.out_trade_no);
|
|
516
|
+
if (!result.success)
|
|
517
|
+
throw new Error(result.msg || "渠道关单失败");
|
|
518
|
+
}
|
|
519
|
+
catch (e) {
|
|
520
|
+
logger.warning(`渠道关单不可用,按本地关闭处理 ${order.out_trade_no}: ${e.message}`);
|
|
521
|
+
}
|
|
522
|
+
await knex(TABLE)
|
|
523
|
+
.where("id", order.id)
|
|
524
|
+
.update({ status: "cancelled", updated_at: new Date() });
|
|
525
|
+
return (await knex(TABLE).where("id", order.id).first());
|
|
526
|
+
}
|
|
527
|
+
export async function syncRefund(refundId) {
|
|
528
|
+
const refund = await getRefund(refundId);
|
|
529
|
+
if (!refund)
|
|
530
|
+
throw new Error("退款记录不存在");
|
|
531
|
+
if (refund.status === REFUND_STATUS_SUCCESS)
|
|
532
|
+
return refund;
|
|
533
|
+
const order = await getOrder(refund.payment_order_id);
|
|
534
|
+
if (!order)
|
|
535
|
+
throw new Error("支付单不存在");
|
|
536
|
+
const config = await getPaymentSettings();
|
|
537
|
+
const payProvider = createPaymentProvider(order.provider, config);
|
|
538
|
+
let result;
|
|
539
|
+
try {
|
|
540
|
+
result = await payProvider.queryRefund(order.out_trade_no, refund.refund_no);
|
|
541
|
+
}
|
|
542
|
+
catch (e) {
|
|
543
|
+
logger.warning(`查询退款状态失败 ${refund.refund_no}: ${e.message}`);
|
|
544
|
+
return refund;
|
|
545
|
+
}
|
|
546
|
+
const applied = refund.status === REFUND_STATUS_PROCESSING;
|
|
547
|
+
if (result.status === "success" || result.status === "processing") {
|
|
548
|
+
await applyRefundResult(refund, order, { ...result, success: true }, refund.amount_cents, applied);
|
|
549
|
+
}
|
|
550
|
+
else {
|
|
551
|
+
await knex(REFUND_TABLE)
|
|
552
|
+
.where("id", refund.id)
|
|
553
|
+
.update({
|
|
554
|
+
status: REFUND_STATUS_FAILED,
|
|
555
|
+
error_msg: (result.msg || "退款失败").slice(0, 500),
|
|
556
|
+
updated_at: new Date(),
|
|
557
|
+
});
|
|
558
|
+
if (!applied && order.status === "refunding") {
|
|
559
|
+
await knex(TABLE).where("id", order.id).update({ status: "paid" });
|
|
560
|
+
}
|
|
561
|
+
}
|
|
562
|
+
const saved = (await getRefund(refund.id));
|
|
563
|
+
await dispatchRefundEvent(order, saved);
|
|
564
|
+
return saved;
|
|
565
|
+
}
|
|
566
|
+
export async function getProviderCapabilitiesByDb(provider) {
|
|
567
|
+
const config = await getPaymentSettings();
|
|
568
|
+
return getProviderCapabilities(provider || getActiveProvider(config), config);
|
|
569
|
+
}
|
|
570
|
+
// ─── 分账 ───
|
|
571
|
+
export const SPLIT_SOURCE_MANUAL = "manual";
|
|
572
|
+
export const SPLIT_SOURCE_AUTO = "auto";
|
|
573
|
+
export const SPLIT_STATUS_PROCESSING = "processing";
|
|
574
|
+
export const SPLIT_STATUS_SUCCESS = "success";
|
|
575
|
+
export const SPLIT_STATUS_FAILED = "failed";
|
|
576
|
+
export const SPLIT_STATUS_FINISHED = "finished";
|
|
577
|
+
export function generateSplitNo() {
|
|
578
|
+
return `S${generateOutTradeNo()}`;
|
|
579
|
+
}
|
|
580
|
+
export function generateSplitReturnNo() {
|
|
581
|
+
return `SR${generateOutTradeNo()}`;
|
|
582
|
+
}
|
|
583
|
+
export async function getSplit(splitId) {
|
|
584
|
+
return (await knex(SPLIT_TABLE)
|
|
585
|
+
.where("id", splitId)
|
|
586
|
+
.first());
|
|
587
|
+
}
|
|
588
|
+
export async function listSplitReceivers(splitId) {
|
|
589
|
+
return (await knex(SPLIT_RECEIVER_TABLE)
|
|
590
|
+
.where("split_id", splitId)
|
|
591
|
+
.orderBy("id", "asc"));
|
|
592
|
+
}
|
|
593
|
+
export async function listSplits(input = {}) {
|
|
594
|
+
const page = input.page ?? 1;
|
|
595
|
+
const size = input.size ?? 20;
|
|
596
|
+
const base = knex(SPLIT_TABLE);
|
|
597
|
+
if (input.paymentOrderId !== null && input.paymentOrderId !== undefined) {
|
|
598
|
+
base.where("payment_order_id", input.paymentOrderId);
|
|
599
|
+
}
|
|
600
|
+
if (input.status)
|
|
601
|
+
base.where("status", input.status);
|
|
602
|
+
if (input.source)
|
|
603
|
+
base.where("source", input.source);
|
|
604
|
+
const totalRow = (await base.clone().count({ c: "*" }).first());
|
|
605
|
+
const items = (await base
|
|
606
|
+
.clone()
|
|
607
|
+
.orderBy("id", "desc")
|
|
608
|
+
.offset((page - 1) * size)
|
|
609
|
+
.limit(size));
|
|
610
|
+
return { total: Number(totalRow?.c ?? 0), items };
|
|
611
|
+
}
|
|
612
|
+
export async function listSplitReturns(splitId, status, page = 1, size = 20) {
|
|
613
|
+
const base = knex(SPLIT_RETURN_TABLE);
|
|
614
|
+
if (splitId !== null && splitId !== undefined)
|
|
615
|
+
base.where("split_id", splitId);
|
|
616
|
+
if (status)
|
|
617
|
+
base.where("status", status);
|
|
618
|
+
const totalRow = (await base.clone().count({ c: "*" }).first());
|
|
619
|
+
const items = (await base
|
|
620
|
+
.clone()
|
|
621
|
+
.orderBy("id", "desc")
|
|
622
|
+
.offset((page - 1) * size)
|
|
623
|
+
.limit(size));
|
|
624
|
+
return { total: Number(totalRow?.c ?? 0), items };
|
|
625
|
+
}
|
|
626
|
+
export async function bindSplitReceiver(provider, receiverType, account, name = "", relationType = "") {
|
|
627
|
+
const config = await getPaymentSettings();
|
|
628
|
+
const payProvider = createPaymentProvider(provider, config);
|
|
629
|
+
return payProvider.bindSplitReceiver(receiverType, account, name, relationType);
|
|
630
|
+
}
|
|
631
|
+
async function applySplitResult(split, receiverRows, order, result, totalCents, alreadyApplied) {
|
|
632
|
+
const status = result.success
|
|
633
|
+
? result.status === SPLIT_STATUS_SUCCESS
|
|
634
|
+
? SPLIT_STATUS_SUCCESS
|
|
635
|
+
: result.status === SPLIT_STATUS_FINISHED
|
|
636
|
+
? SPLIT_STATUS_FINISHED
|
|
637
|
+
: SPLIT_STATUS_PROCESSING
|
|
638
|
+
: SPLIT_STATUS_FAILED;
|
|
639
|
+
const patch = {
|
|
640
|
+
status,
|
|
641
|
+
channel_split_no: result.channelSplitNo || split.channel_split_no || null,
|
|
642
|
+
error_msg: result.success ? null : (result.msg || "分账失败").slice(0, 500),
|
|
643
|
+
updated_at: new Date(),
|
|
644
|
+
};
|
|
645
|
+
await knex(SPLIT_TABLE).where("id", split.id).update(patch);
|
|
646
|
+
if (!result.success) {
|
|
647
|
+
await knex(SPLIT_RECEIVER_TABLE).where("split_id", split.id).update({
|
|
648
|
+
status: "failed",
|
|
649
|
+
error_msg: patch["error_msg"],
|
|
650
|
+
updated_at: new Date(),
|
|
651
|
+
});
|
|
652
|
+
return;
|
|
653
|
+
}
|
|
654
|
+
if (!alreadyApplied) {
|
|
655
|
+
await knex(TABLE)
|
|
656
|
+
.where("id", order.id)
|
|
657
|
+
.update({
|
|
658
|
+
split_amount_cents: (order.split_amount_cents || 0) + totalCents,
|
|
659
|
+
updated_at: new Date(),
|
|
660
|
+
});
|
|
661
|
+
}
|
|
662
|
+
const byKey = new Map();
|
|
663
|
+
for (const item of result.receivers || []) {
|
|
664
|
+
const key = `${String(item["receiver_type"] || item["receiverType"] || "")}|${String(item["account"] || "")}`;
|
|
665
|
+
byKey.set(key, item);
|
|
666
|
+
}
|
|
667
|
+
for (const row of receiverRows) {
|
|
668
|
+
const matched = byKey.get(`${row.receiver_type}|${row.account}`);
|
|
669
|
+
const rowStatus = matched
|
|
670
|
+
? String(matched["status"] || "")
|
|
671
|
+
: status === SPLIT_STATUS_SUCCESS || status === SPLIT_STATUS_FINISHED
|
|
672
|
+
? "success"
|
|
673
|
+
: "pending";
|
|
674
|
+
await knex(SPLIT_RECEIVER_TABLE)
|
|
675
|
+
.where("id", row.id)
|
|
676
|
+
.update({
|
|
677
|
+
status: rowStatus || "pending",
|
|
678
|
+
channel_detail_id: matched?.["channel_detail_id"] ?? null,
|
|
679
|
+
error_msg: matched?.["error_msg"] ?? null,
|
|
680
|
+
updated_at: new Date(),
|
|
681
|
+
});
|
|
682
|
+
}
|
|
683
|
+
}
|
|
684
|
+
async function dispatchSplitEvent(eventType, order, split) {
|
|
685
|
+
await events.dispatchPaymentEvent({
|
|
686
|
+
eventType,
|
|
687
|
+
paymentOrder: order,
|
|
688
|
+
split: split,
|
|
689
|
+
payload: {
|
|
690
|
+
provider: split.provider,
|
|
691
|
+
splitNo: split.split_no,
|
|
692
|
+
status: split.status,
|
|
693
|
+
},
|
|
694
|
+
});
|
|
695
|
+
}
|
|
696
|
+
export async function createSplit(input) {
|
|
697
|
+
const order = await getOrder(input.paymentOrderId);
|
|
698
|
+
if (!order)
|
|
699
|
+
throw new Error("支付单不存在");
|
|
700
|
+
if (order.status !== "paid") {
|
|
701
|
+
throw new Error(`当前支付单状态不可分账: ${order.status}`);
|
|
702
|
+
}
|
|
703
|
+
if ((order.refunded_amount_cents || 0) > 0) {
|
|
704
|
+
throw new Error("支付单已发生退款,不可分账");
|
|
705
|
+
}
|
|
706
|
+
const parsed = (input.receivers || []).map((item) => {
|
|
707
|
+
const receiverType = String(item.receiver_type || item.type || "").trim();
|
|
708
|
+
const account = String(item.account || "").trim();
|
|
709
|
+
const amountCents = Number(item.amount_cents || 0);
|
|
710
|
+
if (!receiverType || !account || amountCents <= 0) {
|
|
711
|
+
throw new Error("分账接收方参数不完整(receiver_type/account/amount_cents)");
|
|
712
|
+
}
|
|
713
|
+
return {
|
|
714
|
+
receiverType,
|
|
715
|
+
account,
|
|
716
|
+
amountCents,
|
|
717
|
+
description: item.description || "",
|
|
718
|
+
name: item.name || "",
|
|
719
|
+
};
|
|
720
|
+
});
|
|
721
|
+
const total = parsed.reduce((sum, r) => sum + r.amountCents, 0);
|
|
722
|
+
const remaining = order.amount_cents - (order.split_amount_cents || 0);
|
|
723
|
+
if (total <= 0)
|
|
724
|
+
throw new Error("分账金额必须大于 0");
|
|
725
|
+
if (total > remaining) {
|
|
726
|
+
throw new Error(`分账金额超出可分配余额(剩余可分配 ${remaining} 分)`);
|
|
727
|
+
}
|
|
728
|
+
const splitNo = (input.splitNo || "").trim() || generateSplitNo();
|
|
729
|
+
const existing = (await knex(SPLIT_TABLE)
|
|
730
|
+
.where("split_no", splitNo)
|
|
731
|
+
.first());
|
|
732
|
+
if (existing)
|
|
733
|
+
return existing;
|
|
734
|
+
const config = await getPaymentSettings();
|
|
735
|
+
const payProvider = createPaymentProvider(order.provider, config);
|
|
736
|
+
const now = new Date();
|
|
737
|
+
const [splitId] = await knex(SPLIT_TABLE).insert({
|
|
738
|
+
split_no: splitNo,
|
|
739
|
+
payment_order_id: order.id,
|
|
740
|
+
out_trade_no: order.out_trade_no,
|
|
741
|
+
provider: order.provider,
|
|
742
|
+
transaction_id: order.trade_no || "",
|
|
743
|
+
total_amount_cents: order.amount_cents,
|
|
744
|
+
split_amount_cents: total,
|
|
745
|
+
status: SPLIT_STATUS_PROCESSING,
|
|
746
|
+
source: input.source || SPLIT_SOURCE_MANUAL,
|
|
747
|
+
operator_id: input.operatorId ?? null,
|
|
748
|
+
remark: (input.reason || "").slice(0, 255),
|
|
749
|
+
created_at: now,
|
|
750
|
+
updated_at: now,
|
|
751
|
+
});
|
|
752
|
+
const split = (await getSplit(Number(splitId)));
|
|
753
|
+
const receiverIds = [];
|
|
754
|
+
for (const r of parsed) {
|
|
755
|
+
const [rid] = await knex(SPLIT_RECEIVER_TABLE).insert({
|
|
756
|
+
split_id: split.id,
|
|
757
|
+
receiver_type: r.receiverType,
|
|
758
|
+
account: r.account,
|
|
759
|
+
name: r.name || "",
|
|
760
|
+
amount_cents: r.amountCents,
|
|
761
|
+
description: r.description || "",
|
|
762
|
+
status: "pending",
|
|
763
|
+
created_at: now,
|
|
764
|
+
updated_at: now,
|
|
765
|
+
});
|
|
766
|
+
receiverIds.push(Number(rid));
|
|
767
|
+
}
|
|
768
|
+
const receiverRows = (await knex(SPLIT_RECEIVER_TABLE)
|
|
769
|
+
.whereIn("id", receiverIds)
|
|
770
|
+
.orderBy("id", "asc"));
|
|
771
|
+
let result;
|
|
772
|
+
try {
|
|
773
|
+
result = await payProvider.split(order.out_trade_no, split.split_no, parsed, input.reason || "", order.trade_no || "");
|
|
774
|
+
}
|
|
775
|
+
catch (e) {
|
|
776
|
+
result = {
|
|
777
|
+
success: false,
|
|
778
|
+
msg: `分账请求异常: ${e.message}`,
|
|
779
|
+
splitNo: split.split_no,
|
|
780
|
+
outTradeNo: order.out_trade_no,
|
|
781
|
+
channelSplitNo: "",
|
|
782
|
+
status: SPLIT_STATUS_FAILED,
|
|
783
|
+
receivers: [],
|
|
784
|
+
raw: {},
|
|
785
|
+
};
|
|
786
|
+
}
|
|
787
|
+
await applySplitResult(split, receiverRows, order, result, total, false);
|
|
788
|
+
const saved = (await getSplit(split.id));
|
|
789
|
+
await dispatchSplitEvent(saved.status === SPLIT_STATUS_SUCCESS
|
|
790
|
+
? events.EVENT_SPLIT_SUCCEEDED
|
|
791
|
+
: saved.status === SPLIT_STATUS_PROCESSING
|
|
792
|
+
? events.EVENT_SPLIT_PROCESSING
|
|
793
|
+
: events.EVENT_SPLIT_FAILED, order, saved);
|
|
794
|
+
return saved;
|
|
795
|
+
}
|
|
796
|
+
export async function querySplit(splitId) {
|
|
797
|
+
const split = await getSplit(splitId);
|
|
798
|
+
if (!split)
|
|
799
|
+
throw new Error("分账单不存在");
|
|
800
|
+
if (split.status === SPLIT_STATUS_FINISHED)
|
|
801
|
+
return split;
|
|
802
|
+
const order = await getOrder(split.payment_order_id);
|
|
803
|
+
if (!order)
|
|
804
|
+
throw new Error("支付单不存在");
|
|
805
|
+
const config = await getPaymentSettings();
|
|
806
|
+
const payProvider = createPaymentProvider(order.provider, config);
|
|
807
|
+
let result;
|
|
808
|
+
try {
|
|
809
|
+
result = await payProvider.querySplit(order.out_trade_no, split.split_no, split.transaction_id || order.trade_no || "");
|
|
810
|
+
}
|
|
811
|
+
catch (e) {
|
|
812
|
+
logger.warning(`查询分账状态失败 ${split.split_no}: ${e.message}`);
|
|
813
|
+
return split;
|
|
814
|
+
}
|
|
815
|
+
const receiverRows = await listSplitReceivers(split.id);
|
|
816
|
+
const applied = split.status === SPLIT_STATUS_SUCCESS ||
|
|
817
|
+
split.status === SPLIT_STATUS_PROCESSING;
|
|
818
|
+
await applySplitResult(split, receiverRows, order, result, split.split_amount_cents, applied);
|
|
819
|
+
const saved = (await getSplit(split.id));
|
|
820
|
+
await dispatchSplitEvent(saved.status === SPLIT_STATUS_SUCCESS
|
|
821
|
+
? events.EVENT_SPLIT_SUCCEEDED
|
|
822
|
+
: saved.status === SPLIT_STATUS_PROCESSING
|
|
823
|
+
? events.EVENT_SPLIT_PROCESSING
|
|
824
|
+
: events.EVENT_SPLIT_FAILED, order, saved);
|
|
825
|
+
return saved;
|
|
826
|
+
}
|
|
827
|
+
export async function finishSplit(splitId, reason = "") {
|
|
828
|
+
const split = await getSplit(splitId);
|
|
829
|
+
if (!split)
|
|
830
|
+
throw new Error("分账单不存在");
|
|
831
|
+
if (split.status !== SPLIT_STATUS_SUCCESS &&
|
|
832
|
+
split.status !== SPLIT_STATUS_PROCESSING) {
|
|
833
|
+
throw new Error(`当前分账单状态不可完结: ${split.status}`);
|
|
834
|
+
}
|
|
835
|
+
const order = await getOrder(split.payment_order_id);
|
|
836
|
+
if (!order)
|
|
837
|
+
throw new Error("支付单不存在");
|
|
838
|
+
const config = await getPaymentSettings();
|
|
839
|
+
const payProvider = createPaymentProvider(order.provider, config);
|
|
840
|
+
let result;
|
|
841
|
+
try {
|
|
842
|
+
result = await payProvider.finishSplit(order.out_trade_no, split.split_no, split.transaction_id || order.trade_no || "", reason);
|
|
843
|
+
}
|
|
844
|
+
catch (e) {
|
|
845
|
+
result = {
|
|
846
|
+
success: false,
|
|
847
|
+
msg: `完结分账异常: ${e.message}`,
|
|
848
|
+
splitNo: split.split_no,
|
|
849
|
+
outTradeNo: order.out_trade_no,
|
|
850
|
+
channelSplitNo: "",
|
|
851
|
+
status: SPLIT_STATUS_FAILED,
|
|
852
|
+
receivers: [],
|
|
853
|
+
raw: {},
|
|
854
|
+
};
|
|
855
|
+
}
|
|
856
|
+
if (result.success) {
|
|
857
|
+
await knex(SPLIT_TABLE)
|
|
858
|
+
.where("id", split.id)
|
|
859
|
+
.update({
|
|
860
|
+
status: SPLIT_STATUS_FINISHED,
|
|
861
|
+
finished_at: new Date(),
|
|
862
|
+
channel_split_no: result.channelSplitNo || split.channel_split_no || null,
|
|
863
|
+
error_msg: null,
|
|
864
|
+
updated_at: new Date(),
|
|
865
|
+
});
|
|
866
|
+
}
|
|
867
|
+
else {
|
|
868
|
+
await knex(SPLIT_TABLE)
|
|
869
|
+
.where("id", split.id)
|
|
870
|
+
.update({
|
|
871
|
+
error_msg: (result.msg || "完结分账失败").slice(0, 500),
|
|
872
|
+
updated_at: new Date(),
|
|
873
|
+
});
|
|
874
|
+
}
|
|
875
|
+
const saved = (await getSplit(split.id));
|
|
876
|
+
await dispatchSplitEvent(result.success ? events.EVENT_SPLIT_FINISHED : events.EVENT_SPLIT_FAILED, order, saved);
|
|
877
|
+
return saved;
|
|
878
|
+
}
|
|
879
|
+
export async function createSplitReturn(input) {
|
|
880
|
+
const split = await getSplit(input.splitId);
|
|
881
|
+
if (!split)
|
|
882
|
+
throw new Error("分账单不存在");
|
|
883
|
+
if (split.status !== SPLIT_STATUS_SUCCESS &&
|
|
884
|
+
split.status !== SPLIT_STATUS_PROCESSING) {
|
|
885
|
+
throw new Error(`当前分账单状态不可回退: ${split.status}`);
|
|
886
|
+
}
|
|
887
|
+
if (input.amountCents <= 0)
|
|
888
|
+
throw new Error("回退金额必须大于 0");
|
|
889
|
+
const returnedRow = (await knex(SPLIT_RETURN_TABLE)
|
|
890
|
+
.where("split_id", split.id)
|
|
891
|
+
.whereIn("status", [SPLIT_STATUS_SUCCESS, SPLIT_STATUS_PROCESSING])
|
|
892
|
+
.sum({ total: "amount_cents" })
|
|
893
|
+
.first());
|
|
894
|
+
const returnedTotal = Number(returnedRow?.total ?? 0);
|
|
895
|
+
if (input.amountCents + returnedTotal > split.split_amount_cents) {
|
|
896
|
+
throw new Error("回退金额超出分账总额");
|
|
897
|
+
}
|
|
898
|
+
const order = await getOrder(split.payment_order_id);
|
|
899
|
+
if (!order)
|
|
900
|
+
throw new Error("支付单不存在");
|
|
901
|
+
const returnNo = (input.returnNo || "").trim() || generateSplitReturnNo();
|
|
902
|
+
const existing = (await knex(SPLIT_RETURN_TABLE)
|
|
903
|
+
.where("return_no", returnNo)
|
|
904
|
+
.first());
|
|
905
|
+
if (existing)
|
|
906
|
+
return existing;
|
|
907
|
+
const config = await getPaymentSettings();
|
|
908
|
+
const payProvider = createPaymentProvider(order.provider, config);
|
|
909
|
+
const now = new Date();
|
|
910
|
+
const [rowId] = await knex(SPLIT_RETURN_TABLE).insert({
|
|
911
|
+
return_no: returnNo,
|
|
912
|
+
split_id: split.id,
|
|
913
|
+
payment_order_id: order.id,
|
|
914
|
+
out_trade_no: order.out_trade_no,
|
|
915
|
+
provider: order.provider,
|
|
916
|
+
receiver_type: input.receiverType,
|
|
917
|
+
receiver_account: input.receiverAccount,
|
|
918
|
+
amount_cents: input.amountCents,
|
|
919
|
+
reason: (input.reason || "").slice(0, 255),
|
|
920
|
+
status: SPLIT_STATUS_PROCESSING,
|
|
921
|
+
operator_id: input.operatorId ?? null,
|
|
922
|
+
created_at: now,
|
|
923
|
+
updated_at: now,
|
|
924
|
+
});
|
|
925
|
+
let result;
|
|
926
|
+
try {
|
|
927
|
+
result = await payProvider.returnSplit(order.out_trade_no, split.split_no, returnNo, input.amountCents, input.receiverType, input.receiverAccount, input.reason || "", split.transaction_id || order.trade_no || "");
|
|
928
|
+
}
|
|
929
|
+
catch (e) {
|
|
930
|
+
result = {
|
|
931
|
+
success: false,
|
|
932
|
+
msg: `分账回退异常: ${e.message}`,
|
|
933
|
+
splitNo: split.split_no,
|
|
934
|
+
outTradeNo: order.out_trade_no,
|
|
935
|
+
channelSplitNo: "",
|
|
936
|
+
status: SPLIT_STATUS_FAILED,
|
|
937
|
+
receivers: [],
|
|
938
|
+
raw: {},
|
|
939
|
+
};
|
|
940
|
+
}
|
|
941
|
+
await knex(SPLIT_RETURN_TABLE)
|
|
942
|
+
.where("id", Number(rowId))
|
|
943
|
+
.update({
|
|
944
|
+
status: result.success
|
|
945
|
+
? result.status === SPLIT_STATUS_SUCCESS
|
|
946
|
+
? SPLIT_STATUS_SUCCESS
|
|
947
|
+
: SPLIT_STATUS_PROCESSING
|
|
948
|
+
: SPLIT_STATUS_FAILED,
|
|
949
|
+
channel_return_no: result.channelSplitNo || null,
|
|
950
|
+
error_msg: result.success
|
|
951
|
+
? null
|
|
952
|
+
: (result.msg || "分账回退失败").slice(0, 500),
|
|
953
|
+
updated_at: new Date(),
|
|
954
|
+
});
|
|
955
|
+
const saved = (await knex(SPLIT_RETURN_TABLE)
|
|
956
|
+
.where("id", Number(rowId))
|
|
957
|
+
.first());
|
|
958
|
+
await events.dispatchPaymentEvent({
|
|
959
|
+
eventType: result.success
|
|
960
|
+
? events.EVENT_SPLIT_RETURNED
|
|
961
|
+
: events.EVENT_SPLIT_FAILED,
|
|
962
|
+
paymentOrder: order,
|
|
963
|
+
split: split,
|
|
964
|
+
payload: {
|
|
965
|
+
returnNo: saved.return_no,
|
|
966
|
+
amountCents: saved.amount_cents,
|
|
967
|
+
receiverType: saved.receiver_type,
|
|
968
|
+
receiverAccount: saved.receiver_account,
|
|
969
|
+
status: saved.status,
|
|
970
|
+
},
|
|
971
|
+
});
|
|
972
|
+
return saved;
|
|
973
|
+
}
|
|
225
974
|
//# sourceMappingURL=service.js.map
|