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>
This commit is contained in:
liufumingren 2026-10-29 17:21:16 +08:00
parent 98fae0f9d2
commit 3e2bd56416
19 changed files with 2252 additions and 27 deletions

View File

@ -0,0 +1,63 @@
'use strict';
const { Controller } = require('egg');
/** 路径参数转正整数,非法返回 null */
function toId(value) {
const id = Number(value);
return Number.isInteger(id) && id > 0 ? id : null;
}
/**
* web 平台管理员:管理员成员(`/api/web/admin/members`)
*
* 鉴权:`middleware.apiAuth()` + `middleware.platformAdmin()`(能进来的都是平台管理员)。
*
* - `GET /api/web/admin/me` 当前账号是不是平台管理员(前端决定要不要显示平台菜单)
* - `GET /api/web/admin/members` 平台管理员列表(含账号信息)
* - `POST /api/web/admin/members` 添加(body `{ account, name?, role?, remark? }`,account = 用户名/手机号/邮箱)
* - `DELETE /api/web/admin/members/:id` 移除(软删;不能删自己、不能删最后一个)
*/
class WebAdminMemberController extends Controller {
/** GET /api/web/admin/me */
async me() {
const { ctx } = this;
const user = ctx.state.user;
ctx.body = {
ok: true,
data: {
admin: true,
builtin: ctx.service.adminMember.isBootstrap(user.id),
user: { id: Number(user.id), username: user.username || null, nickname: user.nickname || null },
},
};
}
/** GET /api/web/admin/members */
async index() {
const { ctx } = this;
const list = await ctx.service.adminMember.list();
ctx.body = { ok: true, data: { list, total: list.length } };
}
/** POST /api/web/admin/members */
async create() {
const { ctx } = this;
const { account, name, role, remark } = ctx.request.body || {};
const data = await ctx.service.adminMember.add({ account, name, role, remark });
ctx.status = 201;
ctx.body = { ok: true, data };
}
/** DELETE /api/web/admin/members/:id */
async destroy() {
const { ctx } = this;
const id = toId(ctx.params.id);
if (!id) ctx.throw(400, 'id 必须是正整数');
const data = await ctx.service.adminMember.remove({ id, operatorUserId: ctx.state.user.id });
ctx.body = { ok: true, data };
}
}
module.exports = WebAdminMemberController;

View File

@ -0,0 +1,49 @@
'use strict';
const { Controller } = require('egg');
/**
* web 平台管理员:**所有订单**(`/api/web/admin/orders`)
*
* 鉴权:`middleware.apiAuth()` + `middleware.platformAdmin()`。
*
* - `GET /api/web/admin/orders?page=&pageSize=&keyword=&status=&subjectId=`
* 所有续期订单(带主体名 / 下单人),keyword 模糊匹配订单号 / 套餐名 / 主体名
* - `POST /api/web/admin/orders/:orderNo/confirm`
* **确认订单**:与支付渠道回调走**同一个** `service.subjectOrder.payNotify()`,
* 所以「标记已支付 + 主体顺延 + 失效状态缓存 + 幂等」这些后续动作完全一致,
* 只是渠道记成 `manual`、流水号记成 `ADMIN-<时间戳>`(便于和真实渠道对账区分)。
*/
class WebAdminOrderController extends Controller {
/** GET /api/web/admin/orders */
async index() {
const { ctx } = this;
const data = await ctx.service.subjectOrder.listAll({
page: ctx.query.page,
pageSize: ctx.query.pageSize,
keyword: ctx.query.keyword,
status: ctx.query.status,
subjectId: ctx.query.subjectId,
});
ctx.body = { ok: true, data };
}
/** POST /api/web/admin/orders/:orderNo/confirm */
async confirm() {
const { ctx } = this;
const orderNo = String(ctx.params.orderNo || '').trim();
if (!orderNo) ctx.throw(400, 'orderNo 不能为空');
const data = await ctx.service.subjectOrder.payNotify({
orderNo,
transactionId: `ADMIN-${Date.now()}`,
channel: 'manual',
});
ctx.logger.info('[admin] 平台管理员 %s 确认订单 %s(duplicated=%s)',
ctx.state.user.id, orderNo, data.duplicated);
ctx.body = { ok: true, data };
}
}
module.exports = WebAdminOrderController;

View File

@ -0,0 +1,48 @@
'use strict';
const { Controller } = require('egg');
/** 路径参数转正整数,非法返回 null */
function toId(value) {
const id = Number(value);
return Number.isInteger(id) && id > 0 ? id : null;
}
/**
* web 平台管理员:**所有主体**(`/api/web/admin/subjects`)
*
* 鉴权:`middleware.apiAuth()` + `middleware.platformAdmin()`。
*
* - `GET /api/web/admin/subjects?page=&pageSize=&keyword=&status=&expired=`
* 所有主体(带成员数 / 管理员账号 / 是否过期),keyword 模糊匹配主体名或备注
* - `PUT /api/web/admin/subjects/:id`
* 改授权到期时间:`{ expireAt: '2027-01-01 00:00:00' }` 直接设,
* 或 `{ extendDays: 30 }` 顺延;也可顺带改 `remark` / `status`
*/
class WebAdminSubjectController extends Controller {
/** GET /api/web/admin/subjects */
async index() {
const { ctx } = this;
const data = await ctx.service.subject.listAll({
page: ctx.query.page,
pageSize: ctx.query.pageSize,
keyword: ctx.query.keyword,
status: ctx.query.status,
expired: ctx.query.expired,
});
ctx.body = { ok: true, data };
}
/** PUT /api/web/admin/subjects/:id */
async update() {
const { ctx } = this;
const id = toId(ctx.params.id);
if (!id) ctx.throw(400, 'id 必须是正整数');
const { expireAt, extendDays, remark, status } = ctx.request.body || {};
const data = await ctx.service.subject.setExpireAt(id, { expireAt, extendDays, remark, status }, ctx.state.user.id);
ctx.body = { ok: true, data };
}
}
module.exports = WebAdminSubjectController;

View File

@ -0,0 +1,40 @@
'use strict';
/**
* **平台管理员**校验(挂在 `middleware.apiAuth()` 后面)
*
* 用法:`router.get('/api/web/admin/subjects', apiAuth, platformAdmin, controller.web.adminSubject.index)`
*
* 通过条件:`service.adminMember.isAdmin(当前用户 id)` ——
* `admin_members` 表里启用中的行,或 `config.internal.adminIds`(env `INTERNAL_ADMIN_IDS`,内置/救急入口)。
*
* 不通过:403 `{ status: 'not_platform_admin', message }`。
* 通过后 `ctx.state.platformAdmin = { user, role }`。
*
* ⚠️ 这是**平台级**权限(能看/改所有主体的数据),只有 `/api/web/admin/*` 用它;
* 主体内的业务接口仍然只认「你是不是这个主体的成员」(`middleware/subjectAuth`)。
*/
module.exports = (options = {}) => {
return async function platformAdmin(ctx, next) {
const user = ctx.state.user || (ctx.locals && ctx.locals.user) || null;
if (!user || !user.id) {
ctx.status = 401;
ctx.body = { ok: false, status: 'unauthorized', message: '请先登录' };
return;
}
const isAdmin = await ctx.service.adminMember.isAdmin(user.id);
if (!isAdmin) {
ctx.status = 403;
ctx.body = {
ok: false,
status: 'not_platform_admin',
message: options.message || '需要平台管理员权限',
};
return;
}
ctx.state.platformAdmin = { user, builtin: ctx.service.adminMember.isBootstrap(user.id) };
await next();
};
};

View File

@ -0,0 +1,35 @@
'use strict';
/**
* 平台管理员(admin_members)
*
* 一行 = 一个平台管理员账号(`user_id` 唯一):
* - `role`:1 超级管理员 / 2 管理员(目前权限一样,留字段给以后细分)
* - `status`:1 启用 / 0 停用(停用等价于移除,但保留记录便于审计)
* - 软删除:paranoid(`deleted_at`)
*
* ⚠️ 与 `wechat_gateway_bindings` 同理:软删的行仍然占着 `uk_admin_members_user` 唯一索引,
* 所以「查重 / 重新添加同一个人」必须带 `paranoid: false`(见 service/admin_member.js)。
*/
module.exports = (app) => {
const { BIGINT, STRING, TINYINT, DATE } = app.Sequelize;
const AdminMember = app.model.define('admin_member', {
id: { type: BIGINT.UNSIGNED, primaryKey: true, autoIncrement: true, comment: '主键' },
userId: { type: BIGINT.UNSIGNED, allowNull: false, unique: true, comment: '平台管理员的账号 users.id' },
name: { type: STRING(32), allowNull: false, defaultValue: '', comment: '显示名(不填就用账号昵称/用户名)' },
role: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 1, comment: '角色:1 超级管理员 2 管理员' },
status: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 1, comment: '状态:1 启用 0 停用' },
remark: { type: STRING(255), comment: '备注' },
}, {
tableName: 'admin_members',
paranoid: true,
comment: '平台管理员表',
});
AdminMember.associate = function() {
app.model.AdminMember.belongsTo(app.model.User, { foreignKey: 'user_id', as: 'user' });
};
return AdminMember;
};

View File

