packServer/backend/app/service/subject_order.js
liufumingren 3e2bd56416 feat(平台管理): 平台管理员与平台管理台(主体管理 / 订单管理 / 管理员)+ 顶栏下载入口
- 新表 admin_members(user_id 唯一、name、role、status、remark,软删):平台级管理员,
  与「主体管理员」完全分开;迁移会把内置管理员(username=admin,没有则 id=1)先入表
- 鉴权:middleware/platform_admin.js —— admin_members 启用行 **或** INTERNAL_ADMIN_IDS(内置/救急入口),
  其余一律 403 not_platform_admin;接口挂在 /api/web/admin/*
- 主体管理:GET 所有主体(成员数/管理员/是否过期)+ PUT 改授权到期时间
  (直接设 expireAt 或 extendDays 顺延),改完失效 subjectState 缓存,设备心跳立刻生效
- 订单管理:GET 所有订单(主体名/下单人/续期前后)+ POST 确认订单 ——
  复用支付回调的 payNotify()(标记已支付 + 主体顺延 + 失效缓存 + 幂等),渠道记 manual
- 管理员:GET/POST/DELETE /api/web/admin/members(按账号加人、不能删自己/最后一个);
  软删行仍占唯一键,查重带 paranoid:false + restore 复用
- 前端:左侧菜单新增「平台管理」组(只有平台管理员可见,路由 meta.platformAdmin 守卫、
  不需要选主体),新增 AdminSubjectsView / AdminOrdersView / AdminMembersView
- 顶栏右侧新增「下载桌面端 / 下载 Android 扫码台」两个按钮(与权限无关,所有人都显示),
  版本号读 /download/version.json 与 /download/android_client/version.json,未发布则置灰提示
- 测试:admin.test.js 12 例(403/表内/内置/列表/添加/重复/删自己/主体列表/改期限/顺延/订单/确认幂等)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-10-29 17:21:16 +08:00

297 lines
11 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: '已关闭' };
/**
* 主体续期订单 service
*
* 流程:`create()` 选套餐下单(待支付)→ 支付渠道回调 `payNotify()` → 标记已支付 + 主体顺延 + 清状态缓存。
*
* 关键约定:
* - **支付靠回调驱动**:下单不改变期限,只有 `payNotify()` 成功才续期;
* - **价格只认套餐**:下单只收 `planId`,金额取库里的 `subject_plans.price`,不信前端传的金额;
* - **幂等**:同一订单重复回调只续期一次(第二次返回 `duplicated: true`);
* - 续期基数与 `service.subject.update` 一致:未过期在原到期时间上顺延,已过期从当前时间起算。
*/
class SubjectOrderService extends Service {
get Order() {
return this.app.model.SubjectOrder;
}
get Subject() {
return this.app.model.Subject;
}
/**
* 创建订单(管理员):选套餐 → 只建单,不动期限
*
* @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, '订单不存在');
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,
});
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,
});
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 不合法');
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, '订单状态不允许支付');
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 = {}) {
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: Number(order.status),
statusText: STATUS_TEXT[Number(order.status)] || '未知',
/** 前端据此判断要不要继续轮询 */
pending: Number(order.status) === 0,
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;