'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} 实际关闭的条数 */ 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} 关闭的订单数 */ 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} { 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;