liufumingren 7b11f7052d feat(subject): 主体到期暂停设备上报,新增续期订单与支付回调
- 主体状态缓存(Redis 优先、进程内兜底):设备心跳与上报判断不再查库,续期/停用后主动失效
- 上报写接口按缓存校验期限:过期 403 subject_expired、停用 subject_disabled、主体缺失 subject_missing
- 心跳与 /api/scanner/me 返回 subject 状态,桌面端据此暂停推送并在续期后自动补传积压
- 新增续期订单(subject_orders)与接口,支付回调 POST /api/pay/notify 幂等、支持 HMAC 签名,
  另提供内部令牌模拟支付用于联调
- 顺带提交工作区中已完成的「登录协议」后端改动(agreement):与本次改动共用 router.js / config.default.js

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-10-20 18:55:57 +08:00

487 lines
17 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');
/** 绑定码字符集(去掉容易看错的 0/O/1/I) */
const CODE_ALPHABET = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ';
/** 新建主体默认赠送天数(可通过 config.subject.trialDays 覆盖) */
const DEFAULT_TRIAL_DAYS = 7;
/** 成员绑定码默认有效期(秒) */
const BIND_TTL = 600;
function randomCode(length = 6) {
let out = '';
for (let i = 0; i < length; i++) {
out += CODE_ALPHABET[crypto.randomInt(CODE_ALPHABET.length)];
}
return out;
}
const USER_ATTRIBUTES = [ 'id', 'username', 'nickname', 'avatar' ];
/**
* 主体(租户)service
*
* 职责:
* - 主体列表 / 创建(默认赠送 N 天)/ 修改(管理员)
* - 成员管理:列表、按姓名快速添加、删除
* - 成员微信绑定码:发码 → 手机扫码 → 登录用户确认 → 绑定该成员
* - 供中间件用的「当前用户是否属于该主体 / 主体是否过期」判断
*/
class SubjectService extends Service {
get Subject() {
return this.app.model.Subject;
}
get Member() {
return this.app.model.SubjectMember;
}
get trialDays() {
const cfg = this.app.config.subject || {};
return Number(cfg.trialDays || DEFAULT_TRIAL_DAYS);
}
get prefix() {
return (this.app.config.cache && this.app.config.cache.prefix) || 'packs:';
}
bindKey(code) {
return `${this.prefix}member:bind:${code}`;
}
/** 是否已过期(含稍后到期判断,统一用服务器时间) */
isExpired(subject) {
if (!subject || !subject.expireAt) return false;
return new Date(subject.expireAt).getTime() <= Date.now();
}
/** 主体的基础展示字段(固定输出 camelCase,避免驼峰/下划线混排) */
present(subject, extra = {}) {
return Object.assign({
id: Number(subject.id),
name: subject.name,
adminUserId: Number(subject.adminUserId),
expireAt: subject.expireAt,
status: Number(subject.status),
remark: subject.remark || null,
createdAt: subject.createdAt,
expired: this.isExpired(subject),
}, extra);
}
/**
* 当前用户能进的主体列表(含自己的角色/姓名、成员数、是否过期)
* @param {number} userId 当前登录用户
*/
async listForUser(userId) {
const members = await this.Member.findAll({
where: { userId: Number(userId), status: 1 },
order: [[ 'id', 'ASC' ]],
raw: true,
});
if (!members.length) return [];
const ids = members.map(item => Number(item.subjectId));
const subjects = await this.Subject.findAll({
where: { id: { [Op.in]: ids } },
order: [[ 'id', 'ASC' ]],
});
const byId = new Map(subjects.map(row => [ Number(row.id), row ]));
const counts = await this.Member.count({
where: { subjectId: { [Op.in]: ids }, status: 1 },
group: [ 'subject_id' ],
raw: true,
}).catch(() => []);
const countMap = new Map((counts || []).map(row => [ Number(row.subjectId || row.subject_id), row.count ]));
const list = [];
for (const member of members) {
const subject = byId.get(Number(member.subjectId));
if (!subject) continue; // 主体被删除
list.push(this.present(subject, {
role: Number(member.role),
memberName: member.name,
memberId: Number(member.id),
memberCount: countMap.get(Number(subject.id)) || 0,
}));
}
// 可用的主体排前面,同组按 id
list.sort((a, b) => (a.expired === b.expired ? a.id - b.id : (a.expired ? 1 : -1)));
return list;
}
/** 该用户在主体里的成员记录(没加入返回 null) */
async memberOf(subjectId, userId) {
if (!subjectId || !userId) return null;
return this.Member.findOne({
where: { subjectId: Number(subjectId), userId: Number(userId), status: 1 },
});
}
/**
* 取「当前用户可用」的主体(不存在 / 不是成员 → 404)
* 中间件也用它做范围校验
*/
async findForUser(subjectId, userId) {
const id = Number(subjectId);
if (!Number.isInteger(id) || id <= 0) this.ctx.throw(400, '缺少主体 id');
const member = await this.memberOf(id, userId);
if (!member) this.ctx.throw(404, '主体不存在或你不是该主体的成员');
const subject = await this.Subject.findByPk(id);
if (!subject) this.ctx.throw(404, '主体不存在或你不是该主体的成员');
return { subject, member };
}
/** 管理员校验(只有主体管理员能改主体信息 / 增删成员) */
async ensureAdmin(subjectId, userId) {
const found = await this.findForUser(subjectId, userId);
const isAdmin = Number(found.subject.adminUserId) === Number(userId) || Number(found.member.role) === 1;
if (!isAdmin) this.ctx.throw(403, '只有主体管理员可以执行该操作');
return found;
}
/**
* 创建主体
*
* - 管理员默认就是创建人
* - 使用期限默认**赠送 7 天**(`config.subject.trialDays`)
* - 创建人自动成为管理员成员(姓名取昵称 / 用户名)
*
* @param {object} params { userId, name, days?, remark? }
*/
async create({ userId, name, days, remark } = {}) {
if (!userId) this.ctx.throw(401, '缺少用户身份');
const finalName = String(name || '').trim();
if (!finalName) this.ctx.throw(422, '主体名称不能为空');
if (finalName.length > 64) this.ctx.throw(422, '主体名称不能超过 64 个字符');
const grantDays = days === undefined || days === null || days === ''
? this.trialDays
: Number(days);
if (!Number.isFinite(grantDays) || grantDays <= 0 || grantDays > 3650) {
this.ctx.throw(422, '使用天数必须在 1~3650 之间');
}
const expireAt = new Date(Date.now() + Math.round(grantDays) * 24 * 3600 * 1000);
const subject = await this.Subject.create({
name: finalName,
adminUserId: Number(userId),
expireAt,
status: 1,
remark: remark || null,
});
const user = await this.app.model.User.findByPk(Number(userId), { attributes: USER_ATTRIBUTES });
const memberName = (user && (user.nickname || user.username)) || `用户${userId}`;
await this.Member.create({
subjectId: Number(subject.id),
userId: Number(userId),
name: String(memberName).slice(0, 32),
role: 1,
boundAt: new Date(),
status: 1,
});
this.ctx.logger.info('[subject] 用户 %s 创建主体 %s(%s,到期 %s)',
userId, subject.id, finalName, expireAt.toISOString());
return this.present(subject, {
role: 1,
memberName,
memberCount: 1,
});
}
/**
* 修改主体(管理员):名称 / 备注 / 续期
* @param {object} patch { name?, remark?, extendDays? }
*/
async update(subjectId, userId, patch = {}) {
const { subject } = await this.ensureAdmin(subjectId, userId);
const fields = {};
if (patch.name !== undefined) {
const next = String(patch.name || '').trim();
if (!next) this.ctx.throw(422, '主体名称不能为空');
fields.name = next.slice(0, 64);
}
if (patch.remark !== undefined) fields.remark = patch.remark;
if (patch.status !== undefined) fields.status = Number(patch.status) === 0 ? 0 : 1;
if (patch.extendDays !== undefined && patch.extendDays !== null && patch.extendDays !== '') {
const days = Number(patch.extendDays);
if (!Number.isFinite(days) || days <= 0 || days > 3650) this.ctx.throw(422, '续期天数必须在 1~3650 之间');
// 已过期:从现在开始算;未过期:在原到期时间上顺延
const base = this.isExpired(subject) ? Date.now() : new Date(subject.expireAt).getTime();
fields.expireAt = new Date(base + Math.round(days) * 24 * 3600 * 1000);
}
await subject.update(fields);
// 名称 / 状态 / 期限都可能变,让设备心跳与上报判断立刻读到新值
await this.ctx.service.subjectState.invalidate(subjectId);
const member = await this.memberOf(subject.id, userId);
return this.present(subject, {
role: member ? Number(member.role) : 2,
memberName: member ? member.name : null,
});
}
/** 成员列表(带账号信息) */
async members(subjectId, userId) {
await this.findForUser(subjectId, userId);
const rows = await this.Member.findAll({
where: { subjectId: Number(subjectId) },
order: [[ 'role', 'ASC' ], [ 'id', 'ASC' ]],
include: [{ model: this.app.model.User, as: 'user', required: false, attributes: USER_ATTRIBUTES }],
});
return rows.map(row => {
const data = row.toJSON();
return {
id: Number(data.id),
name: data.name,
role: Number(data.role),
status: Number(data.status),
userId: data.userId ? Number(data.userId) : null,
boundAt: data.boundAt,
wechatBound: Boolean(data.wechatOpenid),
user: data.user || null,
createdAt: data.createdAt,
};
});
}
/**
* 按姓名快速添加成员(先只建成员,账号/微信稍后用绑定码绑定)
* @param {object} params { subjectId, userId 操作人, name, role? }
*/
async addMember({ subjectId, userId, name, role } = {}) {
await this.findForUser(subjectId, userId);
const finalName = String(name || '').trim();
if (!finalName) this.ctx.throw(422, '成员姓名不能为空');
if (finalName.length > 32) this.ctx.throw(422, '成员姓名不能超过 32 个字符');
const duplicated = await this.Member.findOne({
where: { subjectId: Number(subjectId), name: finalName, userId: null },
});
if (duplicated) this.ctx.throw(409, `已存在同名且未绑定的成员「${finalName}」`);
const created = await this.Member.create({
subjectId: Number(subjectId),
userId: null,
name: finalName,
role: Number(role) === 1 ? 1 : 2,
status: 1,
});
this.ctx.logger.info('[subject] 用户 %s 在主体 %s 添加成员「%s」', userId, subjectId, finalName);
return {
id: Number(created.id),
name: created.name,
role: Number(created.role),
status: Number(created.status),
userId: null,
boundAt: null,
wechatBound: false,
user: null,
createdAt: created.createdAt,
};
}
/** 删除成员(不能删管理员,也不能删自己) */
async removeMember({ subjectId, operatorUserId, memberId } = {}) {
await this.findForUser(subjectId, operatorUserId);
const member = await this.Member.findOne({
where: { id: Number(memberId), subjectId: Number(subjectId) },
});
if (!member) this.ctx.throw(404, '成员不存在');
const subject = await this.Subject.findByPk(Number(subjectId));
if (subject && Number(subject.adminUserId) === Number(member.userId)) {
this.ctx.throw(422, '不能删除主体管理员');
}
if (Number(member.userId) === Number(operatorUserId)) {
this.ctx.throw(422, '不能删除自己');
}
await member.destroy();
this.ctx.logger.info('[subject] 用户 %s 从主体 %s 移除成员「%s」', operatorUserId, subjectId, member.name);
return { id: Number(member.id) };
}
/**
* 给「未绑定账号/微信」的成员生成绑定码
*
* 手机扫码后打开前端 `/wechat?bind=<码>`,已登录的账号点确认即可完成绑定。
* @return {Promise<object>} { code, bindUrl, qrUrl, expiresIn }
*/
async createBindCode({ subjectId, memberId, operatorUserId } = {}) {
const { subject } = await this.findForUser(subjectId, operatorUserId);
const member = await this.Member.findOne({
where: { id: Number(memberId), subjectId: Number(subjectId) },
});
if (!member) this.ctx.throw(404, '成员不存在');
if (member.userId) this.ctx.throw(409, '该成员已绑定账号,如需换绑请先解绑');
const code = randomCode(6);
const payload = JSON.stringify({
status: 'pending',
subjectId: Number(subjectId),
subjectName: subject.name,
memberId: Number(memberId),
name: member.name,
});
await this.app.redis.setex(this.bindKey(code), BIND_TTL, payload);
const origin = this.app.config.email.siteUrl || this.ctx.origin;
const bindUrl = `${String(origin).replace(/\/+$/, '')}/wechat?bind=${encodeURIComponent(code)}`;
return {
code,
memberId: Number(memberId),
memberName: member.name,
bindUrl,
qrUrl: `/api/wechat/qrcode.svg?code=${encodeURIComponent(code)}&mode=member`,
expiresIn: BIND_TTL,
};
}
/** 绑定码状态(扫码页轮询) */
async bindStatus(code) {
const normalized = String(code || '').trim().toUpperCase();
if (!normalized) return { status: 'bad_format' };
const raw = await this.app.redis.get(this.bindKey(normalized));
if (!raw) return { status: 'expired' };
let data = null;
try {
data = JSON.parse(raw);
} catch (err) {
return { status: 'expired' };
}
return {
status: data.status || 'pending',
code: normalized,
subjectId: data.subjectId,
memberId: data.memberId,
memberName: data.name,
subjectName: data.subjectName,
boundName: data.boundName,
};
}
/**
* 手机侧确认绑定:把当前登录账号绑到该成员上
*
* @param {string} code 绑定码
* @param {number} userId 当前登录用户(手机端已登录)
*/
async confirmBind(code, userId) {
const normalized = String(code || '').trim().toUpperCase();
if (!normalized || !userId) {
return { ok: false, reason: 'bad_param', message: '参数不完整' };
}
const raw = await this.app.redis.get(this.bindKey(normalized));
if (!raw) return { ok: false, reason: 'expired', message: '绑定码已失效,请让管理员重新生成' };
let data = null;
try {
data = JSON.parse(raw);
} catch (err) {
return { ok: false, reason: 'expired', message: '绑定码已失效,请让管理员重新生成' };
}
if (data.status === 'confirmed') return { ok: false, reason: 'used', message: '该绑定码已被使用' };
const subject = await this.Subject.findByPk(Number(data.subjectId));
if (!subject) return { ok: false, reason: 'expired', message: '主体已不存在' };
const member = await this.Member.findByPk(Number(data.memberId));
if (!member) return { ok: false, reason: 'expired', message: '成员已不存在' };
if (member.userId && Number(member.userId) !== Number(userId)) {
return { ok: false, reason: 'bound', message: '该成员已绑定其他账号' };
}
// 同一主体下,一个账号只能有一条成员记录
const mine = await this.memberOf(subject.id, userId);
if (mine && Number(mine.id) !== Number(member.id)) {
return { ok: false, reason: 'joined', message: '你已经是该主体的成员了' };
}
let openid = null;
try {
const wechat = await this.app.model.WechatOauth.findOne({
where: { userId: Number(userId) },
order: [[ 'id', 'DESC' ]],
attributes: [ 'openid' ],
});
openid = wechat ? wechat.openid : null;
} catch (err) {
openid = null;
}
await member.update({
userId: Number(userId),
wechatOpenid: openid,
boundAt: new Date(),
status: 1,
});
const user = await this.app.model.User.findByPk(Number(userId), { attributes: USER_ATTRIBUTES });
const boundName = (user && (user.nickname || user.username)) || `用户${userId}`;
await this.app.redis.setex(this.bindKey(normalized), BIND_TTL, JSON.stringify({
status: 'confirmed',
subjectId: Number(subject.id),
memberId: Number(member.id),
name: member.name,
subjectName: subject.name,
boundName,
}));
this.ctx.logger.info('[subject] 主体 %s 成员「%s」绑定到用户 %s(%s)',
subject.id, member.name, userId, boundName);
return {
ok: true,
status: 'confirmed',
subjectId: Number(subject.id),
subjectName: subject.name,
memberId: Number(member.id),
memberName: member.name,
boundName,
};
}
/**
* 该用户可进入的第一个主体(设备扫码登录时用:设备没有「当前主体」概念)
* @return {Promise<number|null>}
*/
async defaultSubjectId(userId) {
try {
const list = await this.listForUser(userId);
const usable = list.find(item => !item.expired && Number(item.status) === 1);
return usable ? Number(usable.id) : (list.length ? Number(list[0].id) : null);
} catch (err) {
// 早期部署/单测里可能没有主体数据,设备登录不应因此失败
this.ctx.logger.warn('[subject] 读取默认主体失败: %s', err.message);
return null;
}
}
}
module.exports = SubjectService;