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>
This commit is contained in:
liufumingren 2026-11-07 16:22:58 +08:00
parent 3566c000f4
commit 8949b7198c
15 changed files with 1337 additions and 22 deletions

View File

@ -460,6 +460,10 @@ npm run cov
| `PAY_MOCK` / `PAY_CALLBACK_SECRET` | 开发默认开 / 空 | 模拟支付回调(免签名)/ 回调签名密钥(`X-Pay-Sign`) |
| `PAY_AMOUNT_PER_DAY` | `0` | 每天默认价格(0 = 不校验金额,内部测试用) |
| `PAY_ORDER_TTL` | `7200` | **待支付订单有效期(秒)**:超时自动关闭,之后的回调/手工确认一律 409(与微信扫码支付二维码 2 小时有效期对齐) |
| `WXPAY_APP_ID` / `WXPAY_MCH_ID` / `WXPAY_API_KEY` | 空 | **微信 Native 扫码支付**凭证(appid / 商户号 / APIv2 密钥);缺任意一项 = 未开通,下单只建单不出二维码 |
| `WXPAY_NOTIFY_URL` | 空 | 支付回调地址(公网 https,不带参数);不配则用 `SITE_URL` + `/api/pay/wechat/notify` |
| `WXPAY_ENABLED` / `WXPAY_SIGN_TYPE` / `WXPAY_API_BASE` / `WXPAY_TIMEOUT` | `true` / `MD5` / `https://api.mch.weixin.qq.com` / `8000` | 临时停用 / 签名类型(`MD5` 或 `HMAC-SHA256`)/ 接口地址(切沙箱)/ 超时(毫秒) |
| `WXPAY_BODY` / `WXPAY_QR_CELL` / `WXPAY_QR_MARGIN` | 空 / `6` / `4` | 商品描述前缀(默认站点名)/ 二维码单元格像素 / 静默区格数 |
| `WECHAT_STATE_TTL` | `600` | 扫码串码(二维码)有效期(秒)——设备扫码登录用 |
| `WECHAT_CODE_LENGTH` | `6` | 扫码串码长度(数字 + 大写字母,去掉了 0/O/1/I 等易混字符) |
| `WECHAT_SPM_PATTERN` | `1.0.{code}.1` | 二维码地址里的 spm 格式(`{code}` 会被替换成串码) |
@ -1113,10 +1117,11 @@ await this.ctx.service.cache.remember('user:1', 60, () => loadFromMysql());
|---|---|---|
| GET | `/api/web/subject-plans` | 上架套餐 `{ list: [{ id, code, name, days, price, originalPrice, tag, description, pricePerDay }] }`(任何登录用户可读) |
| GET | `/api/web/subjects/:id/orders` | 订单列表(成员可见,`{ total, page, pageSize, list }`) |
| POST | `/api/web/subjects/:id/orders` | **选套餐下单** `{ planId, remark? }`(仅管理员)→ `{ orderNo, planId, planName, days, amount, status:0待支付, pending:true, payExpireAt, expired:false, … }`;**金额只认套餐价**,前端传的 `amount/days` 一律忽略 |
| GET | `/api/web/subjects/:id/orders/:orderNo` | 单笔订单(续期弹窗每 2s 轮询支付状态,`pending=false` 即停止;超时会被就地关闭成 `status=2`) |
| POST | `/api/web/subjects/:id/orders/:orderNo/close` | 关闭待支付订单(仅管理员;已支付 → 409) |
| POST | `/api/web/subjects/:id/orders` | **选套餐下单** `{ planId, remark? }`(仅管理员)→ `{ orderNo, planId, planName, days, amount, status:0待支付, pending:true, payExpireAt, expired:false, reused, codeUrl, qrImage, payable, … }`;**金额只认套餐价**,前端传的 `amount/days` 一律忽略。同一主体 + 同一套餐还有**没超时**的待支付单时直接返回**原订单**(`reused:true`,连二维码一起,不重复建单);已超时则先关单再新建 |
| GET | `/api/web/subjects/:id/orders/:orderNo` | 单笔订单(续期弹窗每 2s 轮询支付状态,`pending=false` 即停止;超时会被就地关闭成 `status=2`;顺带节流查单,回调丢了也能补入账) |
| POST | `/api/web/subjects/:id/orders/:orderNo/close` | 关闭待支付订单(仅管理员;已支付 → 409;先在微信侧关单,若发现「其实已付」就入账而不是关单) |
| POST | `/api/pay/notify` | **公开的渠道回调** `{ orderNo, transactionId?, amount?, channel?, paidAt? }` → `{ duplicated, order }`;订单不存在 404、金额不符 422、签名错 400、**超时失效 409** |
| POST | `/api/pay/wechat/notify` | **微信支付结果通知**(公开,XML 进出,APIv2 密钥验签);回 `{ return_code, return_msg }` |
| POST | `/api/internal/subject-orders/:orderNo/pay` | **内部令牌**:模拟支付成功(不需要签名),方便联调/补单;超时订单同样 409 |
**待支付订单 2 小时自动失效**(`config.pay.orderTtl`,env `PAY_ORDER_TTL`,默认 `7200` 秒):
@ -1166,6 +1171,35 @@ curl -X POST http://127.0.0.1:7300/api/internal/subject-orders/<orderNo>/pay \
-H "X-Internal-Token: <INTERNAL_TOKEN>"
```
### 微信 Native 扫码支付(原生扫码 / APIv2)
`service/wxpay.js` 负责和微信打交道,订单侧只认「已支付」这个结果:
1. 下单:`POST /api/web/subjects/:id/orders` → 建单后**同一请求内**调【统一下单】拿 `code_url`,
落库到 `subject_orders.code_url` / `prepay_id`,并把二维码在**服务端本地**画成 SVG
(响应里的 `qrImage` 是 data URL,零外链,前端直接 `<img :src>`);
2. 扫码支付:用户微信扫码 → 输入密码 → 微信回调 `POST /api/pay/wechat/notify`(XML)→ 验签 → `payNotify()` 续期;
3. 兜底:前端每 2s 轮询订单详情,`detail()` 会用【查询订单】主动查一次单(同订单 10s 节流),
回调丢了也能补入账;
4. 失效:`code_url` 有效期 2 小时,与 `PAY_ORDER_TTL`(默认 7200 秒)一致;订单超时关闭时
会先调【关闭订单】把微信侧一起关掉(若发现「其实已付」则改为入账,不会把已付款订单关掉)。
**复用未支付订单**:同一主体 + 同一套餐还有没超时的待支付单时,下单接口直接返回**原订单**
(`reused: true`,二维码、`payExpireAt` 都不变),不会重复建单;等它超时关单后再下单才建新单。
前端据此只展示剩余支付时间。
**配置**(由发布脚本把 `config/env.prod.sh` 上传到服务器 `shared-config/`,仓库里先留空):
```bash
export WXPAY_APP_ID='' # Native 支付用的 appid(已关联到商户号)
export WXPAY_MCH_ID='' # 商户号
export WXPAY_API_KEY='' # APIv2 密钥(下单签名 + 回调验签)
# 可选:WXPAY_NOTIFY_URL(默认 https://<SITE_URL>/api/pay/wechat/notify)、WXPAY_ENABLED=false
```
⚠️ 三项缺任意一项 = **未开通**:订单照常创建,只是没有二维码(`qrImage: null`、`payable: false`),
前端提示联系管理员。回调地址必须公网可访问、不带参数,并放行 `POST /api/pay/wechat/notify`。
成员绑定不再用 6 位码:改用微信登录网关的二维码,见上文「成员扫码绑定」(`POST /api/web/subjects/:id/members/:memberId/bind-qr`)。
### 主体上下文(统一处理)

View File

@ -0,0 +1,108 @@
'use strict';
const { Controller } = require('egg');
const { buildXml, parseXml, parseWxTime } = require('../../lib/wxpay-xml');
/** 回调包体上限(正常只有几百字节,防止被灌大包) */
const MAX_BODY_BYTES = 64 * 1024;
/**
* 微信支付结果通知(`POST /api/pay/wechat/notify`,**公开接口**,XML 进出)
*
* 文档:https://pay.weixin.qq.com/doc/v2/merchant/4011936582
*
* 处理顺序:读原始 XML → 验签(APIv2 密钥,同时核对 appid / mch_id)→ 只处理
* `return_code=SUCCESS & result_code=SUCCESS` → 走 `service.subjectOrder.payNotify()`
* (标记已支付 + 主体顺延 + 失效缓存,幂等)。
*
* 应答约定(微信按 `return_code` 决定要不要重推):
* - 回调内容有问题但重试也没用(订单不存在 / 已超时关闭 / 金额不符)→ 回 `SUCCESS` 并记 error 日志,人工跟进;
* - 我方临时故障(5xx / 网络)→ 回 `FAIL`,让微信按策略重推。
*/
class PayWechatController extends Controller {
async notify() {
const { ctx } = this;
ctx.set('Cache-Control', 'no-store');
ctx.type = 'application/xml; charset=utf-8';
const raw = await readRawBody(ctx.req);
if (raw === null) {
ctx.status = 413;
ctx.body = replyXml('FAIL', '请求体过大');
return;
}
const params = parseXml(raw);
const orderNo = String(params.out_trade_no || '').trim();
if (!orderNo) {
ctx.logger.warn('[wxpay] 回调缺少 out_trade_no:%s', raw.slice(0, 300));
ctx.body = replyXml('FAIL', '参数错误');
return;
}
const wxpay = ctx.service.wxpay;
if (!wxpay.enabled) {
ctx.logger.error('[wxpay] 收到支付回调但微信支付未配置:out_trade_no=%s', orderNo);
ctx.body = replyXml('FAIL', '微信支付未配置');
return;
}
const sign = wxpay.verifySign(params);
if (!sign.ok) {
ctx.logger.warn('[wxpay] 回调验签失败(%s):out_trade_no=%s', sign.message, orderNo);
ctx.body = replyXml('FAIL', '签名校验失败');
return;
}
if (params.return_code !== 'SUCCESS' || params.result_code !== 'SUCCESS') {
ctx.logger.warn('[wxpay] 支付结果非成功,忽略:out_trade_no=%s return_code=%s result_code=%s err=%s',
orderNo, params.return_code, params.result_code, params.err_code || '');
ctx.body = replyXml('SUCCESS', 'OK');
return;
}
const fee = params.total_fee === undefined || params.total_fee === '' ? null : Number(params.total_fee);
try {
const data = await ctx.service.subjectOrder.payNotify({
orderNo,
transactionId: params.transaction_id || null,
amount: fee === null || !Number.isFinite(fee) ? undefined : fee / 100,
channel: 'wechat',
paidAt: parseWxTime(params.time_end),
});
ctx.logger.info('[wxpay] 回调入账成功:out_trade_no=%s transaction_id=%s duplicated=%s',
orderNo, params.transaction_id || '-', data.duplicated);
ctx.body = replyXml('SUCCESS', 'OK');
} catch (err) {
const status = Number(err.status) || 500;
if (status >= 500) {
ctx.logger.error('[wxpay] 回调处理异常(等微信重推):out_trade_no=%s %s', orderNo, err.message);
ctx.body = replyXml('FAIL', '处理失败');
return;
}
// 404 订单不存在 / 409 已超时关闭 / 422 金额不符:重推也不会成功,回 SUCCESS 停止推送
ctx.logger.error('[wxpay] 回调处理失败(不再重试,需人工核对):out_trade_no=%s status=%s %s',
orderNo, status, err.message);
ctx.body = replyXml('SUCCESS', 'OK');
}
}
}
/** 读原始请求体(`text/xml` 不在 bodyParser 的 enableTypes 里,流还在) */
async function readRawBody(stream, limit = MAX_BODY_BYTES) {
const chunks = [];
let size = 0;
for await (const chunk of stream) {
size += chunk.length;
if (size > limit) return null;
chunks.push(chunk);
}
return Buffer.concat(chunks).toString('utf8');
}
/** 应答报文:`{ return_code, return_msg }` */
function replyXml(returnCode, returnMsg) {
return buildXml({ return_code: returnCode, return_msg: returnMsg });
}
module.exports = PayWechatController;

View File

@ -0,0 +1,89 @@
'use strict';
/**
* 微信支付 APIv2 的**扁平 XML** 编解码(无第三方依赖)
*
* v2 的请求/响应都只有一层 map(`<xml><a>1</a><b>2</b></xml>`),值可能包 CDATA,
* 所以不需要通用 XML 解析器:按「叶子节点」正则提取即可,不会把根节点当成字段。
*/
/**
* 生成 `<xml><k><![CDATA[v]]></k></xml>`
* @param {object} params 字段表(undefined / null 跳过)
* @return {string} XML
*/
function buildXml(params = {}) {
const items = Object.keys(params)
.filter(key => params[key] !== undefined && params[key] !== null)
.map(key => `<${key}><![CDATA[${String(params[key])}]]></${key}>`);
return `<xml>${items.join('')}</xml>`;
}
/**
* 解析扁平 XML(值可以是 CDATA 或普通文本)
* @param {string|Buffer} xml XML 源码
* @return {object} 字段表;解析不出任何字段时返回 {}
*/
function parseXml(xml) {
const out = {};
const text = String(xml || '');
// 非 CDATA 分支用 [^<]* 排除标签,避免把 <xml> 根节点当成一个字段(否则内层字段会被跳过)
const pattern = /<([A-Za-z_][\w.-]*)>\s*(?:<!\[CDATA\[([\s\S]*?)\]\]>|([^<]*))\s*<\/\1>/g;
let matched;
while ((matched = pattern.exec(text))) {
const key = matched[1];
if (key === 'xml') continue;
const value = matched[2] !== undefined ? matched[2] : matched[3];
out[key] = String(value).trim();
}
return out;
}
/**
* 微信回调/返回里的时间(`yyyyMMddHHmmss`,北京时间)→ Date
* @param {string} value 时间字符串
* @return {Date|null} 解析失败返回 null
*/
function parseWxTime(value) {
const matched = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/.exec(String(value || '').trim());
if (!matched) return null;
const [ , y, m, d, hh, mm, ss ] = matched;
// 微信时间固定是 +08:00
return new Date(Date.UTC(Number(y), Number(m) - 1, Number(d), Number(hh) - 8, Number(mm), Number(ss)));
}
/**
* Date → 微信时间字符串(`yyyyMMddHHmmss`,北京时间)
* @param {Date|string|number} date 时间
* @return {string|null} 无效时间返回 null
*/
function formatWxTime(date) {
const ms = date instanceof Date ? date.getTime() : new Date(date).getTime();
if (!Number.isFinite(ms)) return null;
const utc8 = new Date(ms + 8 * 3600 * 1000);
const pad = num => String(num).padStart(2, '0');
return `${utc8.getUTCFullYear()}${pad(utc8.getUTCMonth() + 1)}${pad(utc8.getUTCDate())}`
+ `${pad(utc8.getUTCHours())}${pad(utc8.getUTCMinutes())}${pad(utc8.getUTCSeconds())}`;
}
/**
* 按 UTF-8 字节数截断(微信 body 限 128 字节,中文一个字 3 字节)
* @param {string} value 原文
* @param {number} maxBytes 上限字节数
* @return {string} 截断后的字符串
*/
function truncateUtf8(value, maxBytes = 128) {
const text = String(value || '');
if (Buffer.byteLength(text, 'utf8') <= maxBytes) return text;
let out = '';
let used = 0;
for (const char of text) {
const size = Buffer.byteLength(char, 'utf8');
if (used + size > maxBytes) break;
out += char;
used += size;
}
return out;
}
module.exports = { buildXml, parseXml, parseWxTime, formatWxTime, truncateUtf8 };

View File

@ -34,7 +34,9 @@ module.exports = () => {
// 响应已经开始发送(例如已反代出去 / 流式输出)时不能再改 body
if (ctx.headerSent) return;
const message = status >= 500 ? '服务器内部错误' : err.message;
// 5xx 默认不外传细节;显式标了 `expose` 的(例如「微信支付:签名错误」这类
// 需要运维照着改配置的)才把原始消息透出去
const message = status >= 500 && !err.expose ? '服务器内部错误' : err.message;
// 接口请求返回 JSON,其它(理论上都被 frontend 中间件接走了)返回纯文本
const isApi = ctx.path.startsWith('/api/') || ctx.path === '/health' || ctx.acceptJSON;

View File

@ -23,8 +23,10 @@ module.exports = (app) => {
days: { type: INTEGER.UNSIGNED, allowNull: false, comment: '续期天数' },
amount: { type: DECIMAL(10, 2), allowNull: true, comment: '应付金额(为空表示不校验)' },
status: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 0, comment: '状态:0待支付 1已支付 2已关闭' },
channel: { type: STRING(16), allowNull: true, comment: '支付渠道(mock 等)' },
channel: { type: STRING(16), allowNull: true, comment: '支付渠道(wechat / manual / mock)' },
transactionId: { type: STRING(64), allowNull: true, comment: '渠道流水号' },
codeUrl: { type: STRING(512), allowNull: true, comment: '微信 Native 二维码链接(统一下单返回的 code_url)' },
prepayId: { type: STRING(64), allowNull: true, comment: '微信预支付交易会话标识' },
paidAt: { type: DATE, allowNull: true, comment: '支付时间' },
expireBefore: { type: DATE, allowNull: true, comment: '续期前的到期时间' },
expireAfter: { type: DATE, allowNull: true, comment: '续期后的到期时间' },

View File

@ -104,6 +104,7 @@ module.exports = (app) => {
router.post('/api/web/subjects/:id/members/:memberId/unbind', apiAuth, controller.web.subject.unbindMember);
// 续期订单:选套餐下单不改变期限,支付结果由渠道回调 `POST /api/pay/notify` 驱动
// 微信 Native 扫码:同主体 + 同套餐还有没超时的待支付单时**复用原单**(连二维码一起),不重复建单
// ⚠️ 不挂 subjectAuth:主体已过期也要能下单续期
router.get('/api/web/subject-plans', apiAuth, controller.web.subjectPlan.index);
router.get('/api/web/subjects/:id/orders', apiAuth, controller.web.subjectOrder.index);
@ -226,6 +227,8 @@ module.exports = (app) => {
// ---------- 支付渠道通知(公开,签名见 config.pay)----------
// 渠道接入前用它可以模拟「已付款」:{ orderNo, transactionId, amount } → 续期
router.post('/api/pay/notify', controller.pay.notify.index);
// 微信支付(Native 扫码,APIv2):XML 回调,验签后走同一个 payNotify()
router.post('/api/pay/wechat/notify', controller.pay.wechat.notify);
// 运维模拟支付(内部令牌,不需要渠道签名)
router.post('/api/internal/subject-orders/:orderNo/pay', internalAuth, controller.internal.subjectOrder.pay);

View File

@ -8,18 +8,43 @@ 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()` 选套餐下单(待支付)→ 支付渠道回调 `payNotify()` → 标记已支付 + 主体顺延 + 清状态缓存。
* 流程:`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 {
@ -79,9 +104,11 @@ class SubjectOrderService extends Service {
*/
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, createdAt: { [Op.lt]: cutoff } } },
{ where: { status: 0, created_at: { [Op.lt]: cutoff } } },
);
return Number(closed) || 0;
}
@ -89,7 +116,11 @@ class SubjectOrderService extends Service {
/**
* 创建订单(管理员):选套餐 → 只建单,不动期限
*
* 同一主体 + 同一套餐还有**没超时**的待支付单时直接复用(连二维码一起,不重复建单);
* 已超时的顺手关掉,再建新单。
*
* @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);
@ -105,6 +136,15 @@ class SubjectOrderService extends Service {
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),
@ -115,15 +155,135 @@ class SubjectOrderService extends Service {
days: grantDays,
amount: Math.round(price * 100) / 100,
status: 0,
channel: 'mock',
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);
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 };
}
}
/** 单个订单(续期弹窗轮询支付状态用;必须是该主体成员) */
@ -138,7 +298,9 @@ class SubjectOrderService extends Service {
});
if (!order) this.ctx.throw(404, '订单不存在');
await this.closeExpired([ order ]);
return this.present(order);
// 微信通知可能丢失:轮询时顺带查一次单(内部节流),确认已付就当场入账
if (Number(order.status) === 0) await this.syncPayState(order);
return this.present(order, { qrImage: this.qrImageOf(order) });
}
/** 关闭待支付订单(用户取消 / 重新下单前清理) */
@ -153,11 +315,29 @@ class SubjectOrderService extends Service {
});
if (!order) this.ctx.throw(404, '订单不存在');
if (Number(order.status) === 1) this.ctx.throw(409, '订单已支付,不能关闭');
if (Number(order.status) === 2) return this.present(order);
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', userId, no);
return this.present(order);
this.ctx.logger.info('[order] 用户 %s 关闭订单 %s(微信侧已关=%s)', userId, no, Boolean(remote.closed));
return this.present(order, { qrImage: null });
}
/** 某主体的订单列表(成员可见) */
@ -356,6 +536,10 @@ class SubjectOrderService extends Service {
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,

View File

@ -0,0 +1,324 @@
'use strict';
const { Service } = require('egg');
const crypto = require('crypto');
const qrcode = require('qrcode-generator');
const { buildXml, parseXml, parseWxTime, formatWxTime, truncateUtf8 } = require('../lib/wxpay-xml');
/** 交易状态(`trade_state`)→ 中文,仅用于日志/排查 */
const TRADE_STATE_TEXT = {
SUCCESS: '支付成功',
REFUND: '转入退款',
NOTPAY: '未支付',
CLOSED: '已关闭',
REVOKED: '已撤销',
USERPAYING: '用户支付中',
PAYERROR: '支付失败',
};
/** 回调地址兜底(未配 `config.wxpay.notifyUrl` 时用 SITE_URL 拼) */
const NOTIFY_PATH = '/api/pay/wechat/notify';
/** 上一次记过的配置问题(同一条只记一次,避免每单刷屏) */
let warnedIssues = '';
/**
* 微信支付 Native(原生扫码)—— **APIv2 统一下单**
*
* 文档:https://pay.weixin.qq.com/doc/v2/merchant/4011936530
*
* - `unifiedOrder()` 拿 `code_url`(`weixin://wxpay/bizpayurl?pr=xxx`)→ 本地画成二维码;
* - `queryOrder()` 用于「没收到支付通知」时主动补单(前端轮询订单详情时顺手做);
* - `closeOrder()` 用于关单,保证本地关掉的订单二维码也付不了;
* - `verifySign()` / `signOf()` 负责 APIv2 签名(MD5 或 HMAC-SHA256,密钥是 `config.wxpay.apiKey`)。
*
* ⚠️ 未配置 appId / mchId / apiKey 时 `enabled === false`:调用方据此降级(只建单、不出二维码)。
*/
class WxPayService extends Service {
get cfg() {
return this.app.config.wxpay || {};
}
/** 凭证齐全(且没被 `WXPAY_ENABLED=false` 关掉)才算开通 */
get enabled() {
const cfg = this.cfg;
return Boolean(cfg.enabled !== false && cfg.appId && cfg.mchId && cfg.apiKey);
}
/** 未开通时直接 503,前端据此提示「微信支付未配置」 */
assertEnabled() {
if (!this.enabled) this.fail(503, '微信支付未配置');
}
/**
* 抛一个「消息可以给用户看」的支付错误(`expose = true`)
*
* 这类错误几乎都是配置/凭证问题(签名错误、appid 不匹配…),
* 藏成「服务器内部错误」除了浪费时间没有任何好处;排查细节仍然进日志。
* @param {number} status HTTP 状态码
* @param {string} message 给调用方看的中文原因
* @param {object} [extra] 微信返回的字段表(带上 `err_code`,便于调用方判断 ORDERPAID / ORDERCLOSED)
* @return {never}
*/
fail(status, message, extra = null) {
const err = new Error(message);
err.status = status;
err.expose = true;
if (extra) {
err.code = extra.err_code || null;
err.wxpay = extra;
}
throw err;
}
/**
* 配置自检:列出需要人工处理的问题(缺字段 / 密钥长度不对)
*
* 微信 APIv2 密钥固定 **32 位字母数字**(商户平台 → 账户中心 → API 安全里设置的那个);
* 长度不对时下单会被微信以「签名错误」拒绝,提前指出来省得排查半天。
* @return {string[]} 问题列表,空数组表示没问题
*/
configIssues() {
const cfg = this.cfg;
const issues = [];
if (!cfg.appId) issues.push('缺少 WXPAY_APP_ID');
if (!cfg.mchId) issues.push('缺少 WXPAY_MCH_ID');
if (!cfg.apiKey) {
issues.push('缺少 WXPAY_API_KEY');
} else if (!/^[A-Za-z0-9]{32}$/.test(String(cfg.apiKey))) {
issues.push(`WXPAY_API_KEY 应为 32 位字母数字,当前 ${String(cfg.apiKey).length} 位`);
}
return issues;
}
/**
* 配置有问题就记一条 WARN(同一条提示只记一次)
* @return {string[]} 问题列表(调用方可以据此降级)
*/
warnIfMisconfigured() {
const issues = this.configIssues();
const text = issues.join(';');
if (text && text !== warnedIssues) {
warnedIssues = text;
this.ctx.logger.warn('[wxpay] 配置自检未通过:%s(改 config/env.prod.sh 后重新发布才生效)', text);
}
return issues;
}
/** 回调地址:优先 `WXPAY_NOTIFY_URL`,其次 `SITE_URL`,最后退回本次请求的 origin */
get notifyUrl() {
const cfg = this.cfg;
if (cfg.notifyUrl) return String(cfg.notifyUrl);
const siteUrl = String((this.config.email && this.config.email.siteUrl) || this.ctx.origin || '');
return `${siteUrl.replace(/\/+$/, '')}${NOTIFY_PATH}`;
}
/** 商品描述:`WXPAY_BODY`(或站点名)+ 套餐名,按 128 字节截断 */
bodyOf(description) {
const base = this.cfg.body || `${this.config.siteName}续期`;
return truncateUtf8(description ? `${base}-${description}` : base, 128);
}
/**
* APIv2 签名:字段按 key 升序拼 `k=v&`,末尾接 `&key=<apiKey>`,再 MD5 / HMAC-SHA256 并转大写
*
* 空值字段不参与签名(与微信一致);`sign` 字段本身必须排除。
* @param {object} params 参数表
* @param {string} [signType] MD5 | HMAC-SHA256
* @return {string} 签名(大写十六进制)
*/
signOf(params = {}, signType = this.cfg.signType || 'MD5') {
const content = Object.keys(params)
.filter(key => key !== 'sign' && params[key] !== undefined && params[key] !== null && params[key] !== '')
.sort()
.map(key => `${key}=${params[key]}`)
.join('&');
const payload = `${content}&key=${this.cfg.apiKey}`;
const digest = signType === 'HMAC-SHA256'
? crypto.createHmac('sha256', this.cfg.apiKey).update(payload, 'utf8').digest('hex')
: crypto.createHash('md5').update(payload, 'utf8').digest('hex');
return digest.toUpperCase();
}
/**
* 校验微信回调/返回值签名(同时核对 appid、mch_id,防止串号)
* @param {object} params 解析后的字段表
* @return {{ ok: boolean, message?: string }}
*/
verifySign(params = {}) {
if (!this.enabled) return { ok: false, message: '微信支付未配置' };
if (params.appid && params.appid !== this.cfg.appId) return { ok: false, message: 'appid 不匹配' };
if (params.mch_id && params.mch_id !== this.cfg.mchId) return { ok: false, message: 'mch_id 不匹配' };
const actual = String(params.sign || '').toUpperCase();
const expected = this.signOf(params, params.sign_type || this.cfg.signType || 'MD5');
if (!actual || actual.length !== expected.length) return { ok: false, message: '签名不匹配' };
if (!crypto.timingSafeEqual(Buffer.from(actual), Buffer.from(expected))) {
return { ok: false, message: '签名不匹配' };
}
return { ok: true };
}
/**
* 调 v2 接口(XML 进出,自动补公共参数 + 签名 + 验签)
* @param {string} path 形如 `/pay/unifiedorder`
* @param {object} params 业务参数
* @return {Promise<object>} 微信返回的字段表(result_code 一定是 SUCCESS)
*/
async request(path, params = {}) {
this.assertEnabled();
const payload = Object.assign({}, params, {
appid: this.cfg.appId,
mch_id: this.cfg.mchId,
nonce_str: crypto.randomBytes(16).toString('hex'),
sign_type: this.cfg.signType || 'MD5',
});
payload.sign = this.signOf(payload);
let res = null;
try {
res = await this.app.curl(`${this.cfg.apiBase}${path}`, {
method: 'POST',
headers: { 'Content-Type': 'text/xml; charset=utf-8' },
data: buildXml(payload),
dataType: 'text',
timeout: Number(this.cfg.timeout || 8000),
});
} catch (err) {
this.ctx.logger.error('[wxpay] 请求 %s 失败: %s', path, err.message);
this.fail(502, '微信支付接口不可用,请稍后重试');
}
const status = Number(res && res.status) || 0;
if (status !== 200) {
this.ctx.logger.error('[wxpay] %s 返回 HTTP %s: %s', path, status, String(res && res.data).slice(0, 500));
this.fail(502, `微信支付接口异常(HTTP ${status})`);
}
const body = parseXml(res.data);
if (body.return_code !== 'SUCCESS') {
const message = body.return_msg || '通讯失败';
this.ctx.logger.error('[wxpay] %s 通讯失败: %s(配置自检:%s)',
path, message, this.configIssues().join(';') || '无');
// 「签名错误 / appid 与 mch_id 不匹配」这些必须让人看见,否则完全没法定位
this.fail(502, `微信支付:${message}`);
}
const sign = this.verifySign(body);
if (!sign.ok) {
this.ctx.logger.error('[wxpay] %s 返回验签失败(%s): %j', path, sign.message, body);
this.fail(502, '微信支付返回结果验签失败');
}
if (body.result_code !== 'SUCCESS') {
// 业务错误码(ORDERPAID / ORDERNOTEXIST / ORDERCLOSED / OUT_TRADE_NO_USED …)带给调用方判断
this.fail(502, `微信支付:${body.err_code_des || body.err_code || '业务处理失败'}`, body);
}
return body;
}
/**
* 统一下单(NATIVE)
*
* 同一 `out_trade_no` 重复下单且参数不变时微信返回同一个 `prepay_id` / `code_url`,
* 所以「复用原订单」时重复调用是安全的。
* @param {object} params { orderNo, totalFee(分), description, clientIp, expireAt, productId }
* @return {Promise<{ codeUrl: string, prepayId: string|null }>}
*/
async unifiedOrder({ orderNo, totalFee, description, clientIp, expireAt, productId } = {}) {
const fee = Math.round(Number(totalFee));
if (!Number.isFinite(fee) || fee <= 0) this.ctx.throw(422, '支付金额不合法');
const params = {
body: this.bodyOf(description),
out_trade_no: String(orderNo),
total_fee: String(fee),
spbill_create_ip: String(clientIp || '127.0.0.1'),
notify_url: this.notifyUrl,
trade_type: 'NATIVE',
product_id: String(productId || orderNo),
};
// 二维码与订单同时失效:超过 time_expire 微信侧也会拒绝支付
const expire = expireAt ? formatWxTime(expireAt) : null;
if (expire) params.time_expire = expire;
const res = await this.request('/pay/unifiedorder', params);
if (!res.code_url) this.fail(502, '微信支付没有返回二维码链接');
return { codeUrl: res.code_url, prepayId: res.prepay_id || null };
}
/**
* 查单(回调丢失时补单用)
* @param {object} params { orderNo }
* @return {Promise<object>} { tradeState, tradeStateText, transactionId, totalFee(分), paidAt }
*/
async queryOrder({ orderNo } = {}) {
const res = await this.request('/pay/orderquery', { out_trade_no: String(orderNo) });
return {
tradeState: res.trade_state || '',
tradeStateText: TRADE_STATE_TEXT[res.trade_state] || res.trade_state || '',
transactionId: res.transaction_id || null,
totalFee: res.total_fee === undefined ? null : Number(res.total_fee),
paidAt: parseWxTime(res.time_end),
};
}
/**
* 关闭订单(本地关单时同步关掉微信侧,避免已关订单还能被扫码支付)
* @param {object} params { orderNo }
* @return {Promise<{ closed: boolean, already?: boolean }>}
*/
async closeOrder({ orderNo } = {}) {
try {
await this.request('/pay/closeorder', { out_trade_no: String(orderNo) });
return { closed: true };
} catch (err) {
if (err.code === 'ORDERCLOSED') return { closed: true, already: true };
throw err;
}
}
/**
* 二维码内容画成 **SVG data URL**(零外链,前端直接塞 `<img :src>`)
*
* 自己拼 SVG 而不是用库的 `createSvgTag`:库会**每个格子一段 path**(一段 30 字节),
* 实测同一个码体积差 4 倍;这里把同一行连续的深色格子合并成一段,轮询时省流量。
* @param {string} content 二维码内容(`code_url`)
* @return {string|null} data URL;内容为空返回 null
*/
qrDataUrl(content) {
if (!content) return null;
const cellSize = Number(this.cfg.qrCellSize) || 6;
const marginCells = Number(this.cfg.qrMargin) || 4;
const qr = qrcode(0, 'M'); // 版本自动、纠错等级 M
qr.addData(String(content));
qr.make();
const size = qr.getModuleCount();
const total = (size + marginCells * 2) * cellSize;
const segments = [];
for (let row = 0; row < size; row++) {
let col = 0;
while (col < size) {
if (!qr.isDark(row, col)) {
col += 1;
continue;
}
let run = 1;
while (col + run < size && qr.isDark(row, col + run)) run += 1;
const x = (col + marginCells) * cellSize;
const y = (row + marginCells) * cellSize;
const width = run * cellSize;
segments.push(`M${x},${y}h${width}v${cellSize}h-${width}z`);
col += run;
}
}
const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${total} ${total}" shape-rendering="crispEdges">`
+ `<rect width="${total}" height="${total}" fill="#ffffff"/>`
+ `<path d="${segments.join('')}" fill="#000000"/></svg>`;
return `data:image/svg+xml;base64,${Buffer.from(svg, 'utf8').toString('base64')}`;
}
}
module.exports = WxPayService;

