476 lines
18 KiB
JavaScript
476 lines
18 KiB
JavaScript
'use strict';
|
||
|
||
const { Service } = require('egg');
|
||
const { Op } = require('sequelize');
|
||
const crypto = require('crypto');
|
||
|
||
/**
|
||
* 扫描器(设备)service
|
||
*
|
||
* 设备**只有一种身份**:扫码登录换来的长期 JWT ——
|
||
* `GET /api/device/login`(设备发码 → 手机确认)→ `loginByScan()` 建/取记录 + 签长期 JWT,
|
||
* 库里只存当前令牌的 `jti`(重签 → 旧令牌立即失效)。
|
||
* 不再有「sn + secret 注册 / 登录」那套入口(`secret_hash` 列作为历史字段保留,不再写入)。
|
||
*/
|
||
|
||
/** 列表/详情默认不返回历史密钥字段、令牌标识与刷新令牌摘要 */
|
||
const SAFE_ATTRIBUTES = { exclude: [ 'secretHash', 'tokenJti', 'refreshTokenHash' ] };
|
||
/** 关联用户时只带这几个展示字段 */
|
||
const USER_ATTRIBUTES = [ 'id', 'username', 'nickname' ];
|
||
|
||
/**
|
||
* 输出前兜底清洗:历史密钥字段与令牌标识(jti)永不外泄
|
||
* —— 即使 attributes 过滤被绕过(如单测 mock),这里也能兜住
|
||
*/
|
||
function sanitize(row) {
|
||
if (!row) return row;
|
||
const { secretHash, tokenJti, refreshTokenHash, refreshExpiresAt, ...rest } = row;
|
||
return rest;
|
||
}
|
||
/** 刷新令牌只存摘要(不存原文) */
|
||
function sha256(text) {
|
||
return crypto.createHash('sha256').update(String(text)).digest('hex');
|
||
}
|
||
class ScannerService extends Service {
|
||
get Scanner() {
|
||
return this.app.model.Scanner;
|
||
}
|
||
|
||
/**
|
||
* 设备扫码登录:**登录即注册**(`GET /api/device/login` 的唯一落地方法)
|
||
*
|
||
* - 按 SN 找不到记录 → 现场 `create` 一条,归属 = 扫码确认的那个用户(这就是「注册」);
|
||
* - 找到「无主」记录(`user_id` 为空)→ 由确认者**认领**(软删除的顺手复活);
|
||
* - 找到「已属于别人」的记录 → **403**,拒绝(避免扫一下就把别人的设备换绑走);
|
||
* - 设备被禁用(`status = 0`)→ 403;
|
||
* - 无论走哪条路径都换发长期 JWT(`jti` 轮换 → 旧令牌立即失效)。
|
||
*
|
||
* ⚠️ 调用方必须已经确认过登录(`userId` 来自 `POST /api/wechat/confirm` 的确认人)
|
||
*
|
||
* @param {object} params { sn? 设备自报序列号(不传则服务端生成), name?, vendor?, model?, firmware?,
|
||
* userId 确认登录的用户, ip?, expiresIn? 令牌有效期(秒数,不传用 config.jwt.deviceExpiresIn) }
|
||
* @return {Promise<object>} 扫描器信息 + token(JWT) + firstTime(本次是否新建记录)
|
||
*/
|
||
async loginByScan({ sn, name, vendor, model, firmware, userId, subjectId, ip, expiresIn } = {}) {
|
||
if (!userId) this.ctx.throw(401, '缺少确认登录的用户');
|
||
|
||
// 设备没有「当前主体」概念:调用方不指定时,用它所属用户的默认主体
|
||
let finalSubjectId = subjectId ? Number(subjectId) : null;
|
||
if (finalSubjectId) {
|
||
// 指定的主体必须「确认人是成员」,否则退回默认主体(不报错,免得设备卡死)
|
||
const allowed = await this.ctx.service.subject
|
||
.findForUser(finalSubjectId, userId)
|
||
.then(() => true)
|
||
.catch(() => false);
|
||
if (!allowed) finalSubjectId = null;
|
||
}
|
||
if (!finalSubjectId) {
|
||
finalSubjectId = await this.ctx.service.subject.defaultSubjectId(userId);
|
||
}
|
||
|
||
const finalSn = String(sn || '').trim() || `DEV-${crypto.randomBytes(6).toString('hex').toUpperCase()}`;
|
||
const include = [{ model: this.app.model.User, as: 'user', required: false, attributes: USER_ATTRIBUTES }];
|
||
|
||
// 带上已删除的一起查:软删的行仍占着 sn 唯一键(否则下面 create 会撞键 500)
|
||
const existing = await this.Scanner.findOne({
|
||
where: { sn: finalSn },
|
||
attributes: SAFE_ATTRIBUTES,
|
||
include,
|
||
paranoid: false,
|
||
});
|
||
|
||
const payload = { userId: Number(userId), lastLoginAt: new Date(), lastSeenAt: new Date() };
|
||
if (finalSubjectId) payload.subjectId = Number(finalSubjectId);
|
||
if (ip) payload.ip = ip;
|
||
if (name) payload.name = name;
|
||
if (vendor) payload.vendor = vendor;
|
||
if (model) payload.model = model;
|
||
if (firmware) payload.firmware = firmware;
|
||
|
||
let scanner;
|
||
let firstTime = false;
|
||
|
||
if (existing) {
|
||
// 已属于别的账号:拒绝(设备转让得先在原账号解绑)
|
||
if (existing.userId && Number(existing.userId) !== Number(userId)) {
|
||
this.ctx.logger.warn('[scanner] %s 已被用户 %s 绑定,拒绝用户 %s 的扫码登录', finalSn, existing.userId, userId);
|
||
this.ctx.throw(403, `扫描器 ${finalSn} 已绑定到其他账号,请先在原账号里解绑`);
|
||
}
|
||
// 设备已在其他主体里(且本次没指定主体):保持原主体,不跟着确认人乱跳
|
||
if (existing.subjectId && !subjectId) delete payload.subjectId;
|
||
if (Number(existing.status) !== 1) this.ctx.throw(403, '扫描器已被禁用');
|
||
|
||
if (existing.deletedAt) await existing.restore(); // 曾被删除 → 复活
|
||
await existing.update(payload);
|
||
scanner = existing;
|
||
} else {
|
||
// 首次「注册」:扫码确认成功才建记录,归属就是确认登录的那个人
|
||
firstTime = true;
|
||
scanner = await this.Scanner.create(Object.assign(payload, {
|
||
sn: finalSn,
|
||
lastRegisterAt: new Date(),
|
||
}));
|
||
}
|
||
|
||
const token = await this.issueToken(scanner, { expiresIn });
|
||
const refresh = await this.issueRefresh(scanner);
|
||
this.ctx.logger.info('[scanner] %s 扫码登录成功(%s,归属用户 %s)',
|
||
finalSn, firstTime ? '首次注册' : '已存在', userId);
|
||
|
||
return Object.assign(sanitize(scanner.toJSON()), {
|
||
token,
|
||
tokenType: 'Bearer',
|
||
refreshToken: refresh.token,
|
||
refreshExpiresIn: refresh.expiresIn,
|
||
refreshExpiresAt: refresh.expiresAt,
|
||
firstTime,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 桌面端「开启设备服务」:把本机注册成当前主体**唯一**的一台设备
|
||
*
|
||
* - **一个主体只允许一台设备在线**:同主体下的其他设备一律「踢下线」(轮换 jti → 旧 JWT 立即 401)
|
||
* - 同一个 SN 重复开启只是换发令牌(不是新建记录)
|
||
* - 调用方(controller)负责先校验「当前用户是该主体管理员」
|
||
*
|
||
* @param {object} params { subjectId, userId, sn?, name?, vendor?, model? }
|
||
* @return {Promise<object>} { device, token, tokenType, expiresIn, kicked }
|
||
*/
|
||
async activateForSubject({ subjectId, userId, sn, name, vendor, model } = {}) {
|
||
if (!subjectId) this.ctx.throw(400, '缺少主体');
|
||
if (!userId) this.ctx.throw(401, '缺少用户身份');
|
||
|
||
const finalSn = String(sn || '').trim() || `PC-${crypto.randomBytes(4).toString('hex').toUpperCase()}`;
|
||
|
||
// ① 踢掉同主体下的其他设备:轮换 jti,旧令牌立刻失效
|
||
const others = await this.Scanner.findAll({
|
||
attributes: [ 'id', 'sn', 'name' ],
|
||
where: { subjectId: Number(subjectId), sn: { [Op.ne]: finalSn } },
|
||
raw: true,
|
||
});
|
||
for (const row of others) {
|
||
await this.Scanner.update({
|
||
tokenJti: crypto.randomUUID(),
|
||
refreshTokenHash: null,
|
||
refreshExpiresAt: null,
|
||
}, { where: { id: row.id } });
|
||
}
|
||
|
||
// ② 本机设备:同 SN 复用(含软删的),否则新建
|
||
const existing = await this.Scanner.findOne({
|
||
where: { sn: finalSn },
|
||
attributes: SAFE_ATTRIBUTES,
|
||
paranoid: false,
|
||
});
|
||
|
||
const fields = {
|
||
subjectId: Number(subjectId),
|
||
userId: Number(userId),
|
||
lastLoginAt: new Date(),
|
||
lastSeenAt: new Date(),
|
||
status: 1,
|
||
};
|
||
if (name) fields.name = String(name).slice(0, 64);
|
||
if (vendor) fields.vendor = String(vendor).slice(0, 64);
|
||
if (model) fields.model = String(model).slice(0, 64);
|
||
|
||
let scanner;
|
||
let firstTime = false;
|
||
if (existing) {
|
||
if (existing.deletedAt) await existing.restore();
|
||
await existing.update(fields);
|
||
scanner = existing;
|
||
} else {
|
||
firstTime = true;
|
||
scanner = await this.Scanner.create(Object.assign({}, fields, {
|
||
sn: finalSn,
|
||
lastRegisterAt: new Date(),
|
||
}));
|
||
}
|
||
|
||
const token = await this.issueToken(scanner);
|
||
const refresh = await this.issueRefresh(scanner);
|
||
|
||
this.ctx.logger.info('[scanner] 主体 %s 开启设备服务:%s(%s),踢下线 %d 台',
|
||
subjectId, finalSn, firstTime ? '新建' : '复用', others.length);
|
||
|
||
return Object.assign(sanitize(scanner.toJSON()), {
|
||
token,
|
||
tokenType: 'Bearer',
|
||
refreshToken: refresh.token,
|
||
refreshExpiresIn: refresh.expiresIn,
|
||
refreshExpiresAt: refresh.expiresAt,
|
||
firstTime,
|
||
expiresIn: this.app.config.jwt.deviceExpiresIn,
|
||
kicked: others.map(row => ({ id: Number(row.id), sn: row.sn, name: row.name })),
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 关闭设备服务 / 让某个设备的令牌立刻失效(轮换 jti)
|
||
* @return {Promise<boolean>} 是否命中记录
|
||
*/
|
||
async revokeToken(scannerId) {
|
||
const scanner = await this.Scanner.findByPk(scannerId);
|
||
if (!scanner) return false;
|
||
|
||
await scanner.update({
|
||
tokenJti: crypto.randomUUID(),
|
||
refreshTokenHash: null,
|
||
refreshExpiresAt: null,
|
||
lastSeenAt: new Date(),
|
||
});
|
||
this.ctx.logger.info('[scanner] 设备 %s 令牌已作废(关闭设备服务)', scanner.sn);
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 签发长期 JWT 并把 jti 写库
|
||
* 库里不保存令牌本体,靠 jti 比对实现撤销:重签后旧令牌立即失效
|
||
* @param {object} scanner 扫描器实例
|
||
* @param {object} options { expiresIn 覆盖有效期(秒数或 '30d' 写法,不传用 config.jwt.scannerExpiresIn) }
|
||
* @return {Promise<string>} JWT
|
||
*/
|
||
async issueToken(scanner, options = {}) {
|
||
const jti = crypto.randomUUID();
|
||
const token = this.ctx.service.jwt.signScanner(scanner, { jti }, { expiresIn: options.expiresIn });
|
||
|
||
await scanner.update({
|
||
tokenJti: jti,
|
||
tokenExpiresAt: this.ctx.service.jwt.expiresAtOf(token),
|
||
});
|
||
this.ctx.logger.info('[scanner] 已签发令牌: %s (jti=%s, expiresIn=%s)',
|
||
scanner.sn, jti, options.expiresIn || this.app.config.jwt.scannerExpiresIn);
|
||
return token;
|
||
}
|
||
|
||
/** 鉴权用:取实例(含 jti,用于和令牌里的 jti 比对) */
|
||
async findByIdForAuth(id) {
|
||
return this.Scanner.findByPk(id, { attributes: { include: [ 'tokenJti' ] } });
|
||
}
|
||
|
||
/**
|
||
* 签发刷新令牌(不透明随机串,库里只存 sha256)
|
||
*
|
||
* 每次签发都会轮换旧值;调用方(激活 / 刷新)负责把明文返回给设备端保存。
|
||
* @param {object} scanner 扫描器实例
|
||
* @return {Promise<{token:string, expiresIn:string|number, expiresAt:Date}>}
|
||
*/
|
||
async issueRefresh(scanner) {
|
||
const token = crypto.randomBytes(32).toString('base64url');
|
||
const spec = this.app.config.jwt.deviceRefreshExpiresIn || '730d';
|
||
const seconds = this.ctx.service.jwt.parseDuration(spec) || 63072000; // 兜底 730 天
|
||
const expiresAt = new Date(Date.now() + seconds * 1000);
|
||
|
||
await scanner.update({
|
||
refreshTokenHash: sha256(token),
|
||
refreshExpiresAt: expiresAt,
|
||
});
|
||
|
||
return { token, expiresIn: spec, expiresAt };
|
||
}
|
||
|
||
/**
|
||
* 用刷新令牌换新的访问令牌(并轮换刷新令牌)
|
||
*
|
||
* 不需要访问令牌(它可能已经过期);刷新令牌本身就是凭据。
|
||
* 校验:hash 反查记录 → 未删除 / status=1 / 刷新令牌未过期 / SN 可选比对。
|
||
* 成功后:`jti` 轮换(旧访问令牌立即失效)+ 刷新令牌轮换(旧刷新令牌立即失效)。
|
||
*
|
||
* @param {object} params { refreshToken 明文, sn? 额外校验, ip? }
|
||
* @return {Promise<object>} { sn, token, tokenType, expiresIn, refreshToken, refreshExpiresIn, refreshExpiresAt }
|
||
*/
|
||
async refreshToken({ refreshToken, sn, ip } = {}) {
|
||
const plain = String(refreshToken || '').trim();
|
||
if (!plain) this.ctx.throw(400, '缺少 refreshToken');
|
||
|
||
const scanner = await this.Scanner.findOne({
|
||
where: { refreshTokenHash: sha256(plain) },
|
||
paranoid: false,
|
||
});
|
||
|
||
if (!scanner) this.ctx.throw(401, '刷新令牌无效');
|
||
if (scanner.deletedAt) this.ctx.throw(401, '扫描器已被删除');
|
||
if (Number(scanner.status) !== 1) this.ctx.throw(403, '扫描器已被禁用');
|
||
if (sn && String(sn).trim() && scanner.sn !== String(sn).trim()) {
|
||
this.ctx.throw(401, '刷新令牌与 SN 不匹配');
|
||
}
|
||
if (!scanner.refreshExpiresAt || new Date(scanner.refreshExpiresAt).getTime() < Date.now()) {
|
||
this.ctx.throw(401, '刷新令牌已过期,请重新开启设备服务');
|
||
}
|
||
|
||
const token = await this.issueToken(scanner);
|
||
const refresh = await this.issueRefresh(scanner);
|
||
await scanner.update(Object.assign({ lastSeenAt: new Date() }, ip ? { ip } : {}));
|
||
|
||
this.ctx.logger.info('[scanner] %s 刷新令牌成功(jti 已轮换)', scanner.sn);
|
||
|
||
return {
|
||
sn: scanner.sn,
|
||
token,
|
||
tokenType: 'Bearer',
|
||
expiresIn: this.app.config.jwt.deviceExpiresIn,
|
||
refreshToken: refresh.token,
|
||
refreshExpiresIn: refresh.expiresIn,
|
||
refreshExpiresAt: refresh.expiresAt,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 用长期 JWT 换设备实例(校验链路与 `middleware/scanner_auth.js` 完全一致,实现在这里)
|
||
*
|
||
* 1. 验签 + 过期检查;2. 回查记录存在且 `status=1`;3. 比对库里的 jti(重签后旧令牌立即失效)。
|
||
* 任何一步不过直接抛 401/403。
|
||
*
|
||
* @param {string} token 长期 JWT
|
||
* @param {object} options { sn 额外要求令牌里的 SN 与它一致(测试页模拟上报用) }
|
||
* @return {Promise<object>} 设备实例(含 tokenJti)
|
||
*/
|
||
async resolveByToken(token, { sn } = {}) {
|
||
if (!token) this.ctx.throw(401, '缺少扫描器令牌(Authorization: Bearer <token>)');
|
||
|
||
const payload = this.ctx.service.jwt.verifyScanner(token);
|
||
const scanner = await this.findByIdForAuth(payload.sub);
|
||
|
||
if (!scanner) this.ctx.throw(401, '扫描器不存在或已被删除');
|
||
if (sn && scanner.sn !== String(sn).trim()) this.ctx.throw(401, '令牌与 SN 不匹配');
|
||
if (Number(scanner.status) !== 1) this.ctx.throw(403, '扫描器已被禁用');
|
||
if (payload.jti && scanner.tokenJti && payload.jti !== scanner.tokenJti) {
|
||
this.ctx.throw(401, '扫描器令牌已失效,请重新登录');
|
||
}
|
||
|
||
return scanner;
|
||
}
|
||
|
||
/** 心跳:刷新最近心跳时间与 IP */
|
||
async heartbeat(scanner, ip) {
|
||
const fields = { lastSeenAt: new Date() };
|
||
if (ip) fields.ip = ip;
|
||
|
||
await scanner.update(fields);
|
||
return sanitize(scanner.toJSON());
|
||
}
|
||
|
||
/** 绑定扫描器到账号(管理侧用:userId / username 二选一) */
|
||
async bind({ scannerId, sn, userId, username }) {
|
||
const scanner = await this.findByKey({ scannerId, sn });
|
||
if (!scanner) this.ctx.throw(404, '扫描器不存在');
|
||
|
||
const targetUserId = await this.resolveUserId({ userId, username });
|
||
if (!targetUserId) this.ctx.throw(422, 'userId 或 username 至少提供一个');
|
||
|
||
await scanner.update({ userId: targetUserId });
|
||
this.ctx.logger.info('[scanner] %s 绑定到用户 %s', scanner.sn, targetUserId);
|
||
return sanitize(scanner.toJSON());
|
||
}
|
||
|
||
/** 解绑(仅清掉归属关系,扫描器记录保留;设备可以再扫码重新认领) */
|
||
async unbind({ scannerId, sn }) {
|
||
const scanner = await this.findByKey({ scannerId, sn });
|
||
if (!scanner) return null;
|
||
|
||
await scanner.update({ userId: null });
|
||
return sanitize(scanner.toJSON());
|
||
}
|
||
|
||
/** 按主键 / SN 查扫描器 */
|
||
async findByKey({ scannerId, sn }) {
|
||
if (scannerId) return this.Scanner.findByPk(scannerId);
|
||
if (sn) return this.Scanner.findOne({ where: { sn } });
|
||
return null;
|
||
}
|
||
|
||
async findById(id) {
|
||
const scanner = await this.Scanner.findByPk(id, {
|
||
attributes: SAFE_ATTRIBUTES,
|
||
include: [{ model: this.app.model.User, as: 'user', required: false, attributes: USER_ATTRIBUTES }],
|
||
});
|
||
return scanner ? sanitize(scanner.toJSON()) : null;
|
||
}
|
||
|
||
/** 分页列表:keyword 模糊匹配 SN / 名称 / 型号(可按主体 / 用户过滤) */
|
||
async list({ page = 1, pageSize = 20, keyword, userId, subjectId, status } = {}) {
|
||
const size = Math.min(Number(pageSize) || 20, 100);
|
||
const current = Math.max(Number(page) || 1, 1);
|
||
|
||
const where = {};
|
||
if (userId) where.userId = Number(userId);
|
||
if (subjectId) where.subjectId = Number(subjectId);
|
||
if (status !== undefined && status !== '' && status !== null) where.status = Number(status);
|
||
if (keyword) {
|
||
where[Op.or] = [
|
||
{ sn: { [Op.like]: `%${keyword}%` } },
|
||
{ name: { [Op.like]: `%${keyword}%` } },
|
||
{ model: { [Op.like]: `%${keyword}%` } },
|
||
];
|
||
}
|
||
|
||
const { rows, count } = await this.Scanner.findAndCountAll({
|
||
where,
|
||
attributes: SAFE_ATTRIBUTES,
|
||
include: [{ model: this.app.model.User, as: 'user', required: false, attributes: USER_ATTRIBUTES }],
|
||
limit: size,
|
||
offset: (current - 1) * size,
|
||
order: [[ 'id', 'DESC' ]],
|
||
});
|
||
|
||
return {
|
||
list: rows.map(row => sanitize(row.toJSON())),
|
||
total: count,
|
||
page: current,
|
||
pageSize: size,
|
||
};
|
||
}
|
||
|
||
/** 软删除扫描器 */
|
||
async remove(id) {
|
||
const affected = await this.Scanner.destroy({ where: { id } });
|
||
return affected > 0;
|
||
}
|
||
|
||
/** 总数(首页统计用) */
|
||
async count(where = {}) {
|
||
return this.Scanner.count({ where });
|
||
}
|
||
|
||
/**
|
||
* 某主体下的设备 id 列表(主体端查「通道 / 记录 / 统计」时用来限定范围)
|
||
* @return {Promise<number[]>}
|
||
*/
|
||
async idsOfSubject(subjectId) {
|
||
if (!subjectId) return [];
|
||
const rows = await this.Scanner.findAll({
|
||
attributes: [ 'id' ],
|
||
where: { subjectId: Number(subjectId) },
|
||
raw: true,
|
||
});
|
||
return rows.map(row => Number(row.id));
|
||
}
|
||
|
||
/**
|
||
* 某用户名下的设备 id 列表(历史接口,主体体系上线后主体端应改用 `idsOfSubject`)
|
||
* @return {Promise<number[]>}
|
||
*/
|
||
async idsOfUser(userId) {
|
||
const rows = await this.Scanner.findAll({
|
||
attributes: [ 'id' ],
|
||
where: { userId: Number(userId) },
|
||
raw: true,
|
||
});
|
||
return rows.map(row => row.id);
|
||
}
|
||
|
||
/** userId / username(或手机号) → 用户 id,找不到抛 404 */
|
||
async resolveUserId({ userId, username }) {
|
||
if (userId) return Number(userId);
|
||
if (!username) return null;
|
||
|
||
const user = await this.ctx.service.user.findOneBy({ [Op.or]: [{ username }, { phone: username }] });
|
||
if (!user) this.ctx.throw(404, `用户不存在:${username}`);
|
||
return user.id;
|
||
}
|
||
}
|
||
|
||
module.exports = ScannerService;
|