liufumingren dc159c6f08 主体成员:支持多名管理员 + 成员管理仅管理员可写
后端
- 数据库层面本来就允许多管理员(subject_members 只有 subject_id+user_id 唯一索引,role 无唯一约束),
  新增 PUT /api/web/subjects/:id/members/:memberId/role(role=1 管理员 / 2 成员)
- 服务层 setMemberRole:创建者不能降级、不能改自己的角色、role 只接受 1/2;返回带 isCreator
- 成员管理收口到管理员:addMember / removeMember / createBindCode 由 findForUser 改为 ensureAdmin
  (此前任何成员都能增删成员,属于越权)
- removeMember 增加「管理员需先取消管理员身份再移除」;members() 返回 isCreator

前端
- 成员管理弹窗:「设为管理员 / 取消管理员」按钮,仅管理员可见;创建者行标「创建者」、自己行标「(你自己)」
  并隐藏不可操作的按钮;非管理员进入弹窗只看到只读列表 + 提示文案
- subjectApi 增加 updateSubjectMemberRole,SubjectItem.memberId / SubjectMemberItem.isCreator 类型补齐

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

552 lines
20 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,
});
}
/**
* 成员列表(带账号信息)
*
* 任何成员都能看(只读);`isCreator` 用来让前端给「主体创建者」隐藏降级/移除按钮。
*/
async members(subjectId, userId) {
const { subject } = 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 }],
});
const creatorUserId = Number(subject.adminUserId);
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,
// 主体创建者:恒为管理员,不能降级、不能移除
isCreator: Boolean(data.userId) && Number(data.userId) === creatorUserId,
};
});
}
/**
* 按姓名快速添加成员(先只建成员,账号/微信稍后用绑定码绑定)
*
* **仅管理员**可操作(普通成员只能看成员列表)。
* @param {object} params { subjectId, userId 操作人, name, role? }
*/
async addMember({ subjectId, userId, name, role } = {}) {
await this.ensureAdmin(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,
isCreator: false,
};
}
/**
* 设置成员角色(**仅管理员**)
*
* 一个主体可以有多名管理员(`role=1`),`subjects.admin_user_id` 只是创建者,同样恒为管理员:
* - 创建者不能降级(否则「创建者」与 `role` 两套判断会打架);
* - 不能改自己的角色(避免管理员把自己降成成员后没人能管);
* - 允许给**还没绑定账号**的成员设为管理员:等他用绑定码绑定后直接就是管理员。
*
* @param {object} params { subjectId, operatorUserId, memberId, role }
*/
async setMemberRole({ subjectId, operatorUserId, memberId, role } = {}) {
const { subject } = await this.ensureAdmin(subjectId, operatorUserId);
const next = Number(role);
if (next !== 1 && next !== 2) this.ctx.throw(422, '角色只能是 1(管理员)或 2(成员)');
const member = await this.Member.findOne({
where: { id: Number(memberId), subjectId: Number(subjectId) },
});
if (!member) this.ctx.throw(404, '成员不存在');
if (Number(member.userId) && Number(member.userId) === Number(subject.adminUserId)) {
this.ctx.throw(422, '主体创建者始终是管理员,不能降级');
}
if (Number(member.userId) && Number(member.userId) === Number(operatorUserId)) {
this.ctx.throw(422, '不能修改自己的角色,请让其他管理员操作');
}
if (Number(member.role) !== next) {
await member.update({ role: next });
this.ctx.logger.info('[subject] 用户 %s 把主体 %s 的成员「%s」角色改为 %s',
operatorUserId, subjectId, member.name, next === 1 ? '管理员' : '成员');
}
const user = member.userId
? await this.app.model.User.findByPk(Number(member.userId), { attributes: USER_ATTRIBUTES })
: null;
return {
id: Number(member.id),
name: member.name,
role: Number(member.role),
status: Number(member.status),
userId: member.userId ? Number(member.userId) : null,
boundAt: member.boundAt,
wechatBound: Boolean(member.wechatOpenid),
user: user ? user.toJSON() : null,
createdAt: member.createdAt,
isCreator: Boolean(member.userId) && Number(member.userId) === Number(subject.adminUserId),
};
}
/** 删除成员(仅管理员;不能删创建者/管理员,也不能删自己) */
async removeMember({ subjectId, operatorUserId, memberId } = {}) {
await this.ensureAdmin(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, '不能删除自己');
}
if (Number(member.role) === 1) {
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.ensureAdmin(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;