feat(workstation): 一台工作台支持多路面单摄像头 + 绑定管理可改画布尺寸

- 面单摄像头不再限制一台工作台一路:设置新的不清旧标记,取消最后一路时才清理虚拟通道
- 面单识别配置按 工作台+摄像头 逐路下发,多路共用上报通道;多路时虚拟通道名改用工作台名
- 绑定管理新增画布尺寸(宽×高)编辑:160~7680、自动取偶数;改尺寸时已摆放摄像头按比例缩放
- 画布组件在宽度变化时重新计算等比缩放,避免新画布溢出或缩不满
- 补充后端单测与相关文档

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
liufumingren 2026-11-08 23:45:25 +08:00
parent 78cee0fe1a
commit 2ed4fa8483
17 changed files with 467 additions and 55 deletions

View File

@ -720,8 +720,9 @@ node scripts/backfill-snapshot.js --dry-run
| GET | `/api/scan/channels?page=&pageSize=&keyword=&status=` | **需扫描器 JWT**:当前中控已登记的通道 |
| POST | `/api/scan/records` | **需扫描器 JWT**(主体过期/停用 → 403 `subject_expired` / `subject_disabled`):中控上报扫码,body: `{ records: [{ barcode, scanTime, channelId }] }` → `{ received, inserted, updated, duplicated, suppressed, invalid, unknownChannels }`(`updated` = 24 小时内同一运单被覆盖为最新扫描时间的条数;`suppressed` = 比库里已有记录更旧、被忽略的条数) |
| GET | `/api/scan/records?page=&pageSize=&channelId=&barcode=&startTime=&endTime=` | **需扫描器 JWT**:当前中控上报的扫码记录 |
| GET | `/api/scanner/label-cameras` | **需扫描器 JWT**:本机该跑的**面单摄像头识别配置** → `{ revision, items, channels, warnings, scannedAt }`。返回本主体、启用中工作台(**散单和团购都支持**)里被设为面单摄像头的绑定;`items[]` 带 `workstationId/Name`、**`wsType`(1 散单 / 2 团购)**、`channelId/Name`(**本机的扫码通道**;工作台没接扫码枪时是**虚拟通道** `CAM-<工作台id>`,见下)、`virtualChannel`(true = 虚拟通道)、`cameraId/Name`、`cameraChannelNo`、`streamType`、`nvr{host,port,username,password}`。`channels[]` 是本机所有被工作台绑定的通道 + `wsType`(含虚拟通道),设备端用它决定**扫码枪**那条路的记录规则(散单取第一次、团购取最后一次)。`revision` 是内容指纹(含密码和通道模式),变了设备端就重建识别任务。RTSP 路径**不在这里拼**(要按录像机「首个数字通道号」换算,只有设备端问得到)。读接口,不挂 `subjectActive` |
| PUT | `/api/web/workstations/:id/cameras/:cameraId/label` | 设置/取消面单摄像头(`{ isLabelCamera: true/false }`,不传按设置)。**散单、团购都可以**;一台工作台最多一路,设新的会先清旧的;取消时顺手清理虚拟通道 |
| GET | `/api/scanner/label-cameras` | **需扫描器 JWT**:本机该跑的**面单摄像头识别配置** → `{ revision, items, channels, warnings, scannedAt }`。返回本主体、启用中工作台(**散单和团购都支持**)里被设为面单摄像头的绑定;**一台工作台可以有多路**,每路各占一条 `items`;`items[]` 带 `workstationId/Name`、**`wsType`(1 散单 / 2 团购)**、`channelId/Name`(**本机的扫码通道**;工作台没接扫码枪时是**虚拟通道** `CAM-<工作台id>`,见下)、`virtualChannel`(true = 虚拟通道)、`cameraId/Name`、`cameraChannelNo`、`streamType`、`nvr{host,port,username,password}`。`channels[]` 是本机所有被工作台绑定的通道 + `wsType`(含虚拟通道),设备端用它决定**扫码枪**那条路的记录规则(散单取第一次、团购取最后一次)。`revision` 是内容指纹(含密码和通道模式),变了设备端就重建识别任务。RTSP 路径**不在这里拼**(要按录像机「首个数字通道号」换算,只有设备端问得到)。读接口,不挂 `subjectActive` |
| PUT | `/api/web/workstations/:id/cameras/:cameraId/label` | 设置/取消面单摄像头(`{ isLabelCamera: true/false }`,不传按设置)。**散单、团购都可以**;一台工作台可以设多路,互不清除;取消最后一路时顺手清理虚拟通道 |
| PUT | `/api/web/workstations/:id` | 更新工作台配置;`canvasWidth` / `canvasHeight`(像素,160~7680,自动取偶数)可改**合成画布尺寸**,已摆放的摄像头会按比例缩放 |
扫码上报的两个接口都**不会因为重复而报错**(幂等):完全重复的条数计入 `duplicated`,
**同一运单号 24 小时内重复扫描的只保留一条**:时间更新就覆盖(`updated`),更旧的上报忽略(`suppressed`);
@ -1285,7 +1286,7 @@ export WXPAY_API_KEY='' # APIv2 密钥(下单签名 + 回调验签)
### 面单摄像头 & 虚拟通道(`CAM-<工作台id>`)
工作台的**面单摄像头**(`workstation_cameras.is_label_camera = 1`,一台工作台最多一路,散单/团购都能设)
工作台的**面单摄像头**(`workstation_cameras.is_label_camera = 1`,一台工作台可以设多路,散单/团购都能设)
由桌面端拉 RTSP 识别条码,识别结果按「该工作台 + 本机通道」上报。记录规则按工作台类型分流
(下发里的 `wsType`):**散单取第一次 + 立即上报,团购和扫码枪一样静默 5 秒取最后一次**。
@ -1295,9 +1296,9 @@ export WXPAY_API_KEY='' # APIv2 密钥(下单签名 + 回调验签)
| 项 | 规则 |
|---|---|
| 通道 id | `CAM-<工作台id>`,与设备上报的真实通道(纯数字 / `DESKTOP`)不会冲突 |
| 通道名 | `面单摄像头·<摄像头名>` |
| 创建 | 设备拉配置时幂等自愈(`label_scan.ensureVirtualChannel`),并绑到该工作台(回放定位靠 `scanner+channel → 工作台`) |
| 清理 | 取消面单摄像头、绑上真实扫码通道、删除工作台时自动清掉(`workstation.releaseVirtualChannel`) |
| 通道名 | `面单摄像头·<摄像头名>`;多路面单摄像头共用一条通道时用 `面单摄像头·<工作台名>` |
| 创建 | 设备拉配置时幂等自愈(`label_scan.ensureVirtualChannel`),并绑到该工作台(回放定位靠 `scanner+channel → 工作台`);同一工作台的多路面单摄像头共用这一条 |
| 清理 | 取消**最后一路**面单摄像头、绑上真实扫码通道、删除工作台时自动清掉(`workstation.releaseVirtualChannel`) |
| 对账豁免 | `POST /api/scan/channels` 的 `replace: true` **不动** `CAM-` 前缀的通道(设备列表里永远没有它) |
| 前端 | 工作台详情里标记「虚拟」,不给解绑;人工绑定通道列表里也不出现 |
| 播报 | 虚拟通道没有对应的安卓扫码工位,所以**不会**通知安卓端播报 |

