- 新增 service/wxpay.js:统一下单 / 查询订单 / 关闭订单 / APIv2 验签,二维码在服务端本地生成 SVG - 新增 pay/wechat.js 与 XML 编解码,公开回调 POST /api/pay/wechat/notify - 订单:同主体 + 同套餐复用未超时待支付单;2 小时超时关单;回调 / 查单 / 手工确认统一走 payNotify - 迁移 subject_orders 增加 code_url / prepay_id 等字段,配置项 WXPAY_* - 前端续期弹窗展示二维码并按 2s 轮询支付结果 - 文档与测试同步更新 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
562 lines
24 KiB
JavaScript
562 lines
24 KiB
JavaScript
'use strict';
|
||
|
||
const { Service } = require('egg');
|
||
const crypto = require('crypto');
|
||
const { Op } = require('sequelize');
|
||
|
||
const DAY_MS = 24 * 3600 * 1000;
|
||
const STATUS_TEXT = { 0: '待支付', 1: '已支付', 2: '已关闭' };
|
||
/** 待支付订单默认有效期:2 小时(与微信扫码支付二维码有效期对齐) */
|
||
const DEFAULT_ORDER_TTL_SECONDS = 2 * 3600;
|
||
/** 主动查单节流:同一个订单 10 秒内只问一次微信(前端 2s 一轮询,没必要每轮都打) */
|
||
const QUERY_THROTTLE_MS = 10 * 1000;
|
||
/** 查单节流表的清理阈值(条数 / 记录保留时长) */
|
||
const QUERY_MAP_LIMIT = 500;
|
||
const QUERY_KEEP_MS = 10 * 60 * 1000;
|
||
|
||
/** orderNo → 上次主动查单时间(单实例内存节流,丢了也只是多查一次) */
|
||
const lastQueryAt = new Map();
|
||
|
||
/** 节流放行判断:可以查就登记并返回 true */
|
||
function takeQuerySlot(orderNo) {
|
||
const now = Date.now();
|
||
if (now - (lastQueryAt.get(orderNo) || 0) < QUERY_THROTTLE_MS) return false;
|
||
lastQueryAt.set(orderNo, now);
|
||
if (lastQueryAt.size > QUERY_MAP_LIMIT) {
|
||
for (const [ key, at ] of lastQueryAt) {
|
||
if (now - at > QUERY_KEEP_MS) lastQueryAt.delete(key);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 主体续期订单 service
|
||
*
|
||
* 流程:`create()` 选套餐下单(待支付)→ 微信 Native 统一下单拿 `code_url` → 前端展示二维码
|
||
* → 用户扫码付款 → 渠道回调 `payNotify()` → 标记已支付 + 主体顺延 + 清状态缓存。
|
||
*
|
||
* 关键约定:
|
||
* - **支付靠回调驱动**:下单不改变期限,只有 `payNotify()` 成功才续期;
|
||
* - **价格只认套餐**:下单只收 `planId`,金额取库里的 `subject_plans.price`,不信前端传的金额;
|
||
* - **复用未过期订单**:同一主体 + 同一套餐还有没超时的待支付单时直接返回**原订单**(连二维码一起),
|
||
* 不重复建单;超时关单后再下单才建新单;
|
||
* - **幂等**:同一订单重复回调只续期一次(第二次返回 `duplicated: true`);
|
||
* - **2 小时自动失效**:待支付订单超过 `config.pay.orderTtl`(默认 7200 秒)未支付即关闭,
|
||
* 之后再来的支付回调一律 409 —— 与微信扫码支付二维码 2 小时有效期保持一致;
|
||
* - **回调查单兜底**:微信通知可能丢失,轮询订单详情时会主动查单(`syncPayState`)补入账;
|
||
* - 续期基数与 `service.subject.update` 一致:未过期在原到期时间上顺延,已过期从当前时间起算。
|
||
*/
|
||
class SubjectOrderService extends Service {
|
||
get Order() {
|
||
return this.app.model.SubjectOrder;
|
||
}
|
||
|
||
get Subject() {
|
||
return this.app.model.Subject;
|
||
}
|
||
|
||
/** 待支付订单有效期(毫秒),`config.pay.orderTtl` 秒,默认 2 小时 */
|
||
get orderTtlMs() {
|
||
const seconds = Number(this.config.pay && this.config.pay.orderTtl);
|
||
return (Number.isFinite(seconds) && seconds > 0 ? seconds : DEFAULT_ORDER_TTL_SECONDS) * 1000;
|
||
}
|
||
|
||
/** 支付截止时间 = 下单时间 + 有效期 */
|
||
payExpireAtOf(order) {
|
||
const createdAt = order.createdAt || order.created_at;
|
||
const baseMs = createdAt ? new Date(createdAt).getTime() : Date.now();
|
||
return new Date(baseMs + this.orderTtlMs);
|
||
}
|
||
|
||
/** 是否已过支付截止时间(只有待支付订单才谈得上超时) */
|
||
isExpired(order, now = Date.now()) {
|
||
const createdAt = order.createdAt || order.created_at;
|
||
if (Number(order.status) !== 0 || !createdAt) return false;
|
||
return this.payExpireAtOf(order).getTime() <= now;
|
||
}
|
||
|
||
/**
|
||
* 把已超时的待支付订单标记为已关闭(读路径顺手收口,不依赖定时任务)
|
||
*
|
||
* @param {Array} orders Sequelize 实例或普通行;关闭后实例的 `status` 会同步改成 2
|
||
* @return {Promise<number>} 实际关闭的条数
|
||
*/
|
||
async closeExpired(orders = []) {
|
||
const expired = orders.filter(row => this.isExpired(row));
|
||
if (!expired.length) return 0;
|
||
|
||
const ids = expired.map(row => Number(row.id));
|
||
const [ affected ] = await this.Order.update(
|
||
{ status: 2 },
|
||
{ where: { id: { [Op.in]: ids }, status: 0 } },
|
||
);
|
||
expired.forEach(row => { row.status = 2; });
|
||
|
||
this.ctx.logger.info('[order] 超时未支付,自动关闭订单 %d 笔:%s', ids.length, ids.join(','));
|
||
return Number(affected) || 0;
|
||
}
|
||
|
||
/**
|
||
* 定时任务入口:批量关闭所有超时未支付的订单
|
||
*
|
||
* @return {Promise<number>} 关闭的订单数
|
||
*/
|
||
async sweepExpired() {
|
||
const cutoff = new Date(Date.now() - this.orderTtlMs);
|
||
// 注意:模型的时间戳属性名是 `created_at`(config.sequelize.define.createdAt 改过名),
|
||
// 写成 `createdAt` 会被当成不存在的列,定时任务每次都报 ER_BAD_FIELD_ERROR
|
||
const [ closed ] = await this.Order.update(
|
||
{ status: 2 },
|
||
{ where: { status: 0, created_at: { [Op.lt]: cutoff } } },
|
||
);
|
||
return Number(closed) || 0;
|
||
}
|
||
|
||
/**
|
||
* 创建订单(管理员):选套餐 → 只建单,不动期限
|
||
*
|
||
* 同一主体 + 同一套餐还有**没超时**的待支付单时直接复用(连二维码一起,不重复建单);
|
||
* 已超时的顺手关掉,再建新单。
|
||
*
|
||
* @param {object} params { subjectId, userId, planId, remark }
|
||
* @return {Promise<object>} 订单(含 `reused` / `codeUrl` / `qrImage`)
|
||
*/
|
||
async create({ subjectId, userId, planId, remark } = {}) {
|
||
const { subject } = await this.ctx.service.subject.ensureAdmin(subjectId, userId);
|
||
|
||
const plan = await this.ctx.service.subjectPlan.findActive(planId);
|
||
const grantDays = Number(plan.days);
|
||
const price = Number(plan.price);
|
||
|
||
if (!Number.isFinite(grantDays) || grantDays <= 0 || grantDays > 3650) {
|
||
this.ctx.throw(422, '套餐天数不合法,请联系管理员');
|
||
}
|
||
if (!Number.isFinite(price) || price <= 0) {
|
||
this.ctx.throw(422, '该套餐未设置价格,请联系管理员');
|
||
}
|
||
|
||
// 复用:同一主体 + 同一套餐 + 还没过支付截止时间 → 原单原二维码,前端只看剩余时间
|
||
const reusable = await this.findReusable({ subjectId: subject.id, planId: plan.id });
|
||
if (reusable) {
|
||
await this.ensurePayment(reusable);
|
||
this.ctx.logger.info('[order] 复用未支付订单 %s(主体 %s,套餐 %s,支付截止 %s)',
|
||
reusable.orderNo, subject.id, plan.code, this.payExpireAtOf(reusable).toISOString());
|
||
return this.present(reusable, { reused: true, qrImage: this.qrImageOf(reusable) });
|
||
}
|
||
|
||
const order = await this.Order.create({
|
||
orderNo: generateOrderNo(),
|
||
subjectId: Number(subject.id),
|
||
userId: Number(userId),
|
||
planId: Number(plan.id),
|
||
planCode: plan.code,
|
||
planName: plan.name,
|
||
days: grantDays,
|
||
amount: Math.round(price * 100) / 100,
|
||
status: 0,
|
||
channel: this.ctx.service.wxpay.enabled ? 'wechat' : 'mock',
|
||
expireBefore: subject.expireAt,
|
||
remark: remark || null,
|
||
});
|
||
|
||
try {
|
||
await this.ensurePayment(order);
|
||
} catch (err) {
|
||
// 微信下单失败 = 这笔订单付不了:直接关掉,别让用户看到「有订单但没有二维码」的假象
|
||
await this.Order.update({ status: 2 }, { where: { id: order.id, status: 0 } });
|
||
order.status = 2;
|
||
throw err;
|
||
}
|
||
|
||
this.ctx.logger.info('[order] 用户 %s 为主体 %s 创建续期订单 %s(套餐 %s,%s 天,金额 %s)',
|
||
userId, subject.id, order.orderNo, plan.code, grantDays, price);
|
||
|
||
return this.present(order, { reused: false, qrImage: this.qrImageOf(order) });
|
||
}
|
||
|
||
/**
|
||
* 可沿用的待支付订单:同一主体 + 同一套餐 + 还没过支付截止时间
|
||
*
|
||
* 过期的就地关掉(不参与复用),避免「拿着失效二维码去付款」。
|
||
* @param {object} params { subjectId, planId }
|
||
* @return {Promise<object|null>} 可复用的订单
|
||
*/
|
||
async findReusable({ subjectId, planId } = {}) {
|
||
const rows = await this.Order.findAll({
|
||
where: { subjectId: Number(subjectId), planId: Number(planId), status: 0 },
|
||
order: [[ 'id', 'DESC' ]],
|
||
limit: 5,
|
||
});
|
||
await this.closeExpired(rows);
|
||
return rows.find(row => Number(row.status) === 0) || null;
|
||
}
|
||
|
||
/**
|
||
* 确保待支付订单有微信二维码(`code_url`)
|
||
*
|
||
* 已经生成过就直接用;微信支付未配置时什么都不做(订单照样存在,只是没二维码)。
|
||
* @param {object} order 订单实例
|
||
* @return {Promise<object>} 订单实例
|
||
*/
|
||
async ensurePayment(order) {
|
||
const wxpay = this.ctx.service.wxpay;
|
||
// 没配好(缺凭证 / 密钥长度不对)只记一条 WARN:订单照样建,但不生成二维码
|
||
wxpay.warnIfMisconfigured();
|
||
if (!wxpay.enabled || !order || Number(order.status) !== 0 || order.codeUrl) return order;
|
||
|
||
const fee = Math.round(Number(order.amount) * 100);
|
||
const { codeUrl, prepayId } = await wxpay.unifiedOrder({
|
||
orderNo: order.orderNo,
|
||
totalFee: fee,
|
||
description: order.planName || `${order.days} 天`,
|
||
clientIp: this.ctx.ip,
|
||
expireAt: this.payExpireAtOf(order),
|
||
productId: order.orderNo,
|
||
});
|
||
|
||
await order.update({ codeUrl, prepayId, channel: 'wechat' });
|
||
this.ctx.logger.info('[order] 订单 %s 已下单微信 Native 支付(%s 分)', order.orderNo, fee);
|
||
return order;
|
||
}
|
||
|
||
/** 待支付订单的二维码图片(data URL);不可支付/未配置微信支付时返回 null */
|
||
qrImageOf(order) {
|
||
if (!order || Number(order.status) !== 0 || !order.codeUrl) return null;
|
||
return this.ctx.service.wxpay.qrDataUrl(order.codeUrl);
|
||
}
|
||
|
||
/**
|
||
* 主动查单补入账(微信通知可能丢失,前端轮询订单详情时顺带做一次)
|
||
*
|
||
* 节流:同一订单 10 秒最多查一次;任何失败都只记日志,不影响读订单。
|
||
* @param {object} order 订单实例
|
||
* @param {object} [options] { force } 跳过节流
|
||
* @return {Promise<object>} 订单实例(已重新读取最新状态)
|
||
*/
|
||
async syncPayState(order, { force = false } = {}) {
|
||
const wxpay = this.ctx.service.wxpay;
|
||
if (!wxpay.enabled || !order || Number(order.status) !== 0 || order.channel !== 'wechat') return order;
|
||
if (!force && !takeQuerySlot(order.orderNo)) return order;
|
||
if (force) takeQuerySlot(order.orderNo);
|
||
|
||
let result;
|
||
try {
|
||
result = await wxpay.queryOrder({ orderNo: order.orderNo });
|
||
} catch (err) {
|
||
this.ctx.logger.warn('[wxpay] 主动查单失败 %s:%s', order.orderNo, err.message);
|
||
return order;
|
||
}
|
||
if (result.tradeState !== 'SUCCESS') return order;
|
||
|
||
try {
|
||
await this.payNotify({
|
||
orderNo: order.orderNo,
|
||
transactionId: result.transactionId,
|
||
amount: result.totalFee === null ? undefined : result.totalFee / 100,
|
||
channel: 'wechat',
|
||
paidAt: result.paidAt,
|
||
});
|
||
this.ctx.logger.info('[wxpay] 主动查单确认已支付,订单 %s 已入账', order.orderNo);
|
||
} catch (err) {
|
||
this.ctx.logger.warn('[wxpay] 主动查单后入账失败 %s:%s', order.orderNo, err.message);
|
||
return order;
|
||
}
|
||
|
||
const fresh = await this.Order.findByPk(Number(order.id));
|
||
if (fresh) Object.assign(order, typeof fresh.toJSON === 'function' ? fresh.toJSON() : fresh);
|
||
return order;
|
||
}
|
||
|
||
/**
|
||
* 本地关单前先在微信侧关掉,避免二维码过期前还能被扫付
|
||
* @param {object} order 订单实例
|
||
* @return {Promise<{ skipped?: boolean, closed?: boolean, paid?: boolean, failed?: string }>}
|
||
*/
|
||
async closeRemote(order) {
|
||
const wxpay = this.ctx.service.wxpay;
|
||
if (!wxpay.enabled || !order || order.channel !== 'wechat') return { skipped: true };
|
||
try {
|
||
const result = await wxpay.closeOrder({ orderNo: order.orderNo });
|
||
return { closed: true, already: result.already };
|
||
} catch (err) {
|
||
if (err.code === 'ORDERPAID') return { paid: true };
|
||
this.ctx.logger.warn('[wxpay] 关闭微信订单 %s 失败(忽略):%s', order.orderNo, err.message);
|
||
return { failed: err.message };
|
||
}
|
||
}
|
||
|
||
/** 单个订单(续期弹窗轮询支付状态用;必须是该主体成员) */
|
||
async detail({ subjectId, userId, orderNo } = {}) {
|
||
await this.ctx.service.subject.findForUser(subjectId, userId);
|
||
|
||
const no = String(orderNo || '').trim();
|
||
if (!no) this.ctx.throw(400, 'orderNo 不能为空');
|
||
|
||
const order = await this.Order.findOne({
|
||
where: { orderNo: no, subjectId: Number(subjectId) },
|
||
});
|
||
if (!order) this.ctx.throw(404, '订单不存在');
|
||
await this.closeExpired([ order ]);
|
||
// 微信通知可能丢失:轮询时顺带查一次单(内部节流),确认已付就当场入账
|
||
if (Number(order.status) === 0) await this.syncPayState(order);
|
||
return this.present(order, { qrImage: this.qrImageOf(order) });
|
||
}
|
||
|
||
/** 关闭待支付订单(用户取消 / 重新下单前清理) */
|
||
async close({ subjectId, userId, orderNo } = {}) {
|
||
await this.ctx.service.subject.ensureAdmin(subjectId, userId);
|
||
|
||
const no = String(orderNo || '').trim();
|
||
if (!no) this.ctx.throw(400, 'orderNo 不能为空');
|
||
|
||
const order = await this.Order.findOne({
|
||
where: { orderNo: no, subjectId: Number(subjectId) },
|
||
});
|
||
if (!order) this.ctx.throw(404, '订单不存在');
|
||
if (Number(order.status) === 1) this.ctx.throw(409, '订单已支付,不能关闭');
|
||
if (Number(order.status) === 2) return this.present(order, { qrImage: null });
|
||
|
||
// 先在微信侧关单:用户可能刚好付完(回调还没到),那就是已支付,不能再当「关闭」处理
|
||
const remote = await this.closeRemote(order);
|
||
if (remote.paid) {
|
||
this.ctx.logger.info('[order] 订单 %s 微信侧已支付,改为入账', no);
|
||
await this.syncPayState(order, { force: true });
|
||
if (Number(order.status) === 0) {
|
||
try {
|
||
await this.payNotify({ orderNo: no, channel: 'wechat' });
|
||
const fresh = await this.Order.findOne({ where: { orderNo: no, subjectId: Number(subjectId) } });
|
||
if (fresh) Object.assign(order, typeof fresh.toJSON === 'function' ? fresh.toJSON() : fresh);
|
||
} catch (err) {
|
||
// 补入账失败(比如订单已超时):仍按「关闭」走,记 error 日志等人工核对这笔钱
|
||
this.ctx.logger.error('[order] 订单 %s 微信侧已支付但补入账失败:%s', no, err.message);
|
||
}
|
||
}
|
||
if (Number(order.status) === 1) return this.present(order, { qrImage: this.qrImageOf(order) });
|
||
}
|
||
|
||
await order.update({ status: 2 });
|
||
this.ctx.logger.info('[order] 用户 %s 关闭订单 %s(微信侧已关=%s)', userId, no, Boolean(remote.closed));
|
||
return this.present(order, { qrImage: null });
|
||
}
|
||
|
||
/** 某主体的订单列表(成员可见) */
|
||
async list({ subjectId, userId, page = 1, pageSize = 20 } = {}) {
|
||
await this.ctx.service.subject.findForUser(subjectId, userId);
|
||
|
||
const size = Math.min(Math.max(Number(pageSize) || 20, 1), 100);
|
||
const current = Math.max(Number(page) || 1, 1);
|
||
const result = await this.Order.findAndCountAll({
|
||
where: { subjectId: Number(subjectId) },
|
||
order: [[ 'id', 'DESC' ]],
|
||
limit: size,
|
||
offset: (current - 1) * size,
|
||
});
|
||
await this.closeExpired(result.rows);
|
||
|
||
return {
|
||
total: result.count,
|
||
page: current,
|
||
pageSize: size,
|
||
list: result.rows.map(row => this.present(row)),
|
||
};
|
||
}
|
||
|
||
/**
|
||
* **平台管理员视角**:所有订单(分页,带主体名 / 下单人)
|
||
*
|
||
* @param {object} params { page, pageSize, keyword, status, subjectId }
|
||
* keyword 模糊匹配订单号 / 套餐名 / 主体名
|
||
*/
|
||
async listAll({ page = 1, pageSize = 20, keyword, status, subjectId } = {}) {
|
||
const size = Math.min(Math.max(Number(pageSize) || 20, 1), 100);
|
||
const current = Math.max(Number(page) || 1, 1);
|
||
|
||
const where = {};
|
||
if (status !== undefined && status !== '' && status !== null) where.status = Number(status);
|
||
if (subjectId) where.subjectId = Number(subjectId);
|
||
|
||
const subjectIds = [];
|
||
if (keyword) {
|
||
const like = `%${String(keyword).trim()}%`;
|
||
// 主体名也参与搜索:先按名字捞主体 id,再 OR 进主查询
|
||
const matched = await this.Subject.findAll({ where: { name: { [Op.like]: like } }, attributes: [ 'id' ], limit: 200 });
|
||
subjectIds.push(...matched.map(row => Number(row.id)));
|
||
where[Op.or] = [
|
||
{ orderNo: { [Op.like]: like } },
|
||
{ planName: { [Op.like]: like } },
|
||
...(subjectIds.length ? [{ subjectId: { [Op.in]: subjectIds } }] : []),
|
||
];
|
||
}
|
||
|
||
const { rows, count } = await this.Order.findAndCountAll({
|
||
where,
|
||
order: [[ 'id', 'DESC' ]],
|
||
limit: size,
|
||
offset: (current - 1) * size,
|
||
});
|
||
await this.closeExpired(rows);
|
||
|
||
const ids = [ ...new Set(rows.map(row => Number(row.subjectId))) ];
|
||
const subjects = ids.length
|
||
? await this.Subject.findAll({ where: { id: { [Op.in]: ids } }, attributes: [ 'id', 'name', 'expireAt', 'status' ], paranoid: false })
|
||
: [];
|
||
const subjectMap = new Map(subjects.map(row => [ Number(row.id), row ]));
|
||
|
||
const userIds = [ ...new Set(rows.map(row => Number(row.userId)).filter(Boolean)) ];
|
||
const users = userIds.length
|
||
? await this.app.model.User.findAll({ where: { id: { [Op.in]: userIds } }, attributes: [ 'id', 'username', 'nickname' ], paranoid: false })
|
||
: [];
|
||
const userMap = new Map(users.map(row => [ Number(row.id), row.toJSON() ]));
|
||
|
||
return {
|
||
list: rows.map(row => {
|
||
const subject = subjectMap.get(Number(row.subjectId));
|
||
const user = userMap.get(Number(row.userId)) || null;
|
||
return this.present(row, {
|
||
subjectName: subject ? subject.name : null,
|
||
subjectExpireAt: subject ? subject.expireAt : null,
|
||
userName: user ? (user.nickname || user.username) : null,
|
||
});
|
||
}),
|
||
total: count,
|
||
page: current,
|
||
pageSize: size,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 支付通知(渠道回调):标记已支付 + 主体续期 + 失效状态缓存
|
||
*
|
||
* @param {object} params { orderNo, transactionId?, amount?, channel?, paidAt? }
|
||
* @return {Promise<object>} { duplicated, order }
|
||
*/
|
||
async payNotify({ orderNo, transactionId, amount, channel, paidAt } = {}) {
|
||
const no = String(orderNo || '').trim();
|
||
if (!no) this.ctx.throw(422, 'orderNo 不能为空');
|
||
if (no.length > 32) this.ctx.throw(422, 'orderNo 不合法');
|
||
|
||
// 超时未支付的订单先关掉:超过 2 小时的支付回调 / 手工确认都不该让它续期
|
||
const stale = await this.Order.findOne({ where: { orderNo: no } });
|
||
if (stale && this.isExpired(stale)) {
|
||
await this.Order.update({ status: 2 }, { where: { id: stale.id, status: 0 } });
|
||
this.ctx.logger.info('[order] 订单 %s 超过支付截止时间,已自动关闭', no);
|
||
this.ctx.throw(409, '订单已超时失效,请重新下单');
|
||
}
|
||
|
||
const transaction = await this.app.model.transaction();
|
||
try {
|
||
const order = await this.Order.findOne({
|
||
where: { orderNo: no },
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
});
|
||
if (!order) this.ctx.throw(404, '订单不存在');
|
||
|
||
// 已支付:幂等返回(重复回调不重复续期)
|
||
if (Number(order.status) === 1) {
|
||
await transaction.rollback();
|
||
return { duplicated: true, order: this.present(order) };
|
||
}
|
||
if (Number(order.status) !== 0) this.ctx.throw(409, '订单状态不允许支付');
|
||
// 兜底:与定时任务 / 其它实例的关单并发时,也不让超时订单续期
|
||
if (this.isExpired(order)) this.ctx.throw(409, '订单已超时失效,请重新下单');
|
||
|
||
const paid = amount === undefined || amount === null || amount === '' ? null : Number(amount);
|
||
if (paid !== null) {
|
||
if (!Number.isFinite(paid) || paid < 0) this.ctx.throw(422, '支付金额不合法');
|
||
if (order.amount !== null && order.amount !== undefined && Math.abs(paid - Number(order.amount)) > 0.001) {
|
||
this.ctx.throw(422, '支付金额与订单金额不一致');
|
||
}
|
||
}
|
||
|
||
const subject = await this.Subject.findByPk(Number(order.subjectId), {
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
});
|
||
if (!subject) this.ctx.throw(404, '订单对应的主体不存在');
|
||
|
||
const beforeMs = subject.expireAt ? new Date(subject.expireAt).getTime() : Date.now();
|
||
const baseMs = beforeMs <= Date.now() ? Date.now() : beforeMs;
|
||
const expireAfter = new Date(baseMs + Number(order.days) * DAY_MS);
|
||
|
||
await subject.update({ expireAt: expireAfter }, { transaction });
|
||
await order.update({
|
||
status: 1,
|
||
channel: channel || order.channel || null,
|
||
transactionId: transactionId ? String(transactionId).slice(0, 64) : null,
|
||
paidAt: paidAt ? new Date(paidAt) : new Date(),
|
||
expireBefore: order.expireBefore || new Date(beforeMs),
|
||
expireAfter,
|
||
}, { transaction });
|
||
|
||
await transaction.commit();
|
||
|
||
// 续期后必须失效缓存:否则设备心跳/上报会继续看到「已过期」,最多延迟一个 TTL
|
||
await this.ctx.service.subjectState.invalidate(order.subjectId);
|
||
|
||
this.ctx.logger.info('[order] 订单 %s 已支付,主体 %s 续期 %s 天:%s → %s',
|
||
order.orderNo, order.subjectId, order.days,
|
||
new Date(beforeMs).toISOString(), expireAfter.toISOString());
|
||
|
||
return { duplicated: false, order: this.present(order) };
|
||
} catch (err) {
|
||
try {
|
||
await transaction.rollback();
|
||
} catch (_) {
|
||
// 忽略:事务可能已经被上面的分支回滚过
|
||
}
|
||
throw err;
|
||
}
|
||
}
|
||
|
||
present(order, extra = {}) {
|
||
const status = Number(order.status);
|
||
const payExpireAt = this.payExpireAtOf(order);
|
||
// 只有待支付订单有「超时」概念;已支付 / 已关闭一律不算
|
||
const expired = status === 0 && payExpireAt.getTime() <= Date.now();
|
||
|
||
return Object.assign({
|
||
id: Number(order.id),
|
||
orderNo: order.orderNo,
|
||
subjectId: Number(order.subjectId),
|
||
userId: Number(order.userId),
|
||
planId: order.planId === null || order.planId === undefined ? null : Number(order.planId),
|
||
planCode: order.planCode || null,
|
||
planName: order.planName || null,
|
||
days: Number(order.days),
|
||
amount: order.amount === null || order.amount === undefined ? null : Number(order.amount),
|
||
status,
|
||
statusText: STATUS_TEXT[status] || '未知',
|
||
/** 前端据此判断要不要继续轮询(超时后不再轮询,等下一次读取时订单会被关掉) */
|
||
pending: status === 0 && !expired,
|
||
/** 支付截止时间(下单时间 + config.pay.orderTtl,默认 2 小时) */
|
||
payExpireAt,
|
||
/** 是否已过支付截止时间(仅 status=0 时可能为 true;关单后看 status=2) */
|
||
expired,
|
||
channel: order.channel || null,
|
||
transactionId: order.transactionId || null,
|
||
/** 微信 Native 二维码链接(下单后才有;未配置微信支付时为 null) */
|
||
codeUrl: order.codeUrl || null,
|
||
/** 前端是否应该展示二维码去扫码付款(待支付 + 已生成 code_url) */
|
||
payable: status === 0 && !expired && Boolean(order.codeUrl),
|
||
paidAt: order.paidAt || null,
|
||
expireBefore: order.expireBefore || null,
|
||
expireAfter: order.expireAfter || null,
|
||
remark: order.remark || null,
|
||
createdAt: order.createdAt || order.created_at || null,
|
||
}, extra);
|
||
}
|
||
}
|
||
|
||
/** 订单号:SO + 年月日时分秒 + 6 位随机(32 位以内) */
|
||
function generateOrderNo() {
|
||
const now = new Date();
|
||
const pad = num => String(num).padStart(2, '0');
|
||
const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`
|
||
+ `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
|
||
return `SO${stamp}${String(crypto.randomInt(0, 1000000)).padStart(6, '0')}`;
|
||
}
|
||
|
||
module.exports = SubjectOrderService;
|