476 lines
18 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 { 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;