liufumingren b2eea28001 feat(微信网关): 扫码登录 / 绑定微信 / 工作台扫码登入,废弃自建登录码
对接 https://gateway.gztbyc.com:二维码与「扫码确认」由网关提供,本服务只负责
申请临时码 → 验签收通知 → 落地自己的业务。

- 新增 service/wx_gateway.js + controller/gateway/notify.js(POST /api/wechat-gateway/notify,验签 401 / 会话过期 200 ignored)
- 新增 controller/web/wx_gateway.js(登录二维码 / 长轮询 / SVG+GIF / 个人中心绑定与解绑)
- 新表 wechat_gateway_bindings(uk(app_key, openid)):一个微信只绑一个账号,解绑是软删,
  再绑定走 restore 复用(否则会撞唯一键报 Validation error)
- 「这个微信已绑别的账号」策略:原账号正常 → 拒绝并提示对方账号名;原账号禁用/已删 → 直接改绑;
  拿不到原账号 → 运维接口 GET/DELETE /api/internal/wechat-bindings 强制解绑
- 主体成员改为「扫码绑定」:管理员出二维码 → 成员微信扫码 → 已有账号直接继承(自动建的临时账号删掉),
  没有账号则由服务端建号并绑成其登录方式;subject_members.temp_user_id 记录临时账号
- 废弃自建登录码:删除 GET /api/wechat/login(6 位串码)与 workstations.login_code(迁移 20261028121000),
  工作台改扫码登入,成员绑定码与 /wechat?bind= 手机确认页下线
- 前端:登录页/个人中心/主体成员/工作台全部切到网关;桌面端登录窗改网关二维码 + 长轮询
- 测试:wx-gateway.test.js 覆盖登录/绑定/解绑-再绑/禁用账号改绑/运维强制解绑/成员绑定/工作台登入

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

