packServer/backend/app/service/subject_order.js
liufumingren 4704e10777 feat(首页/订单): 实时看板 + 待支付订单 2 小时自动失效
- 首页改成深色实时看板:今日/昨日维度、每 30 秒静默刷新(后台标签页跳过)、
  切维度/切回前台立刻刷;工作台榜按「占比」出条并同时给条数与百分比;
  支持原生全屏,`AppLayout :immersive` 隐藏左侧菜单与顶栏占满整屏
- 待支付订单 2 小时自动失效(`config.pay.orderTtl` / `PAY_ORDER_TTL`,默认 7200 秒):
  定时任务 `app/schedule/subject_order_expire.js` 每分钟扫一次,
  详情/列表/平台订单列表读到超时订单就地关单,支付回调入口再兜一层;
  超时后的渠道回调与手工确认一律 409;`present()` 下发 `payExpireAt / expired / pending`,
  前端展示支付截止时间、超时后停止轮询、平台端隐藏「确认订单」按钮
- 文档同步:根 README 与 backend/README(订单 TTL、看板刷新策略、全屏降级)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-10-30 23:05:26 +08:00

378 lines
15 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
const { Service } = require('egg');
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;
/**
* 主体续期订单 service
*
* 流程:`create()` 选套餐下单(待支付)→ 支付渠道回调 `payNotify()` → 标记已支付 + 主体顺延 + 清状态缓存。
*
* 关键约定:
* - **支付靠回调驱动**:下单不改变期限,只有 `payNotify()` 成功才续期;
* - **价格只认套餐**:下单只收 `planId`,金额取库里的 `subject_plans.price`,不信前端传的金额;
* - **幂等**:同一订单重复回调只续期一次(第二次返回 `duplicated: true`);
* - **2 小时自动失效**:待支付订单超过 `config.pay.orderTtl`(默认 7200 秒)未支付即关闭,
* 之后再来的支付回调一律 409 —— 与微信扫码支付二维码 2 小时有效期保持一致;
* - 续期基数与 `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);
const [ closed ] = await this.Order.update(
{ status: 2 },
{ where: { status: 0, createdAt: { [Op.lt]: cutoff } } },
);
return Number(closed) || 0;
}
/**
* 创建订单(管理员):选套餐 → 只建单,不动期限
*
* @param {object} params { subjectId, userId, planId, remark }
*/
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 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: 'mock',
expireBefore: subject.expireAt,
remark: remark || null,
});
this.ctx.logger.info('[order] 用户 %s 为主体 %s 创建续期订单 %s(套餐 %s,%s 天,金额 %s)',
userId, subject.id, order.orderNo, plan.code, grantDays, price);
return this.present(order);
}
/** 单个订单(续期弹窗轮询支付状态用;必须是该主体成员) */
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 ]);
return this.present(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);
await order.update({ status: 2 });
this.ctx.logger.info('[order] 用户 %s 关闭订单 %s', userId, no);
return this.present(order);
}
/** 某主体的订单列表(成员可见) */
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,
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;