packServer/backend/app/service/workstation.js

504 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 { Op } = require('sequelize');
/**
* 工作台 service
*
* 一个工作台可以绑定:
* - 多个**摄像头**(workstation_cameras,多对多)
* - 多个**扫码通道**(workstation_scan_channels,通道来自中控 scan_channels)
*
* 归属判定:工作台有自己的 `user_id`;绑定时还要校验「摄像头所属 NVR」和
* 「中控」都属于当前用户,防止把别人的设备挂到自己工作台上。
*/
class WorkstationService extends Service {
get Workstation() {
return this.app.model.Workstation;
}
get LinkCamera() {
return this.app.model.WorkstationCamera;
}
get LinkScanChannel() {
return this.app.model.WorkstationScanChannel;
}
/** 分页列表(附带摄像头数 / 扫码通道数) */
async list({ page = 1, pageSize = 20, keyword, status, wsType, subjectId } = {}) {
const size = Math.min(Number(pageSize) || 20, 100);
const current = Math.max(Number(page) || 1, 1);
const where = { subjectId: Number(subjectId) };
if (status !== undefined && status !== '' && status !== null) where.status = Number(status);
if (wsType !== undefined && wsType !== '' && wsType !== null) where.wsType = Number(wsType) === 2 ? 2 : 1;
if (keyword) {
where[Op.or] = [
{ code: { [Op.like]: `%${keyword}%` } },
{ name: { [Op.like]: `%${keyword}%` } },
];
}
const { rows, count } = await this.Workstation.findAndCountAll({
where,
limit: size,
offset: (current - 1) * size,
order: [[ 'id', 'DESC' ]],
});
const ids = rows.map(row => row.id);
const [ cameraCounts, scanCounts ] = ids.length
? await Promise.all([
this.LinkCamera.count({ where: { workstationId: { [Op.in]: ids } }, group: [ 'workstationId' ], raw: true }),
this.LinkScanChannel.count({ where: { workstationId: { [Op.in]: ids } }, group: [ 'workstationId' ], raw: true }),
])
: [ [], [] ];
const cameraMap = new Map(cameraCounts.map(item => [ Number(item.workstationId), item.count ]));
const scanMap = new Map(scanCounts.map(item => [ Number(item.workstationId), item.count ]));
const list = rows.map(row => Object.assign(row.toJSON(), {
cameraCount: cameraMap.get(Number(row.id)) || 0,
scanChannelCount: scanMap.get(Number(row.id)) || 0,
}));
return { list, total: count, page: current, pageSize: size };
}
/** 取「我的」工作台;不存在或不属于当前用户 → 404 */
async findOwned(id, subjectId) {
const workstation = await this.Workstation.findByPk(id);
if (!workstation || Number(workstation.subjectId) !== Number(subjectId)) {
this.ctx.throw(404, '工作台不存在或不属于当前账号');
}
return workstation;
}
/** 详情:工作台 + 已绑摄像头 + 已绑扫码通道 */
async detail(id, subjectId) {
const workstation = await this.findOwned(id, subjectId);
const [ cameraLinks, scanLinks ] = await Promise.all([
this.LinkCamera.findAll({
where: { workstationId: workstation.id },
include: [{
model: this.app.model.Camera,
as: 'camera',
required: true,
include: [{ model: this.app.model.Nvr, as: 'nvr', attributes: [ 'id', 'name', 'host', 'port' ] }],
}],
order: [[ 'sort_no', 'ASC' ], [ 'id', 'ASC' ]],
}),
this.LinkScanChannel.findAll({
where: { workstationId: workstation.id },
include: [{
model: this.app.model.Scanner,
as: 'scanner',
required: false,
attributes: [ 'id', 'sn', 'name', 'status' ],
}],
order: [[ 'sort_no', 'ASC' ], [ 'id', 'ASC' ]],
}),
]);
return Object.assign(workstation.toJSON(), {
cameras: cameraLinks.map(link => {
const data = link.toJSON();
return Object.assign(data, {
camera: data.camera ? Object.assign(data.camera, {
displayName: `${data.camera.nvr ? data.camera.nvr.name || data.camera.nvr.host : 'NVR'}-${data.camera.channelNo}`,
}) : null,
});
}),
scanChannels: scanLinks.map(link => link.toJSON()),
});
}
/** 新增工作台(同一主体下 code 唯一;软删过的会被复活并更新) */
async create({ subjectId, userId, code, name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, remark } = {}) {
const finalCode = String(code || '').trim() || `WS-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 5)}`;
const finalType = Number(wsType) === 2 ? 2 : 1;
const range = this._recordRange({
recordBeforeSec,
recordAfterSec,
recordMaxSec: finalType === 2 ? undefined : recordMaxSec,
});
const existing = await this.Workstation.findOne({
where: { subjectId: Number(subjectId), code: finalCode },
paranoid: false,
});
if (existing) {
if (existing.deletedAt) await existing.restore();
const nextType = wsType === undefined ? (Number(existing.wsType) === 2 ? 2 : 1) : finalType;
const before = range.recordBeforeSec ?? Number(existing.recordBeforeSec ?? 60);
const after = range.recordAfterSec ?? Number(existing.recordAfterSec ?? 60);
await existing.update({
name: name === undefined ? existing.name : String(name || '').trim(),
wsType: nextType,
recordBeforeSec: before,
recordAfterSec: after,
recordMaxSec: this._maxSec(nextType, before, after, range.recordMaxSec, existing.recordMaxSec),
remark: remark === undefined ? existing.remark : remark,
status: 1,
});
return this.findOwned(existing.id, subjectId);
}
const before = range.recordBeforeSec ?? 60;
const after = range.recordAfterSec ?? 60;
const created = await this.Workstation.create({
subjectId: Number(subjectId),
userId: userId ? Number(userId) : null,
code: finalCode,
name: String(name || '').trim() || '未命名工作台',
wsType: finalType,
recordBeforeSec: before,
recordAfterSec: after,
recordMaxSec: this._maxSec(finalType, before, after, range.recordMaxSec, 240),
remark: remark || null,
status: 1,
});
this.ctx.logger.info('[workstation] 主体 %s 新增工作台 %s', subjectId, finalCode);
return this.findOwned(created.id, subjectId);
}
/**
* 录制范围校验(秒)
*
* - before / after:0~3600
* - max:10~7200(缺省 240)
* 不传的字段返回 undefined,交给 create/update 决定是否覆盖。
*/
_recordRange({ recordBeforeSec, recordAfterSec, recordMaxSec } = {}) {
const clampInt = (value, min, max, label) => {
const num = Number(value);
if (!Number.isFinite(num)) this.ctx.throw(422, `${label}必须是数字`);
const int = Math.round(num);
if (int < min || int > max) this.ctx.throw(422, `${label}必须在 ${min}~${max} 秒之间`);
return int;
};
return {
recordBeforeSec: recordBeforeSec === undefined || recordBeforeSec === null || recordBeforeSec === ''
? undefined
: clampInt(recordBeforeSec, 0, 3600, '录制范围(前)'),
recordAfterSec: recordAfterSec === undefined || recordAfterSec === null || recordAfterSec === ''
? undefined
: clampInt(recordAfterSec, 0, 3600, '录制范围(后)'),
recordMaxSec: recordMaxSec === undefined || recordMaxSec === null || recordMaxSec === ''
? undefined
: clampInt(recordMaxSec, 10, 7200, '最大录制时长'),
};
}
/**
* 最大录制时长
*
* - 散单:用户可设(不传则沿用旧值 / 默认 240)
* - 团购:以扫码时间为基准,前 + 后就是总时长,没有额外上限(不返回/忽略前端传的值)
*/
_maxSec(wsType, before, after, incoming, fallback) {
if (Number(wsType) === 2) return Number(before) + Number(after);
if (incoming !== undefined && incoming !== null) return incoming;
return Number(fallback ?? 240);
}
/** 更新工作台(code 不开放修改;类型 / 录制范围可改) */
async update(id, subjectId, patch = {}) {
const workstation = await this.findOwned(id, subjectId);
const fields = {};
if (patch.name !== undefined) fields.name = String(patch.name || '').trim();
if (patch.wsType !== undefined) fields.wsType = Number(patch.wsType) === 2 ? 2 : 1;
const nextType = fields.wsType !== undefined
? fields.wsType
: (Number(workstation.wsType) === 2 ? 2 : 1);
// 团购没有「最大录制时长」(= 扫码前 + 扫码后),不校验也不收前端传的值
const range = this._recordRange({
recordBeforeSec: patch.recordBeforeSec,
recordAfterSec: patch.recordAfterSec,
recordMaxSec: nextType === 2 ? undefined : patch.recordMaxSec,
});
const before = range.recordBeforeSec ?? Number(workstation.recordBeforeSec ?? 60);
const after = range.recordAfterSec ?? Number(workstation.recordAfterSec ?? 60);
fields.recordBeforeSec = before;
fields.recordAfterSec = after;
fields.recordMaxSec = this._maxSec(nextType, before, after, range.recordMaxSec, workstation.recordMaxSec);
if (patch.remark !== undefined) fields.remark = patch.remark;
if (patch.status !== undefined) fields.status = Number(patch.status) === 0 ? 0 : 1;
await workstation.update(fields);
return this.findOwned(id, subjectId);
}
/** 删除工作台(连带解除所有绑定,工作台本体软删除) */
async remove(id, subjectId) {
const workstation = await this.findOwned(id, subjectId);
await Promise.all([
this.LinkCamera.destroy({ where: { workstationId: workstation.id } }),
this.LinkScanChannel.destroy({ where: { workstationId: workstation.id } }),
]);
await workstation.destroy();
this.ctx.logger.info('[workstation] 主体 %s 删除工作台 %s', subjectId, workstation.id);
return { id: workstation.id };
}
/**
* 绑定摄像头(追加,重复的自动忽略)
* @param {Array<number>} cameraIds 必须是当前用户 NVR 下的摄像头
*/
async bindCameras({ workstationId, subjectId, cameraIds = [] } = {}) {
const workstation = await this.findOwned(workstationId, subjectId);
const ids = Array.isArray(cameraIds)
? [ ...new Set(cameraIds.map(Number).filter(item => Number.isInteger(item) && item > 0)) ]
: [];
if (!ids.length) this.ctx.throw(422, 'cameraIds 不能为空');
const owned = await this.ctx.service.camera.listOfUser(subjectId);
const ownedIds = new Set(owned.map(item => Number(item.id)));
const invalid = ids.filter(item => !ownedIds.has(item));
if (invalid.length) this.ctx.throw(422, `摄像头不存在或不属于当前账号:${invalid.join(',')}`);
// 一个摄像头只能属于**一个**工作台:已被其他工作台绑定的直接拒绝(返回具体是哪个工作台)
const conflicts = await this.LinkCamera.findAll({
where: { cameraId: { [Op.in]: ids }, workstationId: { [Op.ne]: workstation.id } },
include: [{
model: this.Workstation,
as: 'workstation',
required: false,
attributes: [ 'id', 'code', 'name' ],
}],
});
if (conflicts.length) {
const details = conflicts.map(link => {
const camera = owned.find(item => Number(item.id) === Number(link.cameraId));
const label = (camera && camera.name) || `通道${camera ? camera.channelNo : link.cameraId}`;
const target = link.workstation && (link.workstation.name || link.workstation.code);
return `「${label}」已被工作台「${target || link.workstationId}」绑定,请先在该工作台解绑`;
});
this.ctx.throw(409, details.join(';'));
}
const maxSort = await this.LinkCamera.max('sortNo', { where: { workstationId: workstation.id } }) || 0;
// 默认布局:第 1 个铺满画布(1920×1080);第 2 个 720 宽放右上角;后面的依次叠左下角
const canvasW = Number(workstation.canvasWidth) || 1920;
const canvasH = Number(workstation.canvasHeight) || 1080;
const existing = await this.LinkCamera.count({ where: { workstationId: workstation.id } });
const rows = ids.map((cameraId, index) => {
const slot = existing + index;
let layout;
if (slot === 0) {
layout = { x: 0, y: 0, width: canvasW, height: canvasH, zIndex: 0 };
} else if (slot === 1) {
const width = Math.min(720, canvasW);
const height = Math.round(width * canvasH / canvasW);
layout = { x: canvasW - width, y: 0, width, height, zIndex: 1 };
} else {
const width = Math.min(480, canvasW);
const height = Math.round(width * canvasH / canvasW);
layout = { x: 0, y: canvasH - height, width, height, zIndex: slot };
}
return {
workstationId: workstation.id,
cameraId,
sortNo: Number(maxSort) + index + 1,
streamType: 0,
...layout,
};
});
await this.LinkCamera.bulkCreate(rows, { ignoreDuplicates: true });
this.ctx.logger.info('[workstation] 工作台 %s 绑定摄像头 %s', workstation.id, ids.join(','));
return this.detail(workstation.id, subjectId);
}
/** 解绑摄像头 */
async unbindCamera({ workstationId, subjectId, cameraId } = {}) {
const workstation = await this.findOwned(workstationId, subjectId);
await this.LinkCamera.destroy({ where: { workstationId: workstation.id, cameraId: Number(cameraId) } });
return this.detail(workstation.id, subjectId);
}
/**
* 修改某条绑定在合成画布上的位置 / 大小 / 码流
*
* patch: { x?, y?, width?, height?, streamType?, zIndex? }
* 全部按画布范围夹住,避免存进去一个跑到画布外面的矩形。
*/
async updateCameraLayout({ workstationId, subjectId, cameraId, patch = {} } = {}) {
const workstation = await this.findOwned(workstationId, subjectId);
const link = await this.LinkCamera.findOne({
where: { workstationId: workstation.id, cameraId: Number(cameraId) },
});
if (!link) this.ctx.throw(404, '该摄像头没有绑定到这个工作台');
const canvasW = Number(workstation.canvasWidth) || 1920;
const canvasH = Number(workstation.canvasHeight) || 1080;
const clamp = (value, min, max) => Math.min(Math.max(Math.round(Number(value) || 0), min), max);
const fields = {};
const width = patch.width !== undefined ? clamp(patch.width, 160, canvasW) : Number(link.width) || canvasW;
const height = patch.height !== undefined ? clamp(patch.height, 90, canvasH) : Number(link.height) || canvasH;
if (patch.width !== undefined) fields.width = width;
if (patch.height !== undefined) fields.height = height;
if (patch.x !== undefined) fields.x = clamp(patch.x, 0, Math.max(canvasW - width, 0));
if (patch.y !== undefined) fields.y = clamp(patch.y, 0, Math.max(canvasH - height, 0));
if (patch.streamType !== undefined) fields.streamType = Number(patch.streamType) === 1 ? 1 : 0;
if (patch.zIndex !== undefined) fields.zIndex = clamp(patch.zIndex, 0, 9999);
if (Object.keys(fields).length) await link.update(fields);
return this.detail(workstation.id, subjectId);
}
/**
* 绑定扫码通道(追加,重复的自动忽略)
*
* @param {Array} items [{ scannerId, channelId, channelName? }]
* channelName 不传则取 scan_channels 里的当前名字
*/
async bindScanChannels({ workstationId, subjectId, items = [] } = {}) {
const workstation = await this.findOwned(workstationId, subjectId);
if (!Array.isArray(items) || items.length === 0) this.ctx.throw(422, 'items 不能为空');
const scannerIds = await this.ctx.service.scanner.idsOfSubject(subjectId);
const allowed = new Set(scannerIds.map(Number));
const normalized = [];
const seen = new Set();
for (const raw of items) {
const scannerId = Number(raw && raw.scannerId);
const channelId = String((raw && raw.channelId) || '').trim();
if (!allowed.has(scannerId)) this.ctx.throw(422, `中控不存在或不属于当前账号:${raw && raw.scannerId}`);
if (!channelId) this.ctx.throw(422, 'channelId 不能为空');
const key = `${scannerId}:${channelId}`;
if (seen.has(key)) continue;
seen.add(key);
let channelName = String((raw && raw.channelName) || '').trim();
if (!channelName) {
const channel = await this.app.model.ScanChannel.findOne({
where: { scannerId, channelId },
attributes: [ 'channelName' ],
});
channelName = (channel && channel.channelName) || '';
}
normalized.push({ workstationId: workstation.id, scannerId, channelId, channelName: channelName.slice(0, 128) });
}
const maxSort = await this.LinkScanChannel.max('sortNo', { where: { workstationId: workstation.id } }) || 0;
normalized.forEach((row, index) => { row.sortNo = Number(maxSort) + index + 1; });
// 一个扫码通道也只能属于**一个**工作台
const conflicts = await this.LinkScanChannel.findAll({
where: {
workstationId: { [Op.ne]: workstation.id },
[Op.or]: normalized.map(row => ({ scannerId: row.scannerId, channelId: row.channelId })),
},
include: [{
model: this.Workstation,
as: 'workstation',
required: false,
attributes: [ 'id', 'code', 'name' ],
}],
});
if (conflicts.length) {
const details = conflicts.map(link => {
const row = normalized.find(item => item.scannerId === Number(link.scannerId) && item.channelId === link.channelId);
const label = (row && row.channelName) || link.channelId;
const target = link.workstation && (link.workstation.name || link.workstation.code);
return `扫码通道「${label}」已被工作台「${target || link.workstationId}」绑定,请先在该工作台解绑`;
});
this.ctx.throw(409, [ ...new Set(details) ].join(';'));
}
await this.LinkScanChannel.bulkCreate(normalized, { ignoreDuplicates: true });
this.ctx.logger.info('[workstation] 工作台 %s 绑定扫码通道 %d 个', workstation.id, normalized.length);
return this.detail(workstation.id, subjectId);
}
/** 解绑扫码通道(按绑定记录 id) */
async unbindScanChannel({ workstationId, subjectId, linkId } = {}) {
const workstation = await this.findOwned(workstationId, subjectId);
await this.LinkScanChannel.destroy({ where: { id: Number(linkId), workstationId: workstation.id } });
return this.detail(workstation.id, subjectId);
}
/**
* 当前用户**可绑定**的扫码通道(工作台选择器用)
* 来源:自己的中控(scanners)上报的通道(scan_channels)
*/
async availableScanChannels({ subjectId, keyword } = {}) {
const scannerIds = await this.ctx.service.scanner.idsOfSubject(subjectId);
if (!scannerIds.length) return [];
const where = { scannerId: { [Op.in]: scannerIds } };
if (keyword) {
where[Op.or] = [
{ channelId: { [Op.like]: `%${keyword}%` } },
{ channelName: { [Op.like]: `%${keyword}%` } },
];
}
const rows = await this.app.model.ScanChannel.findAll({
where,
include: [{
model: this.app.model.Scanner,
as: 'scanner',
required: false,
attributes: [ 'id', 'sn', 'name', 'status' ],
}],
order: [[ 'scanner_id', 'ASC' ], [ 'channel_id', 'ASC' ]],
});
// 带上「已被哪个工作台绑定」(null = 还可以绑)
const links = await this.LinkScanChannel.findAll({
where: { scannerId: { [Op.in]: scannerIds } },
include: [{
model: this.Workstation,
as: 'workstation',
required: false,
attributes: [ 'id', 'code', 'name' ],
}],
});
const boundBy = new Map();
for (const link of links) {
boundBy.set(`${link.scannerId}:${link.channelId}`, link.workstation ? link.workstation.toJSON() : null);
}
return rows.map(row => {
const item = row.toJSON();
item.boundWorkstation = boundBy.get(`${item.scannerId}:${item.channelId}`) || null;
return item;
});
}
}
module.exports = WorkstationService;