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

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-08 23:45:25 +08:00

451 lines
19 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 { app, mock, assert } = require('egg-mock/bootstrap');
/**
* 面单摄像头识别配置(`service/label_scan`)
*
* 覆盖三件最容易错的事:
* 1. **散单和团购都支持**面单摄像头,但记录规则不同(下发 `wsType`,由设备端决定);
* 2. **上报通道只认本机的**:别的设备的通道不能用来上报(服务端按 scanner+channel 找工作台快照);
* 工作台没接扫码枪时自动用虚拟通道 `CAM-<工作台id>`;
* 3. **缺条件要给提示**(录像机没密码等),不能让设备端拿到半份配置。
*/
describe('test/app/service/label-scan.test.js', () => {
const subjectId = 1;
const scanner = { id: 7, subjectId, sn: 'MINGREN' };
const instance = (data) => Object.assign({
toJSON: () => data,
update: async (fields) => Object.assign(data, fields),
}, data);
const workstation = (id, name, wsType) => instance({ id, code: `WS-${id}`, name, wsType, status: 1 });
const cameraLink = (id, workstationId, camera) => instance({
id,
workstationId,
cameraId: camera.id,
streamType: 0,
isLabelCamera: 1,
camera: instance({
id: camera.id,
name: camera.name,
channelNo: camera.channelNo,
enabled: 1,
status: 1,
nvr: instance({ id: 1, name: '录像机1', host: '192.168.8.241', port: 8000, username: 'admin' }),
}),
});
const channelLink = (workstationId, scannerId, channelId, channelName, sortNo = 1) =>
instance({ id: workstationId * 10 + sortNo, workstationId, scannerId, channelId, channelName, sortNo });
/** 录像机密码(测试里按需改) */
let nvrPassword = 'p@ss';
// ⚠️ 每个用例都要重新 mock:egg-mock 会在用例结束后把 mock 还原
beforeEach(() => {
nvrPassword = 'p@ss';
app.mockService('nvr', 'passwordOf', () => nvrPassword);
});
function mockModels({ workstations, links, channels, disabled = [], disabledLinks = [] }) {
mock(app, 'model', {
Workstation: {
// 主查询是 status: 1;停用工作台那条是 status: { [Op.ne]: 1 }(对象,不是数字)
async findAll(options = {}) {
const status = options.where && options.where.status;
return typeof status === 'number' && Number(status) === 1 ? workstations : disabled;
},
},
WorkstationCamera: {
// 主查询带 include(录像机/摄像头),停用工作台那条只查 workstationId
async findAll(options = {}) {
return options.include ? links : disabledLinks;
},
},
WorkstationScanChannel: {
async findAll() { return channels; },
async findOrCreate({ defaults }) {
return [ instance(Object.assign({}, defaults)), true ];
},
},
ScanChannel: {
async findOne() { return null; },
async create(fields) { return instance(fields); },
},
Nvr: { async findByPk() { return instance({ id: 1, name: '录像机1', host: '192.168.8.241', passwordEnc: 'x' }); } },
});
}
it('散单工作台 → 下发一路(工作台/摄像头/上报通道/录像机凭据)', async () => {
mockModels({
workstations: [ workstation(2, '散单1号', 1) ],
links: [ cameraLink(11, 2, { id: 12, name: '测试散单面单', channelNo: 64 }) ],
channels: [ channelLink(2, 7, '2', '测试安卓') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.configOf(scanner);
assert(data.items.length === 1, JSON.stringify(data));
const item = data.items[0];
assert(item.workstationId === 2 && item.workstationName === '散单1号');
assert(item.channelId === '2' && item.channelName === '测试安卓');
assert(item.virtualChannel === false, '绑了真实扫码枪就不是虚拟通道');
assert(item.cameraId === 12 && item.cameraChannelNo === 64);
assert(item.streamType === 0);
assert(item.nvr.host === '192.168.8.241' && item.nvr.password === 'p@ss', '要带凭据给设备拉流');
assert(/^sha1:[0-9a-f]{16}$/.test(data.revision), data.revision);
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) ],
links: [ cameraLink(11, 2, { id: 12, name: '测试散单面单', channelNo: 64 }) ],
channels: [], // 本机没有绑任何通道
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.configOf(scanner);
assert(data.items.length === 1, JSON.stringify(data));
const item = data.items[0];
assert(item.channelId === 'CAM-2', item.channelId);
assert(item.channelName === '面单摄像头·测试散单面单', item.channelName);
assert(item.virtualChannel === true, '要标记成虚拟通道,设备端不用去找本机通道');
// 虚拟通道也要进 channels:设备端靠它判断走「取第一次」还是「取最后一次」
assert(data.channels.some(row => row.channelId === 'CAM-2' && row.wsType === 1), JSON.stringify(data.channels));
assert(data.warnings.length === 0, '不需要报警:摄像头自己就是一条通道');
});
it('历史遗留的虚拟通道绑定 → 仍按虚拟通道下发(不会当成真实扫码枪)', async () => {
mockModels({
workstations: [ workstation(2, '散单1号', 1) ],
links: [ cameraLink(11, 2, { id: 12, name: '测试散单面单', channelNo: 64 }) ],
// 上一轮拉配置时自愈出来的绑定,会被当成「本机通道」查出来
channels: [ channelLink(2, 7, 'CAM-2', '面单摄像头·测试散单面单') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.configOf(scanner);
assert(data.items.length === 1, JSON.stringify(data));
assert(data.items[0].channelId === 'CAM-2');
assert(data.items[0].virtualChannel === true);
assert(data.channels.length === 1 && data.channels[0].channelId === 'CAM-2');
});
it('录像机没密码 → 不下发,给提示', async () => {
mockModels({
workstations: [ workstation(2, '散单1号', 1) ],
links: [ cameraLink(11, 2, { id: 12, name: '测试散单面单', channelNo: 64 }) ],
channels: [ channelLink(2, 7, '2', '测试安卓') ],
});
nvrPassword = '';
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.configOf(scanner);
assert(data.items.length === 0);
assert(/没有保存密码/.test(data.warnings[0].message), data.warnings[0].message);
nvrPassword = 'p@ss';
});
it('摄像头已停用 → 不下发,给提示(现场「配了面单但列表里没有」就是这条)', async () => {
const disabled = cameraLink(11, 2, { id: 12, name: '测试散单面单', channelNo: 64 });
disabled.camera.status = 0; // 摄像头管理里停用
mockModels({
workstations: [ workstation(2, '散单1号', 1) ],
links: [ disabled ],
channels: [],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.configOf(scanner);
assert(data.items.length === 0, JSON.stringify(data.items));
assert(data.warnings.length === 1, JSON.stringify(data.warnings));
assert(/已停用/.test(data.warnings[0].message), data.warnings[0].message);
assert(data.warnings[0].workstationId === 2);
});
it('工作台已停用 → 不下发,给提示(现场「配了面单但列表里没有」的另一条原因)', async () => {
mockModels({
workstations: [],
links: [],
channels: [],
disabled: [ instance({ id: 8, code: 'WS-8', name: '旧工作台', status: 0 }) ],
disabledLinks: [ instance({ workstationId: 8 }) ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.configOf(scanner);
assert(data.items.length === 0);
assert(data.warnings.length === 1, JSON.stringify(data.warnings));
assert(data.warnings[0].workstationId === 8);
assert(/已停用/.test(data.warnings[0].message), data.warnings[0].message);
});
it('cameras.enabled = 0(导入通道时的快照)不影响下发:只有 status 是开关', async () => {
const stale = cameraLink(11, 2, { id: 12, name: '后来才装的摄像头', channelNo: 64 });
stale.camera.enabled = 0; // 导入通道时 NVR 上还没有摄像头,后来才装(预览正常但字段一直是 0)
mockModels({
workstations: [ workstation(2, '散单1号', 1) ],
links: [ stale ],
channels: [ channelLink(2, 7, '2', '测试安卓') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.configOf(scanner);
assert(data.items.length === 1, JSON.stringify(data.items));
assert(data.items[0].cameraEnabled === true, 'status=1 就要下发,别被 enabled 快照挡住');
assert(data.warnings.length === 0);
});
it('revision 随内容变化(改通道 / 改密码都会变)', async () => {
mockModels({
workstations: [ workstation(2, '散单1号', 1) ],
links: [ cameraLink(11, 2, { id: 12, name: '测试散单面单', channelNo: 64 }) ],
channels: [ channelLink(2, 7, '2', '测试安卓') ],
});
const ctx = app.createAnonymousContext();
const first = await ctx.service.labelScan.configOf(scanner);
nvrPassword = 'another';
const second = await ctx.service.labelScan.configOf(scanner);
nvrPassword = 'p@ss';
assert(first.revision !== second.revision, '密码变了必须换 revision,设备才会重建');
});
describe('notifyChanged(配置变了要立刻叫醒设备,别等兜底轮询)', () => {
it('按主体给每台启用中的设备入队 labelScan.refresh', async () => {
const enqueued = [];
app.mockService('edgeTask', 'enqueue', async (scannerId, type, payload) => {
enqueued.push({ scannerId, type, payload });
return { id: `task-${scannerId}` };
});
mock(app, 'model', {
Scanner: {
async findAll({ where }) {
assert(where.subjectId === 1 && where.status === 1, '只通知本主体启用中的设备');
return [ { id: 7 }, { id: 9 } ];
},
},
});
const ctx = app.createAnonymousContext();
const count = await ctx.service.labelScan.notifyChanged(1);
assert(count === 2, `应通知 2 台,实际 ${count}`);
assert(enqueued.length === 2, JSON.stringify(enqueued));
assert(enqueued.every(item => item.type === 'labelScan.refresh'), '任务类型必须是设备端认识的 labelScan.refresh');
assert(enqueued.map(item => item.scannerId).join(',') === '7,9');
});
it('没有主体 id 时什么都不做(不查库、不入队)', async () => {
let enqueued = 0;
let queried = false;
app.mockService('edgeTask', 'enqueue', async () => { enqueued++; });
mock(app, 'model', {
Scanner: { async findAll() { queried = true; return []; } },
});
const ctx = app.createAnonymousContext();
const count = await ctx.service.labelScan.notifyChanged(0);
assert(count === 0);
assert(enqueued === 0 && queried === false);
});
it('入队失败不抛错(配置已落库,不能因为通知失败回滚)', async () => {
app.mockService('edgeTask', 'enqueue', async () => { throw new Error('redis down'); });
mock(app, 'model', { Scanner: { async findAll() { return [ { id: 7 } ]; } } });
const ctx = app.createAnonymousContext();
const count = await ctx.service.labelScan.notifyChanged(1);
assert(count === 0, '失败返回 0,不向调用方抛异常');
});
});
});
/**
* 工作台 OSD 字幕配置(`service/label_scan#workstationConfigOf`)
*
* 设备端要把「摄像头名 + 运单号」写到录像机通道的 OSD(= 通道名),
* 所以这里必须给全:**本机负责的工作台**、工作台的全部摄像头、每路摄像头的录像机凭据。
*/
describe('test/app/service/label-scan.test.js - workstationConfigOf', () => {
const subjectId = 1;
const scanner = { id: 7, subjectId, sn: 'MINGREN' };
const instance = (data) => Object.assign({
toJSON: () => data,
update: async (fields) => Object.assign(data, fields),
}, data);
const workstation = (id, name, wsType = 1) => instance({ id, code: `WS-${id}`, name, wsType, status: 1 });
const cameraLink = (workstationId, camera) => instance({
id: camera.id * 100,
workstationId,
cameraId: camera.id,
streamType: 0,
isLabelCamera: 0,
camera: instance({
id: camera.id,
name: camera.name,
channelNo: camera.channelNo,
status: camera.status === undefined ? 1 : camera.status,
nvr: instance({ id: 1, name: '录像机1', host: '192.168.8.241', port: 8000, username: 'admin' }),
}),
});
const channelLink = (workstationId, channelId, channelName) =>
instance({ id: 1, workstationId, scannerId: 7, channelId, channelName, sortNo: 1 });
let nvrPassword = 'p@ss';
beforeEach(() => {
nvrPassword = 'p@ss';
app.mockService('nvr', 'passwordOf', () => nvrPassword);
});
function mockModels({ workstations, links, channels }) {
mock(app, 'model', {
Workstation: { async findAll() { return workstations; } },
WorkstationScanChannel: { async findAll() { return channels; } },
WorkstationCamera: { async findAll() { return links; } },
Nvr: { async findByPk() { return instance({ id: 1, name: '录像机1', host: '192.168.8.241', passwordEnc: 'x' }); } },
});
}
it('工作台 + 全部摄像头(含名称/通道号/录像机凭据)', async () => {
mockModels({
workstations: [ workstation(2, '2号线') ],
links: [
cameraLink(2, { id: 11, name: '2号线面单', channelNo: 45 }),
cameraLink(2, { id: 12, name: '2号线全景', channelNo: 46 }),
],
channels: [ channelLink(2, 'CH1', '2号线扫码枪') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.workstationConfigOf(scanner);
assert(data.items.length === 1, JSON.stringify(data));
const item = data.items[0];
assert(item.workstationId === 2 && item.workstationName === '2号线');
assert(item.channels.length === 1 && item.channels[0].channelId === 'CH1');
assert(item.cameras.length === 2, JSON.stringify(item.cameras));
const camera = item.cameras.find(row => row.cameraId === 11);
assert(camera.cameraName === '2号线面单' && camera.cameraChannelNo === 45);
assert(camera.nvr.host === '192.168.8.241' && camera.nvr.password === 'p@ss');
assert(/^sha1:[0-9a-f]{16}$/.test(data.revision), data.revision);
assert(data.warnings.length === 0);
});
it('没绑本机通道的工作台不下发(扫码事件到不了这台设备)', async () => {
mockModels({
workstations: [ workstation(2, '2号线'), workstation(3, '3号线') ],
links: [
cameraLink(2, { id: 11, name: '2号线面单', channelNo: 45 }),
cameraLink(3, { id: 13, name: '3号线面单', channelNo: 55 }),
],
channels: [ channelLink(3, 'CH9', '9号枪') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.workstationConfigOf(scanner);
assert(data.items.length === 1, JSON.stringify(data));
assert(data.items[0].workstationId === 3);
});
it('停用的摄像头不写 OSD,并给提示', async () => {
mockModels({
workstations: [ workstation(2, '2号线') ],
links: [
cameraLink(2, { id: 11, name: '2号线面单', channelNo: 45 }),
cameraLink(2, { id: 12, name: '2号线全景', channelNo: 46, status: 0 }),
],
channels: [ channelLink(2, 'CH1', '2号线扫码枪') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.workstationConfigOf(scanner);
assert(data.items[0].cameras.length === 1, JSON.stringify(data.items[0].cameras));
assert(data.items[0].cameras[0].cameraId === 11);
assert(data.warnings.some(row => /已停用/.test(row.message)), JSON.stringify(data.warnings));
});
it('录像机没有密码 → 该路不下发(设备端写不了 OSD)', async () => {
nvrPassword = '';
mockModels({
workstations: [ workstation(2, '2号线') ],
links: [ cameraLink(2, { id: 11, name: '2号线面单', channelNo: 45 }) ],
channels: [ channelLink(2, 'CH1', '2号线扫码枪') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.workstationConfigOf(scanner);
assert(data.items.length === 0, JSON.stringify(data.items));
assert(data.warnings.some(row => /没有保存密码/.test(row.message)), JSON.stringify(data.warnings));
});
});