View File

@ -212,6 +212,36 @@ module.exports = (appInfo) => {
orderTtl: Number(env.PAY_ORDER_TTL || 7200),
};
// ==================== 微信支付(Native 扫码支付 / APIv2) ====================
// 文档:https://pay.weixin.qq.com/doc/v2/merchant/4011936530(统一下单)
// 流程:下单 → 统一下单拿 code_url → 前端展示二维码 → 用户微信扫码支付
// → 微信回调 `POST /api/pay/wechat/notify`(XML)→ `service.subjectOrder.payNotify()` 续期。
// ⚠️ 凭证由发布脚本上传到服务器(`config/env.prod.sh`,仓库里先留空);
// appId / mchId / apiKey 缺任意一项 = 未开通:仍然能建单,只是没有二维码(前端提示联系管理员)。
config.wxpay = {
// 临时停用(凭证齐全也可以先关掉):WXPAY_ENABLED=false
enabled: !/^(0|false|no|off)$/i.test(String(env.WXPAY_ENABLED === undefined ? 'true' : env.WXPAY_ENABLED)),
// Native 支付用的 appid(先在「商户平台 → 产品中心 → AppID 账号管理」把公众号/小程序 appid 关联到商户号)
appId: env.WXPAY_APP_ID || '',
// 商户号
mchId: env.WXPAY_MCH_ID || '',
// APIv2 密钥(商户平台 → 账户中心 → API 安全 → 设置 APIv2 密钥),下单签名与回调验签都用它
apiKey: env.WXPAY_API_KEY || '',
// 回调地址(必须是公网 https,不带参数);不配则用 SITE_URL/api/pay/wechat/notify
notifyUrl: env.WXPAY_NOTIFY_URL || '',
// 统一下单/查单/关单接口地址(切沙箱时改这里)
apiBase: String(env.WXPAY_API_BASE || 'https://api.mch.weixin.qq.com').replace(/\/+$/, ''),
// 签名类型:MD5(默认)/ HMAC-SHA256
signType: env.WXPAY_SIGN_TYPE || 'MD5',
// 商品描述(微信要求 ≤128 字节);不配则用「站点名-套餐名」
body: env.WXPAY_BODY || '',
// 调微信接口的超时(毫秒)
timeout: Number(env.WXPAY_TIMEOUT || 8000),
// 二维码(本地画 SVG,零外链):单元格像素 / 静默区格数(QR 规范建议 ≥ 4)
qrCellSize: Number(env.WXPAY_QR_CELL || 6),
qrMargin: Number(env.WXPAY_QR_MARGIN || 4),
};
// ==================== 业务配置 ====================
config.cache = {
// 缓存 key 前缀,多项目共用一个 Redis 时用来隔离

View File

@ -0,0 +1,34 @@
'use strict';
/**
* 微信 Native 扫码支付(APIv2)落库字段
*
* - `code_url`:统一下单返回的二维码链接(`weixin://wxpay/bizpayurl?pr=xxx`),
* 有效期 2 小时;与 `config.pay.orderTtl` 一致,订单超时关闭后二维码也不再可用;
* - `prepay_id`:预支付交易会话标识,排查/对账用。
*
* 两个字段都可为空:未配置微信支付时订单照建,只是不会生成二维码。
*/
module.exports = {
async up(queryInterface, Sequelize) {
const { STRING } = Sequelize;
await queryInterface.addColumn('subject_orders', 'code_url', {
type: STRING(512),
allowNull: true,
comment: '微信 Native 二维码链接(code_url)',
after: 'transaction_id',
});
await queryInterface.addColumn('subject_orders', 'prepay_id', {
type: STRING(64),
allowNull: true,
comment: '微信预支付交易会话标识',
after: 'code_url',
});
},
async down(queryInterface) {
await queryInterface.removeColumn('subject_orders', 'prepay_id');
await queryInterface.removeColumn('subject_orders', 'code_url');
},
};

View File

@ -82,7 +82,7 @@ describe('test/app/controller/subject-order.test.js', () => {
status: 1,
}, overrides));
function mockModels({ memberRole = 1, subject, order, plan, log } = {}) {
function mockModels({ memberRole = 1, subject, order, plan, log, pendingOrders = [], onCreate } = {}) {
mock(app, 'model', {
User: { async findByPk() { return instance(Object.assign({}, USER)); } },
SubjectMember: {
@ -101,8 +101,13 @@ describe('test/app/controller/subject-order.test.js', () => {
async findAll() { return [ planRow() ]; },
},
SubjectOrder: {
async create(fields) { return orderRow(Object.assign({ id: 101 }, fields)); },
async create(fields) {
if (onCreate) onCreate(fields);
return orderRow(Object.assign({ id: 101 }, fields));
},
async findOne() { return typeof order === 'function' ? order() : order; },
async findByPk() { return typeof order === 'function' ? order() : order; },
async findAll() { return typeof pendingOrders === 'function' ? pendingOrders() : pendingOrders; },
async findAndCountAll() { return { rows: [ orderRow() ], count: 1 }; },
async update(fields, options) {
orderUpdates.push({ fields, options });
@ -118,6 +123,36 @@ describe('test/app/controller/subject-order.test.js', () => {
app.createAnonymousContext().service.subjectState.clearLocalCache();
});
// ---------------- 微信 Native 支付(回调 + 订单复用) ----------------
const WX_KEY = 'wx-key-1';
/** 微信 APIv2 签名(测试里独立实现) */
function wxSign(params, key = WX_KEY) {
const content = Object.keys(params)
.filter(name => name !== 'sign' && params[name] !== undefined && params[name] !== null && params[name] !== '')
.sort()
.map(name => `${name}=${params[name]}`)
.join('&');
return crypto.createHash('md5').update(`${content}&key=${key}`, 'utf8').digest('hex').toUpperCase();
}
/** 微信回调 XML(自动带正确签名) */
function wxNotifyXml(params) {
const fields = Object.assign({}, params);
fields.sign = wxSign(fields);
return `<xml>${Object.keys(fields).map(name => `<${name}><![CDATA[${fields[name]}]]></${name}>`).join('')}</xml>`;
}
/** 填上一套假凭证,让 service 认为「微信支付已开通」 */
function enableWxpay() {
mock(app.config.wxpay, 'enabled', true);
mock(app.config.wxpay, 'appId', 'wx-app-1');
mock(app.config.wxpay, 'mchId', '1900000109');
mock(app.config.wxpay, 'apiKey', WX_KEY);
mock(app.config.wxpay, 'signType', 'MD5');
}
it('GET /api/web/subject-plans:返回上架套餐(含计算好的每天单价)', async () => {
mockModels();
@ -232,6 +267,9 @@ describe('test/app/controller/subject-order.test.js', () => {
assert(closed === 1, `应关闭 1 笔,实际 ${closed}`);
assert(orderUpdates.length === 1 && orderUpdates[0].fields.status === 2, JSON.stringify(orderUpdates));
assert(orderUpdates[0].options.where.status === 0, JSON.stringify(orderUpdates[0].options));
// 时间戳属性名是 created_at(不是 createdAt),写错会变成「不存在的列」
assert(orderUpdates[0].options.where.created_at, JSON.stringify(orderUpdates[0].options.where));
assert(orderUpdates[0].options.where.createdAt === undefined, JSON.stringify(orderUpdates[0].options.where));
});
it('POST /api/pay/notify:支付成功后主体续期,且缓存失效(设备立刻看到新期限)', async () => {
@ -315,4 +353,129 @@ describe('test/app/controller/subject-order.test.js', () => {
assert(res.body.data.order.status === 1, JSON.stringify(res.body));
});
it('POST /api/web/subjects/:id/orders:同套餐还有未支付订单 → 复用原单(不重复建单,剩余时间照旧)', async () => {
const existing = orderRow({ id: 200, orderNo: 'SO-REUSE-0001', createdAt: new Date() });
let created = 0;
mockModels({
subject: subjectRow(new Date(Date.now() + 86400000)),
pendingOrders: [ existing ],
onCreate: () => { created++; },
});
const res = await app.httpRequest().post(`/api/web/subjects/${SUBJECT_ID}/orders`)
.set(auth()).send({ planId: 7 }).expect(201);
const data = res.body.data;
assert(data.orderNo === 'SO-REUSE-0001', JSON.stringify(data));
assert(data.reused === true, JSON.stringify(data));
assert(created === 0, '同套餐未支付订单存在时不能再建单');
const remain = new Date(data.payExpireAt).getTime() - Date.now();
assert(remain > ORDER_TTL_MS - 60000 && remain <= ORDER_TTL_MS,
`应显示原订单剩余时间(约 2 小时),实际 ${remain}ms`);
});
it('POST /api/web/subjects/:id/orders:原订单已超时 → 关掉原单再建新单', async () => {
const stale = orderRow({ id: 200, orderNo: 'SO-STALE-0001', createdAt: new Date(Date.now() - 3 * 3600 * 1000) });
let created = 0;
mockModels({
subject: subjectRow(new Date(Date.now() + 86400000)),
pendingOrders: [ stale ],
onCreate: () => { created++; },
});
const res = await app.httpRequest().post(`/api/web/subjects/${SUBJECT_ID}/orders`)
.set(auth()).send({ planId: 7 }).expect(201);
assert(res.body.data.orderNo !== 'SO-STALE-0001', JSON.stringify(res.body));
assert(res.body.data.reused === false, JSON.stringify(res.body));
assert(created === 1, '超时订单不能复用,应新建一笔');
assert(orderUpdates.some(item => item.fields.status === 2), '超时的原订单应被关闭');
});
it('POST /api/web/subjects/:id/orders:微信支付未配置 → 订单照建但没有二维码', async () => {
mockModels({ subject: subjectRow(new Date(Date.now() + 86400000)) });
const res = await app.httpRequest().post(`/api/web/subjects/${SUBJECT_ID}/orders`)
.set(auth()).send({ planId: 7 }).expect(201);
const data = res.body.data;
assert(data.qrImage === null && data.payable === false, JSON.stringify(data));
assert(data.codeUrl === null, JSON.stringify(data));
});
it('POST /api/pay/wechat/notify:验签通过 → 入账并回 SUCCESS(XML)', async () => {
enableWxpay();
const order = orderRow();
mockModels({ subject: subjectRow(new Date(Date.now() - 86400000)), order: () => order });
const xml = wxNotifyXml({
return_code: 'SUCCESS',
result_code: 'SUCCESS',
appid: 'wx-app-1',
mch_id: '1900000109',
nonce_str: 'wx-nonce',
out_trade_no: order.orderNo,
transaction_id: '4200001234',
total_fee: '9900',
time_end: '20261106103000',
});
const res = await app.httpRequest().post('/api/pay/wechat/notify')
.set('Content-Type', 'text/xml').send(xml).expect(200);
assert(res.text.includes('<![CDATA[SUCCESS]]>'), res.text);
assert(order.status === 1, JSON.stringify(order));
assert(order.transactionId === '4200001234', JSON.stringify(order));
assert(order.channel === 'wechat', JSON.stringify(order));
});
it('POST /api/pay/wechat/notify:签名不对 → 回 FAIL,不入账', async () => {
enableWxpay();
const order = orderRow();
mockModels({ subject: subjectRow(new Date(Date.now() - 86400000)), order: () => order });
const xml = '<xml><return_code><![CDATA[SUCCESS]]></return_code>'
+ '<result_code><![CDATA[SUCCESS]]></result_code>'
+ '<appid><![CDATA[wx-app-1]]></appid><mch_id><![CDATA[1900000109]]></mch_id>'
+ `<out_trade_no><![CDATA[${order.orderNo}]]></out_trade_no>`
+ '<total_fee><![CDATA[9900]]></total_fee><sign><![CDATA[BAD]]></sign></xml>';
const res = await app.httpRequest().post('/api/pay/wechat/notify')
.set('Content-Type', 'text/xml').send(xml).expect(200);
assert(res.text.includes('<![CDATA[FAIL]]>'), res.text);
assert(order.status === 0, '验签失败不能入账');
});
it('POST /api/pay/wechat/notify:微信支付未配置 → 回 FAIL', async () => {
const res = await app.httpRequest().post('/api/pay/wechat/notify')
.set('Content-Type', 'text/xml')
.send('<xml><return_code><![CDATA[SUCCESS]]></return_code>'
+ '<result_code><![CDATA[SUCCESS]]></result_code>'
+ '<out_trade_no><![CDATA[SO1]]></out_trade_no></xml>')
.expect(200);
assert(res.text.includes('<![CDATA[FAIL]]>'), res.text);
});
it('POST /api/web/subjects/:id/orders:微信返回「签名错误」→ 502 且透出原因(订单被关掉)', async () => {
enableWxpay();
mock(app, 'httpclient', {
async request() {
return {
status: 200,
data: '<xml><return_code><![CDATA[FAIL]]></return_code><return_msg><![CDATA[签名错误]]></return_msg></xml>',
};
},
});
mockModels({ subject: subjectRow(new Date(Date.now() + 86400000)) });
const res = await app.httpRequest().post(`/api/web/subjects/${SUBJECT_ID}/orders`)
.set(auth()).send({ planId: 7 }).expect(502);
assert(String(res.body.message).includes('签名错误'), JSON.stringify(res.body));
assert(orderUpdates.some(item => item.fields.status === 2), '下单失败要顺手关掉这笔订单');
});
});

View File

@ -0,0 +1,232 @@
'use strict';
const { app, mock, assert } = require('egg-mock/bootstrap');
const crypto = require('crypto');
const { buildXml, parseXml, formatWxTime, parseWxTime, truncateUtf8 } = require('../../../app/lib/wxpay-xml');
const KEY = '0123456789abcdef0123456789abcdef';
/** 微信 APIv2 签名(测试里独立实现一遍,避免「用被测代码验被测代码」) */
function wxSign(params, key = KEY, signType = 'MD5') {
const content = Object.keys(params)
.filter(name => name !== 'sign' && params[name] !== undefined && params[name] !== null && params[name] !== '')
.sort()
.map(name => `${name}=${params[name]}`)
.join('&');
const payload = `${content}&key=${key}`;
const digest = signType === 'HMAC-SHA256'
? crypto.createHmac('sha256', key).update(payload, 'utf8').digest('hex')
: crypto.createHash('md5').update(payload, 'utf8').digest('hex');
return digest.toUpperCase();
}
/** 微信应答(自动带正确签名) */
function wxResponse(params, key = KEY) {
return buildXml(Object.assign({}, params, { sign: wxSign(params, key) }));
}
const ctx = () => app.createAnonymousContext();
/** 填上一套假凭证,让 service 认为「已开通」 */
function configure() {
const cfg = app.config.wxpay;
mock(cfg, 'enabled', true);
mock(cfg, 'appId', 'wx-app-1');
mock(cfg, 'mchId', '1900000109');
mock(cfg, 'apiKey', KEY);
mock(cfg, 'signType', 'MD5');
mock(cfg, 'notifyUrl', 'https://trace.example.com/api/pay/wechat/notify');
mock(cfg, 'apiBase', 'https://api.mch.weixin.qq.com');
}
/**
* 微信 Native 支付(APIv2)
*
* 重点:
* - 签名/验签与微信规则一致(独立实现复算请求签名);
* - 统一下单能拿到 `code_url`,参数按 NATIVE 传;
* - 微信的业务错误码(ORDERPAID 等)要原样带给调用方(关单时据此判断「其实已付」)。
*/
describe('test/app/service/wxpay.test.js', () => {
it('wxpay-xml:扁平 XML 编解码 / 时间互转 / 按 UTF-8 字节截断', async () => {
const xml = buildXml({ return_code: 'SUCCESS', return_msg: 'OK' });
assert(xml === '<xml><return_code><![CDATA[SUCCESS]]></return_code><return_msg><![CDATA[OK]]></return_msg></xml>', xml);
const parsed = parseXml(xml);
assert(parsed.return_code === 'SUCCESS' && parsed.return_msg === 'OK');
assert(parsed.xml === undefined, '根节点不能被当成字段');
// 值可能是 CDATA,也可能是普通文本
const mixed = parseXml('<xml><a>1</a><b><![CDATA[x<y]]></b><c/></xml>');
assert(mixed.a === '1' && mixed.b === 'x<y', JSON.stringify(mixed));
const date = new Date('2026-11-06T02:03:04Z');
assert(formatWxTime(date) === '20261106100304', formatWxTime(date));
assert(parseWxTime('20261106100304').toISOString() === date.toISOString());
assert(parseWxTime('bad') === null);
assert(Buffer.byteLength(truncateUtf8('续期订单', 6), 'utf8') === 6, '中文按字节截断');
assert(Buffer.byteLength(truncateUtf8('abcdef', 6), 'utf8') === 6);
});
it('未配置凭证 → enabled=false,调接口直接 503', async () => {
const wxpay = ctx().service.wxpay;
assert(wxpay.enabled === false, '单测环境默认没有微信支付凭证');
let error = null;
try {
await wxpay.unifiedOrder({ orderNo: 'SO1', totalFee: 100 });
} catch (err) {
error = err;
}
assert(error && error.status === 503, JSON.stringify(error && error.message));
});
it('统一下单:参数/签名正确,返回 code_url', async () => {
configure();
let captured = null;
mock(app, 'httpclient', {
async request(url, options) {
captured = { url, xml: options.data };
return {
status: 200,
data: wxResponse({
return_code: 'SUCCESS',
result_code: 'SUCCESS',
appid: 'wx-app-1',
mch_id: '1900000109',
nonce_str: 'wx-nonce',
prepay_id: 'wx-prepay-1',
code_url: 'weixin://wxpay/bizpayurl?pr=abc',
}),
};
},
});
const result = await ctx().service.wxpay.unifiedOrder({
orderNo: 'SO20261106100000000001',
totalFee: 9900,
description: '30 天',
clientIp: '1.2.3.4',
expireAt: new Date('2026-11-06T02:00:00Z'),
});
assert(result.codeUrl === 'weixin://wxpay/bizpayurl?pr=abc', JSON.stringify(result));
assert(result.prepayId === 'wx-prepay-1');
assert(captured.url === 'https://api.mch.weixin.qq.com/pay/unifiedorder', captured.url);
const req = parseXml(captured.xml);
assert(req.trade_type === 'NATIVE');
assert(req.total_fee === '9900');
assert(req.out_trade_no === 'SO20261106100000000001');
assert(req.spbill_create_ip === '1.2.3.4');
assert(req.notify_url === 'https://trace.example.com/api/pay/wechat/notify');
assert(req.time_expire === '20261106100000', req.time_expire);
assert(req.sign === wxSign(req), '请求签名应能被独立实现复算');
});
it('统一下单:return_code=FAIL → 502;result_code=FAIL 保留业务错误码', async () => {
configure();
mock(app, 'httpclient', {
async request() {
return { status: 200, data: buildXml({ return_code: 'FAIL', return_msg: '签名错误' }) };
},
});
let error = null;
try {
await ctx().service.wxpay.unifiedOrder({ orderNo: 'SO1', totalFee: 100 });
} catch (err) {
error = err;
}
assert(error && error.status === 502, JSON.stringify(error && error.message));
mock(app, 'httpclient', {
async request() {
return {
status: 200,
data: wxResponse({
return_code: 'SUCCESS',
result_code: 'FAIL',
appid: 'wx-app-1',
mch_id: '1900000109',
err_code: 'ORDERPAID',
err_code_des: '订单已支付',
}),
};
},
});
error = null;
try {
await ctx().service.wxpay.closeOrder({ orderNo: 'SO1' });
} catch (err) {
error = err;
}
assert(error && error.code === 'ORDERPAID', JSON.stringify(error && error.message));
});
it('统一下单:应答验签不过 → 502(防伪造回调/应答)', async () => {
configure();
mock(app, 'httpclient', {
async request() {
return {
status: 200,
data: '<xml><return_code><![CDATA[SUCCESS]]></return_code>'
+ '<result_code><![CDATA[SUCCESS]]></result_code><sign><![CDATA[BAD]]></sign></xml>',
};
},
});
let error = null;
try {
await ctx().service.wxpay.queryOrder({ orderNo: 'SO1' });
} catch (err) {
error = err;
}
assert(error && error.status === 502, JSON.stringify(error && error.message));
});
it('verifySign / signOf:正确签名通过,签名或商户号不对一律拒绝', async () => {
configure();
const wxpay = ctx().service.wxpay;
const params = { appid: 'wx-app-1', mch_id: '1900000109', nonce_str: 'n1', out_trade_no: 'SO1' };
assert(wxpay.verifySign(Object.assign({}, params, { sign: wxSign(params) })).ok === true);
assert(wxpay.verifySign(Object.assign({}, params, { sign: 'BAD' })).ok === false);
const otherMch = Object.assign({}, params, { mch_id: '1999999999' });
assert(wxpay.verifySign(Object.assign({}, otherMch, { sign: wxSign(otherMch) })).ok === false,
'别人家的商户号不能通过');
assert(wxpay.signOf({ a: '1' }) === wxSign({ a: '1' }));
assert(wxpay.signOf({ a: '1' }, 'HMAC-SHA256') === wxSign({ a: '1' }, KEY, 'HMAC-SHA256'));
});
it('qrDataUrl:把 code_url 画成本地 SVG data URL', async () => {
const wxpay = ctx().service.wxpay;
const url = wxpay.qrDataUrl('weixin://wxpay/bizpayurl?pr=abc');
assert(url.startsWith('data:image/svg+xml;base64,'), url);
const svg = Buffer.from(url.split(',')[1], 'base64').toString('utf8');
assert(svg.includes('<svg'), svg.slice(0, 80));
assert(wxpay.qrDataUrl('') === null);
});
it('configIssues / warnIfMisconfigured:缺字段、密钥长度不对都要能指出来', async () => {
const wxpay = ctx().service.wxpay;
const issues = wxpay.configIssues();
assert(issues.some(item => item.includes('WXPAY_APP_ID')), JSON.stringify(issues));
assert(issues.some(item => item.includes('WXPAY_MCH_ID')), JSON.stringify(issues));
assert(issues.some(item => item.includes('WXPAY_API_KEY')), JSON.stringify(issues));
configure();
assert(wxpay.configIssues().length === 0, JSON.stringify(wxpay.configIssues()));
// 34 位(微信要求 32 位字母数字)必须报出来
mock(app.config.wxpay, 'apiKey', '4e5qwrtyuiopasdfghjklzxcvbnm123456');
const bad = wxpay.configIssues();
assert(bad.length === 1 && bad[0].includes('32 位'), JSON.stringify(bad));
assert(wxpay.warnIfMisconfigured().length === 1);
});
});

View File

@ -130,6 +130,14 @@ export interface SubjectOrder {
payExpireAt?: string | null;
/** 是否已超时失效(仅待支付订单可能为 true) */
expired?: boolean;
/** 微信 Native 二维码链接(`weixin://wxpay/bizpayurl?...`,下单后才有) */
codeUrl?: string | null;
/** 二维码图片(SVG data URL,服务端本地生成);未开通微信支付时为 null */
qrImage?: string | null;
/** 是否可以扫码付款(待支付 + 已生成二维码) */
payable?: boolean;
/** true = 沿用了同一主体 + 同一套餐的未支付订单(没有重复建单) */
reused?: boolean;
channel?: string | null;
transactionId?: string | null;
paidAt?: string | null;

View File

@ -150,7 +150,9 @@ onMounted(() => load(1));
<td class="muted">
<template v-if="row.status === 1 && row.expireAfter">
{{ formatTime(row.expireBefore) }} → <b>{{ formatTime(row.expireAfter) }}</b>
<span v-if="row.paidAt" class="cell-sub">支付于 {{ formatTime(row.paidAt) }}</span>
<span v-if="row.paidAt" class="cell-sub">
支付于 {{ formatTime(row.paidAt) }}<template v-if="row.channel">({{ row.channel === 'wechat' ? '微信支付' : row.channel === 'manual' ? '手工确认' : row.channel }})</template>
</span>
</template>
<template v-else>—</template>
</td>

View File

@ -110,8 +110,47 @@ const order = ref<SubjectOrder | null>(null);
const paid = ref(false);
let orderTimer: number | null = null;
/** 倒计时用「当前时间」,每秒刷新一次(只在续期弹窗打开时跑) */
const now = ref(Date.now());
let clockTimer: number | null = null;
/** 订单剩余支付时间(毫秒,最小 0) */
const orderRemainMs = computed(() => {
const current = order.value;
if (!current || current.status !== 0 || !current.payExpireAt) return 0;
return Math.max(new Date(current.payExpireAt).getTime() - now.value, 0);
});
/** 剩余时间文案:`mm:ss`;超过 1 小时显示 `h:mm:ss` */
const orderRemainText = computed(() => {
const ms = orderRemainMs.value;
if (!order.value || order.value.status !== 0) return '';
if (ms <= 0) return '已超时';
const total = Math.floor(ms / 1000);
const pad = (value: number) => String(value).padStart(2, '0');
const hours = Math.floor(total / 3600);
const minutes = Math.floor((total % 3600) / 60);
const seconds = total % 60;
return hours > 0 ? `${hours}:${pad(minutes)}:${pad(seconds)}` : `${pad(minutes)}:${pad(seconds)}`;
});
const currentPlan = computed(() => plans.value.find(item => item.id === planId.value) || null);
function startClock() {
stopClock();
now.value = Date.now();
clockTimer = window.setInterval(() => {
now.value = Date.now();
}, 1000);
}
function stopClock() {
if (clockTimer !== null) {
window.clearInterval(clockTimer);
clockTimer = null;
}
}
async function openRenew(item: SubjectItem) {
renewSubject.value = item;
renewOpen.value = true;
@ -120,6 +159,7 @@ async function openRenew(item: SubjectItem) {
error.value = '';
ok.value = '';
stopOrderPolling();
startClock();
if (!plans.value.length) {
plansLoading.value = true;
@ -138,7 +178,7 @@ async function openRenew(item: SubjectItem) {
planId.value = preferred ? preferred.id : null;
}
/** 生成订单:只建单,不改期限 */
/** 生成订单:只建单,不改期限(同一套餐还有未支付的原单时后端会直接复用) */
async function createOrder() {
const subject = renewSubject.value;
if (!subject || !planId.value) {
@ -152,6 +192,7 @@ async function createOrder() {
try {
order.value = await createSubjectOrder(subject.id, planId.value);
paid.value = false;
now.value = Date.now();
startOrderPolling();
} catch (err) {
error.value = err instanceof ApiError ? err.message : '下单失败';
@ -160,7 +201,7 @@ async function createOrder() {
}
}
/** 轮询订单状态:只有支付回调确认后(status=1)才算续期成功 */
/** 轮询订单状态:只有微信回调(或查单兜底)确认后(status=1)才算续期成功 */
function startOrderPolling() {
stopOrderPolling();
orderTimer = window.setInterval(async () => {
@ -178,7 +219,7 @@ function startOrderPolling() {
paid.value = true;
ok.value = `订单已支付,「${subject.name}」续期 ${latest.days} 天,到期时间:${formatTime(latest.expireAfter)}`;
await load();
} else if (Number(latest.status) === 2) {
} else if (Number(latest.status) === 2 || !latest.pending) {
stopOrderPolling();
}
} catch {
@ -210,6 +251,7 @@ async function closeOrder() {
function finishRenew() {
stopOrderPolling();
stopClock();
renewOpen.value = false;
order.value = null;
}
@ -411,6 +453,7 @@ onMounted(load);
onBeforeUnmount(() => {
stopBindPolling();
stopOrderPolling();
stopClock();
});
/** 列表里标出「当前主体」 */
@ -670,7 +713,7 @@ function isSelf(member: SubjectMemberItem) {
</template>
</div>
<!-- 生成订单后:等待支付确认 -->
<!-- 生成订单后:微信扫码支付 → 回调确认 -->
<div v-else class="order-box">
<div class="order-row"><span>订单号</span><code>{{ order.orderNo }}</code></div>
<div class="order-row"><span>套餐</span><b>{{ order.planName || `${order.days} 天` }}</b></div>
@ -683,9 +726,22 @@ function isSelf(member: SubjectMemberItem) {
</span>
</div>
<!-- 待支付:二维码由服务端按微信 code_url 本地生成(data URL),不用外链图片 -->
<div v-if="order.status === 0" class="pay-block">
<img v-if="order.qrImage" :src="order.qrImage" class="pay-qr" alt="微信扫码支付二维码" />
<div class="pay-tip">
<p v-if="order.qrImage" class="pay-title">请用<b>微信扫一扫</b>完成支付</p>
<p v-else class="pay-title text-danger">暂时无法生成支付二维码,请联系管理员处理。</p>
<p v-if="order.reused" class="hint">已沿用之前未支付的订单(同一套餐),没有重复下单。</p>
<p v-if="orderRemainText" class="pay-remain">
剩余支付时间 <b>{{ orderRemainText }}</b>
</p>
</div>
</div>
<p v-if="order.status === 0" class="alert alert-info">
订单已生成,<b>尚未续期</b>:支付确认(渠道回调)到账后才会计入期限,本窗口会自动刷新状态。<br />
请在 <b>{{ formatTime(order.payExpireAt) }}</b> 前完成支付,逾期订单会自动关闭。
订单已生成,<b>尚未续期</b>:支付到账后才会计入期限,本窗口会自动刷新状态。<br />
请在 <b>{{ formatTime(order.payExpireAt) }}</b> 前完成支付,逾期订单与二维码会一起失效。
</p>
<p v-else-if="order.status === 1" class="alert alert-ok">
支付已确认,主体已续期 {{ order.days }} 天,新到期时间:{{ formatTime(order.expireAfter) }}
@ -880,4 +936,48 @@ function isSelf(member: SubjectMemberItem) {
color: #dc2626;
font-size: 16px;
}
/* ---------------- 微信扫码支付 ---------------- */
.pay-block {
display: flex;
align-items: center;
gap: 16px;
padding: 12px;
border: 1px solid #e5e7eb;
border-radius: 10px;
background: #f8fafc;
}
.pay-qr {
width: 168px;
height: 168px;
flex: 0 0 auto;
padding: 8px;
background: #fff;
border-radius: 8px;
}
.pay-tip {
display: flex;
flex-direction: column;
gap: 6px;
min-width: 0;
}
.pay-title {
margin: 0;
font-size: 14px;
color: #1f2937;
}
.pay-remain {
margin: 0;
font-size: 13px;
color: #475569;
}
.pay-remain b {
color: #dc2626;
font-variant-numeric: tabular-nums;
}
</style>