720 lines
28 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');
/** 新建主体默认赠送天数(可通过 config.subject.trialDays 覆盖) */
const DEFAULT_TRIAL_DAYS = 7;
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:';
}
/** 是否已过期(含稍后到期判断,统一用服务器时间) */
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 || subject.created_at,
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) };
}
/**
* 给「未绑定账号/微信」的成员出一张扫码绑定二维码(**仅管理员**)
*
* 走微信登录网关(`scene=bind`):成员用手机微信扫码 → 网关回调后按两种情形落地:
* - 这个微信**已经是某个平台账号**的登录方式 → 成员直接绑到那个账号(之前自动建的临时账号删掉);
* - 这个微信**还没有平台账号** → 自动给这名成员建一个账号,并把微信绑成它的登录方式。
*
* @param {object} params { subjectId, memberId, operatorUserId }
* @return {Promise<object>} { memberId, memberName, state, pageUrl, qrUrl, expiresIn }
*/
async createBindQr({ subjectId, memberId, operatorUserId } = {}) {
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 && Number(member.userId) !== Number(member.tempUserId)) {
this.ctx.throw(409, '该成员已绑定账号,如需换绑请先「解除绑定」');
}
const session = await this.ctx.service.wxGateway.openSession({
purpose: 'member',
scene: 'bind',
payload: { subjectId: Number(subjectId), memberId: Number(member.id) },
});
return {
memberId: Number(member.id),
memberName: member.name,
state: session.state,
pageUrl: session.pageUrl,
qrUrl: `/api/wechat-gateway/qrcode.svg?state=${encodeURIComponent(session.state)}`,
expiresIn: session.expiresIn,
};
}
/**
* 网关确认后:把「扫码的微信」落到这名成员上(`service/wx_gateway.js#handleMemberBind` 调)
*
* @param {object} params
* @param {number} params.subjectId
* @param {number} params.memberId
* @param {string} params.openid 扫码的微信
* @param {string} [params.unionid]
* @param {number|null} [params.boundUserId] 这个微信已经属于哪个平台账号(没有就 null)
* @return {Promise<object>} { subjectId, subjectName, memberId, memberName, userId, boundName, autoCreated }
*/
async bindMemberWithWechat({ subjectId, memberId, openid, unionid = null, boundUserId = null } = {}) {
const subject = await this.Subject.findByPk(Number(subjectId));
if (!subject) this.ctx.throw(404, '主体已不存在');
const member = await this.Member.findOne({
where: { id: Number(memberId), subjectId: Number(subjectId) },
});
if (!member) this.ctx.throw(404, '成员已不存在');
const currentUserId = member.userId ? Number(member.userId) : null;
const tempUserId = member.tempUserId ? Number(member.tempUserId) : null;
const now = new Date();
// ① 这个微信已经属于某个平台账号:成员直接绑到它
if (boundUserId) {
const userId = Number(boundUserId);
if (currentUserId && currentUserId !== userId && currentUserId !== tempUserId) {
this.ctx.throw(409, '该成员已绑定其他账号,如需换绑请先「解除绑定」');
}
// 同一主体下,一个账号只能有一条成员记录
const mine = await this.memberOf(subject.id, userId);
if (mine && Number(mine.id) !== Number(member.id)) {
this.ctx.throw(409, '你已经是该主体的成员了');
}
await member.update({
userId,
tempUserId: null,
wechatOpenid: String(openid),
boundAt: now,
status: 1,
});
// 自动建的临时账号用不上了,删掉(顺带清掉它上面的微信绑定)
if (tempUserId && tempUserId !== userId) await this.dropTempUser(tempUserId);
const user = await this.app.model.User.findByPk(userId, { attributes: USER_ATTRIBUTES });
const boundName = (user && (user.nickname || user.username)) || `用户${userId}`;
this.ctx.logger.info('[subject] 主体 %s 成员「%s」绑定到已有账号 %s(%s)', subject.id, member.name, userId, boundName);
return this.presentBind({ subject, member, userId, boundName, autoCreated: false });
}
// ② 这个微信还没有平台账号:自动给这名成员建一个,微信就是它的登录方式
if (currentUserId && currentUserId !== tempUserId) {
this.ctx.throw(409, '该成员已绑定其他账号,如需换绑请先「解除绑定」');
}
const existingTemp = tempUserId ? await this.ctx.service.user.findById(tempUserId) : null;
const tempUser = existingTemp || await this.createTempUserForMember(member);
await this.ctx.service.wxGateway.upsertBinding({
userId: Number(tempUser.id),
openid,
unionid,
bindScene: 'member',
});
await member.update({
userId: Number(tempUser.id),
tempUserId: Number(tempUser.id),
wechatOpenid: String(openid),
boundAt: now,
status: 1,
});
this.ctx.logger.info('[subject] 主体 %s 成员「%s」自动建号 %s 并绑定微信', subject.id, member.name, tempUser.id);
return this.presentBind({
subject,
member,
userId: Number(tempUser.id),
boundName: tempUser.nickname || tempUser.username || `用户${tempUser.id}`,
autoCreated: true,
});
}
presentBind({ subject, member, userId, boundName, autoCreated }) {
return {
subjectId: Number(subject.id),
subjectName: subject.name,
memberId: Number(member.id),
memberName: member.name,
userId: Number(userId),
boundName,
autoCreated: Boolean(autoCreated),
};
}
/** 给成员自动建一个账号(用户名 member<成员id>,随机密码;成员姓名当昵称) */
async createTempUserForMember(member) {
const password = crypto.randomBytes(24).toString('hex');
const base = `member${member.id}`;
let lastError = null;
for (let i = 0; i < 5; i++) {
const username = i === 0 ? base : `${base}_${crypto.randomBytes(3).toString('hex')}`;
try {
return await this.ctx.service.auth.register({
username,
password,
nickname: member.name,
email: null,
phone: null,
});
} catch (err) {
// 用户名撞了(可能撞的是软删的旧账号)→ 换个带随机后缀的再试
if (err.status !== 409 && err.name !== 'SequelizeUniqueConstraintError') throw err;
lastError = err;
}
}
throw lastError || new Error('给成员创建账号失败');
}
/** 删掉自动建的临时账号(软删;顺带清掉它的微信绑定,免得那个微信再也绑不上别的账号) */
async dropTempUser(userId) {
const id = Number(userId);
if (!id) return;
try {
await this.app.model.WechatGatewayBinding.destroy({ where: { userId: id }, force: true });
await this.app.model.User.destroy({ where: { id } });
this.ctx.logger.info('[subject] 已删除临时账号 %s', id);
} catch (err) {
this.ctx.logger.warn('[subject] 删除临时账号 %s 失败: %s', id, err.message);
}
}
/**
* 解除成员的账号绑定(**仅管理员**)
*
* 手机换了人 / 绑错了时的兜底:解绑后成员回到「未绑定」,可以重新出二维码绑别人。
* 自动建给成员的临时账号会一并删掉(它上面没有别的登录方式,留着也没人能用)。
*
* @param {object} params { subjectId, memberId, operatorUserId }
* @return {Promise<object>} 解绑后的成员(同 `members()` 里的结构)
*/
async unbindMember({ subjectId, memberId, operatorUserId } = {}) {
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) return this.presentMember(member, Number(subjectId));
const userId = Number(member.userId);
const tempUserId = member.tempUserId ? Number(member.tempUserId) : null;
await member.update({
userId: null,
tempUserId: null,
wechatOpenid: null,
boundAt: null,
});
// 自动建的临时账号没人能再登录了,直接删掉(顺带清它的微信绑定)
if (tempUserId && tempUserId === userId) await this.dropTempUser(tempUserId);
this.ctx.logger.info('[subject] 用户 %s 解除主体 %s 成员「%s」的账号绑定(原 userId=%s)',
operatorUserId, subjectId, member.name, userId);
return this.presentMember(member, Number(subjectId));
}
presentMember(row, subjectId) {
const data = row.toJSON ? row.toJSON() : row;
return {
id: Number(data.id),
subjectId: Number(subjectId),
name: data.name,
role: Number(data.role),
status: Number(data.status),
userId: data.userId ? Number(data.userId) : null,
boundAt: data.boundAt || null,
wechatBound: Boolean(data.wechatOpenid),
user: null,
isCreator: false,
};
}
/**
* 该用户可进入的第一个主体(设备扫码登录时用:设备没有「当前主体」概念)
* @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;
}
}
/**
* **平台管理员视角**:所有主体(分页)
*
* 与 `listForUser()` 的区别:不看成员关系,谁都能列;额外带「管理员账号名 / 成员数」。
*
* @param {object} params { page, pageSize, keyword, status, expired }
* keyword 模糊匹配主体名 / 备注;status = 1|0;expired = '1' 只看已过期、'0' 只看未过期
*/
async listAll({ page = 1, pageSize = 20, keyword, status, expired } = {}) {
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) === 0 ? 0 : 1;
if (String(expired) === '1') where.expireAt = { [Op.lte]: new Date() };
if (String(expired) === '0') where.expireAt = { [Op.gt]: new Date() };
if (keyword) {
const like = `%${String(keyword).trim()}%`;
where[Op.or] = [
{ name: { [Op.like]: like } },
{ remark: { [Op.like]: like } },
];
}
const { rows, count } = await this.Subject.findAndCountAll({
where,
order: [[ 'id', 'DESC' ]],
limit: size,
offset: (current - 1) * size,
});
const ids = rows.map(row => Number(row.id));
const counts = ids.length
? await this.Member.count({ where: { subjectId: { [Op.in]: ids }, status: 1 }, group: [ 'subject_id' ], raw: true }).catch(() => [])
: [];
const countRows = Array.isArray(counts) ? counts : [];
const countMap = new Map(countRows.map(row => [ Number(row.subjectId || row.subject_id), Number(row.count) || 0 ]));
const adminIds = [ ...new Set(rows.map(row => Number(row.adminUserId))) ];
const admins = adminIds.length
? await this.app.model.User.findAll({ where: { id: { [Op.in]: adminIds } }, attributes: [ 'id', 'username', 'nickname' ], paranoid: false })
: [];
const adminMap = new Map(admins.map(user => [ Number(user.id), user.toJSON() ]));
return {
list: rows.map(row => {
const admin = adminMap.get(Number(row.adminUserId)) || null;
return this.present(row, {
memberCount: countMap.get(Number(row.id)) || 0,
adminUser: admin ? { id: Number(admin.id), username: admin.username, nickname: admin.nickname } : null,
});
}),
total: count,
page: current,
pageSize: size,
};
}
/**
* **平台管理员**改授权到期时间(不校验成员关系)
*
* 两种用法(都不传就报错):
* - `expireAt`:直接设成某个时间(可以设成过去 = 立即到期);
* - `extendDays`:顺延 N 天(未过期从原到期时间算,已过期从现在算 —— 与 `update()` 一致)。
*
* 改完必须失效主体状态缓存,否则设备心跳/上报还会读到旧的期限。
*
* @param {number} subjectId 主体 id
* @param {object} patch { expireAt?, extendDays?, remark?, status? }
* @param {number} operatorUserId 操作人(只记日志)
*/
async setExpireAt(subjectId, patch = {}, operatorUserId = null) {
const id = Number(subjectId);
if (!Number.isInteger(id) || id <= 0) this.ctx.throw(400, '主体 id 必须是正整数');
const subject = await this.Subject.findByPk(id);
if (!subject) this.ctx.throw(404, '主体不存在');
const fields = {};
if (patch.expireAt !== undefined && patch.expireAt !== null && patch.expireAt !== '') {
const at = new Date(patch.expireAt);
if (Number.isNaN(at.getTime())) this.ctx.throw(422, '到期时间格式不对');
fields.expireAt = at;
} else 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);
}
if (patch.remark !== undefined) fields.remark = patch.remark;
if (patch.status !== undefined) fields.status = Number(patch.status) === 0 ? 0 : 1;
if (!Object.keys(fields).length) this.ctx.throw(422, '没有要修改的字段(expireAt / extendDays / remark / status)');
const before = subject.expireAt;
await subject.update(fields);
await this.ctx.service.subjectState.invalidate(id);
this.ctx.logger.info('[subject] 平台管理员 %s 修改主体 %s 的期限:%s → %s',
operatorUserId, id, before ? new Date(before).toISOString() : 'null',
subject.expireAt ? new Date(subject.expireAt).toISOString() : 'null');
return this.present(subject);
}
}
module.exports = SubjectService;