@ -12,6 +12,7 @@ module.exports = (app) => {
const subjectActive = middleware.subjectActive();
const internalAuth = middleware.internalAuth();
const scannerAuth = middleware.scannerAuth();
const platformAdmin = middleware.platformAdmin();
// ==================== JSON 接口 ====================
// 控制器按「谁在调」分模块(app/controller/<模块>/):
@ -44,16 +45,39 @@ module.exports = (app) => {
router.post('/api/web/auth/forgot', controller.web.auth.forgot);
router.post('/api/web/auth/reset', controller.web.auth.reset);
// ---------- 微信小程序登录(code2Session → openid → 绑定/新建平台账号) ----------
router.post('/api/web/auth/wechat/login', controller.web.wechatMp.login);
router.post('/api/web/auth/wechat/bind', apiAuth, controller.web.wechatMp.bind);
router.get('/api/web/auth/wechat/bindings', apiAuth, controller.web.wechatMp.bindings);
router.delete('/api/web/auth/wechat/bindings/:id', apiAuth, controller.web.wechatMp.unbind);
// ---------- 微信登录网关(扫码登录 / 绑定微信;文档 https://gateway.gztbyc.com/#/docs) ----------
// 网关回调:**公开接口**,靠 `sign` + `timestamp` 鉴权(见 controller/gateway/notify.js)。
// ⚠️ 网关管理台里的「服务端通知地址」要配成能公网访问的 `<域名>/api/wechat-gateway/notify`。
router.post('/api/wechat-gateway/notify', controller.gateway.notify.index);
// 登录页扫码:申请二维码(公开)→ 长轮询结果
router.post('/api/web/auth/wechat-gateway/qrcode', controller.web.wxGateway.createLoginQr);
router.get('/api/web/auth/wechat-gateway/login', controller.web.wxGateway.loginStatus);
// 二维码图片:SVG 给浏览器,GIF 给桌面端(WPF 不能渲染 SVG)
router.get('/api/wechat-gateway/qrcode.svg', controller.web.wxGateway.qrSvg);
router.get('/api/wechat-gateway/qrcode.gif', controller.web.wxGateway.qrGif);
router.get('/api/web/me', apiAuth, controller.web.profile.show);
router.put('/api/web/me', apiAuth, controller.web.profile.update);
router.put('/api/web/me/password', apiAuth, controller.web.profile.changePassword);
// 个人中心「绑定微信」(走微信登录网关,扫码绑定 / 解绑)
router.post('/api/web/me/wechat/qrcode', apiAuth, controller.web.wxGateway.createBindQr);
router.get('/api/web/me/wechat/status', apiAuth, controller.web.wxGateway.bindStatus);
router.get('/api/web/me/wechat/bindings', apiAuth, controller.web.wxGateway.bindings);
router.delete('/api/web/me/wechat/bindings/:id', apiAuth, controller.web.wxGateway.unbind);
// ---------- 平台管理员(能看所有主体 / 订单;能改授权期限、确认订单、加平台管理员) ----------
// 鉴权:apiAuth(登录)+ platformAdmin(admin_members 里启用,或 INTERNAL_ADMIN_IDS 内置名单)
router.get('/api/web/admin/me', apiAuth, platformAdmin, controller.web.adminMember.me);
router.get('/api/web/admin/members', apiAuth, platformAdmin, controller.web.adminMember.index);
router.post('/api/web/admin/members', apiAuth, platformAdmin, controller.web.adminMember.create);
router.delete('/api/web/admin/members/:id', apiAuth, platformAdmin, controller.web.adminMember.destroy);
router.get('/api/web/admin/subjects', apiAuth, platformAdmin, controller.web.adminSubject.index);
router.put('/api/web/admin/subjects/:id', apiAuth, platformAdmin, controller.web.adminSubject.update);
router.get('/api/web/admin/orders', apiAuth, platformAdmin, controller.web.adminOrder.index);
// 确认订单 = 支付回调的后续动作(同一套 payNotify:标记已支付 + 主体顺延 + 失效缓存)
router.post('/api/web/admin/orders/:orderNo/confirm', apiAuth, platformAdmin, controller.web.adminOrder.confirm);
// ---------- 主体(租户):不输主体 id,靠「当前用户是否是成员」判定 ----------
// 除这几个以外的业务接口都要额外带 `X-Subject-Id`(middleware/subjectAuth)
router.get('/api/web/subjects', apiAuth, controller.web.subject.index);
@ -65,8 +89,11 @@ module.exports = (app) => {
router.delete('/api/web/subjects/:id/members/:memberId', apiAuth, controller.web.subject.removeMember);
// 设/取消管理员(一个主体可多名管理员;创建者恒为管理员,不能降级)
router.put('/api/web/subjects/:id/members/:memberId/role', apiAuth, controller.web.subject.updateMemberRole);
// 给未绑定账号/微信的成员生成绑定码(手机扫码后绑定)
router.post('/api/web/subjects/:id/members/:memberId/bind-code', apiAuth, controller.web.subject.memberBindCode);
// 给未绑定账号/微信的成员出一张扫码绑定二维码(微信登录网关:成员用微信扫码即可绑定)
router.post('/api/web/subjects/:id/members/:memberId/bind-qr', apiAuth, controller.web.subject.memberBindQr);
router.get('/api/web/subjects/:id/members/:memberId/bind-qr/status', apiAuth, controller.web.subject.memberBindQrStatus);
// 解除成员的账号绑定(绑错了 / 手机换人时用)
router.post('/api/web/subjects/:id/members/:memberId/unbind', apiAuth, controller.web.subject.unbindMember);
// 续期订单:选套餐下单不改变期限,支付结果由渠道回调 `POST /api/pay/notify` 驱动
// ⚠️ 不挂 subjectAuth:主体已过期也要能下单续期
@ -76,10 +103,6 @@ module.exports = (app) => {
router.get('/api/web/subjects/:id/orders/:orderNo', apiAuth, controller.web.subjectOrder.show);
router.post('/api/web/subjects/:id/orders/:orderNo/close', apiAuth, controller.web.subjectOrder.close);
// 成员绑定:手机扫码页(公开查状态)+ 登录后确认绑定
router.get('/api/subject/member-bind', controller.auth.memberBind.status);
router.post('/api/subject/member-bind/confirm', apiAuth, controller.auth.memberBind.confirm);
// 首页统计(只统计当前主体的数据)
router.get('/api/web/stats', apiAuth, subjectAuth, controller.web.stats.index);
@ -132,16 +155,25 @@ module.exports = (app) => {
router.delete('/api/web/cameras/:id', apiAuth, subjectAuth, subjectAdmin, controller.web.camera.destroy);
// 工作台:CRUD + 绑定摄像头 + 绑定扫码通道
// 扫码登入工作台:二维码按需生成(微信登录网关,一次性),管理员在成员弹窗里显示;
// 用户手机微信扫码确认后由网关回调落地登录记录(见 controller/gateway/notify.js)。
router.get('/api/web/workstation-scan-channels', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.availableScanChannels);
router.get('/api/web/workstations', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.index);
router.post('/api/web/workstations', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.create);
router.get('/api/web/workstations/:id', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.show);
router.put('/api/web/workstations/:id', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.update);
router.delete('/api/web/workstations/:id', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.destroy);
// 成员登录记录:二维码扫码登入(网关)+ 当前/历史成员 + 手动下线 + 一键全部下线
router.post('/api/web/workstations/:id/login-qr', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.loginQr);
router.get('/api/web/workstations/:id/login-qr/status', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.loginQrStatus);
router.get('/api/web/workstations/:id/members', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.members);
router.post('/api/web/workstations/:id/members/offline-all', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.offlineAll);
router.post('/api/web/workstations/:id/members/:recordId/offline', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.offlineMember);
router.post('/api/web/workstations/:id/cameras', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.bindCameras);
router.delete('/api/web/workstations/:id/cameras/:cameraId', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.unbindCamera);
// 合成画面布局(拖拽/缩放后保存)
router.put('/api/web/workstations/:id/cameras/:cameraId/layout', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.updateCameraLayout);
router.put('/api/web/workstations/:id/cameras/:cameraId/label', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.setLabelCamera);
router.post('/api/web/workstations/:id/scan-channels', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.bindScanChannels);
router.delete('/api/web/workstations/:id/scan-channels/:linkId', apiAuth, subjectAuth, subjectAdmin, controller.web.workstation.unbindScanChannel);
@ -159,12 +191,9 @@ module.exports = (app) => {
router.put('/api/users/:id', internalAuth, controller.internal.user.update);
router.delete('/api/users/:id', internalAuth, controller.internal.user.destroy);
// 微信授权(绑定关系)
router.get('/api/users/:id/wechats', internalAuth, controller.internal.wechat.indexByUser);
router.get('/api/wechat/:appid/:openid', internalAuth, controller.internal.wechat.show);
router.post('/api/wechat/bind', internalAuth, controller.internal.wechat.bind);
router.put('/api/wechat/:id/tokens', internalAuth, controller.internal.wechat.updateTokens);
router.delete('/api/wechat/:id', internalAuth, controller.internal.wechat.unbind);
// 微信登录网关的绑定关系(排查 + 强制解绑:微信绑在前员工账号上时用)
router.get('/api/internal/wechat-bindings', internalAuth, controller.internal.wechat.bindings);
router.delete('/api/internal/wechat-bindings/:id', internalAuth, controller.internal.wechat.unbindBinding);
// 系统配置(读接口带 Redis 缓存,写接口自动失效)
router.get('/api/configs', internalAuth, controller.internal.config.index);
@ -188,16 +217,12 @@ module.exports = (app) => {
router.post('/api/internal/subject-orders/:orderNo/pay', internalAuth, controller.internal.subjectOrder.pay);
// ---------- 公开的登录接口(auth)----------
// 登录码二维码(SVG,本地生成;前端登录页直接 img 引用)
// 登录页扫码登录已改为「微信登录网关」(见上方 /api/web/auth/wechat-gateway/*),
// 这里保留的是**设备扫码登录**用到的同一套公开接口(6 位串码 + 手机页确认)。
// 登录码二维码(SVG,本地生成;手机页面/设备端直接 img 引用)
router.get('/api/wechat/qrcode.svg', controller.auth.wechat.qrcode);
// 同一张二维码的 GIF 版(桌面端 WPF 不能渲染 SVG)
router.get('/api/wechat/qrcode.gif', controller.auth.wechat.qrcodeGif);
// 扫码登录(前端/客户端接口):不带参数发串码,带 ?code=&wait= 长轮询并拿用户 JWT
router.get('/api/wechat/login', controller.auth.wechat.login);
// 查登录码状态(无需登录)
router.get('/api/wechat/status', controller.auth.wechat.status);
// 微信公众号网页授权回调(微信把手机浏览器重定向到这里,处理完再转回前端 /wechat 页)
router.get('/api/wechat/callback', controller.auth.wechat.callback);
// 设备发码 + 长轮询:**这一步才注册/绑定**并直接拿到长期 JWT(发码不需要任何凭据)
router.get('/api/device/login', controller.device.auth.login);
// 刷新访问令牌:凭据是刷新令牌本身(访问令牌可能已过期,所以不能挂 scannerAuth)
@ -220,4 +245,6 @@ module.exports = (app) => {
router.get('/api/scan/channels', scannerAuth, controller.device.scan.channels);
router.post('/api/scan/records', scannerAuth, subjectActive, controller.device.scan.reportRecords);
router.get('/api/scan/records', scannerAuth, controller.device.scan.records);
// 面单摄像头识别配置(读,不写业务数据,所以不挂 subjectActive)
router.get('/api/scanner/label-cameras', scannerAuth, controller.device.scan.labelCameras);
};

View File

@ -0,0 +1,192 @@
'use strict';
const { Service } = require('egg');
const { Op } = require('sequelize');
const ROLE_TEXT = { 1: '超级管理员', 2: '管理员' };
const USER_ATTRIBUTES = [ 'id', 'username', 'nickname', 'email', 'phone', 'avatar', 'status' ];
/**
* 平台管理员(`admin_members`)
*
* 平台管理员 = 能看所有主体 / 所有订单、改授权到期时间、确认订单、加别的平台管理员的人。
* 与「主体管理员」(`subject_members.role=1`) 完全分开:后者只管自己那个主体。
*
* 谁能算平台管理员(满足其一):
* 1. `admin_members` 里 `status=1` 的行;
* 2. `config.internal.adminIds`(env `INTERNAL_ADMIN_IDS`,默认 `[1]`)里的账号 ——
* **内置/救急入口**:就算把最后一个管理员在页面上删了,也还能靠它进来加回来。
*/
class AdminMemberService extends Service {
get AdminMember() {
return this.app.model.AdminMember;
}
get User() {
return this.app.model.User;
}
/** 配置里的内置管理员 id 列表 */
get bootstrapIds() {
const cfg = this.app.config.internal || {};
return Array.isArray(cfg.adminIds) ? cfg.adminIds.map(Number) : [];
}
/** 这个账号是不是平台管理员(查库 + 内置名单) */
async isAdmin(userId) {
const id = Number(userId);
if (!Number.isInteger(id) || id <= 0) return false;
const row = await this.AdminMember.findOne({ where: { userId: id, status: 1 } });
if (row) return true;
return this.bootstrapIds.includes(id);
}
/** 内置名单里的账号(前端提示「内置管理员」用) */
isBootstrap(userId) {
return this.bootstrapIds.includes(Number(userId));
}
/**
* 平台管理员列表(含账号信息)
* @return {Promise<Array<object>>}
*/
async list() {
const rows = await this.AdminMember.findAll({ order: [[ 'role', 'ASC' ], [ 'id', 'ASC' ]] });
const userIds = rows.map(row => Number(row.userId));
// 内置名单里的人如果表里没有,也要露出来(否则页面上看不到「自己为什么是管理员」)
for (const id of this.bootstrapIds) {
if (!userIds.includes(id)) userIds.push(id);
}
const users = userIds.length
? await this.User.findAll({
where: { id: { [Op.in]: userIds } },
attributes: USER_ATTRIBUTES,
paranoid: false, // 账号被删了也要能看出来
})
: [];
const userMap = new Map(users.map(user => [ Number(user.id), user.toJSON() ]));
const list = rows.map(row => this.present(row, userMap.get(Number(row.userId))));
// 只在 bootstrap 名单里、表里没有的:补成「内置管理员」
for (const id of this.bootstrapIds) {
if (rows.some(row => Number(row.userId) === id)) continue;
list.push({
id: null,
userId: id,
name: this.nameOf(userMap.get(id)),
role: 1,
roleText: ROLE_TEXT[1],
status: 1,
remark: '内置管理员(INTERNAL_ADMIN_IDS)',
builtin: true,
user: userMap.get(id) || null,
createdAt: null,
});
}
return list;
}
/**
* 添加平台管理员(按账号找用户)
*
* 账号可以是用户名 / 手机号 / 邮箱(与登录一致)。已经在名单里的:
* - 启用中 → 409;
* - 停用/软删 → 恢复并更新角色(避免撞唯一索引,也方便「加回来」)。
*
* @param {object} params { account, name, role, remark }
*/
async add({ account, name, role, remark } = {}) {
const key = String(account || '').trim();
if (!key) this.ctx.throw(422, '请填写账号(用户名 / 手机号 / 邮箱)');
if (key.length > 128) this.ctx.throw(422, '账号过长');
const user = await this.User.findOne({
where: { [Op.or]: [ { username: key }, { phone: key }, { email: key.toLowerCase() } ] },
attributes: USER_ATTRIBUTES,
paranoid: false,
});
if (!user) this.ctx.throw(404, '账号不存在,请先在「个人中心」注册,或用运维脚本建号');
if (Number(user.status) !== 1 || user.deletedAt) this.ctx.throw(409, '该账号已被禁用或删除,不能设为管理员');
const finalRole = Number(role) === 2 ? 2 : 1;
// ⚠️ 必须带 paranoid:false:软删的行仍占着 user_id 唯一索引,查不到就会撞唯一键(报 Validation error)
const existing = await this.AdminMember.findOne({ where: { userId: Number(user.id) }, paranoid: false });
if (existing && !existing.deletedAt && Number(existing.status) === 1) {
this.ctx.throw(409, `${this.nameOf(user)} 已经是平台管理员了`);
}
const payload = {
userId: Number(user.id),
name: String(name || '').trim().slice(0, 32) || this.nameOf(user),
role: finalRole,
status: 1,
remark: remark === undefined ? existing && existing.remark : remark,
};
let row;
if (existing) {
if (existing.deletedAt) await existing.restore();
await existing.update(payload);
row = existing;
} else {
row = await this.AdminMember.create(payload);
}
this.ctx.logger.info('[admin] 添加平台管理员:userId=%s(%s,role=%s)', user.id, payload.name, finalRole);
return this.present(row, user.toJSON());
}
/**
* 移除平台管理员(软删)
*
* 两条保护:不能移除自己(避免当场把自己锁在外面)、不能移除最后一个启用的管理员。
*/
async remove({ id, operatorUserId } = {}) {
const rowId = Number(id);
if (!Number.isInteger(rowId) || rowId <= 0) this.ctx.throw(400, 'id 必须是正整数');
const row = await this.AdminMember.findByPk(rowId);
if (!row) this.ctx.throw(404, '管理员不存在');
if (Number(row.userId) === Number(operatorUserId)) this.ctx.throw(409, '不能移除自己');
const enabled = await this.AdminMember.count({ where: { status: 1 } });
if (Number(row.status) === 1 && enabled <= 1 && !this.bootstrapIds.length) {
this.ctx.throw(409, '至少要保留一个平台管理员');
}
await row.destroy();
this.ctx.logger.info('[admin] 移除平台管理员:id=%s userId=%s(操作人 %s)', row.id, row.userId, operatorUserId);
return { id: rowId, userId: Number(row.userId) };
}
/** 展示字段(固定 camelCase) */
present(row, user) {
const role = Number(row.role) || 1;
return {
id: Number(row.id),
userId: Number(row.userId),
name: row.name || this.nameOf(user),
role,
roleText: ROLE_TEXT[role] || '管理员',
status: Number(row.status),
remark: row.remark || null,
builtin: this.isBootstrap(row.userId),
user: user || null,
createdAt: row.createdAt || row.created_at || null,
};
}
/** 账号的显示名:备注名 → 昵称 → 用户名 → #id */
nameOf(user) {
if (!user) return '未知账号';
return String(user.nickname || user.username || `#${user.id}`);
}
}
module.exports = AdminMemberService;

View File

@ -2,6 +2,7 @@
const { Service } = require('egg');
const crypto = require('crypto');
const { Op } = require('sequelize');
const DAY_MS = 24 * 3600 * 1000;
const STATUS_TEXT = { 0: '待支付', 1: '已支付', 2: '已关闭' };
@ -120,6 +121,68 @@ class SubjectOrderService extends Service {
};
}
/**
* **平台管理员视角**:所有订单(分页,带主体名 / 下单人)
*
* @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,
};
}
/**
* 支付通知(渠道回调):标记已支付 + 主体续期 + 失效状态缓存
*
@ -216,7 +279,7 @@ class SubjectOrderService extends Service {
expireBefore: order.expireBefore || null,
expireAfter: order.expireAfter || null,
remark: order.remark || null,
createdAt: order.createdAt || null,
createdAt: order.createdAt || order.created_at || null,
}, extra);
}
}

View File

@ -0,0 +1,53 @@
'use strict';
/**
* 平台管理员(`admin_members`)
*
* 「主体管理员」(`subject_members.role=1`)只管自己那个主体;
* 这里记的是**平台级管理员**:能看所有主体 / 所有订单、能改授权到期时间、能确认订单、能加别的平台管理员。
*
* 与 `config.internal.adminIds`(env `INTERNAL_ADMIN_IDS`)的关系:
* - 这张表是**主**名单(可在页面上自助维护);
* - `INTERNAL_ADMIN_IDS` 里的人**始终**算平台管理员(内置管理员 / 线上救急入口,避免把最后一个管理员删掉后进不去)。
*
* 迁移会把内置管理员(`users.username = 'admin'`,没有就用 id=1)先塞进来,保证升级后立刻能用;
* 找不到就什么都不插(不影响迁移成功)。
*/
module.exports = {
async up(queryInterface, Sequelize) {
const { BIGINT, STRING, TINYINT, DATE } = Sequelize;
await queryInterface.createTable('admin_members', {
id: { type: BIGINT.UNSIGNED, primaryKey: true, autoIncrement: true, allowNull: false },
user_id: { type: BIGINT.UNSIGNED, allowNull: false, comment: '平台管理员的账号 users.id' },
name: { type: STRING(32), allowNull: false, defaultValue: '', comment: '显示名(不填就用账号昵称/用户名)' },
role: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 1, comment: '角色:1 超级管理员 2 管理员' },
status: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 1, comment: '状态:1 启用 0 停用' },
remark: { type: STRING(255), allowNull: true, comment: '备注' },
created_at: { type: DATE, allowNull: false, defaultValue: Sequelize.literal('CURRENT_TIMESTAMP') },
updated_at: { type: DATE, allowNull: false, defaultValue: Sequelize.literal('CURRENT_TIMESTAMP') },
deleted_at: { type: DATE, allowNull: true },
}, { comment: '平台管理员表' });
await queryInterface.addIndex('admin_members', [ 'user_id' ], {
name: 'uk_admin_members_user',
unique: true,
});
await queryInterface.addIndex('admin_members', [ 'status' ], { name: 'idx_admin_members_status' });
// 内置管理员先入表(升级后立刻能在页面上看到并继续加人)
await queryInterface.sequelize.query(
`INSERT INTO admin_members (user_id, name, role, status, remark, created_at, updated_at)
SELECT u.id, COALESCE(NULLIF(u.nickname, ''), NULLIF(u.username, ''), CONCAT('用户', u.id)), 1, 1, '内置管理员(迁移初始化)', NOW(), NOW()
FROM users u
WHERE (u.username = 'admin' OR u.id = 1)
AND u.deleted_at IS NULL
ORDER BY (u.username = 'admin') DESC, u.id ASC
LIMIT 1`,
);
},
async down(queryInterface) {
await queryInterface.dropTable('admin_members');
},
};

View File

@ -0,0 +1,452 @@
'use strict';
const { app, mock, assert } = require('egg-mock/bootstrap');
/** 假实例:update 时把字段同时合并回实例自身(present 读的是实例属性) */
const instance = data => {
const obj = {
toJSON: () => data,
update: async fields => {
Object.assign(data, fields);
Object.assign(obj, fields);
},
restore: async () => { data.deletedAt = null; obj.deletedAt = null; },
destroy: async () => { data.deletedAt = new Date(); obj.deletedAt = data.deletedAt; },
};
return Object.assign(obj, data);
};
const ADMIN = { id: 1, username: 'admin', nickname: '管理员', status: 1 };
const OTHER = { id: 2, username: 'ops', nickname: '运维', email: 'ops@example.com', phone: null, avatar: '', status: 1 };
/**
* 平台管理员(`/api/web/admin/*`)
*
* 重点:
* - 鉴权:`admin_members` 里启用中的行 **或** `config.internal.adminIds`(内置/救急),其余一律 403;
* - 管理员成员:列表(内置的也露出来)、添加(按账号找用户、已在名单里 409)、移除(不能删自己);
* - 主体:所有主体都能看,能直接改授权到期时间(直接设 / 顺延);
* - 订单:所有订单都能看,能「确认订单」——走支付回调的同一套 `payNotify`,重复确认幂等。
*/
describe('test/app/controller/admin.test.js', () => {
const BEARER = 'Bearer';
const token = () => app.createAnonymousContext().service.jwt.signUser(ADMIN);
const auth = () => ({ Authorization: `${BEARER} ${token()}` });
/** 默认:`admin_members` 里没有行、内置名单里也没有这个人 → 不是平台管理员 */
function mockModels(overrides = {}) {
mock(app, 'model', Object.assign({
User: {
async findByPk() { return instance(Object.assign({}, ADMIN)); },
async findOne() { return null; },
async findAll() { return []; },
},
AdminMember: {
async findOne() { return null; },
async findAll() { return []; },
async count() { return 0; },
async findByPk() { return null; },
async create(fields) { return instance(Object.assign({ id: 9 }, fields)); },
},
Subject: {
async findByPk() { return null; },
async findAndCountAll() { return { rows: [], count: 0 }; },
async findAll() { return []; },
},
// 平台管理员的名单表里查到的那一行(启用)
SubjectMember: {
async count() { return 0; },
async findAll() { return []; },
async findOne() { return null; },
},
SubjectOrder: {
async findAndCountAll() { return { rows: [], count: 0 }; },
async findOne() { return null; },
},
transaction: async () => ({
LOCK: { UPDATE: 'UPDATE' },
async commit() {},
async rollback() {},
}),
}, overrides));
}
/** `admin_members` 里给 ADMIN 放一行(= 表里登记的平台管理员) */
const enabledRow = (overrides = {}) => instance(Object.assign({
id: 1,
userId: 1,
name: '管理员',
role: 1,
status: 1,
remark: null,
deletedAt: null,
createdAt: new Date(),
}, overrides));
let originAdminIds = [];
beforeEach(() => {
originAdminIds = app.config.internal.adminIds;
// 默认把内置名单清空,只让 `admin_members` 生效(每个用例自己决定要不要加)
app.config.internal.adminIds = [];
});
afterEach(() => {
app.config.internal.adminIds = originAdminIds;
});
/** 让 ADMIN 成为平台管理员(表里有一行) */
function grantByTable(overrides = {}) {
mockModels(Object.assign({
AdminMember: {
async findOne() { return enabledRow(); },
async findAll() { return [ enabledRow() ]; },
async count() { return 1; },
async findByPk() { return enabledRow(); },
async create(fields) { return instance(Object.assign({ id: 9 }, fields)); },
},
}, overrides));
}
it('不是平台管理员:/api/web/admin/* 一律 403', async () => {
mockModels();
const res = await app.httpRequest().get('/api/web/admin/subjects').set(auth()).expect(403);
assert(res.body.status === 'not_platform_admin', JSON.stringify(res.body));
await app.httpRequest().get('/api/web/admin/members').set(auth()).expect(403);
await app.httpRequest().get('/api/web/admin/orders').set(auth()).expect(403);
await app.httpRequest().post('/api/web/admin/orders/SO1/confirm').set(auth()).send({}).expect(403);
});
it('平台管理员(表里登记):GET /api/web/admin/me 返回 admin=true', async () => {
grantByTable();
const res = await app.httpRequest().get('/api/web/admin/me').set(auth()).expect(200);
assert(res.body.data.admin === true, JSON.stringify(res.body));
assert(res.body.data.builtin === false, '表里登记的不算内置');
});
it('内置管理员(INTERNAL_ADMIN_IDS):表里没有也算平台管理员', async () => {
mockModels();
app.config.internal.adminIds = [ 1 ];
const res = await app.httpRequest().get('/api/web/admin/me').set(auth()).expect(200);
assert(res.body.data.admin === true && res.body.data.builtin === true, JSON.stringify(res.body));
});
it('GET /api/web/admin/members:表里的 + 内置名单(表里没有的)都列出来', async () => {
mockModels();
app.config.internal.adminIds = [ 1 ];
mock(app, 'model', {
User: {
async findByPk() { return instance(Object.assign({}, ADMIN)); },
async findAll() { return [ instance(Object.assign({}, ADMIN)), instance(Object.assign({}, OTHER)) ]; },
},
AdminMember: {
async findOne() { return null; },
async findAll() {
return [ instance({ id: 5, userId: 2, name: '运维', role: 2, status: 1, remark: null, createdAt: new Date() }) ];
},
async count() { return 1; },
},
});
const res = await app.httpRequest().get('/api/web/admin/members').set(auth()).expect(200);
const list = res.body.data.list;
assert(list.length === 2, JSON.stringify(list));
const builtin = list.find(item => item.builtin === true);
assert(builtin && builtin.userId === 1 && builtin.id === null, '内置管理员要露出来(id=null)');
const normal = list.find(item => item.userId === 2);
assert(normal && normal.id === 5 && normal.user.username === 'ops', JSON.stringify(normal));
});
it('POST /api/web/admin/members:账号不存在 → 404', async () => {
grantByTable();
const res = await app.httpRequest().post('/api/web/admin/members')
.set(auth()).send({ account: 'nobody' }).expect(404);
assert(/账号不存在/.test(res.body.message), JSON.stringify(res.body));
});
it('POST /api/web/admin/members:已经是管理员 → 409', async () => {
grantByTable();
mock(app, 'model', {
User: {
async findByPk() { return instance(Object.assign({}, ADMIN)); },
async findOne() { return instance(Object.assign({}, OTHER)); },
async findAll() { return []; },
},
AdminMember: {
async findOne({ where } = {}) {
// isAdmin(1) → 启用行;按 userId=2 查重 → 也当作已存在(启用)
return enabledRow(where && Number(where.userId) === 2 ? { id: 6, userId: 2, status: 1 } : {});
},
async findAll() { return [ enabledRow() ]; },
async count() { return 2; },
},
});
const res = await app.httpRequest().post('/api/web/admin/members')
.set(auth()).send({ account: 'ops' }).expect(409);
assert(/已经是平台管理员/.test(res.body.message), JSON.stringify(res.body));
});
it('POST /api/web/admin/members:正常添加 → 201(带账号信息,角色可选)', async () => {
grantByTable();
let created = null;
mock(app, 'model', {
User: {
async findByPk() { return instance(Object.assign({}, ADMIN)); },
async findOne() { return instance(Object.assign({}, OTHER)); },
async findAll() { return []; },
},
AdminMember: {
async findOne({ where } = {}) {
return where && Number(where.userId) === 2 ? null : enabledRow();
},
async findAll() { return [ enabledRow() ]; },
async count() { return 1; },
async create(fields) {
created = fields;
return instance(Object.assign({ id: 7 }, fields));
},
},
});
const res = await app.httpRequest().post('/api/web/admin/members')
.set(auth()).send({ account: 'ops', role: 2 }).expect(201);
assert(created && created.userId === 2 && created.role === 2, JSON.stringify(created));
assert(res.body.data.user.username === 'ops', JSON.stringify(res.body.data));
assert(res.body.data.roleText === '管理员', JSON.stringify(res.body.data));
});
it('DELETE /api/web/admin/members/:id:不能移除自己 → 409;移除别人 → 200', async () => {
grantByTable();
mock(app, 'model', {
User: {
async findByPk() { return instance(Object.assign({}, ADMIN)); },
async findAll() { return []; },
},
AdminMember: {
async findOne() { return enabledRow(); },
async findAll() { return [ enabledRow() ]; },
async count() { return 2; },
async findByPk(id) {
return Number(id) === 1
? enabledRow()
: instance({ id: 6, userId: 2, name: '运维', role: 2, status: 1, deletedAt: null });
},
},
});
const self = await app.httpRequest().delete('/api/web/admin/members/1').set(auth()).expect(409);
assert(/不能移除自己/.test(self.body.message), JSON.stringify(self.body));
const other = await app.httpRequest().delete('/api/web/admin/members/6').set(auth()).expect(200);
assert(other.body.data.id === 6 && other.body.data.userId === 2, JSON.stringify(other.body));
});
it('GET /api/web/admin/subjects:所有主体(keyword 走主体名/备注模糊)', async () => {
grantByTable();
let seenWhere = null;
// Sequelize 的 count({ group, raw }) 返回的是 [{ subject_id, count }] 这样的数组
mock(app, 'model', {
User: {
async findByPk() { return instance(Object.assign({}, ADMIN)); },
async findAll() { return [ instance({ id: 42, username: 'owner', nickname: '老板' }) ]; },
},
AdminMember: {
async findOne() { return enabledRow(); },
async findAll() { return [ enabledRow() ]; },
async count() { return 1; },
},
SubjectMember: { async count() { return [ { subject_id: 8, count: 2 } ]; } },
Subject: {
async findAndCountAll(options) {
seenWhere = options.where;
return {
rows: [ instance({
id: 8,
name: '某某仓库',
adminUserId: 42,
expireAt: new Date(Date.now() + 86400000),
status: 1,
remark: null,
}) ],
count: 1,
};
},
async findAll() { return [ instance({ id: 42, username: 'owner', nickname: '老板' }) ]; },
},
});
const res = await app.httpRequest()
.get(`/api/web/admin/subjects?keyword=${encodeURIComponent('仓库')}&pageSize=5`)
.set(auth()).expect(200);
const data = res.body.data;
assert(data.total === 1 && data.list.length === 1, JSON.stringify(data));
assert(data.list[0].memberCount === 2, '要带成员数');
assert(data.list[0].adminUser && data.list[0].adminUser.username === 'owner', JSON.stringify(data.list[0]));
assert(seenWhere && Array.isArray(seenWhere[Object.getOwnPropertySymbols(seenWhere)[0]]), 'keyword 要走 OR 模糊匹配');
});
it('PUT /api/web/admin/subjects/:id:直接设到期时间 / 顺延 / 时间格式不对 → 422', async () => {
grantByTable();
const subject = instance({
id: 8,
name: '某某仓库',
adminUserId: 42,
expireAt: new Date(Date.now() + 86400000),
status: 1,
remark: null,
});
mock(app, 'model', {
User: {
async findByPk() { return instance(Object.assign({}, ADMIN)); },
async findAll() { return []; },
},
AdminMember: {
async findOne() { return enabledRow(); },
async findAll() { return [ enabledRow() ]; },
async count() { return 1; },
},
Subject: {
async findByPk() { return subject; },
async findAndCountAll() { return { rows: [], count: 0 }; },
async findAll() { return []; },
},
});
const set = await app.httpRequest().put('/api/web/admin/subjects/8')
.set(auth()).send({ expireAt: '2027-01-01T00:00:00+08:00' }).expect(200);
assert(new Date(set.body.data.expireAt).toISOString() === '2026-12-31T16:00:00.000Z', JSON.stringify(set.body.data));
// 顺延:未过期 → 在原到期时间上加天数
const before = new Date(subject.expireAt).getTime();
const extended = await app.httpRequest().put('/api/web/admin/subjects/8')
.set(auth()).send({ extendDays: 30 }).expect(200);
assert(
new Date(extended.body.data.expireAt).getTime() === before + 30 * 86400000,
`顺延应按原到期时间相加:${extended.body.data.expireAt}`,
);
await app.httpRequest().put('/api/web/admin/subjects/8')
.set(auth()).send({ expireAt: '不是时间' }).expect(422);
});
it('GET /api/web/admin/orders:带主体名与下单人', async () => {
grantByTable();
mock(app, 'model', {
User: {
async findByPk() { return instance(Object.assign({}, ADMIN)); },
async findAll() { return [ instance({ id: 3, username: 'boss', nickname: '老板' }) ]; },
},
AdminMember: {
async findOne() { return enabledRow(); },
async findAll() { return [ enabledRow() ]; },
async count() { return 1; },
},
Subject: {
async findAll() { return [ instance({ id: 8, name: '某某仓库', expireAt: new Date(), status: 1 }) ]; },
},
SubjectOrder: {
async findAndCountAll() {
return {
rows: [ instance({
id: 100,
orderNo: 'SO20261029120000000001',
subjectId: 8,
userId: 3,
days: 30,
amount: 99,
status: 0,
channel: null,
createdAt: new Date(),
}) ],
count: 1,
};
},
},
});
const res = await app.httpRequest().get('/api/web/admin/orders?status=0').set(auth()).expect(200);
const row = res.body.data.list[0];
assert(row.orderNo === 'SO20261029120000000001', JSON.stringify(row));
assert(row.subjectName === '某某仓库' && row.userName === '老板', JSON.stringify(row));
assert(row.pending === true && row.statusText === '待支付', JSON.stringify(row));
});
it('POST /api/web/admin/orders/:orderNo/confirm:与支付回调同一套动作(续期 + 幂等)', async () => {
grantByTable();
const order = instance({
id: 100,
orderNo: 'SO20261029120000000001',
subjectId: 8,
userId: 3,
days: 30,
amount: 99,
status: 0,
channel: null,
transactionId: null,
paidAt: null,
expireBefore: null,
expireAfter: null,
remark: null,
createdAt: new Date(),
});
const subject = instance({
id: 8,
name: '某某仓库',
adminUserId: 42,
expireAt: new Date(Date.now() + 86400000),
status: 1,
});
const log = [];
mock(app, 'model', {
User: {
async findByPk() { return instance(Object.assign({}, ADMIN)); },
async findAll() { return []; },
},
AdminMember: {
async findOne() { return enabledRow(); },
async findAll() { return [ enabledRow() ]; },
async count() { return 1; },
},
Subject: {
async findByPk() { return subject; },
async findAll() { return []; },
},
SubjectOrder: {
async findOne() { return order; },
async findAndCountAll() { return { rows: [], count: 0 }; },
},
transaction: async () => ({
LOCK: { UPDATE: 'UPDATE' },
async commit() { log.push('commit'); },
async rollback() { log.push('rollback'); },
}),
});
const before = new Date(subject.expireAt).getTime();
const res = await app.httpRequest().post('/api/web/admin/orders/SO20261029120000000001/confirm')
.set(auth()).send({}).expect(200);
assert(res.body.data.duplicated === false, JSON.stringify(res.body));
assert(res.body.data.order.status === 1, JSON.stringify(res.body.data.order));
assert(res.body.data.order.channel === 'manual', '手工确认要记成 manual,便于和真实渠道区分');
assert(
new Date(subject.expireAt).getTime() === before + 30 * 86400000,
`主体应顺延 30 天,实际 ${subject.expireAt}`,
);
assert(log.includes('commit'), '要提交事务');
// 再点一次:幂等(不重复续期)
const again = await app.httpRequest().post('/api/web/admin/orders/SO20261029120000000001/confirm')
.set(auth()).send({}).expect(200);
assert(again.body.data.duplicated === true, JSON.stringify(again.body));
assert(
new Date(subject.expireAt).getTime() === before + 30 * 86400000,
'重复确认不能再加天数',
);
});
});

151
frontend/src/api/admin.ts Normal file
View File

@ -0,0 +1,151 @@
/**
* 平台管理员接口(`/api/web/admin/*`)
*
* 「平台管理员」= 能看**所有**主体 / 订单、改授权到期时间、确认订单、加别的平台管理员的人
* (与「主体管理员」`subject_members.role=1` 完全不同:后者只管自己那个主体)。
*
* 后端鉴权:user JWT + `admin_members` 里启用(或 `INTERNAL_ADMIN_IDS` 内置名单),
* 非平台管理员一律 403 `status='not_platform_admin'`。
*/
import { api } from '@/api/client';
/** 平台管理员成员 */
export interface AdminMemberItem {
/** `admin_members.id`;内置管理员(只在 INTERNAL_ADMIN_IDS 里)为 null */
id: number | null;
userId: number;
name: string;
/** 1 超级管理员 2 管理员 */
role: number;
roleText: string;
status: number;
remark?: string | null;
/** 来自 INTERNAL_ADMIN_IDS 内置名单(页面上不能移除) */
builtin: boolean;
user?: {
id: number;
username?: string | null;
nickname?: string | null;
email?: string | null;
phone?: string | null;
avatar?: string | null;
status?: number;
} | null;
createdAt?: string | null;
}
/** 平台视角的主体(带成员数 / 管理员账号) */
export interface AdminSubjectItem {
id: number;
name: string;
adminUserId: number;
expireAt: string;
status: number;
remark?: string | null;
expired: boolean;
memberCount: number;
adminUser: { id: number; username?: string | null; nickname?: string | null } | null;
createdAt?: string | null;
}
/** 平台视角的续期订单 */
export interface AdminOrderItem {
id: number;
orderNo: string;
subjectId: number;
subjectName?: string | null;
userId: number;
userName?: string | null;
planId?: number | null;
planName?: string | null;
days: number;
amount?: number | null;
/** 0 待支付 1 已支付 2 已关闭 */
status: number;
statusText: string;
pending: boolean;
channel?: string | null;
transactionId?: string | null;
paidAt?: string | null;
expireBefore?: string | null;
expireAfter?: string | null;
remark?: string | null;
createdAt?: string | null;
}
export interface AdminPaged<T> {
list: T[];
total: number;
page: number;
pageSize: number;
}
/** 当前账号是不是平台管理员(前端决定要不要显示「平台管理」菜单) */
export function fetchAdminMe(): Promise<{ admin: boolean; builtin: boolean; user: { id: number; username?: string | null; nickname?: string | null } }> {
return api.get('/api/web/admin/me');
}
/** 平台管理员列表 */
export function fetchAdminMembers(): Promise<{ list: AdminMemberItem[]; total: number }> {
return api.get('/api/web/admin/members');
}
/** 添加平台管理员(account = 用户名 / 手机号 / 邮箱) */
export function addAdminMember(body: { account: string; name?: string; role?: number; remark?: string }): Promise<AdminMemberItem> {
return api.post('/api/web/admin/members', body);
}
/** 移除平台管理员(软删;不能删自己、不能删最后一个) */
export function removeAdminMember(id: number): Promise<{ id: number; userId: number }> {
return api.del(`/api/web/admin/members/${id}`);
}
/** 所有主体(分页) */
export function fetchAdminSubjects(params: {
page?: number;
pageSize?: number;
keyword?: string;
status?: number | '';
/** '1' 只看已过期,'0' 只看未过期 */
expired?: '' | '0' | '1';
} = {}): Promise<AdminPaged<AdminSubjectItem>> {
const query = new URLSearchParams();
if (params.page) query.set('page', String(params.page));
if (params.pageSize) query.set('pageSize', String(params.pageSize));
if (params.keyword) query.set('keyword', params.keyword);
if (params.status !== undefined && params.status !== '') query.set('status', String(params.status));
if (params.expired) query.set('expired', params.expired);
const qs = query.toString();
return api.get(`/api/web/admin/subjects${qs ? `?${qs}` : ''}`);
}
/** 改主体授权到期时间:直接设 `expireAt`(ISO)或用 `extendDays` 顺延 */
export function updateAdminSubject(
id: number,
body: { expireAt?: string; extendDays?: number; remark?: string; status?: number },
): Promise<AdminSubjectItem> {
return api.put(`/api/web/admin/subjects/${id}`, body);
}
/** 所有订单(分页) */
export function fetchAdminOrders(params: {
page?: number;
pageSize?: number;
keyword?: string;
status?: number | '';
subjectId?: number | '';
} = {}): Promise<AdminPaged<AdminOrderItem>> {
const query = new URLSearchParams();
if (params.page) query.set('page', String(params.page));
if (params.pageSize) query.set('pageSize', String(params.pageSize));
if (params.keyword) query.set('keyword', params.keyword);
if (params.status !== undefined && params.status !== '') query.set('status', String(params.status));
if (params.subjectId) query.set('subjectId', String(params.subjectId));
const qs = query.toString();
return api.get(`/api/web/admin/orders${qs ? `?${qs}` : ''}`);
}
/** 确认订单(与支付回调同一套后续动作:标记已支付 + 主体顺延 + 失效缓存) */
export function confirmAdminOrder(orderNo: string): Promise<{ duplicated: boolean; order: AdminOrderItem }> {
return api.post(`/api/web/admin/orders/${encodeURIComponent(orderNo)}/confirm`, {});
}

View File

@ -0,0 +1,53 @@
/**
* 安装包版本信息(顶栏「下载桌面端 / Android 扫码台」用)
*
* ⚠️ 这两个接口**不是** `{ ok, data }` 包装:后端直接把 `version.json` 原样吐出来
* (见 `backend/app/controller/download.js`),所以不能用 `api/client`,
* 这里用裸 `fetch` + `cache: 'no-store'`(部署时 nginx 也对这两个路径关了缓存)。
*
* GET /download/version.json → 桌面端(Windows 安装包 .msi)
* GET /download/android_client/version.json → Android 扫码台(.apk)
*
* 返回里的 `downloadUrl` 是**打包时写进去的绝对地址**(生产域名),
* 所以本地开发点下载也是去生产取包,这是预期行为。
*/
export type InstallerKind = 'desktop' | 'android_client';
export interface InstallerVersion {
version?: string;
/** 安装包完整地址(绝对 URL) */
downloadUrl?: string;
/** 字节数 */
size?: number;
md5?: string;
publishedAt?: string;
/** Android 才有 */
versionCode?: number;
package?: string;
releaseNotes?: string;
}
const VERSION_PATH: Record<InstallerKind, string> = {
desktop: '/download/version.json',
android_client: '/download/android_client/version.json',
};
/** 取安装包版本信息;没有发布过 / 网络异常都返回 null(按钮照常显示,只是点不了) */
export async function fetchInstallerVersion(kind: InstallerKind): Promise<InstallerVersion | null> {
try {
const res = await fetch(VERSION_PATH[kind], { cache: 'no-store' });
if (!res.ok) return null;
const data = (await res.json()) as InstallerVersion;
return data && data.downloadUrl ? data : null;
} catch {
return null;
}
}
/** 字节数 → `135 MB`(顶栏提示用) */
export function formatSize(size?: number): string {
const bytes = Number(size);
if (!Number.isFinite(bytes) || bytes <= 0) return '';
const mb = bytes / 1024 / 1024;
return mb >= 1 ? `${mb.toFixed(mb >= 100 ? 0 : 1)} MB` : `${Math.max(Math.round(bytes / 1024), 1)} KB`;
}

View File

@ -1,6 +1,6 @@
<script setup lang="ts">
/** 业务页公用布局:左侧菜单 + 顶栏(右上角主体切换) + 内容区 */
import { computed, onMounted } from 'vue';
/** 业务页公用布局:左侧菜单 + 顶栏(右上角下载入口 / 主体切换 / 账号) + 内容区 */
import { computed, onMounted, ref } from 'vue';
import { useRouter } from 'vue-router';
import { clearToken, currentUser, displayName } from '@/composables/useAuth';
import {
@ -12,6 +12,8 @@ import {
subjects,
subjectsLoaded,
} from '@/composables/useSubject';
import { clearPlatformAdmin, ensurePlatformAdmin, isPlatformAdmin } from '@/composables/usePlatformAdmin';
import { fetchInstallerVersion, formatSize, type InstallerVersion } from '@/api/download';
/**
* fill = true:列表页用 —— 内容区不滚动,卡片吃掉剩余高度,只有表格内部滚动(表头吸顶、分页贴底)
@ -46,6 +48,16 @@ const menus = computed(() => allMenus.filter(item => {
return true;
}));
/**
* 平台管理菜单:**只有平台管理员**能看到(与主体管理员是两套权限)
* 这三个页面看的是「所有主体 / 所有订单 / 所有平台管理员」,不需要选主体。
*/
const platformMenus = [
{ to: '/admin/subjects', label: '主体管理' },
{ to: '/admin/orders', label: '订单管理' },
{ to: '/admin/members', label: '管理员' },
];
/** 当前主体(用于右上角展示 / 过期提示) */
const current = computed(() => subjects.value.find(item => item.id === currentSubjectId.value) || null);
@ -55,6 +67,42 @@ const avatarText = computed(() => {
return name.slice(0, 1).toUpperCase();
});
// ---------------- 右上角下载入口(桌面端 / Android 扫码台) ----------------
/**
* 与权限无关:**所有人、所有页面都显示**(顶栏在 AppLayout 里,登录后就能看到)。
* 版本信息来自 `GET /download/version.json` 和 `GET /download/android_client/version.json`
* (后端直接吐 version.json 原文,里面的 downloadUrl 是打包时写死的绝对地址)。
*/
const desktopPkg = ref<InstallerVersion | null>(null);
const androidPkg = ref<InstallerVersion | null>(null);
/** 顶栏按钮的 hover 提示:有版本就带上版本号 / 大小 / 发布时间 */
function packageTitle(label: string, pkg: InstallerVersion | null): string {
if (!pkg) return `${label}:还没有发布过安装包`;
const parts = [ `${label} v${pkg.version || '?'}` ];
const size = formatSize(pkg.size);
if (size) parts.push(size);
if (pkg.publishedAt) parts.push(`发布 ${pkg.publishedAt.slice(0, 10)}`);
parts.push('点击下载');
return parts.join(' · ');
}
/** 还没发布时按钮置灰、点了给个提示(不让浏览器跳到 404) */
function guardDownload(event: MouseEvent, pkg: InstallerVersion | null, label: string) {
if (pkg && pkg.downloadUrl) return;
event.preventDefault();
window.alert(`${label}还没有发布安装包,请稍后再试。`);
}
async function loadPackages() {
const [ desktop, android ] = await Promise.all([
fetchInstallerVersion('desktop'),
fetchInstallerVersion('android_client'),
]);
desktopPkg.value = desktop;
androidPkg.value = android;
}
/** 剩余天数(未过期时才显示;今天到期算 0 天) */
const daysLeft = computed(() => {
if (!current.value || current.value.expired) return null;
@ -73,12 +121,17 @@ function onSwitch(event: Event) {
function logout() {
// 令牌在本地,退出即清掉并回登录页(服务端无需回调)
clearToken();
clearPlatformAdmin();
router.replace({ name: 'login' });
}
onMounted(() => {
// 直接打开内页(刷新)时也能把主体下拉填满
if (!subjectsLoaded.value) loadSubjects().catch(() => undefined);
// 平台管理员判定(非管理员会 403,这里静默处理)
ensurePlatformAdmin().catch(() => undefined);
// 右上角下载入口的版本号(拿不到就只显示按钮,点了给提示)
loadPackages();
});
</script>
@ -89,6 +142,12 @@ onMounted(() => {
<nav>
<RouterLink v-for="item in menus" :key="item.to" :to="item.to">{{ item.label }}</RouterLink>
<!-- 平台管理(只有平台管理员可见;看的是所有主体 / 所有订单) -->
<template v-if="isPlatformAdmin">
<div class="nav-group">平台管理</div>
<RouterLink v-for="item in platformMenus" :key="item.to" :to="item.to">{{ item.label }}</RouterLink>
</template>
</nav>
</aside>
<div class="main">
@ -96,6 +155,36 @@ onMounted(() => {
<slot name="title">控制台</slot>
<div class="topbar-right">
<!-- 下载入口:**与权限无关,所有人都能看到**(桌面端 / Android 扫码台) -->
<div class="downloads">
<a
class="download-btn"
:class="{ 'is-missing': !desktopPkg }"
:href="desktopPkg?.downloadUrl || undefined"
:title="packageTitle('桌面端(Windows)', desktopPkg)"
rel="noopener"
@click="guardDownload($event, desktopPkg, '桌面端')"
>
<span class="download-icon" aria-hidden="true">↓</span>
<span class="download-text">下载桌面端</span>
<span v-if="desktopPkg?.version" class="download-version">v{{ desktopPkg.version }}</span>
</a>
<a
class="download-btn"
:class="{ 'is-missing': !androidPkg }"
:href="androidPkg?.downloadUrl || undefined"
:title="packageTitle('Android 扫码台', androidPkg)"
rel="noopener"
@click="guardDownload($event, androidPkg, 'Android 扫码台')"
>
<span class="download-icon" aria-hidden="true">↓</span>
<span class="download-text">下载 Android 扫码台</span>
<span v-if="androidPkg?.version" class="download-version">v{{ androidPkg.version }}</span>
</a>
</div>
<span class="topbar-divider" aria-hidden="true" />
<!-- 主体切换(右上角) -->
<div v-if="subjects.length" class="subject-picker">
<span class="subject-label">主体</span>
@ -130,6 +219,16 @@ onMounted(() => {
</template>
<style scoped>
/* 菜单分组标题(平台管理) */
.nav-group {
margin: 12px 4px 4px;
padding-top: 10px;
border-top: 1px solid rgba(255, 255, 255, 0.08);
font-size: 11px;
letter-spacing: 0.08em;
color: #64748b;
}
/* 标题与右上角一组:标题可以被压缩,右侧不折行 */
.topbar {
gap: 12px;
@ -150,6 +249,67 @@ onMounted(() => {
margin: 0 2px;
}
/* 下载入口(桌面端 / Android 扫码台):小胶囊按钮,窄屏只留图标 + 名称 */
.downloads {
display: flex;
align-items: center;
gap: 6px;
}
.download-btn {
display: inline-flex;
align-items: center;
gap: 4px;
height: 28px;
padding: 0 10px;
border: 1px solid var(--border);
border-radius: 999px;
background: #fff;
color: #334155;
font-size: 12px;
white-space: nowrap;
transition: border-color 0.15s ease, color 0.15s ease, background 0.15s ease;
}
.download-btn:hover {
border-color: var(--brand);
color: var(--brand);
background: rgba(37, 99, 235, 0.06);
}
/* 还没发布安装包:置灰(点了会提示,不会跳 404) */
.download-btn.is-missing {
color: #94a3b8;
background: #f8fafc;
cursor: not-allowed;
}
.download-icon {
font-size: 13px;
line-height: 1;
}
.download-version {
color: #94a3b8;
font-size: 11px;
}
/* 窄屏:版本号先藏起来,保证主体切换与账号不被挤 */
@media (max-width: 1180px) {
.download-version {
display: none;
}
}
@media (max-width: 1000px) {
.download-text {
display: none;
}
.download-btn {
padding: 0 8px;
}
}
/* 账号区:头像 + 昵称 + 退出登录 */
.user-box {
display: flex;

View File

@ -0,0 +1,50 @@
/**
* 平台管理员状态(决定要不要显示「平台管理」菜单 / 能不能进 `/admin/*` 页面)
*
* - 登录后懒加载一次(`GET /api/web/admin/me`),结果按令牌缓存;
* - 非平台管理员该接口返回 403 → 这里当成 `false`(不弹错、不影响其它页面);
* - 换账号 / 退出时要 `clearPlatformAdmin()`(见 AppLayout 的退出按钮)。
*/
import { ref } from 'vue';
import { fetchAdminMe } from '@/api/admin';
import { getToken } from '@/composables/useAuth';
/** 当前账号是不是平台管理员 */
export const isPlatformAdmin = ref(false);
/** 是不是 `INTERNAL_ADMIN_IDS` 内置管理员(页面上会标注) */
export const isBuiltinAdmin = ref(false);
/** 这份结果是用哪个令牌拉下来的(换账号/退出后自动重拉) */
let loadedForToken = '';
/** 清掉(退出登录 / 换账号) */
export function clearPlatformAdmin(): void {
isPlatformAdmin.value = false;
isBuiltinAdmin.value = false;
loadedForToken = '';
}
/**
* 确保已经问过后端(同一个令牌只问一次)
* @param force 强制重拉(例如刚在别处加了管理员)
*/
export async function ensurePlatformAdmin(force = false): Promise<boolean> {
const token = getToken();
if (!token) {
clearPlatformAdmin();
return false;
}
if (!force && loadedForToken === token) return isPlatformAdmin.value;
try {
const data = await fetchAdminMe();
isPlatformAdmin.value = Boolean(data && data.admin);
isBuiltinAdmin.value = Boolean(data && data.builtin);
} catch {
// 403(不是平台管理员)或网络错误:都当作没有权限,页面自己不需要报错
isPlatformAdmin.value = false;
isBuiltinAdmin.value = false;
}
loadedForToken = token;
return isPlatformAdmin.value;
}

View File

@ -1,6 +1,7 @@
import { createRouter, createWebHistory, type RouteRecordRaw } from 'vue-router';
import { getToken } from '@/composables/useAuth';
import { ensureSubjects, hasSubject, isSubjectAdmin } from '@/composables/useSubject';
import { ensurePlatformAdmin } from '@/composables/usePlatformAdmin';
/**
* 路由表(meta.public = 不需要登录)
@ -9,6 +10,9 @@ import { ensureSubjects, hasSubject, isSubjectAdmin } from '@/composables/useSub
*
* `meta.adminOnly = true`:业务数据页(设备 / 录像机 / 摄像头 / 工作台 / 扫码记录),
* **只有主体管理员**能进;普通成员直接跳回首页并提示(后端同名接口也返回 403)。
*
* `meta.platformAdmin = true`:**平台管理员**页面(主体管理 / 订单管理 / 管理员),
* 不看主体、不需要选主体;不是平台管理员直接跳回首页(后端同名接口返回 403)。
*/
const routes: RouteRecordRaw[] = [
{ path: '/login', name: 'login', component: () => import('@/views/LoginView.vue'), meta: { public: true, bare: true } },
@ -37,6 +41,25 @@ const routes: RouteRecordRaw[] = [
{ path: '/workstations', name: 'workstations', component: () => import('@/views/WorkstationsView.vue'), meta: { adminOnly: true } },
{ path: '/records', name: 'records', component: () => import('@/views/RecordsView.vue'), meta: { adminOnly: true } },
{ path: '/profile', name: 'profile', component: () => import('@/views/ProfileView.vue'), meta: { allowNoSubject: true } },
// 平台管理(只有平台管理员能进;看的是所有主体 / 所有订单,不需要选主体)
{
path: '/admin/subjects',
name: 'admin-subjects',
component: () => import('@/views/AdminSubjectsView.vue'),
meta: { allowNoSubject: true, platformAdmin: true },
},
{
path: '/admin/orders',
name: 'admin-orders',
component: () => import('@/views/AdminOrdersView.vue'),
meta: { allowNoSubject: true, platformAdmin: true },
},
{
path: '/admin/members',
name: 'admin-members',
component: () => import('@/views/AdminMembersView.vue'),
meta: { allowNoSubject: true, platformAdmin: true },
},
// 测试页只在开发构建里存在:生产包不包含该路由,也不会产出它的 chunk
...(import.meta.env.DEV
? [{ path: '/test', name: 'test', component: () => import('@/views/TestView.vue'), meta: { adminOnly: true } } as RouteRecordRaw]
@ -90,6 +113,11 @@ router.beforeEach(async (to) => {
if (to.meta.adminOnly === true && !isSubjectAdmin.value) {
return { name: 'home', query: { denied: '1' } };
}
// 平台管理页只有平台管理员能进(没权限按「被拒绝」处理,与主体管理员那种一致)
if (to.meta.platformAdmin === true) {
const allowed = await ensurePlatformAdmin();
if (!allowed) return { name: 'home', query: { denied: '1' } };
}
}
return true;
});

View File

@ -449,6 +449,13 @@ th {
border-color: #fecaca;
}
/* 待处理 / 待支付(订单管理里用) */
.badge-warn {
color: #b45309;
background: #fffbeb;
border-color: #fde68a;
}
/* 工作台类型:散单(蓝)/ 团购(橙) */
.badge-single {
color: #1d4ed8;

View File

@ -0,0 +1,218 @@
<script setup lang="ts">
/**
* 平台管理 · 管理员(平台管理员的成员列表 / 添加 / 移除)
*
* 接口:`GET/POST /api/web/admin/members`、`DELETE /api/web/admin/members/:id`
* 鉴权:平台管理员。
*
* 说明:
* - 「平台管理员」与「主体管理员」是两套权限:前者能看**所有**主体和订单;
* - `INTERNAL_ADMIN_IDS`(env)里的账号是**内置管理员**,恒为管理员、页面上不能移除(线上救急入口);
* - 添加 = 按账号(用户名 / 手机号 / 邮箱)把已有用户设成平台管理员。
*/
import { onMounted, ref } from 'vue';
import AppLayout from '@/components/AppLayout.vue';
import { ApiError } from '@/api/client';
import { addAdminMember, fetchAdminMembers, removeAdminMember, type AdminMemberItem } from '@/api/admin';
import { currentUser } from '@/composables/useAuth';
import { formatTime } from '@/utils/format';
const list = ref<AdminMemberItem[]>([]);
const loading = ref(false);
const error = ref('');
const ok = ref('');
const account = ref('');
const displayName = ref('');
const role = ref(2);
const adding = ref(false);
const removing = ref(0);
async function load() {
loading.value = true;
error.value = '';
try {
const data = await fetchAdminMembers();
list.value = data.list;
} catch (err) {
error.value = err instanceof ApiError ? err.message : '加载失败';
} finally {
loading.value = false;
}
}
async function add() {
const key = account.value.trim();
if (!key) {
error.value = '请填写账号(用户名 / 手机号 / 邮箱)';
return;
}
adding.value = true;
error.value = '';
ok.value = '';
try {
const created = await addAdminMember({
account: key,
name: displayName.value.trim() || undefined,
role: role.value,
});
account.value = '';
displayName.value = '';
role.value = 2;
ok.value = `${created.name}(${created.user?.username || created.userId})已设为平台管理员`;
await load();
} catch (err) {
error.value = err instanceof ApiError ? err.message : '添加失败';
} finally {
adding.value = false;
}
}
async function remove(row: AdminMemberItem) {
if (row.id === null) return;
if (Number(row.userId) === Number(currentUser.value?.id)) {
error.value = '不能移除自己';
return;
}
if (!window.confirm(`确认移除平台管理员「${row.name}」?\n\n移除后该账号立刻失去「主体管理 / 订单管理 / 管理员」的入口。`)) return;
removing.value = row.id;
error.value = '';
ok.value = '';
try {
await removeAdminMember(row.id);
ok.value = `已移除平台管理员「${row.name}」`;
await load();
} catch (err) {
error.value = err instanceof ApiError ? err.message : '移除失败';
} finally {
removing.value = 0;
}
}
/** 账号自己的那一行(不可移除) */
function isSelf(row: AdminMemberItem): boolean {
return Number(row.userId) === Number(currentUser.value?.id);
}
onMounted(load);
</script>
<template>
<AppLayout fill>
<template #title>管理员</template>
<div v-if="error" class="alert alert-error">{{ error }}</div>
<div v-if="ok" class="alert alert-ok">{{ ok }}</div>
<div class="card">
<h3>平台管理员</h3>
<p class="hint">
平台管理员可以看所有主体和所有订单、调整主体的授权到期时间、确认订单,并在这里添加别的平台管理员。
主体管理员(「主体 / 成员」里设的那种)只能管自己那个主体。
</p>
<div class="add-row">
<input v-model="account" placeholder="账号:用户名 / 手机号 / 邮箱" @keyup.enter="add" />
<input v-model="displayName" placeholder="显示名(可选)" />
<select v-model.number="role">
<option :value="1">超级管理员</option>
<option :value="2">管理员</option>
</select>
<button class="btn" :disabled="adding || !account.trim()" @click="add">{{ adding ? '添加中…' : '添加管理员' }}</button>
</div>
<div class="table-wrap">
<table class="table table-list">
<thead>
<tr>
<th>管理员</th>
<th>账号</th>
<th>联系方式</th>
<th style="width: 110px">角色</th>
<th style="width: 110px">状态</th>
<th>添加时间</th>
<th style="width: 100px">操作</th>
</tr>
</thead>
<tbody>
<tr v-for="row in list" :key="`${row.id}-${row.userId}`">
<td>
<b>{{ row.name }}</b>
<span v-if="isSelf(row)" class="badge badge-ok">我自己</span>
<span v-if="row.builtin" class="badge badge-single">内置</span>
<span v-if="row.remark" class="cell-sub">{{ row.remark }}</span>
</td>
<td>
{{ row.user?.username || `#${row.userId}` }}
<span v-if="row.user?.nickname" class="cell-sub">{{ row.user.nickname }}</span>
</td>
<td class="muted">
{{ row.user?.phone || '—' }}
<span v-if="row.user?.email" class="cell-sub">{{ row.user.email }}</span>
</td>
<td>{{ row.roleText }}</td>
<td>
<span :class="['badge', row.status === 1 ? 'badge-ok' : 'badge-off']">
{{ row.status === 1 ? '启用' : '停用' }}
</span>
</td>
<td class="muted">{{ row.createdAt ? formatTime(row.createdAt) : '—' }}</td>
<td>
<button
v-if="row.id !== null && !isSelf(row)"
class="btn btn-danger btn-sm"
:disabled="removing === row.id"
@click="remove(row)"
>{{ removing === row.id ? '移除中…' : '移除' }}</button>
<span v-else class="hint">—</span>
</td>
</tr>
<tr v-if="!list.length">
<td colspan="7" class="hint">{{ loading ? '加载中…' : '还没有平台管理员。' }}</td>
</tr>
</tbody>
</table>
</div>
<p class="hint">
最后一条提示:`INTERNAL_ADMIN_IDS`(环境变量)里的账号恒为平台管理员,页面上移除不了 ——
万一管理员都被删了,还能用它登录把入口加回来。
</p>
</div>
</AppLayout>
</template>
<style scoped>
.add-row {
display: flex;
align-items: center;
gap: 8px;
flex-wrap: wrap;
margin: 12px 0 16px;
}
.add-row input {
min-width: 200px;
}
.add-row select {
height: 32px;
padding: 0 8px;
border: 1px solid var(--border);
border-radius: 8px;
background: #fff;
font-size: 13px;
}
.cell-sub {
display: block;
margin-top: 2px;
font-size: 12px;
color: var(--text-muted);
}
td .badge {
margin-left: 4px;
}
</style>

View File

@ -0,0 +1,205 @@
<script setup lang="ts">
/**
* 平台管理 · 订单管理(**所有**主体的续期订单)
*
* 接口:`GET /api/web/admin/orders`、`POST /api/web/admin/orders/:orderNo/confirm`
* 鉴权:平台管理员。
*
* 「确认订单」= 走**支付回调的同一套后续动作**(`service.subjectOrder.payNotify`):
* 标记已支付 + 主体顺延 + 失效状态缓存 + 幂等。用于线下收款 / 手工补单:
* 渠道会记成 `manual`(区别于真实支付渠道),流水号记成 `ADMIN-<时间戳>`。
*/
import { onMounted, ref } from 'vue';
import AppLayout from '@/components/AppLayout.vue';
import DataPager from '@/components/DataPager.vue';
import { ApiError } from '@/api/client';
import { confirmAdminOrder, fetchAdminOrders, type AdminOrderItem } from '@/api/admin';
import { formatTime } from '@/utils/format';
const list = ref<AdminOrderItem[]>([]);
const total = ref(0);
const page = ref(1);
const pageSize = ref(10);
const keyword = ref('');
const status = ref<number | ''>('');
const loading = ref(false);
const error = ref('');
const ok = ref('');
const confirming = ref('');
async function load(targetPage = page.value) {
loading.value = true;
error.value = '';
try {
const data = await fetchAdminOrders({
page: targetPage,
pageSize: pageSize.value,
keyword: keyword.value.trim(),
status: status.value,
});
list.value = data.list;
total.value = data.total;
page.value = data.page;
} catch (err) {
error.value = err instanceof ApiError ? err.message : '加载失败';
} finally {
loading.value = false;
}
}
function search() {
load(1);
}
function changePageSize(size: number) {
pageSize.value = size;
}
/** 订单状态对应的徽标样式 */
function statusClass(row: AdminOrderItem): string {
if (row.status === 1) return 'badge-ok';
if (row.status === 2) return 'badge-off';
return 'badge-warn';
}
async function confirmOrder(row: AdminOrderItem) {
const tip = `确认订单 ${row.orderNo} 已收款?\n\n`
+ `主体:${row.subjectName || `#${row.subjectId}`}\n`
+ `套餐:${row.planName || `${row.days} 天`}(${row.amount === null || row.amount === undefined ? '未设置金额' : `¥${row.amount}`})\n`
+ '确认后会**立刻**为该主体顺延期限(与支付回调同一套逻辑)。';
if (!window.confirm(tip)) return;
confirming.value = row.orderNo;
error.value = '';
ok.value = '';
try {
const data = await confirmAdminOrder(row.orderNo);
const after = data.order?.expireAfter;
ok.value = data.duplicated
? `订单 ${row.orderNo} 之前已经确认过了(不会重复续期)`
: `订单 ${row.orderNo} 已确认,「${row.subjectName || `#${row.subjectId}`}」续期 ${row.days} 天`
+ (after ? `,新到期时间:${formatTime(after)}` : '');
await load();
} catch (err) {
error.value = err instanceof ApiError ? err.message : '确认失败';
} finally {
confirming.value = '';
}
}
onMounted(() => load(1));
</script>
<template>
<AppLayout fill>
<template #title>订单管理</template>
<div v-if="error" class="alert alert-error">{{ error }}</div>
<div v-if="ok" class="alert alert-ok">{{ ok }}</div>
<div class="card">
<div class="toolbar">
<input v-model="keyword" placeholder="搜索订单号 / 套餐 / 主体名称" @keyup.enter="search" />
<select v-model="status" class="filter-select" @change="search">
<option value="">全部状态</option>
<option :value="0">待支付</option>
<option :value="1">已支付</option>
<option :value="2">已关闭</option>
</select>
<button class="btn" :disabled="loading" @click="search">搜索</button>
<span class="hint toolbar-tip">「确认订单」等于线下收款到账:标记已支付并立即给主体续期。</span>
</div>
<div class="table-wrap">
<table class="table table-list">
<thead>
<tr>
<th>订单号</th>
<th>主体</th>
<th>下单人</th>
<th>套餐 / 天数</th>
<th style="width: 90px">金额</th>
<th style="width: 90px">状态</th>
<th>续期前后</th>
<th style="width: 110px">操作</th>
</tr>
</thead>
<tbody>
<tr v-for="row in list" :key="row.id">
<td>
<code>{{ row.orderNo }}</code>
<span class="cell-sub">{{ formatTime(row.createdAt) }}</span>
</td>
<td>
{{ row.subjectName || `#${row.subjectId}` }}
<span class="cell-sub">主体 #{{ row.subjectId }}</span>
</td>
<td class="muted">{{ row.userName || `#${row.userId}` }}</td>
<td>
{{ row.planName || '—' }}
<span class="cell-sub">{{ row.days }} 天</span>
</td>
<td>{{ row.amount === null || row.amount === undefined ? '—' : `¥${row.amount}` }}</td>
<td>
<span :class="['badge', statusClass(row)]">{{ row.statusText }}</span>
<span v-if="row.channel === 'manual'" class="cell-sub">手工确认</span>
</td>
<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>
</template>
<template v-else>—</template>
</td>
<td>
<button
v-if="row.status === 0"
class="btn btn-sm"
:disabled="confirming === row.orderNo"
@click="confirmOrder(row)"
>{{ confirming === row.orderNo ? '确认中…' : '确认订单' }}</button>
<span v-else class="hint">—</span>
</td>
</tr>
<tr v-if="!list.length">
<td colspan="8" class="hint">{{ loading ? '加载中…' : '没有符合条件的订单。' }}</td>
</tr>
</tbody>
</table>
</div>
<DataPager :page="page" :page-size="pageSize" :total="total" :loading="loading"
unit="笔订单" @update:page="load" @update:page-size="changePageSize" />
</div>
</AppLayout>
</template>
<style scoped>
.toolbar {
display: flex;
align-items: center;
gap: 8px;
flex-wrap: wrap;
margin-bottom: 12px;
}
.toolbar-tip {
margin-left: auto;
}
.filter-select {
height: 32px;
padding: 0 8px;
border: 1px solid var(--border);
border-radius: 8px;
background: #fff;
font-size: 13px;
}
.cell-sub {
display: block;
margin-top: 2px;
font-size: 12px;
color: var(--text-muted);
}
</style>

View File

@ -0,0 +1,331 @@
<script setup lang="ts">
/**
* 平台管理 · 主体管理(**所有**主体)
*
* 接口:`GET /api/web/admin/subjects`、`PUT /api/web/admin/subjects/:id`
* 鉴权:平台管理员(非管理员后端的这些接口一律 403,路由守卫也会挡)
*
* 主要动作:改「授权到期时间」——可以**直接设某天某时**,也可以在现有基础上**顺延 N 天**。
* 改完会失效主体状态缓存,设备心跳/上报立刻读到新期限。
*/
import { computed, onMounted, ref } from 'vue';
import AppLayout from '@/components/AppLayout.vue';
import DataPager from '@/components/DataPager.vue';
import ModalBox from '@/components/ModalBox.vue';
import { ApiError } from '@/api/client';
import { fetchAdminSubjects, updateAdminSubject, type AdminSubjectItem } from '@/api/admin';
import { formatTime } from '@/utils/format';
type ExpiredFilter = '' | '0' | '1';
const list = ref<AdminSubjectItem[]>([]);
const total = ref(0);
const page = ref(1);
const pageSize = ref(10);
const keyword = ref('');
const expired = ref<ExpiredFilter>('');
const loading = ref(false);
const error = ref('');
const ok = ref('');
async function load(targetPage = page.value) {
loading.value = true;
error.value = '';
try {
const data = await fetchAdminSubjects({
page: targetPage,
pageSize: pageSize.value,
keyword: keyword.value.trim(),
expired: expired.value,
});
list.value = data.list;
total.value = data.total;
page.value = data.page;
} catch (err) {
error.value = err instanceof ApiError ? err.message : '加载失败';
} finally {
loading.value = false;
}
}
function search() {
load(1);
}
function changePageSize(size: number) {
pageSize.value = size;
}
/** 剩余天数(已过期返回负数) */
function daysLeft(item: AdminSubjectItem): number {
const diff = new Date(item.expireAt).getTime() - Date.now();
return Math.ceil(diff / 86400000);
}
// ---------------- 改期限 ----------------
const editing = ref<AdminSubjectItem | null>(null);
/** 'set' = 直接设到期时间;'extend' = 顺延 N 天 */
const mode = ref<'set' | 'extend'>('set');
/** datetime-local 的值(本地时间,`YYYY-MM-DDTHH:mm`) */
const expireLocal = ref('');
const extendDays = ref(30);
const saving = ref(false);
/** ISO → `datetime-local` 需要的本地时间字符串 */
function toLocalInput(iso: string): string {
const date = new Date(iso);
if (Number.isNaN(date.getTime())) return '';
const pad = (num: number) => String(num).padStart(2, '0');
return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
}
function openEdit(item: AdminSubjectItem) {
ok.value = '';
error.value = '';
editing.value = item;
mode.value = 'set';
// 默认往后加 30 天,避免误操作把还在有效期的主体直接改到过期
expireLocal.value = toLocalInput(new Date(Date.now() + 30 * 86400000).toISOString());
extendDays.value = 30;
}
function closeEdit() {
if (saving.value) return;
editing.value = null;
}
/** 快捷:在当前到期时间上顺延 N 天 → 填进「直接设置」里 */
function quickExtend(days: number) {
const item = editing.value;
if (!item) return;
const base = new Date(item.expireAt).getTime();
const from = base > Date.now() ? base : Date.now();
expireLocal.value = toLocalInput(new Date(from + days * 86400000).toISOString());
mode.value = 'set';
}
const canSave = computed(() => {
if (!editing.value) return false;
if (mode.value === 'set') return Boolean(expireLocal.value);
return Number(extendDays.value) > 0;
});
async function save() {
const item = editing.value;
if (!item || !canSave.value) return;
const name = item.name;
saving.value = true;
error.value = '';
ok.value = '';
try {
const body = mode.value === 'set'
? { expireAt: new Date(expireLocal.value).toISOString() }
: { extendDays: Number(extendDays.value) };
const updated = await updateAdminSubject(item.id, body);
editing.value = null;
ok.value = `「${name}」的授权到期时间已改为 ${formatTime(updated.expireAt)}`;
await load();
} catch (err) {
error.value = err instanceof ApiError ? err.message : '保存失败';
} finally {
saving.value = false;
}
}
onMounted(() => load(1));
</script>
<template>
<AppLayout fill>
<template #title>主体管理</template>
<div v-if="error" class="alert alert-error">{{ error }}</div>
<div v-if="ok" class="alert alert-ok">{{ ok }}</div>
<div class="card">
<div class="toolbar">
<input v-model="keyword" placeholder="搜索主体名称 / 备注" @keyup.enter="search" />
<select v-model="expired" class="filter-select" @change="search">
<option value="">全部状态</option>
<option value="0">未过期</option>
<option value="1">已过期</option>
</select>
<button class="btn" :disabled="loading" @click="search">搜索</button>
<span class="hint toolbar-tip">平台管理员可以看所有主体,并直接调整授权到期时间。</span>
</div>
<div class="table-wrap">
<table class="table table-list">
<thead>
<tr>
<th>主体</th>
<th>管理员账号</th>
<th style="width: 90px">成员数</th>
<th>授权到期时间</th>
<th style="width: 110px">状态</th>
<th style="width: 130px">操作</th>
</tr>
</thead>
<tbody>
<tr v-for="row in list" :key="row.id">
<td>
<div class="cell-main">
<code class="muted">#{{ row.id }}</code>
<b>{{ row.name }}</b>
</div>
<div v-if="row.remark" class="cell-sub">{{ row.remark }}</div>
</td>
<td class="muted">
{{ row.adminUser ? (row.adminUser.nickname || row.adminUser.username) : '—' }}
<span v-if="row.adminUser?.username" class="cell-sub">@{{ row.adminUser.username }}</span>
</td>
<td>{{ row.memberCount }}</td>
<td>
{{ formatTime(row.expireAt) }}
<span :class="['badge', row.expired ? 'badge-off' : 'badge-ok']">
{{ row.expired ? '已过期' : `剩 ${daysLeft(row)} 天` }}
</span>
</td>
<td>
<span :class="['badge', row.status === 1 ? 'badge-ok' : 'badge-off']">
{{ row.status === 1 ? '启用' : '停用' }}
</span>
</td>
<td>
<button class="btn btn-ghost btn-sm" @click="openEdit(row)">改到期时间</button>
</td>
</tr>
<tr v-if="!list.length">
<td colspan="6" class="hint">{{ loading ? '加载中…' : '没有符合条件的主体。' }}</td>
</tr>
</tbody>
</table>
</div>
<DataPager :page="page" :page-size="pageSize" :total="total" :loading="loading"
unit="个主体" @update:page="load" @update:page-size="changePageSize" />
</div>
<!-- 改授权到期时间 -->
<ModalBox :open="Boolean(editing)" :title="`改授权到期时间 · ${editing?.name || ''}`" width="520px" @close="closeEdit">
<div v-if="editing" class="edit-body">
<p class="hint">
当前到期时间:<b>{{ formatTime(editing.expireAt) }}</b>
<span :class="['badge', editing.expired ? 'badge-off' : 'badge-ok']">
{{ editing.expired ? '已过期' : `剩 ${daysLeft(editing)} 天` }}
</span>
</p>
<div class="mode-row">
<label class="mode-item" :class="{ active: mode === 'set' }">
<input v-model="mode" type="radio" value="set" />
<span>直接设置到期时间</span>
</label>
<label class="mode-item" :class="{ active: mode === 'extend' }">
<input v-model="mode" type="radio" value="extend" />
<span>在现有基础上顺延</span>
</label>
</div>
<div v-if="mode === 'set'" class="field">
<span class="field-label">新的到期时间</span>
<input v-model="expireLocal" type="datetime-local" />
<div class="quick-row">
<button class="btn btn-ghost btn-sm" type="button" @click="quickExtend(7)">+7 天</button>
<button class="btn btn-ghost btn-sm" type="button" @click="quickExtend(30)">+30 天</button>
<button class="btn btn-ghost btn-sm" type="button" @click="quickExtend(90)">+90 天</button>
<button class="btn btn-ghost btn-sm" type="button" @click="quickExtend(365)">+1 年</button>
</div>
</div>
<div v-else class="field">
<span class="field-label">顺延天数(未过期从原到期时间算,已过期从现在算)</span>
<input v-model.number="extendDays" type="number" min="1" max="3650" />
</div>
<p class="hint">改完立刻生效:设备心跳与上报会马上按新期限判断。</p>
</div>
<template #footer>
<button class="btn btn-ghost" :disabled="saving" @click="closeEdit">取消</button>
<button class="btn" :disabled="saving || !canSave" @click="save">{{ saving ? '保存中…' : '保存' }}</button>
</template>
</ModalBox>
</AppLayout>
</template>
<style scoped>
.toolbar {
display: flex;
align-items: center;
gap: 8px;
flex-wrap: wrap;
margin-bottom: 12px;
}
.toolbar-tip {
margin-left: auto;
}
.filter-select {
height: 32px;
padding: 0 8px;
border: 1px solid var(--border);
border-radius: 8px;
background: #fff;
font-size: 13px;
}
.cell-main {
display: flex;
align-items: baseline;
gap: 6px;
}
.cell-sub {
display: block;
margin-top: 2px;
font-size: 12px;
color: var(--text-muted);
}
.edit-body {
display: flex;
flex-direction: column;
gap: 12px;
}
.mode-row {
display: flex;
gap: 10px;
flex-wrap: wrap;
}
.mode-item {
display: flex;
align-items: center;
gap: 6px;
padding: 8px 12px;
border: 1px solid var(--border);
border-radius: 8px;
font-size: 13px;
cursor: pointer;
}
.mode-item.active {
border-color: var(--brand);
background: rgba(37, 99, 235, 0.06);
}
.field-label {
font-size: 13px;
color: var(--text-muted);
}
.quick-row {
display: flex;
gap: 6px;
flex-wrap: wrap;
}
</style>