View File

@ -96,7 +96,8 @@ class ScanController extends Controller {
/**
* GET /api/scanner/label-cameras —— 本机该跑的**面单摄像头识别配置**(需长期 JWT)
*
* 只返回本主体、散单、启用中的工作台里被设为「面单摄像头」的那几路,
* 只返回本主体、启用中的工作台里被设为「面单摄像头」的那几路(散单/团购都支持,
* 一台工作台可以有多路),
* 附上报通道与录像机凭据(RTSP 路径由设备端按录像机起始数字通道推算)。
* `revision` 是内容指纹:变了设备端就重建识别任务。
*/

View File

@ -83,9 +83,9 @@ class WebWorkstationController extends Controller {
const id = toId(ctx.params.id);
if (!id) ctx.throw(400, 'id 必须是正整数');
const { name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, idleTimeoutSec, remark, status } = ctx.request.body || {};
const { name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, idleTimeoutSec, remark, status, canvasWidth, canvasHeight } = ctx.request.body || {};
const data = await ctx.service.workstation.update(id, ctx.state.subjectId, {
name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, idleTimeoutSec, remark, status,
name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, idleTimeoutSec, remark, status, canvasWidth, canvasHeight,
});
ctx.body = { ok: true, data };
}
@ -159,7 +159,7 @@ class WebWorkstationController extends Controller {
* PUT /api/web/workstations/:id/cameras/:cameraId/label
* body: { isLabelCamera?: boolean }(不传 = 设为面单摄像头)
*
* 仅散单工作台可设置,一台工作台最多一路。
* 散单、团购工作台都可以设置,一台工作台可以设置多路。
*/
async setLabelCamera() {
const { ctx } = this;

View File

@ -6,12 +6,12 @@
* 背景:扫码记录的上报结构是「中控 + 通道」,回放定位靠 `scanner+channel → 工作台`
* 反查快照(`pack.snapshotMap`)。工作台只设了面单摄像头、没接扫码枪时,
* 识别结果没有通道可挂 → 这里给它一条虚拟通道 `CAM-<工作台id>`,
* 名字是「面单摄像头·<摄像头名>」,整条链路(上报、落库、回放定位、安卓播报)都不用特殊处理。
* 名字是「面单摄像头·<摄像头名>」(多路时「面单摄像头·<工作台名>」),整条链路(上报、落库、回放定位、安卓播报)都不用特殊处理。
*
* 约定:
* - 前缀固定 `CAM-`,和设备上报的真实通道(纯数字 / `DESKTOP`)不会冲突;
* - 虚拟通道**只由服务端维护**,设备端全量对账(`replace: true`)时必须豁免;
* - 工作台取消面单摄像头 / 改绑真实通道时,由 `workstation` 服务清理掉。
* - 工作台取消最后一路面单摄像头 / 改绑真实通道时,由 `workstation` 服务清理掉。
*/
const VIRTUAL_CHANNEL_PREFIX = 'CAM-';

View File

@ -42,7 +42,7 @@ function buildSnapshot(workstation, link) {
cameraName: camera.name || camera.channelName || `通道${camera.channelNo}`,
channelNo: Number(camera.channelNo) || 0,
streamType: asInt(item.streamType, 0),
/** 面单摄像头(仅散单工作台会为 1) */
/** 面单摄像头(散单/团购都可能为 1,一台工作台可多路) */
isLabelCamera: asInt(item.isLabelCamera, 0),
nvrId: Number(camera.nvrId) || 0,
nvrName: nvr.name || '',

View File

@ -24,7 +24,7 @@ module.exports = (app) => {
streamType: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 0, comment: '0 主码流 1 子码流' },
zIndex: { type: INTEGER, allowNull: false, defaultValue: 0, comment: '叠放顺序' },
/** 面单摄像头(仅散单工作台,一台工作台最多一路) */
/** 面单摄像头(散单/团购都能设,一台工作台可以有多路) */
isLabelCamera: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 0, comment: '是否面单摄像头:1 是 0 否' },
}, {
tableName: 'workstation_cameras',

View File

@ -15,11 +15,13 @@ const { virtualChannelIdOf, isVirtualChannelId } = require('../lib/virtual-chann
* - 只看**本主体**、启用中的工作台(**散单和团购都支持**面单摄像头);停用的工作台/摄像头
* 不下发,但会给一条 warning 说明原因(现场「配了面单但设备列表里没有」时看这个);
* - 只看被标记为面单摄像头(`workstation_cameras.is_label_camera = 1`)的绑定;
* **一台工作台可以有多路**,每一路各下发一条 `items`(设备端按 工作台+摄像头+通道 重建任务);
* 摄像头本身停用(`cameras.status = 0`)时不下发,改给一条 warning;
* 注意**不看** `cameras.enabled`:那是导入通道时的快照,不代表现在有没有画面;
* - 上报通道取「该工作台绑定、且属于**本设备**的扫码通道」(多条时取 sortNo 最小的一条);
* 工作台**没接扫码枪**(没绑本机通道)时,自动给它一条虚拟通道 `CAM-<工作台id>`
* (名字 `面单摄像头·<摄像头名>`,见 `lib/virtual-channel`)——摄像头可以完全替代扫码枪;
* (名字 `面单摄像头·<摄像头名>`,多路时用 `面单摄像头·<工作台名>`,见 `lib/virtual-channel`)
* ——摄像头可以完全替代扫码枪;多路面单摄像头共用这一条通道;
* - 下发的每一项都带 `wsType`:设备端据此决定记录规则
* (散单 wsType=1 → 时间取第一次、立即上报;团购 wsType=2 → 和扫码枪一样静默 5 秒取最后一次);
* - 另外下发 `channels`(本设备所有被工作台绑定的通道 + 对应 wsType,含虚拟通道),
@ -133,17 +135,24 @@ class LabelScanService extends Service {
}
const items = [];
const seenWorkstations = new Set();
const passwordCache = new Map();
// 一台工作台可以有多路面单摄像头:每路各下发一条,共用同一条上报通道。
// 虚拟通道名称用工作台名(否则多路会互相覆盖成最后一路的摄像头名)。
const labelCameraCount = new Map();
for (const link of links) {
const key = Number(link.workstationId);
labelCameraCount.set(key, (labelCameraCount.get(key) || 0) + 1);
}
for (const link of links) {
const workstationId = Number(link.workstationId);
if (seenWorkstations.has(workstationId)) continue; // 一个工作台只保留一路(DB 也保证)
seenWorkstations.add(workstationId);
const workstation = workstationById.get(workstationId);
const camera = link.camera;
if (!workstation || !camera) continue;
const workstationName = workstation.name || workstation.code || `工作台${workstationId}`;
const cameraName = camera.name || camera.channelName || `通道${camera.channelNo}`;
// ⚠️ 只看 `status`(用户自己的启用/停用)。
@ -157,7 +166,7 @@ class LabelScanService extends Service {
if (!cameraEnabled) {
warnings.push({
workstationId,
workstationName: workstation.name || workstation.code,
workstationName,
message: `摄像头「${cameraName}」已停用(摄像头管理里启用后再试),不会做面单识别`,
});
continue;
@ -168,24 +177,29 @@ class LabelScanService extends Service {
const realChannel = boundChannel && !isVirtualChannelId(boundChannel.channelId) ? boundChannel : null;
const virtualChannelId = virtualChannelIdOf(workstationId);
let channelId = realChannel ? String(realChannel.channelId) : virtualChannelId;
let channelName = realChannel ? (realChannel.channelName || '') : `面单摄像头·${cameraName}`;
const sharedChannelName = labelCameraCount.get(workstationId) > 1 ? workstationName : cameraName;
let channelName = realChannel ? (realChannel.channelName || '') : `面单摄像头·${sharedChannelName}`;
const virtualChannel = !realChannel;
const nvr = camera.nvr;
if (!nvr) {
warnings.push({
workstationId,
workstationName: workstation.name || workstation.code,
workstationName,
message: `摄像头「${cameraName}」找不到录像机`,
});
continue;
}
const password = await this.passwordOf(nvr.id);
let password = passwordCache.get(Number(nvr.id));
if (password === undefined) {
password = await this.passwordOf(nvr.id);
passwordCache.set(Number(nvr.id), password);
}
if (!password) {
warnings.push({
workstationId,
workstationName: workstation.name || workstation.code,
workstationName,
message: `录像机「${nvr.name || nvr.host}」没有保存密码,无法拉流`,
});
continue;
@ -204,7 +218,7 @@ class LabelScanService extends Service {
items.push({
workstationId,
workstationCode: workstation.code || '',
workstationName: workstation.name || workstation.code || '',
workstationName,
// 1 散单(时间取第一次、立即上报)/ 2 团购(静默 5 秒、时间取最后一次,和扫码枪一样)
wsType: Number(workstation.wsType) === 1 ? 1 : 2,
channelId,
@ -386,7 +400,7 @@ class LabelScanService extends Service {
*
* 为什么需要:扫码记录的上报结构是「中控 + 通道」,回放定位靠 `scanner+channel → 工作台` 反查快照;
* 工作台没接扫码枪时没有通道,识别结果就没有落脚点。这里给它补一条**虚拟通道**
* `CAM-<工作台id>`(名字 `面单摄像头·<摄像头名>`)并绑到工作台,整条链路就不用改。
* `CAM-<工作台id>`(名字 `面单摄像头·<摄像头名>`,多路时 `面单摄像头·<工作台名>`)并绑到工作台,整条链路就不用改。
*
* 只在设备拉配置时顺带自愈(包括历史遗留的「设了面单但没通道」的配置)。
*

View File

@ -11,6 +11,10 @@ const IDLE_TIMEOUT_SINGLE_SEC = 1800;
const IDLE_TIMEOUT_MIN_SEC = 60;
const IDLE_TIMEOUT_MAX_SEC = 24 * 3600;
/** 合成画布尺寸范围(像素);合成输出走 ffmpeg,宽高取偶数更稳 */
const CANVAS_MIN = 160;
const CANVAS_MAX = 7680;
/**
* 工作台 service
*
@ -211,6 +215,52 @@ class WorkstationService extends Service {
return int;
}
/**
* 画布尺寸校验(像素)
*
* 不传返回 undefined(调用方沿用旧值)。宽高限制在 160~7680,并四舍五入到偶数
* (合成输出走 ffmpeg,yuv420p 对奇数宽高不友好)。
*/
_canvasSize(value, label) {
if (value === undefined || value === null || value === '') return undefined;
const num = Number(value);
if (!Number.isFinite(num)) this.ctx.throw(422, `${label}必须是数字`);
let int = Math.round(num);
if (int < CANVAS_MIN || int > CANVAS_MAX) {
this.ctx.throw(422, `${label}必须在 ${CANVAS_MIN}~${CANVAS_MAX} 像素之间`);
}
if (int % 2 !== 0) int -= 1;
return int;
}
/**
* 画布尺寸变了 → 把每路摄像头的矩形按比例缩放,保持原来的合成构图
*
* 宽/高为 0 的旧数据按「整张旧画布」算;缩放后夹在新画布范围内。
* @return {Promise<number>} 实际更新的绑定行数
*/
async _rescaleCameraLayouts(workstationId, oldW, oldH, newW, newH) {
const scaleX = newW / oldW;
const scaleY = newH / oldH;
const links = await this.LinkCamera.findAll({ where: { workstationId } });
let changed = 0;
for (const link of links) {
const width = Math.min(Math.max(Math.round((Number(link.width) || oldW) * scaleX), 160), newW);
const height = Math.min(Math.max(Math.round((Number(link.height) || oldH) * scaleY), 90), newH);
const x = Math.min(Math.max(Math.round((Number(link.x) || 0) * scaleX), 0), newW - width);
const y = Math.min(Math.max(Math.round((Number(link.y) || 0) * scaleY), 0), newH - height);
if (x !== Number(link.x) || y !== Number(link.y)
|| width !== Number(link.width) || height !== Number(link.height)) {
await link.update({ x, y, width, height });
changed++;
}
}
return changed;
}
/**
* 录制范围校验(秒)
*
@ -254,7 +304,7 @@ class WorkstationService extends Service {
return Number(fallback ?? 240);
}
/** 更新工作台(code / 登录码不开放修改;类型 / 录制范围 / 不活跃下线时间可改) */
/** 更新工作台(code / 登录码不开放修改;类型 / 录制范围 / 画布尺寸 / 不活跃下线时间可改) */
async update(id, subjectId, patch = {}) {
const workstation = await this.findOwned(id, subjectId);
@ -289,8 +339,31 @@ class WorkstationService extends Service {
if (patch.remark !== undefined) fields.remark = patch.remark;
if (patch.status !== undefined) fields.status = Number(patch.status) === 0 ? 0 : 1;
// 合成画布尺寸:允许改;已有摄像头的矩形按比例缩放,保持原来的合成构图
const oldCanvasW = Number(workstation.canvasWidth) || 1920;
const oldCanvasH = Number(workstation.canvasHeight) || 1080;
const canvasW = this._canvasSize(patch.canvasWidth, '画布宽');
const canvasH = this._canvasSize(patch.canvasHeight, '画布高');
const nextCanvasW = canvasW ?? oldCanvasW;
const nextCanvasH = canvasH ?? oldCanvasH;
if (nextCanvasW !== oldCanvasW || nextCanvasH !== oldCanvasH) {
fields.canvasWidth = nextCanvasW;
fields.canvasHeight = nextCanvasH;
}
await workstation.update(fields);
if (fields.canvasWidth !== undefined) {
const rescaled = await this._rescaleCameraLayouts(
workstation.id, oldCanvasW, oldCanvasH, nextCanvasW, nextCanvasH,
);
this.ctx.logger.info(
'[workstation] 工作台 %s 画布 %dx%d → %dx%d(按比例缩放 %d 路摄像头布局)',
workstation.id, oldCanvasW, oldCanvasH, nextCanvasW, nextCanvasH, rescaled,
);
}
// 名称/类型/启用状态都会改变下发给设备的面单配置(wsType 决定记录规则)→ 叫醒设备重拉
await this._notifyLabelScan(subjectId);
@ -499,7 +572,8 @@ class WorkstationService extends Service {
* 设置 / 取消「面单摄像头」
*
* 散单和团购工作台都可以设(区别在设备端的记录规则:散单取第一次、团购取最后一次,
* 见设备端下发里的 `wsType`);一台工作台最多一路,设新的会先把旧的取消掉。
* 见设备端下发里的 `wsType`)。**一台工作台可以设多路**:每路都单独识别,
* 识别结果都按本工作台的上报通道(真实通道或虚拟通道 `CAM-<id>`)上报。
* `isLabelCamera` 不传按「设置」处理。
*/
async setLabelCamera({ workstationId, subjectId, cameraId, isLabelCamera } = {}) {
@ -514,16 +588,16 @@ class WorkstationService extends Service {
? true
: !(isLabelCamera === false || isLabelCamera === 0 || isLabelCamera === '0' || isLabelCamera === 'false');
if (label) {
await this.LinkCamera.update(
{ isLabelCamera: 0 },
{ where: { workstationId: workstation.id, isLabelCamera: 1 } },
);
}
await link.update({ isLabelCamera: label ? 1 : 0 });
// 取消面单摄像头:这台工作台的虚拟通道(`CAM-<id>`)没用了,顺手清掉
if (!label) await this.releaseVirtualChannel(workstation.id);
// 取消面单摄像头:工作台已经没有任何面单摄像头了,虚拟通道(`CAM-<id>`)才没用了;
// 还有别的面单摄像头在用就保留(多路共用同一条上报通道)
if (!label) {
const remaining = await this.LinkCamera.count({
where: { workstationId: workstation.id, isLabelCamera: 1 },
});
if (!remaining) await this.releaseVirtualChannel(workstation.id);
}
this.ctx.logger.info(
'[workstation] 工作台 %s %s面单摄像头(camera %s)',
@ -614,7 +688,7 @@ class WorkstationService extends Service {
* 清理工作台的虚拟扫码通道(`CAM-<工作台id>`)
*
* 虚拟通道由服务端按需创建(`service/label_scan.ensureVirtualChannel`),所以下面几种情况要清掉:
* 取消面单摄像头、绑上真实扫码通道、删除工作台。
* 取消**最后一路**面单摄像头、绑上真实扫码通道、删除工作台。
* 历史扫码记录里的工作台快照是**入库时冻结**的,删掉通道不影响老记录回放。
*
* @return {Promise<number>} 解绑的绑定行数

View File

@ -53,7 +53,7 @@ npm run db:migration:generate -- create_xxx_tables # 生成迁移骨架
| `20261018230000-create-subject-tables` | 新表 `subjects` / `subject_members`;`scanners`/`nvrs`/`cameras`/`workstations`/`scan_channels`/`scan_records` 加 `subject_id`,并把已有数据回填到「每人一个主体」 || `20261019233000-drop-has-ptz-from-cameras` | 删除 `cameras.has_ptz`(预览统一显示云台面板,后端不再标记是否支持云台) |
| `20261024100000-add-workstation-login-fields` | `workstations.login_code`(登录码 `WSC-` 前缀,唯一)/ `last_active_at`(最后活跃时间)/ `idle_timeout_sec`(多少秒不活跃自动下线,团购 3600 / 散单 1800),并回填已有工作台(⚠️ `login_code` 已被 `20261028121000` 删除) |
| `20261024101000-create-workstation-login-records` | 新表 `workstation_login_records`(工作台成员登录记录,含 `(workstation_id, login_at)` 等索引) |
| `20261024102000-add-workstation-camera-label-flag` | `workstation_cameras.is_label_camera`(面单摄像头标记,仅散单工作台;一台工作台最多一路) |
| `20261024102000-add-workstation-camera-label-flag` | `workstation_cameras.is_label_camera`(面单摄像头标记;现支持一台工作台多路,散单/团购都可设) |
| `20261028120000-create-wechat-gateway-bindings` | 新表 `wechat_gateway_bindings`(微信登录网关绑定:`user_id` / `app_key` / `openid`(唯一)/ `unionid` / `bind_scene` / `last_login_at`) |
| `20261028121500-add-subject-member-temp-user` | `subject_members.temp_user_id`(扫码绑定时自动建给成员的临时账号;被已有账号继承时该账号会被删除) |
| `20261028121000-drop-workstation-login-code` | 删除 `workstations.login_code`(`WSC-` 登录码已废弃,扫码登入改走微信登录网关的一次性二维码);`workstation_login_records.login_code` 保留作历史 |

View File

@ -15,7 +15,7 @@ const instance = (data) => Object.assign(
/**
* 工作台「面单摄像头」(`workstation_cameras.is_label_camera`)
*
* 1. 散单 / 团购工作台都可以设置、取消,一台工作台只保留一路(设新的先清旧的);
* 1. 散单 / 团购工作台都可以设置、取消,**一台工作台可以设置多路**(互不清除);
* 2. 记录规则的区别在设备端(按工作台类型:散单取第一次、团购取最后一次),后端只存标记。
*/
describe('test/app/controller/workstation-camera-label.test.js', () => {
@ -88,7 +88,7 @@ describe('test/app/controller/workstation-camera-label.test.js', () => {
}, extra);
}
it('PUT .../cameras/:cameraId/label:散单设置面单摄像头(先清掉旧的)', async () => {
it('PUT .../cameras/:cameraId/label:散单设置面单摄像头(不清掉其它已设的)', async () => {
const ws = workstation(1);
const link = cameraLink();
const cleared = [];
@ -101,6 +101,7 @@ describe('test/app/controller/workstation-camera-label.test.js', () => {
cleared.push({ fields, options });
return [ 1 ];
},
async count() { return 2; },
async findAll() { return [ link ]; },
},
WorkstationScanChannel: { async findAll() { return []; } },
@ -113,10 +114,7 @@ describe('test/app/controller/workstation-camera-label.test.js', () => {
assert(res.body.data.cameras[0].isLabelCamera === 1, '设置后详情里要带 isLabelCamera=1');
assert(link.toJSON().isLabelCamera === 1, '绑定记录要落库为 1');
assert(cleared.length === 1, '设新的之前要先清掉本工作台旧的面单标记');
assert(cleared[0].fields.isLabelCamera === 0);
assert(cleared[0].options.where.workstationId === WS_ID);
assert(cleared[0].options.where.isLabelCamera === 1);
assert(cleared.length === 0, '多路面单摄像头互不影响,不能清掉其它路的标记');
});
it('PUT .../cameras/:cameraId/label:团购工作台也能设置(设备端按 wsType 决定记录规则)', async () => {
@ -132,6 +130,7 @@ describe('test/app/controller/workstation-camera-label.test.js', () => {
cleared.push({ fields, options });
return [ 1 ];
},
async count() { return 2; },
async findAll() { return [ link ]; },
},
WorkstationScanChannel: { async findAll() { return []; } },
@ -144,7 +143,7 @@ describe('test/app/controller/workstation-camera-label.test.js', () => {
assert(res.body.data.cameras[0].isLabelCamera === 1, '团购设置后详情里也要带 isLabelCamera=1');
assert(link.toJSON().isLabelCamera === 1);
assert(cleared.length === 1, '团购同样只保留一路');
assert(cleared.length === 0, '团购同样可以设置多路');
});
it('PUT .../cameras/:cameraId/label:不传 isLabelCamera = 设置;false = 取消', async () => {
@ -157,6 +156,7 @@ describe('test/app/controller/workstation-camera-label.test.js', () => {
WorkstationCamera: {
async findOne() { return link; },
async update() { return [ 1 ]; },
async count() { return 0; },
async findAll() { return [ link ]; },
},
WorkstationScanChannel: {
@ -201,6 +201,7 @@ describe('test/app/controller/workstation-camera-label.test.js', () => {
WorkstationCamera: {
async findOne() { return link; },
async update() { return [ 1 ]; },
async count() { return 0; },
async findAll() { return [ link ]; },
},
WorkstationScanChannel: {
@ -224,4 +225,37 @@ describe('test/app/controller/workstation-camera-label.test.js', () => {
assert(notified.length === 2, `设置和取消都要通知,实际 ${notified.length} 次`);
assert(notified.every(id => id === SUBJECT_ID), JSON.stringify(notified));
});
it('取消其中一路面单摄像头时,还有别的路在用 → 不清理虚拟通道', async () => {
const ws = workstation(1);
const link = cameraLink();
const released = [];
mock(app, 'model', baseModels({
Workstation: { async findByPk() { return ws; } },
WorkstationCamera: {
async findOne() { return link; },
async count() { return 1; }, // 还有另一路面单摄像头
async findAll() { return [ link ]; },
},
WorkstationScanChannel: {
async findAll() { return []; },
async destroy(options) {
released.push(options.where);
return 1;
},
async count() { return 0; },
},
ScanChannel: { async destroy() { return 1; } },
}));
const res = await withSubject(app.httpRequest()
.put(`/api/web/workstations/${WS_ID}/cameras/${CAMERA_ID}/label`)
.send({ isLabelCamera: false }))
.expect(200);
assert(link.toJSON().isLabelCamera === 0, '这一路要取消');
assert(res.body.data.cameras[0].isLabelCamera === 0);
assert(released.length === 0, '其它面单摄像头还在用虚拟通道,不能清掉');
});
});

View File

@ -0,0 +1,155 @@
'use strict';
const jwt = require('jsonwebtoken');
const { app, mock, assert } = require('egg-mock/bootstrap');
/** 伪造的 sequelize 实例(toJSON + update 直接改同一份数据) */
const instance = (data) => Object.assign(
{
toJSON: () => data,
update: async (fields) => Object.assign(data, fields),
},
data,
);
/**
* 工作台合成画布尺寸(`workstations.canvas_width/height`)
*
* 1. 绑定管理里可以改画布宽高(默认 1920×1080 不再是死的);
* 2. 改尺寸时已摆放的摄像头**按比例缩放**,保持原来的合成构图;
* 3. 宽高 160~7680、自动取偶数(ffmpeg 合成对奇数宽高不友好)。
*/
describe('test/app/controller/workstation-canvas.test.js', () => {
const me = { id: 1, username: 'admin', nickname: '小王', status: 1, passwordChangedAt: null };
const SUBJECT_ID = 5;
const WS_ID = 3;
const token = () => {
const cfg = app.config.jwt;
const signed = jwt.sign({ sub: String(me.id), typ: 'user' }, cfg.secret, {
algorithm: 'HS256',
expiresIn: 3600,
issuer: cfg.issuer,
audience: cfg.audience,
});
return `Bearer ${signed}`;
};
const withSubject = (req) => req.set('Authorization', token()).set('X-Subject-Id', String(SUBJECT_ID));
const subjectInstance = () => instance({
id: SUBJECT_ID,
name: '测试主体',
adminUserId: 1,
status: 1,
expireAt: new Date(Date.now() + 86400000),
});
const memberInstance = () => instance({
id: 11,
subjectId: SUBJECT_ID,
userId: 1,
name: 'K0012',
role: 1,
status: 1,
});
const workstation = (width = 1920, height = 1080) => instance({
id: WS_ID,
subjectId: SUBJECT_ID,
code: 'WS-01',
name: '1号工作台',
wsType: 1,
status: 1,
canvasWidth: width,
canvasHeight: height,
});
const cameraLink = (id, cameraId, layout) => instance(Object.assign({
id,
workstationId: WS_ID,
cameraId,
streamType: 0,
}, layout));
function baseModels(extra = {}) {
return Object.assign({
User: { async findByPk() { return instance(me); } },
Subject: { async findByPk() { return subjectInstance(); } },
SubjectMember: { async findOne() { return memberInstance(); } },
}, extra);
}
function mockWorkstation(ws, links = []) {
mock(app, 'model', baseModels({
Workstation: { async findByPk() { return ws; } },
WorkstationCamera: { async findAll() { return links; } },
WorkstationScanChannel: { async findAll() { return []; } },
}));
}
it('改画布尺寸 → 工作台落库 + 已摆放摄像头按比例缩放', async () => {
const ws = workstation();
const full = cameraLink(31, 21, { x: 0, y: 0, width: 1920, height: 1080 });
const corner = cameraLink(32, 22, { x: 1200, y: 0, width: 720, height: 405 });
mockWorkstation(ws, [ full, corner ]);
app.mockService('labelScan', 'notifyChanged', async () => 1);
const res = await withSubject(app.httpRequest()
.put(`/api/web/workstations/${WS_ID}`)
.send({ canvasWidth: 1280, canvasHeight: 720 }))
.expect(200);
assert(res.body.data.canvasWidth === 1280 && res.body.data.canvasHeight === 720);
assert(ws.toJSON().canvasWidth === 1280 && ws.toJSON().canvasHeight === 720, '新尺寸要落库');
assert(full.toJSON().width === 1280 && full.toJSON().height === 720, JSON.stringify(full.toJSON()));
assert(full.toJSON().x === 0 && full.toJSON().y === 0);
assert(corner.toJSON().x === 800 && corner.toJSON().y === 0, JSON.stringify(corner.toJSON()));
assert(corner.toJSON().width === 480 && corner.toJSON().height === 270, JSON.stringify(corner.toJSON()));
});
it('只改宽度 → 高度保持不变', async () => {
const ws = workstation();
const link = cameraLink(31, 21, { x: 960, y: 0, width: 960, height: 1080 });
mockWorkstation(ws, [ link ]);
app.mockService('labelScan', 'notifyChanged', async () => 1);
await withSubject(app.httpRequest()
.put(`/api/web/workstations/${WS_ID}`)
.send({ canvasWidth: 960 }))
.expect(200);
assert(ws.toJSON().canvasWidth === 960 && ws.toJSON().canvasHeight === 1080);
assert(link.toJSON().x === 480 && link.toJSON().width === 480, JSON.stringify(link.toJSON()));
assert(link.toJSON().y === 0 && link.toJSON().height === 1080, '高度不受宽度变化影响');
});
it('奇数宽高自动取偶数(ffmpeg 合成要求)', async () => {
const ws = workstation();
mockWorkstation(ws, []);
app.mockService('labelScan', 'notifyChanged', async () => 1);
await withSubject(app.httpRequest()
.put(`/api/web/workstations/${WS_ID}`)
.send({ canvasWidth: 1281, canvasHeight: 721 }))
.expect(200);
assert(ws.toJSON().canvasWidth === 1280, ws.toJSON().canvasWidth);
assert(ws.toJSON().canvasHeight === 720, ws.toJSON().canvasHeight);
});
it('画布尺寸超出范围 → 422', async () => {
const ws = workstation();
mockWorkstation(ws, []);
app.mockService('labelScan', 'notifyChanged', async () => 1);
const res = await withSubject(app.httpRequest()
.put(`/api/web/workstations/${WS_ID}`)
.send({ canvasWidth: 0 }))
.expect(422);
assert(/画布宽/.test(res.body.message), JSON.stringify(res.body));
assert(ws.toJSON().canvasWidth === 1920, '校验失败不能改库');
});
});

View File

@ -101,6 +101,50 @@ describe('test/app/service/label-scan.test.js', () => {
assert(data.warnings.length === 0);
});
it('同一工作台多路面单摄像头 → 每路各下发一条(共用上报通道)', async () => {
mockModels({
workstations: [ workstation(2, '散单1号', 1) ],
links: [
cameraLink(11, 2, { id: 12, name: '面单特写A', channelNo: 64 }),
cameraLink(12, 2, { id: 13, name: '面单特写B', channelNo: 65 }),
],
channels: [ channelLink(2, 7, '2', '测试安卓') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.configOf(scanner);
assert(data.items.length === 2, JSON.stringify(data.items));
assert(data.items.every(item => item.workstationId === 2), '两路都属于同一个工作台');
assert(data.items.every(item => item.channelId === '2'), '识别结果共用本机的扫码通道');
assert(data.items.map(item => item.cameraId).join(',') === '12,13');
assert(data.items.every(item => item.virtualChannel === false));
assert(data.warnings.length === 0);
});
it('多路面单摄像头 + 没接扫码枪 → 共用虚拟通道,名字用工作台名', async () => {
mockModels({
workstations: [ workstation(2, '散单1号', 1) ],
links: [
cameraLink(11, 2, { id: 12, name: '面单特写A', channelNo: 64 }),
cameraLink(12, 2, { id: 13, name: '面单特写B', channelNo: 65 }),
],
channels: [],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.configOf(scanner);
assert(data.items.length === 2, JSON.stringify(data.items));
assert(data.items.every(item => item.channelId === 'CAM-2'), JSON.stringify(data.items));
assert(
data.items.every(item => item.channelName === '面单摄像头·散单1号'),
'多路共用一个通道名,用工作台名避免互相覆盖',
);
assert(data.channels.length === 1 && data.channels[0].channelId === 'CAM-2', JSON.stringify(data.channels));
assert(data.warnings.length === 0);
});
it('工作台没绑本机通道 → 用虚拟通道 CAM-<工作台id> 上报(摄像头替代扫码枪)', async () => {
mockModels({
workstations: [ workstation(2, '散单1号', 1) ],

View File

@ -929,7 +929,7 @@ ffmpeg(RTSP, tcp) → 灰度 rawvideo 帧 → 读帧线程只留最新一帧(
### 摄像头识别结果 → 记录 + 安卓播报通知
在「工作台 → 绑定管理」里把某路摄像头设为**面单摄像头**(每个工作台只保留一路,散单/团购都能设)后,识别到的条码
在「工作台 → 绑定管理」里把某路摄像头设为**面单摄像头**(每个工作台可以设多路,散单/团购都能设)后,识别到的条码
统一走 `ScanService.ReportCameraScanAsync(channelId, channelName, code, wsType)`。
**与扫码枪的差别(现场场景:面单放进拍摄区 → 开始打包 → 打包完才取走)**:
@ -950,7 +950,7 @@ ffmpeg(RTSP, tcp) → 灰度 rawvideo 帧 → 读帧线程只留最新一帧(
| 扫码枪 | 同样取**第一次** + 立即上报(`DeviceService.ReportFirstSeen`,5 秒内重复算一次) | 静默 5 秒、取**最后一次**(不变) |
**工作台没接扫码枪也能用**(摄像头完全替代扫码枪):服务端会给这种工作台一条**虚拟通道**
`CAM-<工作台id>`(名字 `面单摄像头·<摄像头名>`),下发的 `items[].virtualChannel = true`。
`CAM-<工作台id>`(名字 `面单摄像头·<摄像头名>`;同一工作台多路时用 `面单摄像头·<工作台名>`),下发的 `items[].virtualChannel = true`。
设备端照常上报即可,差别只有:
- 通道名从配置里取(`LabelScanMonitor.ChannelNameOf`),因为 `CAM-` 不在本机 `channels.json` 里;

View File

@ -97,7 +97,7 @@ export interface WorkstationCameraLink {
/** 0 主码流 1 子码流 */
streamType?: number;
zIndex?: number;
/** 1 = 面单摄像头(散单/团购都能设,一台工作台最多一路) */
/** 1 = 面单摄像头(散单/团购都能设,一台工作台可以有多路) */
isLabelCamera?: number;
camera?: (Camera & { displayName?: string }) | null;
}

View File

@ -201,6 +201,10 @@ export function updateWorkstation(id: number, body: {
idleTimeoutSec?: number;
remark?: string;
status?: number;
/** 合成画布宽(像素,160~7680,偶数);改了会按比例缩放已摆放的摄像头 */
canvasWidth?: number;
/** 合成画布高(像素,160~7680,偶数) */
canvasHeight?: number;
}): Promise<Workstation> {
return api.put<Workstation>(`/api/web/workstations/${id}`, body);
}
@ -234,7 +238,7 @@ export function updateWorkstationCameraLayout(id: number, cameraId: number, patc
return api.put<WorkstationDetail>(`/api/web/workstations/${id}/cameras/${cameraId}/layout`, patch);
}
/** 设置 / 取消某路摄像头为面单摄像头(仅散单工作台) */
/** 设置 / 取消某路摄像头为面单摄像头(散单/团购都可以,一台工作台可以设置多路) */
export function setWorkstationLabelCamera(
id: number,
cameraId: number,

View File

@ -2,7 +2,7 @@
/**
* 工作台「合成画面」布局画布
*
* 一个工作台绑定的多个摄像头,要按矩形拼成一张 1920×1080 的输出画面
* 一个工作台绑定的多个摄像头,要按矩形拼成一张输出画面(画布尺寸由工作台配置,默认 1920×1080)
* (后续按这个布局分别拉流录制/合成),所以这里做:
* - 按画布坐标绝对定位每个摄像头(拖拽移动、右下角拖拽缩放)
* - 每块可选「主码流 / 子码流」、可改宽高(选中后在右侧面板里调)
@ -130,6 +130,9 @@ watch(() => props.links, (value) => {
void syncPreviews();
}, { immediate: true, deep: true });
// 画布宽变了(工作台绑定管理里改尺寸)→ 重新按容器宽度等比缩放,避免新画布溢出/缩不满
watch(canvasW, () => measure());
// ---------------- 实时预览 ----------------
async function credentialOf(nvrId: number) {
if (!nvrId) return null;

View File

@ -157,6 +157,9 @@ const detailOpen = ref(false);
const detail = ref<WorkstationDetail | null>(null);
const detailLoading = ref(false);
const detailError = ref('');
/** 画布尺寸草稿:改完点「应用」才保存,避免输入过程中画布跟着抖 */
const canvasDraft = reactive({ width: 1920, height: 1080 });
const canvasSaving = ref(false);
const cameraOptions = ref<Camera[]>([]);
const scanOptions = ref<AvailableScanChannel[]>([]);
@ -212,6 +215,7 @@ async function openDetail(item: Workstation) {
detailLoading.value = true;
try {
detail.value = await fetchWorkstation(item.id);
syncCanvasDraft();
} catch (err) {
detailError.value = err instanceof ApiError ? err.message : '加载失败';
} finally {
@ -219,6 +223,47 @@ async function openDetail(item: Workstation) {
}
}
/** 把当前详情里的画布尺寸同步到草稿 */
function syncCanvasDraft() {
canvasDraft.width = Number(detail.value?.canvasWidth) || 1920;
canvasDraft.height = Number(detail.value?.canvasHeight) || 1080;
}
/**
* 保存画布尺寸
*
* 后端会把已摆放的摄像头按比例缩放;保存后重新拉详情,拿到新的坐标/尺寸。
*/
async function saveCanvasSize() {
if (!detail.value) return;
const width = Math.round(Number(canvasDraft.width) || 0);
const height = Math.round(Number(canvasDraft.height) || 0);
if (width < 160 || width > 7680 || height < 160 || height > 7680) {
detailError.value = '画布宽高必须在 160~7680 像素之间';
return;
}
if (width === (Number(detail.value.canvasWidth) || 1920)
&& height === (Number(detail.value.canvasHeight) || 1080)) {
okMsg.value = '画布尺寸没有变化';
return;
}
canvasSaving.value = true;
detailError.value = '';
try {
await updateWorkstation(detail.value.id, { canvasWidth: width, canvasHeight: height });
detail.value = await fetchWorkstation(detail.value.id);
syncCanvasDraft();
await load();
okMsg.value = `画布尺寸已改为 ${canvasDraft.width}×${canvasDraft.height}`;
} catch (err) {
detailError.value = err instanceof ApiError ? err.message : '画布尺寸保存失败';
} finally {
canvasSaving.value = false;
}
}
async function openCameraPicker() {
showCameraPicker.value = true;
pickedCameras.value = new Set();
@ -229,7 +274,6 @@ async function openCameraPicker() {
detailError.value = err instanceof ApiError ? err.message : '摄像头列表加载失败';
}
}
async function openScanPicker() {
showScanPicker.value = true;
pickedChannels.value = new Set();
@ -337,7 +381,7 @@ function onLayoutChanged(data: WorkstationDetail) {
detail.value = data;
}
/** 设置 / 取消面单摄像头(一台工作台只保留一路,设新的会自动取消旧的) */
/** 设置 / 取消面单摄像头(一台工作台可以设置多路,互不影响) */
async function toggleLabelCamera(link: WorkstationCameraLink) {
if (!detail.value) return;
const next = Number(link.isLabelCamera) !== 1;
@ -734,6 +778,17 @@ onBeforeUnmount(() => {
</span>
</header>
<div class="canvas-size">
<span class="canvas-size-label">画布尺寸</span>
<input v-model.number="canvasDraft.width" type="number" min="160" max="7680" step="2" />
<span class="canvas-size-x">×</span>
<input v-model.number="canvasDraft.height" type="number" min="160" max="7680" step="2" />
<span class="hint">像素(160~7680,偶数);修改后已摆放的摄像头会按比例缩放</span>
<button class="btn btn-sm" :disabled="canvasSaving" @click="saveCanvasSize">
{{ canvasSaving ? '保存中…' : '应用' }}
</button>
</div>
<div v-if="showCameraPicker" class="picker">
<p class="hint">一个摄像头只能属于一个工作台;已被其他工作台绑定的不可选,请先在那台工作台解绑。</p>
<div class="picker-list">
@ -772,14 +827,14 @@ onBeforeUnmount(() => {
/>
<p class="hint">
面单摄像头:从已绑定的摄像头里选一路正对运单的画面;设置新的会自动取消其他摄像头的面单标记
(一台工作台只保留一路)。散单识别取「第一次」时间并立即上报;团购和扫码枪一样,静默 5 秒后取「最后一次」。
面单摄像头:从已绑定的摄像头里选正对运单的画面,可以同时设置多路(多机位各识别各的)。
散单识别取「第一次」时间并立即上报;团购和扫码枪一样,静默 5 秒后取「最后一次」。
没有绑定扫码通道也能用:会自动占一条虚拟通道 <code>CAM-工作台id</code> 来上报识别结果。
</p>
<p v-if="labelCameraWithoutChannel" class="label-note">
ℹ 这个工作台没有绑定扫码通道,面单摄像头会自动占一条虚拟通道
<code>CAM-{{ detail.id }}</code>(名称「面单摄像头·摄像头名」)用来上报识别结果,
<code>CAM-{{ detail.id }}</code>(名称「面单摄像头·摄像头名」,多路时为「面单摄像头·工作台名」)用来上报识别结果,
无需扫码枪也能用;识别到的条码不会通知安卓端播报(没有对应的扫码工位)。
</p>
@ -1024,6 +1079,33 @@ onBeforeUnmount(() => {
border-left: 3px solid #3b82f6;
}
/* 画布尺寸(绑定管理里可改;保存时后端按比例缩放已摆放的摄像头) */
.canvas-size {
display: flex;
align-items: center;
gap: 8px;
flex-wrap: wrap;
margin: 0 0 10px;
padding: 8px 10px;
border: 1px dashed #cbd5e1;
border-radius: 8px;
background: #f8fafc;
}
.canvas-size-label {
font-size: 13px;
font-weight: 600;
color: #334155;
}
.canvas-size input {
width: 88px;
}
.canvas-size-x {
color: #64748b;
}
.scan-section {
border-left: 3px solid #10b981;
}
@ -1149,7 +1231,7 @@ onBeforeUnmount(() => {
font-weight: 600;
}
/* 面单摄像头标记(仅散单工作台) */
/* 面单摄像头标记(散单/团购都可以,一台工作台可多路) */
.label-tag {
flex: none;
padding: 1px 6px;