packServer/backend/app/service/subject_order.js
liufumingren 8949b7198c feat(pay): 微信 Native 扫码支付(下单出码 + 回调入账 + 扫码轮询)
- 新增 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>
2026-11-07 16:23:03 +08:00

562 lines
24 KiB
JavaScript
Raw Permalink 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');
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;