From f8aa4c4899eebde36f563cc6196816c1c899522e Mon Sep 17 00:00:00 2001 From: liufumingren Date: Thu, 29 Oct 2026 17:19:24 +0800 Subject: [PATCH] =?UTF-8?q?feat(=E5=B7=A5=E4=BD=9C=E5=8F=B0):=20=E6=88=90?= =?UTF-8?q?=E5=91=98=E6=89=AB=E7=A0=81=E7=99=BB=E5=85=A5=E3=80=81=E9=9D=A2?= =?UTF-8?q?=E5=8D=95=E6=91=84=E5=83=8F=E5=A4=B4=E4=B8=8E=E8=99=9A=E6=8B=9F?= =?UTF-8?q?=E9=80=9A=E9=81=93?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 工作台成员扫码登入:workstation_login_records 记录谁在什么时候登入/下线了哪台工作台, 超时(团购 1h / 散单 30min)由 schedule/workstation_idle_offline 自动下线; 运单查询的 packers 取当时的登入成员 - 面单摄像头识别:workstation_cameras.is_label_camera + service/label_scan 下发本机该跑的识别配置, 设备端(桌面端 LabelScan 工作线程)按配置做面单识别并上报 - 虚拟通道 CAM-<工作台id>:工作台没接扫码枪时,面单摄像头那一路顶替扫码枪上报,records 规则按 ws_type 区分 - 桌面端:新增 LabelScanMonitor/LabelScanWorker/ScanDeviceKind 与面单预览页,扫描通道支持改名,静默窗口 5s Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- backend/app/controller/device/scan.js | 16 + backend/app/controller/web/workstation.js | 134 +- backend/app/lib/virtual-channel.js | 33 + backend/app/lib/workstation-snapshot.js | 2 + backend/app/model/workstation.js | 8 +- backend/app/model/workstation_camera.js | 3 + backend/app/model/workstation_login_record.js | 45 + .../app/schedule/workstation_idle_offline.js | 34 + backend/app/service/camera.js | 18 + backend/app/service/label_scan.js | 310 +++++ backend/app/service/pack.js | 13 + backend/app/service/workstation.js | 218 ++- backend/app/service/workstation_login.js | 396 ++++++ ...1024100000-add-workstation-login-fields.js | 99 ++ ...101000-create-workstation-login-records.js | 81 ++ ...02000-add-workstation-camera-label-flag.js | 23 + .../workstation-camera-label.test.js | 227 +++ .../app/controller/workstation-login.test.js | 246 ++++ backend/test/app/service/label-scan.test.js | 213 +++ desktop/App.xaml.cs | 90 +- desktop/MainWindow.xaml | 4 + desktop/MainWindow.xaml.cs | 8 +- desktop/Services/Agent/AgentFiles.cs | 133 +- desktop/Services/Agent/AgentHost.cs | 66 +- desktop/Services/DeviceService.cs | 77 ++ desktop/Services/Scan/ChannelConnection.cs | 168 +++ desktop/Services/Scan/DeviceScanner.cs | 6 + desktop/Services/Scan/LabelScanMonitor.cs | 420 ++++++ desktop/Services/Scan/LabelScanWorker.cs | 1221 +++++++++++++++++ desktop/Services/Scan/ScanChannel.cs | 10 + desktop/Services/Scan/ScanDeviceKind.cs | 30 + desktop/Services/Scan/ScanRecordStore.cs | 114 +- desktop/Services/Scan/ScanService.cs | 338 ++++- desktop/Services/SingleInstance.cs | 10 +- desktop/Views/AddChannelWindow.xaml | 7 +- desktop/Views/AddChannelWindow.xaml.cs | 16 + desktop/Views/LabelCameraView.xaml | 75 + desktop/Views/LabelCameraView.xaml.cs | 252 ++++ desktop/Views/ScanTabView.xaml | 31 +- desktop/Views/ScanTabView.xaml.cs | 5 +- desktop/YuncangTrace.LocalService.csproj | 15 +- frontend/src/api/video.ts | 32 + frontend/src/api/videoApi.ts | 84 ++ frontend/src/views/WorkstationsView.vue | 473 ++++++- 44 files changed, 5709 insertions(+), 95 deletions(-) create mode 100644 backend/app/lib/virtual-channel.js create mode 100644 backend/app/model/workstation_login_record.js create mode 100644 backend/app/schedule/workstation_idle_offline.js create mode 100644 backend/app/service/label_scan.js create mode 100644 backend/app/service/workstation_login.js create mode 100644 backend/database/migrations/20261024100000-add-workstation-login-fields.js create mode 100644 backend/database/migrations/20261024101000-create-workstation-login-records.js create mode 100644 backend/database/migrations/20261024102000-add-workstation-camera-label-flag.js create mode 100644 backend/test/app/controller/workstation-camera-label.test.js create mode 100644 backend/test/app/controller/workstation-login.test.js create mode 100644 backend/test/app/service/label-scan.test.js create mode 100644 desktop/Services/Scan/LabelScanMonitor.cs create mode 100644 desktop/Services/Scan/LabelScanWorker.cs create mode 100644 desktop/Services/Scan/ScanDeviceKind.cs create mode 100644 desktop/Views/LabelCameraView.xaml create mode 100644 desktop/Views/LabelCameraView.xaml.cs diff --git a/backend/app/controller/device/scan.js b/backend/app/controller/device/scan.js index c5a5cf1..2c83574 100644 --- a/backend/app/controller/device/scan.js +++ b/backend/app/controller/device/scan.js @@ -93,6 +93,22 @@ class ScanController extends Controller { }); ctx.body = { ok: true, data }; } + /** + * GET /api/scanner/label-cameras —— 本机该跑的**面单摄像头识别配置**(需长期 JWT) + * + * 只返回本主体、散单、启用中的工作台里被设为「面单摄像头」的那几路, + * 附上报通道与录像机凭据(RTSP 路径由设备端按录像机起始数字通道推算)。 + * `revision` 是内容指纹:变了设备端就重建识别任务。 + */ + async labelCameras() { + const { ctx } = this; + const data = await ctx.service.labelScan.configOf(ctx.state.scanner); + ctx.logger.info( + '[label-scan] 设备 %s 拉取面单配置:%d 路(warning %d)', + ctx.state.scanner.sn, data.items.length, data.warnings.length, + ); + ctx.body = { ok: true, data }; + } } module.exports = ScanController; diff --git a/backend/app/controller/web/workstation.js b/backend/app/controller/web/workstation.js index 82b6608..00ecd26 100644 --- a/backend/app/controller/web/workstation.js +++ b/backend/app/controller/web/workstation.js @@ -17,6 +17,16 @@ function toId(value) { * - `POST /:id/scan-channels` { items: [{ scannerId, channelId, channelName? }] } 追加绑定 * - `DELETE /:id/scan-channels/:linkId` 解绑(按绑定记录 id) * - `GET /api/web/workstation-scan-channels` 可绑定通道选择器 + * + * 成员登录(扫码登入工作台,见 `service/workstation_login.js` / `service/wx_gateway.js`): + * - `POST /:id/login-qr` 生成一张扫码登入二维码(微信登录网关,一次性) + * - `GET /:id/login-qr/status?state=&wait=` 长轮询扫码结果(确认后返回登录的成员) + * - `GET /:id/members?status=&page=&pageSize=` 当前/历史成员(`status=1` 只看在线) + * - `POST /:id/members/:recordId/offline` 手动下线某个成员 + * - `POST /:id/members/offline-all` 把该工作台所有在线成员下线 + * + * ⚠️ 旧的「工作台登录码」(`WSC-`)与 `POST /api/web/workstation-login` 已废弃: + * 现场登入改为「按需生成二维码 → 微信扫码确认」。 */ class WebWorkstationController extends Controller { /** GET /api/web/workstations?page=&pageSize=&keyword=&status=&wsType= */ @@ -45,10 +55,10 @@ class WebWorkstationController extends Controller { ctx.body = { ok: true, data: await ctx.service.workstation.detail(id, ctx.state.subjectId) }; } - /** POST /api/web/workstations —— { name?, wsType?, recordBeforeSec?, recordAfterSec?, recordMaxSec?, remark? } */ + /** POST /api/web/workstations —— { name?, wsType?, recordBeforeSec?, recordAfterSec?, recordMaxSec?, idleTimeoutSec?, remark? } */ async create() { const { ctx } = this; - const { code, name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, remark } = ctx.request.body || {}; + const { code, name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, idleTimeoutSec, remark } = ctx.request.body || {}; const data = await ctx.service.workstation.create({ subjectId: ctx.state.subjectId, @@ -59,6 +69,7 @@ class WebWorkstationController extends Controller { recordBeforeSec, recordAfterSec, recordMaxSec, + idleTimeoutSec, remark, }); @@ -72,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, remark, status } = ctx.request.body || {}; + const { name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, idleTimeoutSec, remark, status } = ctx.request.body || {}; const data = await ctx.service.workstation.update(id, ctx.state.subjectId, { - name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, remark, status, + name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, idleTimeoutSec, remark, status, }); ctx.body = { ok: true, data }; } @@ -144,6 +155,29 @@ class WebWorkstationController extends Controller { ctx.body = { ok: true, data }; } + /** + * PUT /api/web/workstations/:id/cameras/:cameraId/label + * body: { isLabelCamera?: boolean }(不传 = 设为面单摄像头) + * + * 仅散单工作台可设置,一台工作台最多一路。 + */ + async setLabelCamera() { + const { ctx } = this; + const id = toId(ctx.params.id); + const cameraId = toId(ctx.params.cameraId); + if (!id || !cameraId) ctx.throw(400, 'id / cameraId 必须是正整数'); + + const { isLabelCamera } = ctx.request.body || {}; + const data = await ctx.service.workstation.setLabelCamera({ + workstationId: id, + subjectId: ctx.state.subjectId, + cameraId, + isLabelCamera, + }); + + ctx.body = { ok: true, data }; + } + /** POST /api/web/workstations/:id/scan-channels —— { items: [{ scannerId, channelId, channelName? }] } */ async bindScanChannels() { const { ctx } = this; @@ -185,6 +219,98 @@ class WebWorkstationController extends Controller { }); ctx.body = { ok: true, data: { list } }; } + + /** + * POST /api/web/workstations/:id/login-qr —— 生成扫码登入二维码 + * + * 返回 `{ state, pageUrl, qrUrl, expiresIn }`:前端把 `qrUrl` 当图片显示, + * 然后拿 `state` 去 `GET /:id/login-qr/status` 长轮询。 + */ + async loginQr() { + const { ctx } = this; + const id = toId(ctx.params.id); + if (!id) ctx.throw(400, 'id 必须是正整数'); + + // 5xx 的 ctx.throw 会被统一错误处理遮成「服务器内部错误」,这里直接给明确提示 + if (!ctx.service.wxGateway.enabled) { + ctx.status = 503; + ctx.body = { ok: false, message: '未开通微信扫码登入(服务端未配置微信登录网关)' }; + return; + } + + const data = await ctx.service.workstation.createLoginQr(id, ctx.state.subjectId); + ctx.body = { ok: true, data }; + } + + /** + * GET /api/web/workstations/:id/login-qr/status?state=&wait= —— 长轮询扫码结果 + * + * `data.status`:pending(还在等扫码)/ confirmed(附登录的成员)/ failed(附原因)/ expired(重新申请二维码) + */ + async loginQrStatus() { + const { ctx } = this; + const id = toId(ctx.params.id); + if (!id) ctx.throw(400, 'id 必须是正整数'); + + // 仍然校验工作台归属:二维码能扫,但只有本主体管理员能看结果 + await ctx.service.workstation.findOwned(id, ctx.state.subjectId); + + const result = await ctx.service.wxGateway.awaitSession(String(ctx.query.state || ''), { + wait: ctx.query.wait, + }); + + if (result.status === 'aborted') { + // 客户端已经断开(关弹窗 / 换页):不用写响应 + ctx.respond = false; + return; + } + + ctx.body = { ok: true, data: result }; + } + + /** POST /api/web/workstations/:id/members/offline-all —— 把该工作台所有在线成员下线 */ + async offlineAll() { + const { ctx } = this; + const id = toId(ctx.params.id); + if (!id) ctx.throw(400, 'id 必须是正整数'); + + const data = await ctx.service.workstation.offlineAllMembers(id, ctx.state.subjectId); + ctx.body = { ok: true, data }; + } + + /** GET /api/web/workstations/:id/members?status=1&startTime=&endTime=&page=&pageSize= —— 当前 / 历史成员 */ + async members() { + const { ctx } = this; + const id = toId(ctx.params.id); + if (!id) ctx.throw(400, 'id 必须是正整数'); + + const { status, startTime, endTime, page, pageSize } = ctx.query; + const data = await ctx.service.workstationLogin.list({ + workstationId: id, + subjectId: ctx.state.subjectId, + status, + startTime, + endTime, + page, + pageSize, + }); + ctx.body = { ok: true, data }; + } + + /** POST /api/web/workstations/:id/members/:recordId/offline —— 手动下线某个成员 */ + async offlineMember() { + const { ctx } = this; + const id = toId(ctx.params.id); + const recordId = toId(ctx.params.recordId); + if (!id || !recordId) ctx.throw(400, 'id / recordId 必须是正整数'); + + const data = await ctx.service.workstationLogin.offlineOne({ + workstationId: id, + subjectId: ctx.state.subjectId, + recordId, + }); + ctx.body = { ok: true, data }; + } } module.exports = WebWorkstationController; diff --git a/backend/app/lib/virtual-channel.js b/backend/app/lib/virtual-channel.js new file mode 100644 index 0000000..d62d960 --- /dev/null +++ b/backend/app/lib/virtual-channel.js @@ -0,0 +1,33 @@ +'use strict'; + +/** + * 「纯摄像头工作台」的虚拟扫码通道 + * + * 背景:扫码记录的上报结构是「中控 + 通道」,回放定位靠 `scanner+channel → 工作台` + * 反查快照(`pack.snapshotMap`)。工作台只设了面单摄像头、没接扫码枪时, + * 识别结果没有通道可挂 → 这里给它一条虚拟通道 `CAM-<工作台id>`, + * 名字是「面单摄像头·<摄像头名>」,整条链路(上报、落库、回放定位、安卓播报)都不用特殊处理。 + * + * 约定: + * - 前缀固定 `CAM-`,和设备上报的真实通道(纯数字 / `DESKTOP`)不会冲突; + * - 虚拟通道**只由服务端维护**,设备端全量对账(`replace: true`)时必须豁免; + * - 工作台取消面单摄像头 / 改绑真实通道时,由 `workstation` 服务清理掉。 + */ + +const VIRTUAL_CHANNEL_PREFIX = 'CAM-'; + +/** 工作台 id → 虚拟通道 id */ +function virtualChannelIdOf(workstationId) { + return `${VIRTUAL_CHANNEL_PREFIX}${Number(workstationId) || 0}`; +} + +/** 是否为虚拟通道 id */ +function isVirtualChannelId(channelId) { + return String(channelId || '').toUpperCase().startsWith(VIRTUAL_CHANNEL_PREFIX); +} + +module.exports = { + VIRTUAL_CHANNEL_PREFIX, + virtualChannelIdOf, + isVirtualChannelId, +}; diff --git a/backend/app/lib/workstation-snapshot.js b/backend/app/lib/workstation-snapshot.js index 1969ac9..6720237 100644 --- a/backend/app/lib/workstation-snapshot.js +++ b/backend/app/lib/workstation-snapshot.js @@ -42,6 +42,8 @@ function buildSnapshot(workstation, link) { cameraName: camera.name || camera.channelName || `通道${camera.channelNo}`, channelNo: Number(camera.channelNo) || 0, streamType: asInt(item.streamType, 0), + /** 面单摄像头(仅散单工作台会为 1) */ + isLabelCamera: asInt(item.isLabelCamera, 0), nvrId: Number(camera.nvrId) || 0, nvrName: nvr.name || '', nvrHost: nvr.host || '', diff --git a/backend/app/model/workstation.js b/backend/app/model/workstation.js index 8a50f41..4b67e56 100644 --- a/backend/app/model/workstation.js +++ b/backend/app/model/workstation.js @@ -7,7 +7,7 @@ * `code` 是业务编号(如「1号工作台」),同一用户下唯一。 */ module.exports = (app) => { - const { BIGINT, STRING, TINYINT, INTEGER } = app.Sequelize; + const { BIGINT, STRING, TINYINT, INTEGER, DATE } = app.Sequelize; const Workstation = app.model.define('workstation', { id: { type: BIGINT.UNSIGNED, primaryKey: true, autoIncrement: true, comment: '主键' }, @@ -21,6 +21,11 @@ module.exports = (app) => { recordBeforeSec: { type: INTEGER.UNSIGNED, allowNull: false, defaultValue: 60, comment: '录制范围:触发点之前秒数' }, recordAfterSec: { type: INTEGER.UNSIGNED, allowNull: false, defaultValue: 60, comment: '录制范围:触发点之后秒数' }, recordMaxSec: { type: INTEGER.UNSIGNED, allowNull: false, defaultValue: 240, comment: '最大录制时长(秒);团购无此限制,固定存 0' }, status: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 1, comment: '状态:1启用 0停用' }, + + /** 扫码上报时刷新;配合 idleTimeoutSec 触发自动下线 */ + lastActiveAt: { type: DATE, comment: '最后活跃时间(扫码上报时刷新)' }, + idleTimeoutSec: { type: INTEGER.UNSIGNED, allowNull: false, defaultValue: 1800, comment: '多少秒不活跃自动下线所有成员(团购 3600 / 散单 1800)' }, + remark: { type: STRING(255), comment: '备注' }, // ↓ 合成画面画布(默认 1920×1080) @@ -36,6 +41,7 @@ module.exports = (app) => { app.model.Workstation.belongsTo(app.model.User, { foreignKey: 'user_id', as: 'user' }); app.model.Workstation.hasMany(app.model.WorkstationCamera, { foreignKey: 'workstation_id', as: 'cameraLinks' }); app.model.Workstation.hasMany(app.model.WorkstationScanChannel, { foreignKey: 'workstation_id', as: 'scanChannelLinks' }); + app.model.Workstation.hasMany(app.model.WorkstationLoginRecord, { foreignKey: 'workstation_id', as: 'loginRecords' }); }; return Workstation; diff --git a/backend/app/model/workstation_camera.js b/backend/app/model/workstation_camera.js index c9f7e88..9a52708 100644 --- a/backend/app/model/workstation_camera.js +++ b/backend/app/model/workstation_camera.js @@ -23,6 +23,9 @@ module.exports = (app) => { height: { type: INTEGER, allowNull: false, defaultValue: 0, comment: '高(0=整张画布)' }, 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', timestamps: true, diff --git a/backend/app/model/workstation_login_record.js b/backend/app/model/workstation_login_record.js new file mode 100644 index 0000000..fd9624a --- /dev/null +++ b/backend/app/model/workstation_login_record.js @@ -0,0 +1,45 @@ +'use strict'; + +/** + * 工作台成员登录记录表模型(workstation_login_records) + * + * 一行 = 某成员在工作台上的一次登录: + * - `status = 1` 在线(`logoutAt` 为空); + * - `status = 0` 已下线(`logoutAt` + `logoutReason`)。 + * + * 查「运单当时是谁打包的」= 用 `workstationId` + `loginAt/logoutAt` 判断 + * 扫码时间点谁还在线(`service/workstationLogin.js#packersMap`)。 + * + * 流水表,**不用软删除**(paranoid 关闭),清理请按时间物理删除。 + */ +module.exports = (app) => { + const { BIGINT, STRING, TINYINT, DATE } = app.Sequelize; + + const WorkstationLoginRecord = app.model.define('workstationLoginRecord', { + id: { type: BIGINT.UNSIGNED, primaryKey: true, autoIncrement: true, comment: '主键' }, + subjectId: { type: BIGINT.UNSIGNED, allowNull: false, comment: '所属主体 subjects.id' }, + workstationId: { type: BIGINT.UNSIGNED, allowNull: false, comment: '工作台 workstations.id' }, + userId: { type: BIGINT.UNSIGNED, allowNull: false, comment: '登录用户 users.id' }, + memberId: { type: BIGINT.UNSIGNED, comment: '主体成员 subject_members.id(非成员为空)' }, + name: { type: STRING(64), allowNull: false, defaultValue: '', comment: '登录时记录的名字(成员工号/姓名,非成员用昵称)' }, + type: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 1, comment: '登录类型:1 扫码登录(预留后续扩展)' }, + loginCode: { type: STRING(64), comment: '登录时使用的工作台登录码' }, + loginAt: { type: DATE, allowNull: false, comment: '登录时间' }, + logoutAt: { type: DATE, comment: '下线时间(在线为空)' }, + status: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 1, comment: '状态:1在线 0已下线' }, + logoutReason: { type: STRING(32), comment: '下线原因:manual / reset_code / idle_timeout / relogin' }, + loginIp: { type: STRING(45), comment: '登录 IP' }, + }, { + tableName: 'workstation_login_records', + paranoid: false, + comment: '工作台成员登录记录表', + }); + + WorkstationLoginRecord.associate = function() { + app.model.WorkstationLoginRecord.belongsTo(app.model.Workstation, { foreignKey: 'workstation_id', as: 'workstation' }); + app.model.WorkstationLoginRecord.belongsTo(app.model.User, { foreignKey: 'user_id', as: 'user' }); + app.model.WorkstationLoginRecord.belongsTo(app.model.SubjectMember, { foreignKey: 'member_id', as: 'member' }); + }; + + return WorkstationLoginRecord; +}; diff --git a/backend/app/schedule/workstation_idle_offline.js b/backend/app/schedule/workstation_idle_offline.js new file mode 100644 index 0000000..a9d283d --- /dev/null +++ b/backend/app/schedule/workstation_idle_offline.js @@ -0,0 +1,34 @@ +'use strict'; + +/** + * 工作台成员自动下线(每分钟一次) + * + * 规则:工作台「最后活跃时间」(`workstations.last_active_at`,扫码上报 / 有人登录都会刷新) + * 超过该工作台配置的 `idle_timeout_sec` 后,把它的**所有在线成员**在 + * `workstation_login_records` 里下线(写 `logout_at` + `status=0`,原因 `idle_timeout`)。 + * + * 默认值:团购 1 小时、散单 30 分钟(见 `service/workstation.js`)。 + * + * 放在 worker 上跑(`type: 'worker'`):多进程/多实例时只由 worker 执行一次, + * 逻辑本身也是幂等的(只处理 `status = 1` 的记录)。 + */ +module.exports = app => { + return { + schedule: { + cron: '0 * * * * *', + type: 'worker', + immediate: false, + disable: app.config.env === 'unittest', + }, + async task(ctx) { + const result = await ctx.service.workstationLogin.sweepIdle(); + if (result.offline) { + ctx.logger.info( + '[workstation-login] 自动下线:在线 %d 条 / 下线 %d 条 / 涉及工作台 %d 台', + result.online, result.offline, result.workstations, + ); + } + return result; + }, + }; +}; diff --git a/backend/app/service/camera.js b/backend/app/service/camera.js index a372737..b6ca166 100644 --- a/backend/app/service/camera.js +++ b/backend/app/service/camera.js @@ -179,6 +179,8 @@ class CameraService extends Service { if (patch.status !== undefined) fields.status = Number(patch.status) === 0 ? 0 : 1; await camera.update(fields); + // 摄像头停用/改名都会改变下发给设备的面单配置 → 叫醒设备重拉 + await this._notifyLabelScan(subjectId); return this.findOwned(id, subjectId); } @@ -191,6 +193,8 @@ class CameraService extends Service { await this.syncNvrChannelCount(camera.nvrId); this.ctx.logger.info('[camera] 主体 %s 删除摄像头 %s', subjectId, camera.id); + // 删掉的可能是面单摄像头 → 设备端要立刻停掉这一路 + await this._notifyLabelScan(subjectId); return { id: camera.id }; } @@ -224,9 +228,23 @@ class CameraService extends Service { await Promise.all(affectedNvrIds.map(nvrId => this.syncNvrChannelCount(nvrId))); this.ctx.logger.info('[camera] 主体 %s 批量删除摄像头 %s', subjectId, ownedIds.join(',')); + // 删掉的可能是面单摄像头 → 设备端要立刻重拉 + await this._notifyLabelScan(subjectId); return { removed, skipped: list.length - ownedIds.length }; } + /** + * 面单识别配置受这次变更影响 → 叫醒本主体设备立刻重拉(失败只记日志) + * @param {number} subjectId 主体 id + */ + async _notifyLabelScan(subjectId) { + try { + await this.ctx.service.labelScan.notifyChanged(subjectId); + } catch (err) { + this.ctx.logger.warn('[camera] 通知设备重拉面单配置失败:%s', err.message); + } + } + /** 回填 NVR 的「已导入通道数」(增删摄像头后保持一致) */ async syncNvrChannelCount(nvrId) { if (!nvrId) return; diff --git a/backend/app/service/label_scan.js b/backend/app/service/label_scan.js new file mode 100644 index 0000000..ec9e30d --- /dev/null +++ b/backend/app/service/label_scan.js @@ -0,0 +1,310 @@ +'use strict'; + +const { Service } = require('egg'); +const crypto = require('crypto'); +const { Op } = require('sequelize'); +const { virtualChannelIdOf, isVirtualChannelId } = require('../lib/virtual-channel'); + +/** + * 面单摄像头**识别配置**(下发给设备出站拉取) + * + * 现场:工作台的「面单摄像头」对着面单区,面单放进去识别到条码就开始打包, + * 识别结果按**该工作台已绑定的扫码通道**上报(这样服务端才能找到工作台快照)。 + * + * 这里只做「算出这台设备该跑哪些识别任务」: + * - 只看**本主体**、启用中的工作台(**散单和团购都支持**面单摄像头); + * - 只看被标记为面单摄像头(`workstation_cameras.is_label_camera = 1`)的绑定; + * - 上报通道取「该工作台绑定、且属于**本设备**的扫码通道」(多条时取 sortNo 最小的一条); + * 工作台**没接扫码枪**(没绑本机通道)时,自动给它一条虚拟通道 `CAM-<工作台id>` + * (名字 `面单摄像头·<摄像头名>`,见 `lib/virtual-channel`)——摄像头可以完全替代扫码枪; + * - 下发的每一项都带 `wsType`:设备端据此决定记录规则 + * (散单 wsType=1 → 时间取第一次、立即上报;团购 wsType=2 → 和扫码枪一样静默 5 秒取最后一次); + * - 另外下发 `channels`(本设备所有被工作台绑定的通道 + 对应 wsType,含虚拟通道), + * 设备端用它决定**扫码枪**那条路的记录规则(散单也走「取第一次」); + * - 设备凭据(NVR 账号密码)随配置下发,设备拿到后直接拉流; + * 服务端不做缓存,接口也只在设备鉴权通过后才返回。 + * + * ⚠️ RTSP 路径不在这里拼:录像机的「首个数字通道号」只有设备端问得到 + * (桌面端 `HikPlaybackService.LogicalChannel` 已经这样做),所以只下发 + * `nvr` + `cameraChannelNo` + `streamType`,由设备端算。 + */ +class LabelScanService extends Service { + get Workstation() { + return this.app.model.Workstation; + } + + get Nvr() { + return this.app.model.Nvr; + } + + /** + * 取本设备的面单识别配置 + * + * @param {object} scanner 当前设备(ctx.state.scanner,已鉴权) + * @return {Promise} { revision, items, warnings, scannedAt } + */ + async configOf(scanner) { + const scannerId = Number(scanner.id); + const subjectId = Number(scanner.subjectId) || 0; + + const workstations = await this.Workstation.findAll({ + where: { subjectId, status: 1 }, + attributes: [ 'id', 'code', 'name', 'wsType' ], + order: [[ 'id', 'ASC' ]], + }); + + const warnings = []; + if (!workstations.length) { + return { revision: revisionOf({ items: [], channels: [] }), items: [], channels: [], warnings, scannedAt: new Date() }; + } + + const ids = workstations.map(row => Number(row.id)); + const workstationById = new Map(workstations.map(row => [ Number(row.id), row ])); + + // 工作台 → 上报通道(只认本设备的通道;多条取 sortNo 最小的) + const channelLinks = await this.app.model.WorkstationScanChannel.findAll({ + where: { workstationId: { [Op.in]: ids }, scannerId }, + attributes: [ 'id', 'workstationId', 'scannerId', 'channelId', 'channelName', 'sortNo' ], + order: [[ 'workstationId', 'ASC' ], [ 'sortNo', 'ASC' ], [ 'id', 'ASC' ]], + }); + + const channelByWorkstation = new Map(); + for (const link of channelLinks) { + const key = Number(link.workstationId); + if (!channelByWorkstation.has(key)) channelByWorkstation.set(key, link); + } + + // 本设备每条通道对应的工作台类型:设备端「扫码枪」那条路也按它决定记录规则 + // (虚拟通道 `CAM-` 不在这里下发,等确认它确实有面单摄像头再加,见下面) + const channels = []; + for (const [ workstationId, link ] of channelByWorkstation) { + if (isVirtualChannelId(link.channelId)) continue; + const workstation = workstationById.get(workstationId); + if (!workstation) continue; + channels.push({ + channelId: String(link.channelId), + channelName: link.channelName || '', + wsType: Number(workstation.wsType) === 1 ? 1 : 2, + }); + } + + const links = await this.app.model.WorkstationCamera.findAll({ + where: { workstationId: { [Op.in]: ids }, isLabelCamera: 1 }, + include: [{ + model: this.app.model.Camera, + as: 'camera', + required: true, + include: [{ model: this.Nvr, as: 'nvr', attributes: [ 'id', 'name', 'host', 'port', 'username' ] }], + }], + order: [[ 'workstationId', 'ASC' ], [ 'id', 'ASC' ]], + }); + + if (!links.length) { + return { revision: revisionOf({ items: [], channels }), items: [], channels, warnings, scannedAt: new Date() }; + } + + const items = []; + const seenWorkstations = new Set(); + + 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 cameraName = camera.name || camera.channelName || `通道${camera.channelNo}`; + + // 没有扫码通道也不要紧:摄像头本身就是一条「虚拟通道」(`CAM-<工作台id>`),见 ensureVirtualChannel + const boundChannel = channelByWorkstation.get(workstationId); + 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 virtualChannel = !realChannel; + + const nvr = camera.nvr; + if (!nvr) { + warnings.push({ + workstationId, + workstationName: workstation.name || workstation.code, + message: `摄像头「${cameraName}」找不到录像机`, + }); + continue; + } + + const password = await this.passwordOf(nvr.id); + if (!password) { + warnings.push({ + workstationId, + workstationName: workstation.name || workstation.code, + message: `录像机「${nvr.name || nvr.host}」没有保存密码,无法拉流`, + }); + continue; + } + + // 纯摄像头工作台:没有扫码枪也能用,识别结果按虚拟通道上报(回放定位靠 scanner+channel 反查工作台) + // 放在校验后面,免得为一条拉不了流的配置凭空建通道 + if (virtualChannel) { + const ensured = await this.ensureVirtualChannel(scanner, workstationId, channelName); + if (ensured) { + channelId = ensured.channelId; + channelName = ensured.channelName; + } + } + + items.push({ + workstationId, + workstationCode: workstation.code || '', + workstationName: workstation.name || workstation.code || '', + // 1 散单(时间取第一次、立即上报)/ 2 团购(静默 5 秒、时间取最后一次,和扫码枪一样) + wsType: Number(workstation.wsType) === 1 ? 1 : 2, + channelId, + channelName, + // true = 这条通道是摄像头自己(工作台没绑扫码枪),设备端照常上报即可 + virtualChannel, + cameraId: Number(camera.id), + cameraName, + cameraChannelNo: Number(camera.channelNo) || 0, + cameraEnabled: Number(camera.status) === 1 && Number(camera.enabled) === 1, + streamType: Number(link.streamType) === 1 ? 1 : 0, + nvr: { + id: Number(nvr.id), + name: nvr.name || '', + host: nvr.host, + port: Number(nvr.port) || 8000, + username: nvr.username || 'admin', + password, + }, + }); + } + + // 虚拟通道(纯摄像头工作台)也要进 channels:设备端靠它判断走「取第一次」还是「取最后一次」 + for (const item of items) { + if (!item.virtualChannel) continue; + if (channels.some(row => row.channelId === item.channelId)) continue; + channels.push({ channelId: item.channelId, channelName: item.channelName, wsType: item.wsType }); + } + + return { revision: revisionOf({ items, channels }), items, channels, warnings, scannedAt: new Date() }; + } + + /** + * 确保「纯摄像头工作台」的虚拟通道存在(幂等)。 + * + * 为什么需要:扫码记录的上报结构是「中控 + 通道」,回放定位靠 `scanner+channel → 工作台` 反查快照; + * 工作台没接扫码枪时没有通道,识别结果就没有落脚点。这里给它补一条**虚拟通道** + * `CAM-<工作台id>`(名字 `面单摄像头·<摄像头名>`)并绑到工作台,整条链路就不用改。 + * + * 只在设备拉配置时顺带自愈(包括历史遗留的「设了面单但没通道」的配置)。 + * + * @return {Promise<{channelId:string, channelName:string}|null>} + */ + async ensureVirtualChannel(scanner, workstationId, channelName) { + if (!scanner || !scanner.id || !workstationId) return null; + + const channelId = virtualChannelIdOf(workstationId); + const name = channelName || '面单摄像头'; + const scannerId = Number(scanner.id); + try { + const ScanChannel = this.app.model.ScanChannel; + // 注意 `paranoid`:通道被取消面单时是**软删**,唯一键还被占着, + // 所以必须用 `paranoid: false` 查出来再 restore,不能直接 findOrCreate。 + let channel = await ScanChannel.findOne({ where: { scannerId, channelId }, paranoid: false }); + if (channel) { + if (channel.deletedAt) await ScanChannel.restore({ where: { id: channel.id } }); + const fields = { lastReportAt: new Date() }; + if (channel.channelName !== name) fields.channelName = name; + if (Number(channel.status) !== 1) fields.status = 1; + await ScanChannel.update(fields, { where: { id: channel.id }, paranoid: false }); + } else { + channel = await ScanChannel.create({ + scannerId, + subjectId: Number(scanner.subjectId) || null, + channelId, + channelName: name, + status: 1, + lastReportAt: new Date(), + }); + } + + const [ link ] = await this.app.model.WorkstationScanChannel.findOrCreate({ + where: { workstationId: Number(workstationId), scannerId, channelId }, + defaults: { channelName: name, sortNo: 0 }, + }); + if (link && link.channelName !== name) { + await link.update({ channelName: name }); + } + + return { channelId, channelName: name }; + } catch (err) { + // 补通道失败不能影响下发:识别照跑,只是这条记录定位不到工作台 + this.ctx.logger.warn('[label-scan] 工作台 %s 的虚拟通道创建失败:%s', workstationId, err.message); + return null; + } + } + + /** + * 叫醒本主体的设备「面单识别配置变了,马上重拉」。 + * + * 设备端收到 `labelScan.refresh` 只当作**一次通知**:真正的配置仍以 + * `GET /api/scanner/label-cameras` 为准(服务端不推送配置内容,避免两份真相)。 + * + * 为什么必须有:设备端只有一个 5 分钟的兜底轮询,现场在网页上改完面单摄像头后 + * 要等好几分钟才生效;期间旧摄像头还在跑、新摄像头不启动,看起来就像「没取到新值」。 + * + * 推送失败只记日志:配置本身已经落库,不能因为通知失败就回滚。 + * + * @param {number} subjectId 主体 id + * @return {Promise} 通知到的设备数 + */ + async notifyChanged(subjectId) { + const id = Number(subjectId) || 0; + if (!id) return 0; + + try { + const scanners = await this.app.model.Scanner.findAll({ + where: { subjectId: id, status: 1 }, + attributes: [ 'id' ], + raw: true, + }); + if (!scanners.length) return 0; + + for (const row of scanners) { + // 队列有 TTL:设备离线期间任务会自己过期,不会无限堆积 + await this.ctx.service.edgeTask.enqueue(Number(row.id), 'labelScan.refresh', {}); + } + + this.ctx.logger.info('[label-scan] 已通知 %d 台设备重拉面单配置(subject %d)', scanners.length, id); + return scanners.length; + } catch (err) { + this.ctx.logger.warn('[label-scan] 通知设备重拉面单配置失败(不影响配置本身):%s', err.message); + return 0; + } + } + + /** 解密录像机密码(只给设备下发,绝不写日志) */ + async passwordOf(nvrId) { + const nvr = await this.Nvr.findByPk(nvrId, { attributes: { include: [ 'passwordEnc' ] } }); + if (!nvr || !nvr.passwordEnc) return ''; + try { + return this.ctx.service.nvr.passwordOf(nvr) || ''; + } catch (err) { + this.ctx.logger.warn('[label-scan] 录像机 %s 密码解密失败:%s', nvrId, err.message); + return ''; + } + } +} + +/** + * 配置指纹:内容(含密码、通道模式)一变就变,设备端据此判断要不要重建识别任务。 + * 只在设备端做「本地缓存 vs 远端」比较,**不落日志**。 + */ +function revisionOf(payload) { + const text = JSON.stringify(payload); + return `sha1:${crypto.createHash('sha1').update(text).digest('hex').slice(0, 16)}`; +} + +module.exports = LabelScanService; diff --git a/backend/app/service/pack.js b/backend/app/service/pack.js index 6b2e387..7bad01d 100644 --- a/backend/app/service/pack.js +++ b/backend/app/service/pack.js @@ -114,6 +114,7 @@ class PackService extends Service { * @return {Promise} { code, found, reason, hints, records:[], streams:[] } * - `reason`: ok / not-found(本主体没扫过)/ foreign(运单存在但属于别的主体) * - `hints`: 给人看的说明(通道没绑工作台 / 工作台没绑摄像头 / 运单不属于本主体…) + * - `records[].packers`: 该次扫码时还在线的人(来自 `workstation_login_records`,可能多人) */ async query({ subjectId, code }) { const barcode = String(code || '').trim(); @@ -189,6 +190,18 @@ class PackService extends Service { for (const stream of (plan.streams || [])) streams.push(stream); } + // 每条记录「当时谁在工作台上」(打包人员,可能多人):按工作台 + 扫码时间批量查一次 + if (records.length) { + const packers = await this.ctx.service.workstationLogin.packersMap(records.map(item => ({ + key: Number(item.id), + workstationId: item.workstationId, + scanTime: item.scanTime, + }))); + for (const item of records) { + item.packers = packers.get(Number(item.id)) || []; + } + } + // `found` = 本主体扫过这个运单;`playback` = 能不能真的拉到回放 // (全部记录都没绑工作台时 found=true / playback=false,前端要区别对待) let reason = records.length ? 'ok' : (rows.length ? 'no-workstation' : 'not-found'); diff --git a/backend/app/service/workstation.js b/backend/app/service/workstation.js index efe71b7..4e64d97 100644 --- a/backend/app/service/workstation.js +++ b/backend/app/service/workstation.js @@ -2,6 +2,14 @@ const { Service } = require('egg'); const { Op } = require('sequelize'); +const { virtualChannelIdOf, isVirtualChannelId, VIRTUAL_CHANNEL_PREFIX } = require('../lib/virtual-channel'); + +/** 不活跃自动下线:默认秒数(团购 1 小时 / 散单 30 分钟) */ +const IDLE_TIMEOUT_GROUP_SEC = 3600; +const IDLE_TIMEOUT_SINGLE_SEC = 1800; +/** 允许配置的范围:1 分钟 ~ 24 小时 */ +const IDLE_TIMEOUT_MIN_SEC = 60; +const IDLE_TIMEOUT_MAX_SEC = 24 * 3600; /** * 工作台 service @@ -12,6 +20,12 @@ const { Op } = require('sequelize'); * * 归属判定:工作台有自己的 `user_id`;绑定时还要校验「摄像头所属 NVR」和 * 「中控」都属于当前用户,防止把别人的设备挂到自己工作台上。 + * + * 另外一台工作台还带: + * - `lastActiveAt` / `idleTimeoutSec`:最后活跃时间与「多久不活跃自动下线所有成员」。 + * + * ⚠️ 现场扫码登入不再用「工作台上贴一张固定的登录码」:改为按需生成一张**一次性** + * 微信扫码二维码(`createLoginQr`,走微信登录网关),见 `service/wx_gateway.js`。 */ class WorkstationService extends Service { get Workstation() { @@ -48,11 +62,16 @@ class WorkstationService extends Service { order: [[ 'id', 'DESC' ]], }); - const ids = rows.map(row => row.id); - const [ cameraCounts, scanCounts ] = ids.length + const ids = rows.map(row => Number(row.id)); + const [ cameraCounts, scanCounts ] = rows.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 }), + // 虚拟通道(面单摄像头自己用)不算「绑定的扫码通道」 + this.LinkScanChannel.count({ + where: { workstationId: { [Op.in]: ids }, channelId: { [Op.notLike]: `${VIRTUAL_CHANNEL_PREFIX}%` } }, + group: [ 'workstationId' ], + raw: true, + }), ]) : [ [], [] ]; @@ -112,12 +131,15 @@ class WorkstationService extends Service { }) : null, }); }), - scanChannels: scanLinks.map(link => link.toJSON()), + scanChannels: scanLinks.map(link => Object.assign(link.toJSON(), { + // 虚拟通道 = 面单摄像头自己占的通道(`CAM-<工作台id>`),由服务端自动维护,前端不给解绑 + virtual: isVirtualChannelId(link.channelId), + })), }); } /** 新增工作台(同一主体下 code 唯一;软删过的会被复活并更新) */ - async create({ subjectId, userId, code, name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, remark } = {}) { + async create({ subjectId, userId, code, name, wsType, recordBeforeSec, recordAfterSec, recordMaxSec, idleTimeoutSec, 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({ @@ -125,6 +147,7 @@ class WorkstationService extends Service { recordAfterSec, recordMaxSec: finalType === 2 ? undefined : recordMaxSec, }); + const timeout = this._idleTimeout(idleTimeoutSec); const existing = await this.Workstation.findOne({ where: { subjectId: Number(subjectId), code: finalCode }, @@ -142,6 +165,8 @@ class WorkstationService extends Service { recordBeforeSec: before, recordAfterSec: after, recordMaxSec: this._maxSec(nextType, before, after, range.recordMaxSec, existing.recordMaxSec), + idleTimeoutSec: timeout + ?? (Number(existing.idleTimeoutSec) || this._defaultIdleTimeout(nextType)), remark: remark === undefined ? existing.remark : remark, status: 1, }); @@ -160,6 +185,7 @@ class WorkstationService extends Service { recordBeforeSec: before, recordAfterSec: after, recordMaxSec: this._maxSec(finalType, before, after, range.recordMaxSec, 240), + idleTimeoutSec: timeout ?? this._defaultIdleTimeout(finalType), remark: remark || null, status: 1, }); @@ -168,6 +194,23 @@ class WorkstationService extends Service { return this.findOwned(created.id, subjectId); } + /** 不活跃自动下线:团购 1 小时 / 散单 30 分钟 */ + _defaultIdleTimeout(wsType) { + return Number(wsType) === 2 ? IDLE_TIMEOUT_GROUP_SEC : IDLE_TIMEOUT_SINGLE_SEC; + } + + /** 不活跃秒数校验(不传返回 undefined,交给调用方决定用旧值还是默认值) */ + _idleTimeout(value) { + if (value === undefined || value === null || value === '') return undefined; + const num = Number(value); + if (!Number.isFinite(num)) this.ctx.throw(422, '不活跃自动下线时间必须是数字'); + const int = Math.round(num); + if (int < IDLE_TIMEOUT_MIN_SEC || int > IDLE_TIMEOUT_MAX_SEC) { + this.ctx.throw(422, `不活跃自动下线时间必须在 ${IDLE_TIMEOUT_MIN_SEC}~${IDLE_TIMEOUT_MAX_SEC} 秒之间`); + } + return int; + } + /** * 录制范围校验(秒) * @@ -211,7 +254,7 @@ class WorkstationService extends Service { return Number(fallback ?? 240); } - /** 更新工作台(code 不开放修改;类型 / 录制范围可改) */ + /** 更新工作台(code / 登录码不开放修改;类型 / 录制范围 / 不活跃下线时间可改) */ async update(id, subjectId, patch = {}) { const workstation = await this.findOwned(id, subjectId); @@ -235,14 +278,26 @@ class WorkstationService extends Service { fields.recordAfterSec = after; fields.recordMaxSec = this._maxSec(nextType, before, after, range.recordMaxSec, workstation.recordMaxSec); + // 不活跃下线时间:显式传了就按传入值;只切类型没传 → 用新类型的默认值 + const timeout = this._idleTimeout(patch.idleTimeoutSec); + if (timeout !== undefined) { + fields.idleTimeoutSec = timeout; + } else if (fields.wsType !== undefined && fields.wsType !== (Number(workstation.wsType) === 2 ? 2 : 1)) { + fields.idleTimeoutSec = this._defaultIdleTimeout(fields.wsType); + } + if (patch.remark !== undefined) fields.remark = patch.remark; if (patch.status !== undefined) fields.status = Number(patch.status) === 0 ? 0 : 1; await workstation.update(fields); + + // 名称/类型/启用状态都会改变下发给设备的面单配置(wsType 决定记录规则)→ 叫醒设备重拉 + await this._notifyLabelScan(subjectId); + return this.findOwned(id, subjectId); } - /** 删除工作台(连带解除所有绑定,工作台本体软删除) */ + /** 删除工作台(连带解除所有绑定 + 把在线成员全部下线;工作台本体软删除) */ async remove(id, subjectId) { const workstation = await this.findOwned(id, subjectId); @@ -250,10 +305,75 @@ class WorkstationService extends Service { this.LinkCamera.destroy({ where: { workstationId: workstation.id } }), this.LinkScanChannel.destroy({ where: { workstationId: workstation.id } }), ]); + await this.releaseVirtualChannel(workstation.id); + const offline = await this.ctx.service.workstationLogin + .offlineAll(workstation.id, 'workstation_deleted'); await workstation.destroy(); - this.ctx.logger.info('[workstation] 主体 %s 删除工作台 %s', subjectId, workstation.id); - return { id: workstation.id }; + this.ctx.logger.info('[workstation] 主体 %s 删除工作台 %s(下线成员 %d 人)', subjectId, workstation.id, offline); + // 工作台没了,它名下的面单识别任务也要停 → 叫醒设备重拉 + await this._notifyLabelScan(subjectId); + return { id: workstation.id, offline }; + } + + /** + * 面单识别配置受这次变更影响 → 叫醒本主体在线设备立刻重拉 + * + * 失败不抛:配置已经落库,下次兜底轮询(设备端 1 分钟)也会补上, + * 不能因为「通知」把工作台的正常操作搞失败。 + */ + async _notifyLabelScan(subjectId) { + try { + await this.ctx.service.labelScan.notifyChanged(subjectId); + } catch (err) { + this.ctx.logger.warn('[workstation] 通知设备重拉面单配置失败:%s', err.message); + } + } + + /** + * 把该工作台**所有在线成员下线**(成员弹窗的「全部下线」) + * @return {Promise} { id, offline } + */ + async offlineAllMembers(id, subjectId) { + const workstation = await this.findOwned(id, subjectId); + + const offline = await this.ctx.service.workstationLogin + .offlineAll(workstation.id, 'offline_all'); + + this.ctx.logger.info('[workstation] 主体 %s 一键下线工作台 %s 成员 %d 人', subjectId, workstation.id, offline); + return { id: Number(workstation.id), offline }; + } + + /** + * 生成「扫码登入本工作台」的二维码(微信登录网关) + * + * 二维码内容 = 网关的授权页地址(临时码,一次有效),用户用微信扫码确认后 + * 网关回调本服务(`/api/wechat-gateway/notify`)→ 写一条工作台登录记录。 + * + * @return {Promise} { state, qrUrl, pageUrl, expiresIn } + */ + async createLoginQr(id, subjectId) { + const workstation = await this.findOwned(id, subjectId); + if (Number(workstation.status) !== 1) this.ctx.throw(403, '工作台已停用,请先启用'); + + const state = await this.ctx.service.subjectState.get(Number(workstation.subjectId)); + if (!state) this.ctx.throw(404, '工作台不存在或不属于当前账号'); + if (state.disabled) this.ctx.throw(403, '所属主体已被停用,请联系管理员'); + if (state.expired) this.ctx.throw(403, `主体「${state.name}」使用期限已到,请联系管理员续期`); + + const session = await this.ctx.service.wxGateway.openSession({ + purpose: 'workstation', + scene: 'login', + payload: { workstationId: Number(workstation.id), subjectId: Number(workstation.subjectId) }, + }); + + return { + workstationId: Number(workstation.id), + state: session.state, + pageUrl: session.pageUrl, + qrUrl: `/api/wechat-gateway/qrcode.svg?state=${encodeURIComponent(session.state)}`, + expiresIn: session.expiresIn, + }; } /** @@ -336,6 +456,8 @@ class WorkstationService extends Service { async unbindCamera({ workstationId, subjectId, cameraId } = {}) { const workstation = await this.findOwned(workstationId, subjectId); await this.LinkCamera.destroy({ where: { workstationId: workstation.id, cameraId: Number(cameraId) } }); + // 解绑的可能正是面单摄像头 → 设备端要立刻重拉配置 + await this._notifyLabelScan(subjectId); return this.detail(workstation.id, subjectId); } @@ -373,6 +495,45 @@ class WorkstationService extends Service { return this.detail(workstation.id, subjectId); } + /** + * 设置 / 取消「面单摄像头」 + * + * 散单和团购工作台都可以设(区别在设备端的记录规则:散单取第一次、团购取最后一次, + * 见设备端下发里的 `wsType`);一台工作台最多一路,设新的会先把旧的取消掉。 + * `isLabelCamera` 不传按「设置」处理。 + */ + async setLabelCamera({ workstationId, subjectId, cameraId, isLabelCamera } = {}) { + 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 label = isLabelCamera === undefined || isLabelCamera === null + ? 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-`)没用了,顺手清掉 + if (!label) await this.releaseVirtualChannel(workstation.id); + + this.ctx.logger.info( + '[workstation] 工作台 %s %s面单摄像头(camera %s)', + workstation.id, label ? '设置' : '取消', cameraId, + ); + // 面单摄像头变了 → 叫醒设备立刻重拉(否则要等 5 分钟兜底轮询) + await this._notifyLabelScan(subjectId); + return this.detail(workstation.id, subjectId); + } + /** * 绑定扫码通道(追加,重复的自动忽略) * @@ -440,14 +601,47 @@ class WorkstationService extends Service { await this.LinkScanChannel.bulkCreate(normalized, { ignoreDuplicates: true }); + // 绑上真实扫码通道后,摄像头虚拟通道就多余了(不然回放定位可能落到 CAM- 上) + await this.releaseVirtualChannel(workstation.id); + this.ctx.logger.info('[workstation] 工作台 %s 绑定扫码通道 %d 个', workstation.id, normalized.length); + // 上报通道变了 → 面单识别结果的落点也变了,设备端要重拉 + await this._notifyLabelScan(subjectId); return this.detail(workstation.id, subjectId); } + /** + * 清理工作台的虚拟扫码通道(`CAM-<工作台id>`) + * + * 虚拟通道由服务端按需创建(`service/label_scan.ensureVirtualChannel`),所以下面几种情况要清掉: + * 取消面单摄像头、绑上真实扫码通道、删除工作台。 + * 历史扫码记录里的工作台快照是**入库时冻结**的,删掉通道不影响老记录回放。 + * + * @return {Promise} 解绑的绑定行数 + */ + async releaseVirtualChannel(workstationId) { + const id = Number(workstationId); + if (!id) return 0; + + const channelId = virtualChannelIdOf(id); + const removed = await this.LinkScanChannel.destroy({ where: { workstationId: id, channelId } }); + + // 通道行只在没被任何工作台绑定时才删(正常情况下一台工作台独占自己的虚拟通道) + const stillUsed = await this.LinkScanChannel.count({ where: { channelId } }); + if (!stillUsed) { + await this.app.model.ScanChannel.destroy({ where: { channelId } }); + } + if (removed) { + this.ctx.logger.info('[workstation] 工作台 %s 清理虚拟通道 %s(解绑 %d)', id, channelId, removed); + } + return removed; + } + /** 解绑扫码通道(按绑定记录 id) */ - async unbindScanChannel({ workstationId, subjectId, linkId } = {}) { - const workstation = await this.findOwned(workstationId, subjectId); + async unbindScanChannel({ workstationId, subjectId, linkId } = {}) { const workstation = await this.findOwned(workstationId, subjectId); await this.LinkScanChannel.destroy({ where: { id: Number(linkId), workstationId: workstation.id } }); + // 上报通道变了 → 设备端要重拉(没有真实通道时服务端会改用虚拟通道) + await this._notifyLabelScan(subjectId); return this.detail(workstation.id, subjectId); } @@ -460,6 +654,8 @@ class WorkstationService extends Service { if (!scannerIds.length) return []; const where = { scannerId: { [Op.in]: scannerIds } }; + // 虚拟通道(`CAM-<工作台id>`,面单摄像头自己用)不给人工绑定 + where.channelId = { [Op.notLike]: `${VIRTUAL_CHANNEL_PREFIX}%` }; if (keyword) { where[Op.or] = [ { channelId: { [Op.like]: `%${keyword}%` } }, diff --git a/backend/app/service/workstation_login.js b/backend/app/service/workstation_login.js new file mode 100644 index 0000000..b67ed23 --- /dev/null +++ b/backend/app/service/workstation_login.js @@ -0,0 +1,396 @@ +'use strict'; + +const { Service } = require('egg'); +const { Op } = require('sequelize'); + +/** 下线原因(写进 `workstation_login_records.logout_reason`) */ +const LOGOUT_REASON = { + /** 管理员在工作台成员列表手动下线 */ + MANUAL: 'manual', + /** 管理员一键下线该工作台所有成员 */ + OFFLINE_ALL: 'offline_all', + /** 旧版「重置登录码」留下的原因(登录码已废弃,仅历史记录里还会出现) */ + RESET_CODE: 'reset_code', + /** 长时间不活跃,定时任务自动下线 */ + IDLE_TIMEOUT: 'idle_timeout', + /** 同一个人再次扫码登录,旧的在线记录自动下线 */ + RELOGIN: 'relogin', + /** 工作台被删除 */ + WORKSTATION_DELETED: 'workstation_deleted', +}; + +/** 登录类型(`type`):预留给后续登录方式扩展,当前只有扫码登录 */ +const LOGIN_TYPE = { + SCAN: 1, +}; + +/** 秒级精度(设备上报的扫码时间是秒级,库里 login_at 带毫秒,比较时统一取整秒) */ +const SECOND = 1000; + +/** + * 工作台成员登录记录 service + * + * 一句话:谁在什么时候登进了哪台工作台、什么时候下线,以及「某次扫码时谁在线」(运单回放定位打包人)。 + * + * 关键约定: + * 1. 一行记录用 `status`(1 在线 / 0 下线)+ `logoutAt` 表达生命周期,**不删记录**(要能查历史); + * 2. 判断「扫码那一刻谁在线」= `loginAt <= scanTime && (logoutAt == null || logoutAt >= scanTime)`, + * 所以查询入口是 `workstationId` + 时间区间(表上有 `(workstation_id, login_at)` 索引); + * 3. 自动下线只看「工作台最后活跃时间」,没有活跃时间时退化为「最晚一条在线记录的登录时间」, + * 否则新建的工作台(从没上报过条码)永远不会被下线。 + */ +class WorkstationLoginService extends Service { + get Record() { + return this.app.model.WorkstationLoginRecord; + } + + get Workstation() { + return this.app.model.Workstation; + } + + /** + * 扫码登入工作台(网关回调确认了「谁」之后调,见 `service/wx_gateway.js#handleWorkstationLogin`) + * + * 名字规则:**是该主体的成员 → 记成员姓名(= 工号)**,否则记用户自己设置的昵称。 + * + * @param {object} params + * @param {object} params.user 平台账号(网关 openid 反查出来的) + * @param {object} params.workstation 工作台(Sequelize 实例) + * @param {string} [params.ip] 登录 IP(网关回调没有真实客户端 IP,通常为空) + * @return {Promise} { workstation, name, isMember, member, record } + */ + async loginByUser({ user, workstation, ip } = {}) { + if (!user) this.ctx.throw(401, '缺少登录用户'); + if (!workstation) this.ctx.throw(404, '工作台不存在或已被删除'); + + const subjectId = Number(workstation.subjectId); + const state = await this.ctx.service.subjectState.get(subjectId); + if (!state) this.ctx.throw(404, '工作台不存在或已被删除'); + if (state.disabled) this.ctx.throw(403, '所属主体已被停用,请联系管理员'); + if (state.expired) this.ctx.throw(403, `主体「${state.name}」使用期限已到,请联系管理员续期`); + if (Number(workstation.status) !== 1) this.ctx.throw(403, '工作台已停用,请联系管理员'); + + const member = await this.app.model.SubjectMember.findOne({ + where: { subjectId, userId: Number(user.id), status: 1 }, + }); + const name = member + ? String(member.name || '').trim() + : String(user.nickname || user.username || '').trim() || `用户${user.id}`; + + const now = new Date(); + // 同一个人在同一台工作台只保留一条在线记录:重新扫码 = 旧记录下线 + const replaced = await this.Record.update({ + status: 0, + logoutAt: now, + logoutReason: LOGOUT_REASON.RELOGIN, + }, { where: { workstationId: workstation.id, userId: Number(user.id), status: 1 } }); + + const record = await this.Record.create({ + subjectId, + workstationId: Number(workstation.id), + userId: Number(user.id), + memberId: member ? Number(member.id) : null, + name, + type: LOGIN_TYPE.SCAN, + loginAt: now, + status: 1, + loginIp: ip ? String(ip).slice(0, 45) : null, + }); + + // 有人登进来也算一次活跃,避免刚登录就被自动下线 + await workstation.update({ lastActiveAt: now }); + + this.ctx.logger.info( + '[workstation-login] 工作台 %s 登录:%s(%s)%s,旧在线记录下线 %d 条', + workstation.code, name, user.id, member ? '(主体成员)' : '(非成员,记昵称)', + Array.isArray(replaced) ? replaced[0] : 0, + ); + + return { + workstation: { + id: Number(workstation.id), + code: workstation.code, + name: workstation.name, + wsType: Number(workstation.wsType) === 2 ? 2 : 1, + subjectId, + subjectName: state.name, + }, + isMember: !!member, + member: member ? { id: Number(member.id), name: member.name, role: Number(member.role) } : null, + name, + record: this.present(record), + }; + } + + /** + * 成员列表(含历史) + * + * @param {object} params + * @param {number} params.workstationId + * @param {number} params.subjectId + * @param {string} [params.status] 1 只看在线 / 0 只看已下线 / 不传 = 全部 + * @param {string} [params.startTime] 登录时间起(含) + * @param {string} [params.endTime] 登录时间止(含) + * @param {number} [params.page] + * @param {number} [params.pageSize] + * @return {Promise} { list, total, page, pageSize, onlineCount } + */ + async list({ workstationId, subjectId, status, startTime, endTime, page = 1, pageSize = 20 } = {}) { + const workstation = await this.ctx.service.workstation.findOwned(workstationId, subjectId); + + const size = Math.min(Number(pageSize) || 20, 100); + const current = Math.max(Number(page) || 1, 1); + + const where = { workstationId: Number(workstation.id) }; + if (status !== undefined && status !== '' && status !== null) { + where.status = Number(status) === 1 ? 1 : 0; + } + + // 时间段:按「登录时间」过滤(配合工作台 id 就能查某天谁在这台工作台上) + const from = parseTime(startTime); + const to = parseTime(endTime); + if (from || to) { + where.loginAt = {}; + if (from) where.loginAt[Op.gte] = from; + if (to) where.loginAt[Op.lte] = to; + } + + const { rows, count } = await this.Record.findAndCountAll({ + where, + include: [{ + model: this.app.model.User, + as: 'user', + required: false, + attributes: [ 'id', 'username', 'nickname' ], + }], + order: [[ 'status', 'DESC' ], [ 'loginAt', 'DESC' ], [ 'id', 'DESC' ]], + limit: size, + offset: (current - 1) * size, + }); + + const onlineCount = await this.Record.count({ + where: { workstationId: Number(workstation.id), status: 1 }, + }); + + return { + list: rows.map(row => { + const data = row.toJSON(); + return Object.assign(this.present(row), { + user: data.user ? { + id: Number(data.user.id), + username: data.user.username, + nickname: data.user.nickname, + } : null, + }); + }), + total: count, + page: current, + pageSize: size, + onlineCount, + }; + } + + /** + * 手动下线某条在线记录(成员列表页的「下线」按钮) + * + * 幂等:已经下线的直接返回(`alreadyOffline: true`),不报错。 + */ + async offlineOne({ workstationId, subjectId, recordId, reason = LOGOUT_REASON.MANUAL } = {}) { + const workstation = await this.ctx.service.workstation.findOwned(workstationId, subjectId); + + const record = await this.Record.findOne({ + where: { id: Number(recordId), workstationId: Number(workstation.id) }, + }); + if (!record) this.ctx.throw(404, '登录记录不存在'); + + if (Number(record.status) !== 1) { + return Object.assign(this.present(record), { alreadyOffline: true }); + } + + const now = new Date(); + await record.update({ status: 0, logoutAt: now, logoutReason: reason }); + this.ctx.logger.info('[workstation-login] 手动下线:工作台 %s 记录 %s(%s)', workstation.code, record.id, record.name); + + return Object.assign(this.present(record), { alreadyOffline: false }); + } + + /** + * 下线某台工作台的全部在线成员 + * + * @param {number} workstationId + * @param {string} reason 见 `LOGOUT_REASON` + * @return {Promise} 受影响条数 + */ + async offlineAll(workstationId, reason) { + const [ affected ] = await this.Record.update({ + status: 0, + logoutAt: new Date(), + logoutReason: reason, + }, { where: { workstationId: Number(workstationId), status: 1 } }); + return Number(affected) || 0; + } + + /** + * 定时任务:扫描在线成员,按「工作台设置的不活跃秒数」批量下线 + * + * 判断基准 `idleBase`: + * - 工作台有 `last_active_at` → 用它(扫码上报 / 有人登录都会刷新); + * - 没有(新建后从没上报过)→ 用该工作台**最晚一条在线记录的登录时间**; + * - 工作台已被删除 → 直接下线。 + * + * @return {Promise} { online, offline, workstations } + */ + async sweepIdle() { + const rows = await this.Record.findAll({ + where: { status: 1 }, + attributes: [ 'id', 'workstationId', 'loginAt' ], + order: [[ 'id', 'ASC' ]], + }); + if (!rows.length) return { online: 0, offline: 0, workstations: 0 }; + + // 按工作台聚合「最晚登录时间」 + const latestLogin = new Map(); + for (const row of rows) { + const key = Number(row.workstationId); + const at = new Date(row.loginAt).getTime(); + if (!latestLogin.has(key) || at > latestLogin.get(key)) latestLogin.set(key, at); + } + + const workstations = await this.Workstation.findAll({ + where: { id: { [Op.in]: [ ...latestLogin.keys() ] } }, + attributes: [ 'id', 'code', 'wsType', 'status', 'lastActiveAt', 'idleTimeoutSec' ], + }); + const byId = new Map(workstations.map(row => [ Number(row.id), row ])); + + const now = Date.now(); + let offline = 0; + let touched = 0; + + for (const [ workstationId, latest ] of latestLogin) { + const workstation = byId.get(workstationId); + if (!workstation) { + // 工作台被删除:记录不能悬着,直接下线(历史仍然可查) + offline += await this.offlineAll(workstationId, LOGOUT_REASON.WORKSTATION_DELETED); + touched++; + continue; + } + + const timeoutSec = Number(workstation.idleTimeoutSec) > 0 + ? Number(workstation.idleTimeoutSec) + : (Number(workstation.wsType) === 2 ? 3600 : 1800); + const idleBase = workstation.lastActiveAt ? new Date(workstation.lastActiveAt).getTime() : latest; + if (now - idleBase < timeoutSec * 1000) continue; + + const affected = await this.offlineAll(workstationId, LOGOUT_REASON.IDLE_TIMEOUT); + if (affected) { + offline += affected; + touched++; + this.ctx.logger.info( + '[workstation-login] 工作台 %s 超过 %d 秒无活跃,自动下线 %d 人', + workstation.code, timeoutSec, affected, + ); + } + } + + return { online: rows.length, offline, workstations: touched }; + } + + /** + * 批量取「这些扫码记录当时的在线成员」 + * + * @param {Array<{key:*, workstationId:number|string, scanTime:Date|string}>} items + * @return {Promise>>} key 同入参的 `key` + */ + async packersMap(items) { + const map = new Map(); + const list = Array.isArray(items) ? items.filter(item => item && item.workstationId && item.scanTime) : []; + if (!list.length) return map; + + const workstationIds = [ ...new Set(list.map(item => Number(item.workstationId))) ]; + const times = list.map(item => new Date(item.scanTime).getTime()); + // 多留 1 秒余量:设备上报的扫码时间是**秒级**,落在数据库里会被截断到整秒, + // 不放大一点的话「登录与扫码同一秒」会被判成扫码早于登录而漏掉 + const minTime = new Date(Math.min(...times) - SECOND); + const maxTime = new Date(Math.max(...times) + SECOND); + + const rows = await this.Record.findAll({ + where: { + workstationId: { [Op.in]: workstationIds }, + loginAt: { [Op.lte]: maxTime }, + [Op.or]: [ + { logoutAt: null }, + { logoutAt: { [Op.gte]: minTime } }, + ], + }, + attributes: [ 'id', 'subjectId', 'workstationId', 'userId', 'memberId', 'name', 'type', 'loginCode', 'loginAt', 'logoutAt', 'status', 'logoutReason', 'loginIp' ], + order: [[ 'loginAt', 'ASC' ], [ 'id', 'ASC' ]], + }); + + // 按工作台分组,减少逐条扫描量 + const byWorkstation = new Map(); + for (const row of rows) { + const key = Number(row.workstationId); + if (!byWorkstation.has(key)) byWorkstation.set(key, []); + byWorkstation.get(key).push(row); + } + + for (const item of list) { + const candidates = byWorkstation.get(Number(item.workstationId)) || []; + const at = new Date(item.scanTime).getTime(); + map.set(item.key, candidates.filter(row => covers(row, at)).map(row => this.present(row))); + } + + return map; + } + + /** 统一输出(camelCase,前端/桌面端直接用) */ + present(row) { + const data = row && typeof row.toJSON === 'function' ? row.toJSON() : (row || {}); + return { + id: Number(data.id), + subjectId: Number(data.subjectId), + workstationId: Number(data.workstationId), + userId: Number(data.userId), + memberId: data.memberId ? Number(data.memberId) : null, + name: data.name || '', + type: Number(data.type) || LOGIN_TYPE.SCAN, + loginCode: data.loginCode || null, + loginAt: data.loginAt, + logoutAt: data.logoutAt || null, + status: Number(data.status), + logoutReason: data.logoutReason || null, + loginIp: data.loginIp || null, + }; + } +} + +/** 时间参数解析:支持 `2026-10-24 12:00:00` / `2026/10/24 12:00` / 10 位或 13 位时间戳 */ +function parseTime(value) { + if (value === undefined || value === null || value === '') return null; + if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value; + + const str = String(value).trim(); + if (!str) return null; + + let date; + if (/^\d{10}$/.test(str)) { + date = new Date(Number(str) * 1000); + } else if (/^\d{13}$/.test(str)) { + date = new Date(Number(str)); + } else { + date = new Date(str.replace(/\//g, '-').replace(' ', 'T')); + } + return date && !Number.isNaN(date.getTime()) ? date : null; +} + +/** 这条登录记录是否覆盖某个时间点(在线中 = 到当前时间为止) */ +function covers(row, at) { + const toSec = value => Math.floor(value / SECOND) * SECOND; + const loginAt = toSec(new Date(row.loginAt).getTime()); + const point = toSec(at); + if (loginAt > point) return false; + if (!row.logoutAt) return true; + return toSec(new Date(row.logoutAt).getTime()) >= point; +} + +module.exports = WorkstationLoginService; diff --git a/backend/database/migrations/20261024100000-add-workstation-login-fields.js b/backend/database/migrations/20261024100000-add-workstation-login-fields.js new file mode 100644 index 0000000..367ef2b --- /dev/null +++ b/backend/database/migrations/20261024100000-add-workstation-login-fields.js @@ -0,0 +1,99 @@ +'use strict'; + +const crypto = require('crypto'); + +/** 登录码字符集(去掉容易看错的 0/O/1/I) */ +const ALPHABET = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ'; + +/** + * 生成一个工作台登录码(形如 `WSC-7K3M9QX2AB`) + * + * ⚠️ 这张码后来被**废弃**了(见 20261028121000-drop-workstation-login-code): + * 扫码登入改走微信登录网关。这里保留一份自包含的生成逻辑, + * 只是为了这个迁移能被完整重放(新库从零跑迁移时不会缺依赖)。 + */ +function generateLoginCode() { + let out = ''; + for (let i = 0; i < 10; i++) { + out += ALPHABET[crypto.randomInt(ALPHABET.length)]; + } + return `WSC-${out}`; +} + +/** 不活跃自动下线默认值:散单 30 分钟 */ +const DEFAULT_IDLE_TIMEOUT_SEC = 30 * 60; +/** 团购 1 小时 */ +const GROUP_IDLE_TIMEOUT_SEC = 60 * 60; + +/** + * 工作台登录相关字段 + * + * - `login_code`:现场贴的登录码(前缀 `WSC-`,建工作台时生成;重置后旧码立即失效) + * - `last_active_at`:最后活跃时间(扫码上报时刷新),配合 `idle_timeout_sec` 做自动下线 + * - `idle_timeout_sec`:多少秒不活跃自动下线该工作台所有在线成员 + * 团购(ws_type=2)默认 3600 秒,散单默认 1800 秒 + * + * 已有工作台在这里回填登录码(唯一索引不能有 NULL 重复,必须逐条生成)。 + */ +module.exports = { + async up(queryInterface, Sequelize) { + const { STRING, INTEGER, DATE } = Sequelize; + + await queryInterface.addColumn('workstations', 'login_code', { + type: STRING(64), + allowNull: true, + after: 'code', + comment: '登录码(扫码登入本工作台,前缀 WSC-)', + }); + + await queryInterface.addColumn('workstations', 'last_active_at', { + type: DATE, + allowNull: true, + after: 'status', + comment: '最后活跃时间(扫码上报时刷新)', + }); + + await queryInterface.addColumn('workstations', 'idle_timeout_sec', { + type: INTEGER.UNSIGNED, + allowNull: false, + defaultValue: DEFAULT_IDLE_TIMEOUT_SEC, + after: 'last_active_at', + comment: '多少秒不活跃自动下线所有成员(团购 3600 / 散单 1800)', + }); + + // 回填:历史工作台也要有登录码(唯一索引下不允许 NULL,也不允许重复) + const rows = await queryInterface.sequelize.query( + 'SELECT id, ws_type FROM workstations', + { type: queryInterface.sequelize.QueryTypes.SELECT }, + ); + const used = new Set(); + for (const row of rows) { + let code = generateLoginCode(); + while (used.has(code)) code = generateLoginCode(); + used.add(code); + + await queryInterface.sequelize.query( + 'UPDATE workstations SET login_code = ?, idle_timeout_sec = ? WHERE id = ?', + { + replacements: [ + code, + Number(row.ws_type) === 2 ? GROUP_IDLE_TIMEOUT_SEC : DEFAULT_IDLE_TIMEOUT_SEC, + row.id, + ], + }, + ); + } + + await queryInterface.addIndex('workstations', [ 'login_code' ], { + name: 'uk_workstations_login_code', + unique: true, + }); + }, + + async down(queryInterface) { + await queryInterface.removeIndex('workstations', 'uk_workstations_login_code'); + await queryInterface.removeColumn('workstations', 'idle_timeout_sec'); + await queryInterface.removeColumn('workstations', 'last_active_at'); + await queryInterface.removeColumn('workstations', 'login_code'); + }, +}; diff --git a/backend/database/migrations/20261024101000-create-workstation-login-records.js b/backend/database/migrations/20261024101000-create-workstation-login-records.js new file mode 100644 index 0000000..eb028e8 --- /dev/null +++ b/backend/database/migrations/20261024101000-create-workstation-login-records.js @@ -0,0 +1,81 @@ +'use strict'; + +/** + * 成员登录记录表(workstation_login_records) + * + * 一行 = 某个成员在某台工作台上的一次登录(扫码登录): + * - `status = 1` 表示**还在线**,`logout_at` 为空; + * - `status = 0` 表示已下线(手动下线 / 重置登录码 / 长时间不活跃),`logout_at` + `logout_reason` 有值。 + * + * 两种用途: + * 1. 工作台「当前成员」:`status = 1` 且 `workstation_id = ?`; + * 2. 运单回放定位打包人:按 `workstation_id + login_at/logout_at` 找「该次扫码发生时还在线的人」, + * 所以 `(workstation_id, login_at)` 必须有索引。 + * + * `name` 是登录当时记下的名字:属于该主体的成员记成员姓名(= 工号),否则记用户自己设置的昵称。 + * `type` 预留给后续的登录方式扩展(当前只有 1 扫码登录)。 + * + * 本表是流水 + 状态表,**不用软删除**,需要清理按时间物理删除。 + */ +module.exports = { + async up(queryInterface, Sequelize) { + const { BIGINT, STRING, TINYINT, DATE, literal } = Sequelize; + + await queryInterface.createTable('workstation_login_records', { + id: { type: BIGINT.UNSIGNED, primaryKey: true, autoIncrement: true, comment: '主键' }, + subject_id: { type: BIGINT.UNSIGNED, allowNull: false, comment: '所属主体 subjects.id' }, + workstation_id: { type: BIGINT.UNSIGNED, allowNull: false, comment: '工作台 workstations.id' }, + user_id: { type: BIGINT.UNSIGNED, allowNull: false, comment: '登录用户 users.id' }, + member_id: { type: BIGINT.UNSIGNED, allowNull: true, comment: '主体成员 subject_members.id(非成员为空)' }, + name: { type: STRING(64), allowNull: false, defaultValue: '', comment: '登录时记录的名字(成员工号/姓名,非成员用昵称)' }, + type: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 1, comment: '登录类型:1 扫码登录(预留后续扩展)' }, + login_code: { type: STRING(64), allowNull: true, comment: '登录时使用的工作台登录码(重置后便于对账)' }, + login_at: { type: DATE, allowNull: false, comment: '登录时间' }, + logout_at: { type: DATE, allowNull: true, comment: '下线时间(在线为空)' }, + status: { type: TINYINT.UNSIGNED, allowNull: false, defaultValue: 1, comment: '状态:1在线 0已下线' }, + logout_reason: { type: STRING(32), allowNull: true, comment: '下线原因:manual / reset_code / idle_timeout / relogin' }, + login_ip: { type: STRING(45), allowNull: true, comment: '登录 IP' }, + created_at: { + type: DATE, + allowNull: false, + defaultValue: literal('CURRENT_TIMESTAMP'), + comment: '创建时间', + }, + updated_at: { + type: DATE, + allowNull: false, + defaultValue: literal('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'), + comment: '更新时间', + }, + }, { + engine: 'InnoDB', + charset: 'utf8mb4', + collate: 'utf8mb4_general_ci', + comment: '工作台成员登录记录表', + }); + + // 按「工作台 + 时间」查历史(运单回放定位打包人) + await queryInterface.addIndex('workstation_login_records', [ 'workstation_id', 'login_at' ], { + name: 'idx_wlr_ws_login_at', + }); + // 当前在线成员(工作台详情弹窗) + await queryInterface.addIndex('workstation_login_records', [ 'workstation_id', 'status' ], { + name: 'idx_wlr_ws_status', + }); + // 一个人在多台工作台上的在线状态 + await queryInterface.addIndex('workstation_login_records', [ 'user_id', 'status' ], { + name: 'idx_wlr_user_status', + }); + await queryInterface.addIndex('workstation_login_records', [ 'subject_id', 'login_at' ], { + name: 'idx_wlr_subject_login_at', + }); + // 定时任务每分钟扫「还在线」的记录 + await queryInterface.addIndex('workstation_login_records', [ 'status' ], { + name: 'idx_wlr_status', + }); + }, + + async down(queryInterface) { + await queryInterface.dropTable('workstation_login_records'); + }, +}; diff --git a/backend/database/migrations/20261024102000-add-workstation-camera-label-flag.js b/backend/database/migrations/20261024102000-add-workstation-camera-label-flag.js new file mode 100644 index 0000000..9f24214 --- /dev/null +++ b/backend/database/migrations/20261024102000-add-workstation-camera-label-flag.js @@ -0,0 +1,23 @@ +'use strict'; + +/** + * 工作台-摄像头绑定:面单摄像头标记 + * + * 散单工作台在「绑定管理」里可以把某一路摄像头设为**面单摄像头**(正对运单特写的画面)。 + * 团购工作台没有这个概念:接口拒绝对团购工作台设置,存量值固定为 0。 + */ +module.exports = { + async up(queryInterface, Sequelize) { + await queryInterface.addColumn('workstation_cameras', 'is_label_camera', { + type: Sequelize.TINYINT.UNSIGNED, + allowNull: false, + defaultValue: 0, + after: 'stream_type', + comment: '是否面单摄像头:1 是 0 否(仅散单工作台)', + }); + }, + + async down(queryInterface) { + await queryInterface.removeColumn('workstation_cameras', 'is_label_camera'); + }, +}; diff --git a/backend/test/app/controller/workstation-camera-label.test.js b/backend/test/app/controller/workstation-camera-label.test.js new file mode 100644 index 0000000..f5ecbc8 --- /dev/null +++ b/backend/test/app/controller/workstation-camera-label.test.js @@ -0,0 +1,227 @@ +'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, +); + +/** + * 工作台「面单摄像头」(`workstation_cameras.is_label_camera`) + * + * 1. 散单 / 团购工作台都可以设置、取消,一台工作台只保留一路(设新的先清旧的); + * 2. 记录规则的区别在设备端(按工作台类型:散单取第一次、团购取最后一次),后端只存标记。 + */ +describe('test/app/controller/workstation-camera-label.test.js', () => { + const me = { id: 1, username: 'admin', nickname: '小王', status: 1, passwordChangedAt: null }; + const SUBJECT_ID = 5; + const WS_ID = 3; + const CAMERA_ID = 21; + + 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 withToken = (req) => req.set('Authorization', token()); + const withSubject = (req) => withToken(req).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 = (wsType) => instance({ + id: WS_ID, + subjectId: SUBJECT_ID, + code: 'WS-01', + name: '1号工作台', + wsType, + status: 1, + }); + + /** 已绑定的摄像头(详情里的 `cameras[]`) */ + const cameraLink = () => instance({ + id: 31, + workstationId: WS_ID, + cameraId: CAMERA_ID, + sortNo: 1, + streamType: 0, + isLabelCamera: 0, + camera: { + id: CAMERA_ID, + name: '面单特写', + channelNo: 2, + nvr: { id: 9, name: '录像机', host: '192.168.1.64', port: 8000 }, + }, + }); + + /** 主体 / 用户 / 成员三件套(鉴权与主体上下文都要用) */ + function baseModels(extra = {}) { + return Object.assign({ + User: { async findByPk() { return instance(me); } }, + Subject: { async findByPk() { return subjectInstance(); } }, + SubjectMember: { async findOne() { return memberInstance(); } }, + }, extra); + } + + it('PUT .../cameras/:cameraId/label:散单设置面单摄像头(先清掉旧的)', async () => { + const ws = workstation(1); + const link = cameraLink(); + const cleared = []; + + mock(app, 'model', baseModels({ + Workstation: { async findByPk() { return ws; } }, + WorkstationCamera: { + async findOne() { return link; }, + async update(fields, options) { + cleared.push({ fields, options }); + return [ 1 ]; + }, + async findAll() { return [ link ]; }, + }, + WorkstationScanChannel: { async findAll() { return []; } }, + })); + + const res = await withSubject(app.httpRequest() + .put(`/api/web/workstations/${WS_ID}/cameras/${CAMERA_ID}/label`) + .send({ isLabelCamera: true })) + .expect(200); + + 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); + }); + + it('PUT .../cameras/:cameraId/label:团购工作台也能设置(设备端按 wsType 决定记录规则)', async () => { + const ws = workstation(2); + const link = cameraLink(); + const cleared = []; + + mock(app, 'model', baseModels({ + Workstation: { async findByPk() { return ws; } }, + WorkstationCamera: { + async findOne() { return link; }, + async update(fields, options) { + cleared.push({ fields, options }); + return [ 1 ]; + }, + async findAll() { return [ link ]; }, + }, + WorkstationScanChannel: { async findAll() { return []; } }, + })); + + const res = await withSubject(app.httpRequest() + .put(`/api/web/workstations/${WS_ID}/cameras/${CAMERA_ID}/label`) + .send({ isLabelCamera: true })) + .expect(200); + + assert(res.body.data.cameras[0].isLabelCamera === 1, '团购设置后详情里也要带 isLabelCamera=1'); + assert(link.toJSON().isLabelCamera === 1); + assert(cleared.length === 1, '团购同样只保留一路'); + }); + + it('PUT .../cameras/:cameraId/label:不传 isLabelCamera = 设置;false = 取消', 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 update() { 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; } }, + })); + + await withSubject(app.httpRequest() + .put(`/api/web/workstations/${WS_ID}/cameras/${CAMERA_ID}/label`)) + .expect(200); + assert(link.toJSON().isLabelCamera === 1, '不传按「设置」处理'); + assert(released.length === 0, '设置时不动通道'); + + 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, '传 false 要取消面单'); + assert(res.body.data.cameras[0].isLabelCamera === 0); + assert(released.length === 1, '取消面单要顺手清掉虚拟通道'); + assert(released[0].channelId === `CAM-${WS_ID}`, JSON.stringify(released[0])); + }); + + it('设置/取消面单摄像头 → 立刻叫醒设备重拉配置(不能等兜底轮询)', async () => { + const ws = workstation(1); + const link = cameraLink(); + const notified = []; + + app.mockService('labelScan', 'notifyChanged', async subjectId => { + notified.push(subjectId); + return 1; + }); + + mock(app, 'model', baseModels({ + Workstation: { async findByPk() { return ws; } }, + WorkstationCamera: { + async findOne() { return link; }, + async update() { return [ 1 ]; }, + async findAll() { return [ link ]; }, + }, + WorkstationScanChannel: { + async findAll() { return []; }, + async destroy() { return 1; }, + async count() { return 0; }, + }, + ScanChannel: { async destroy() { return 1; } }, + })); + + await withSubject(app.httpRequest() + .put(`/api/web/workstations/${WS_ID}/cameras/${CAMERA_ID}/label`) + .send({ isLabelCamera: true })) + .expect(200); + + await withSubject(app.httpRequest() + .put(`/api/web/workstations/${WS_ID}/cameras/${CAMERA_ID}/label`) + .send({ isLabelCamera: false })) + .expect(200); + + assert(notified.length === 2, `设置和取消都要通知,实际 ${notified.length} 次`); + assert(notified.every(id => id === SUBJECT_ID), JSON.stringify(notified)); + }); +}); diff --git a/backend/test/app/controller/workstation-login.test.js b/backend/test/app/controller/workstation-login.test.js new file mode 100644 index 0000000..2a39d63 --- /dev/null +++ b/backend/test/app/controller/workstation-login.test.js @@ -0,0 +1,246 @@ +'use strict'; + +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, +); + +/** + * 工作台成员登录(`workstation_login_records`) + * + * 登入方式已改为「微信登录网关扫码」:网关回调确认了「谁」之后, + * 由 `service/wxGateway` 调 `service/workstationLogin.loginByUser()` 落地(见 wx-gateway.test.js)。 + * + * 这里只盯最容易错的三件事: + * 1. **名字**:属于工作台所属主体的成员 → 记成员姓名(= 工号);否则记用户昵称; + * 2. **在线唯一**:同一个人重新登录 → 旧记录按 `relogin` 下线,只留一条在线; + * 3. **下线**:手动下线 / 一键全部下线都要写 `status=0 + logout_at`,历史记录保留。 + */ +describe('test/app/controller/workstation-login.test.js', () => { + const me = { id: 1, username: 'admin', nickname: '小王', status: 1 }; + const SUBJECT_ID = 5; + + const BEARER = 'Bearer'; + const token = () => app.createAnonymousContext().service.jwt.signUser(me); + const withToken = (req) => req.set('Authorization', BEARER + ' ' + token()); + const withSubject = (req) => withToken(req).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 = (name = 'K0012') => instance({ + id: 11, + subjectId: SUBJECT_ID, + userId: 1, + name, + role: 1, + status: 1, + }); + + /** 主体/用户/成员三件套(登录与主体上下文都要用) */ + function baseModels(extra = {}) { + return Object.assign({ + User: { async findByPk() { return instance(me); } }, + Subject: { async findByPk() { return subjectInstance(); } }, + SubjectMember: { async findOne() { return memberInstance(); } }, + }, extra); + } + + /** 直接调 service(扫码确认那一步在网关回调里,不经过 HTTP) */ + const loginByUser = (params) => app.createAnonymousContext().service.workstationLogin.loginByUser(params); + + it('service.workstationLogin.loginByUser:主体成员 → 记录成员姓名(工号)', async () => { + let created = null; + let lastActiveAt = null; + const workstation = instance({ + id: 3, + subjectId: SUBJECT_ID, + code: 'WS-01', + name: '1号工作台', + wsType: 2, + status: 1, + update: async (fields) => { lastActiveAt = fields.lastActiveAt; }, + }); + + mock(app, 'model', baseModels({ + WorkstationLoginRecord: { + async update(fields, options) { + assert(options.where.userId === 1 && options.where.status === 1, '只下线同一个人原来的在线记录'); + assert(fields.logoutReason === 'relogin'); + return [ 0 ]; + }, + async create(row) { created = row; return instance(Object.assign({ id: 99 }, row)); }, + }, + })); + + const data = await loginByUser({ user: me, workstation }); + + assert(data.isMember === true, JSON.stringify(data)); + assert(data.name === 'K0012'); + assert(data.workstation.id === 3); + assert(data.workstation.subjectName === '测试主体'); + assert(created.name === 'K0012', '成员登录要记成员姓名(工号)'); + assert(created.status === 1 && created.type === 1, '默认在线 + 扫码登录类型'); + assert(created.memberId === 11); + assert(lastActiveAt instanceof Date, '登录也要刷新工作台最后活跃时间'); + }); + + it('service.workstationLogin.loginByUser:不是主体成员 → 记用户昵称', async () => { + let created = null; + mock(app, 'model', baseModels({ + SubjectMember: { async findOne() { return null; } }, + WorkstationLoginRecord: { + async update() { return [ 0 ]; }, + async create(row) { created = row; return instance(Object.assign({ id: 100 }, row)); }, + }, + })); + + const data = await loginByUser({ + user: me, + workstation: instance({ + id: 4, + subjectId: SUBJECT_ID, + code: 'WS-02', + name: '2号工作台', + wsType: 1, + status: 1, + }), + }); + + assert(data.isMember === false, JSON.stringify(data)); + assert(data.name === '小王', '非成员用自己设置的昵称'); + assert(created.name === '小王' && created.memberId === null); + }); + + it('service.workstationLogin.loginByUser:工作台停用 → 403;主体过期 → 403', async () => { + mock(app, 'model', baseModels({ + WorkstationLoginRecord: { async update() { return [ 0 ]; } }, + })); + + await assert.rejects( + () => loginByUser({ + user: me, + workstation: instance({ id: 5, subjectId: SUBJECT_ID, code: 'WS-03', status: 0 }), + }), + err => err.status === 403 && /停用/.test(err.message), + ); + + mock(app, 'model', baseModels({ + Subject: { + async findByPk() { + return instance({ + id: 6, + name: '过期主体', + adminUserId: 1, + status: 1, + expireAt: new Date(Date.now() - 1000), + }); + }, + }, + WorkstationLoginRecord: { async update() { return [ 0 ]; } }, + })); + + await assert.rejects( + () => loginByUser({ + user: me, + workstation: instance({ id: 6, subjectId: 6, code: 'WS-04', status: 1 }), + }), + err => err.status === 403 && /使用期限已到/.test(err.message), + ); + }); + + const onlineRecord = () => instance({ + id: 21, + subjectId: SUBJECT_ID, + workstationId: 3, + userId: 1, + memberId: 11, + name: 'K0012', + type: 1, + loginAt: new Date('2026-10-24T09:00:00+08:00'), + logoutAt: null, + status: 1, + logoutReason: null, + loginIp: '127.0.0.1', + }); + + it('GET /api/web/workstations/:id/members?status=1:只看在线,带在线人数', async () => { + mock(app, 'model', baseModels({ + Workstation: { + async findByPk() { + return instance({ id: 3, subjectId: SUBJECT_ID, code: 'WS-01', name: '1号工作台' }); + }, + }, + WorkstationLoginRecord: { + async findAndCountAll(options) { + assert(options.where.workstationId === 3, '必须按工作台过滤'); + assert(options.where.status === 1, 'status=1 时只看在线'); + // 时间段过滤(配合工作台 id 查「昨天这台工作台上是谁」) + assert(options.where.loginAt, '带时间段时必须有 loginAt 条件'); + assert(Object.getOwnPropertySymbols(options.where.loginAt).length === 2, '起止时间都要带上'); + return { rows: [ onlineRecord() ], count: 1 }; + }, + async count() { return 1; }, + }, + })); + + const res = await withSubject(app.httpRequest() + .get('/api/web/workstations/3/members?status=1&startTime=2026-10-24%2000:00:00&endTime=2026-10-25%2000:00:00')) + .expect(200); + assert(res.body.data.onlineCount === 1, JSON.stringify(res.body)); + assert(res.body.data.list[0].name === 'K0012'); + assert(res.body.data.list[0].status === 1); + }); + + it('POST /api/web/workstations/:id/members/:recordId/offline:写下线时间与原因', async () => { + const record = onlineRecord(); + mock(app, 'model', baseModels({ + Workstation: { + async findByPk() { + return instance({ id: 3, subjectId: SUBJECT_ID, code: 'WS-01' }); + }, + }, + WorkstationLoginRecord: { + async findOne() { return record; }, + }, + })); + + const res = await withSubject(app.httpRequest().post('/api/web/workstations/3/members/21/offline')).expect(200); + + assert(res.body.data.status === 0, JSON.stringify(res.body)); + assert(res.body.data.logoutReason === 'manual'); + assert(record.toJSON().logoutAt instanceof Date, '必须记录下线时间'); + }); + + it('POST /api/web/workstations/:id/members/offline-all:把在线成员全部下线', async () => { + mock(app, 'model', baseModels({ + Workstation: { + async findByPk() { + return instance({ id: 3, subjectId: SUBJECT_ID, code: 'WS-01' }); + }, + }, + WorkstationLoginRecord: { + async update(fields, options) { + assert(options.where.workstationId === 3 && options.where.status === 1, '只下线本工作台的在线记录'); + assert(fields.logoutReason === 'offline_all'); + return [ 2 ]; + }, + }, + })); + + const res = await withSubject(app.httpRequest().post('/api/web/workstations/3/members/offline-all')).expect(200); + + assert(res.body.data.offline === 2, JSON.stringify(res.body)); + }); +}); diff --git a/backend/test/app/service/label-scan.test.js b/backend/test/app/service/label-scan.test.js new file mode 100644 index 0000000..5888e0c --- /dev/null +++ b/backend/test/app/service/label-scan.test.js @@ -0,0 +1,213 @@ +'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 }) { + mock(app, 'model', { + Workstation: { async findAll() { return workstations; } }, + WorkstationCamera: { async findAll() { return links; } }, + 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('工作台没绑本机通道 → 用虚拟通道 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('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,不向调用方抛异常'); + }); + }); +}); diff --git a/desktop/App.xaml.cs b/desktop/App.xaml.cs index b8af8d3..35840f9 100644 --- a/desktop/App.xaml.cs +++ b/desktop/App.xaml.cs @@ -53,6 +53,9 @@ public partial class App : Application /// 正在检查 / 正在弹更新窗:避免自动检查与菜单「检查更新」并发弹两个窗 private bool _updatePrompting; + /// 登录窗还没关时查到的更新:等主窗口显示完再弹(不能塞在登录窗的模态循环里) + private (UpdateInfo Info, Version Current)? _pendingUpdate; + /// NTP 定时校时(运行期间周期性把本机时钟校准到 NTP) private System.Threading.Timer? _ntpTimer; @@ -185,8 +188,17 @@ public partial class App : Application ShowMainWindow(); + // 登录窗关掉之后才弹更新提示(登录期间查到的先攒着,见 CheckUpdatesAsync) + if (_pendingUpdate is { } pending) + { + _pendingUpdate = null; + _ = ShowUpdatePromptAsync(pending.Info, pending.Current); + } // 启动那次检查失败(断网 / 服务未就绪)就在登录后补一次;成功过就不再重复弹窗 - if (!_updateCheckDone) _ = CheckUpdatesAsync(); + else if (!_updateCheckDone) + { + _ = CheckUpdatesAsync(); + } } /// @@ -209,38 +221,18 @@ public partial class App : Application AppLog.Write($"发现新版本 {info.Version}(当前 {current}):{info.DownloadUrl}"); - // 软件内弹窗 + 进度条下载 + 自动安装(不跳浏览器) - AppLog.Write("准备显示更新窗口…"); - var update = new UpdateWindow(info, current) + // ⚠️ 登录窗是模态 ShowDialog:**不能在它的嵌套消息循环里再弹一个模态窗**。 + // 实测过:登录窗恢复登录后 DialogResult=true → 它要关闭,但挂着「它自己的模态子窗」时 + // Windows 会把父子窗一起隐藏、关闭被推迟,两个模态循环互相等 → 主界面永远出不来。 + // 所以登录还没结束就先记下,等主窗口显示完再弹(ShowMainWindow 里接着处理)。 + if (_loginWindow is { IsVisible: true }) { - // 回归测试用:YUNCANG_AUTO_UPDATE=1 时不点按钮直接开始下载 - AutoStart = Environment.GetEnvironmentVariable("YUNCANG_AUTO_UPDATE") == "1", - }; - - // 登录窗是模态 ShowDialog,正开着就挂它做 Owner + Topmost: - // 否则更新窗会被登录页压在后面,表现就是「卡在登录页收不到更新提示」。 - if (_loginWindow is { IsVisible: true } login) - { - update.Owner = login; - update.Topmost = true; - } - // 主窗口在显示时才挂 Owner(托盘隐藏状态下挂 Owner,子窗口也会被一起藏掉) - else if (_main is { IsVisible: true } main) - { - update.Owner = main; - } - else - { - update.Topmost = true; + _pendingUpdate = (info, current); + AppLog.Write("登录窗还开着:更新提示等主窗口出来后再弹"); + return; } - var result = update.ShowDialog(); - AppLog.Write($"更新窗口返回:{result}"); - if (result == true) - { - AppLog.Write("更新已开始安装,退出本程序以释放 exe"); - ExitApplication(); - } + await ShowUpdatePromptAsync(info, current); } catch (Exception ex) { @@ -252,6 +244,33 @@ public partial class App : Application } } + /// + /// 弹出更新窗(下载 + 安装)。**只允许在没有其他模态窗时调用**(见 )。 + /// + private Task ShowUpdatePromptAsync(UpdateInfo info, Version current) + { + AppLog.Write("准备显示更新窗口…"); + var update = new UpdateWindow(info, current) + { + // 回归测试用:YUNCANG_AUTO_UPDATE=1 时不点按钮直接开始下载 + AutoStart = Environment.GetEnvironmentVariable("YUNCANG_AUTO_UPDATE") == "1", + }; + + // 主窗口显示着才挂 Owner(托盘隐藏状态下挂 Owner,子窗口会被一起藏掉) + if (_main is { IsVisible: true } main) update.Owner = main; + else update.Topmost = true; + + var result = update.ShowDialog(); + AppLog.Write($"更新窗口返回:{result}"); + if (result == true) + { + AppLog.Write("更新已开始安装,退出本程序以释放 exe"); + ExitApplication(); + } + + return Task.CompletedTask; + } + /// /// 把 yuncang://open?code=xxx 的注册表项校正到当前 exe。 /// 已经指向当前 exe 时什么都不做(幂等,每次启动都能安全调用)。 @@ -445,7 +464,13 @@ public partial class App : Application var server = _server; var session = _session; var api = _api; - if (server is null || session is null || api is null) return; + if (server is null || session is null || api is null) + { + // 以前这里静默返回 → 表现就是「进程在跑、托盘有图标、但主界面永远出不来」,查不到原因 + AppLog.Write($"[app] 主窗口没建:server={(server is null ? "空" : "有")} " + + $"session={(session is null ? "空" : "有")} api={(api is null ? "空" : "有")}"); + return; + } if (_main is null) { @@ -598,7 +623,8 @@ public partial class App : Application return; } - // 第二次双击 exe(没带 URL):有主窗口就显示,还在登录就把登录窗叫到前面 + // 第二次双击快捷方式(没带 URL / 只带 --show):有主窗口就显示,还在登录就把登录窗叫到前面 + AppLog.Write("另一个实例请求打开界面"); if (_main is null) BringLoginWindowToFront(); else ShowAppWindow(); }); diff --git a/desktop/MainWindow.xaml b/desktop/MainWindow.xaml index edad33e..3b0d6f8 100644 --- a/desktop/MainWindow.xaml +++ b/desktop/MainWindow.xaml @@ -149,6 +149,10 @@ + + + + diff --git a/desktop/MainWindow.xaml.cs b/desktop/MainWindow.xaml.cs index 827ed34..15d8a44 100644 --- a/desktop/MainWindow.xaml.cs +++ b/desktop/MainWindow.xaml.cs @@ -40,6 +40,7 @@ public partial class MainWindow : Window private readonly ScanService _scan; private readonly ScanTabView _scanTabView; private readonly ScanRecordsView _scanRecordsView; + private readonly LabelCameraView _labelCameraView; /// 运单回放查询(后端 `/api/web/pack-query`,用当前主体的用户令牌) private readonly OrderQueryService _queryService; @@ -126,6 +127,10 @@ public partial class MainWindow : Window _scanRecordsView = new ScanRecordsView(_scan); RecordsTabHost.Content = _scanRecordsView; + // 面单摄像头页:单独一个页签(列表 + 最近识别到的条码),与扫码页一同显示/隐藏 + _labelCameraView = new LabelCameraView(_scan); + LabelCameraTabHost.Content = _labelCameraView; + // ⚠️ 扫码**只**落本地记录 + 上报服务器(都发生在 ScanService 内部)。 // 界面上不再订阅扫码事件:历史版本会在每次扫码时自动查一次运单(还会连带自动校验回放), // 用户看到的现象就是「没点查询,打包查询却一直在自动查」。运单查询只允许用户主动发起 @@ -370,10 +375,11 @@ public partial class MainWindow : Window var mismatch = ServiceSubjectMismatch; var canSeeServiceData = !mismatch || isAdmin; - // 扫码通道 / 扫码记录页签只在「扫码服务开着」时出现 + // 扫码通道 / 扫码记录 / 面单摄像头页签只在「扫码服务开着」时出现 var scanTabs = _device.Enabled && canSeeServiceData ? Visibility.Visible : Visibility.Collapsed; ScanTab.Visibility = scanTabs; RecordsTab.Visibility = scanTabs; + LabelCameraTab.Visibility = scanTabs; if (scanTabs == Visibility.Collapsed && MainTabs.SelectedIndex >= 1) MainTabs.SelectedIndex = 0; // 服务主体不一致:统一显示在页签上方(不弹窗,正常进界面) diff --git a/desktop/Services/Agent/AgentFiles.cs b/desktop/Services/Agent/AgentFiles.cs index 7a2da7f..dc299f8 100644 --- a/desktop/Services/Agent/AgentFiles.cs +++ b/desktop/Services/Agent/AgentFiles.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; using System.IO; using System.Text.Json; +using System.Threading; namespace YuncangTrace.LocalService.Services; @@ -60,6 +61,9 @@ public sealed class AgentStatus /// 取流子进程(--hik-worker)状态;没有取流能力时 为 false public AgentHikStatus Hik { get; set; } = new(); + /// 面单识别配置的拉取状态(只拉配置,识别 worker 还没接) + public AgentLabelScanStatus LabelScan { get; set; } = new(); + public string NtpLastSyncAt { get; set; } = ""; public double NtpLastOffsetSeconds { get; set; } public double NtpRoundTripMs { get; set; } @@ -134,6 +138,98 @@ public sealed class AgentHikStatus public DateTime? ProbedAt { get; set; } } +/// 一路面单摄像头的运行状态(桌面端只读展示) +public sealed class AgentLabelCameraStatus +{ + public int WorkstationId { get; set; } + public int CameraId { get; set; } + public string WorkstationName { get; set; } = ""; + public string CameraName { get; set; } = ""; + public string ChannelId { get; set; } = ""; + public string ChannelName { get; set; } = ""; + + /// 工作台 → 摄像头 → 上报通道(**不含密码**) + public string Summary { get; set; } = ""; + + /// 识别中 / 启动中… / 异常 / 已停止 + public string StateText { get; set; } = ""; + + public string LastCode { get; set; } = ""; + + /// 首次识别时间(记录真正用的时间,不会随重复命中刷新) + public DateTime? LastCodeAt { get; set; } + + /// 最近一次命中时间(只用于看摄像头是否在扫) + public DateTime? LastHitAt { get; set; } + + /// 当前码流(主/子 + 分辨率) + public string StreamText { get; set; } = ""; + + /// 最近一帧解码耗时(毫秒,含倾斜补偿) + public double LastDecodeMs { get; set; } + + /// 最近一帧 CV 定位耗时(毫秒,不含解码) + public double LastCvMs { get; set; } + + /// 最近一帧走的路径(ROI / 退避跳过 / 整帧 / 扫角…) + public string LastPath { get; set; } = ""; + + /// ROI 连续解失败次数(≥3 时进入隔帧退避) + public int RoiFailStreak { get; set; } + + /// 同一个码连续解出的次数(≥3 时进入稳态退避) + public int SteadyHits { get; set; } + + /// 从管道读到的总帧数(ffmpeg 实际产出) + public long FramesRead { get; set; } + + /// 按 DecodeFps 限速后丢弃的帧数 + public long FrameThrottled { get; set; } + + /// 解码循环处理的帧总数 + public long FramesDecoded { get; set; } + + /// 等新帧耗时(毫秒) + public double LastWaitMs { get; set; } + + /// 两次取帧之间的完整周期(毫秒) + public double LastLoopMs { get; set; } + + /// 最近一帧自动定位到的条码区域(ROI w x h;未定位时为空文案) + public string RoiText { get; set; } = ""; + + /// 最近一帧「透视矫正 + ZXing 解码」耗时(毫秒) + public double RoiRatio { get; set; } + + /// 最近一次取到帧时积压了几帧(0=实时;>0 说明解码跟不上、旧帧被丢弃) + public long FrameLag { get; set; } + + /// 累计丢弃的旧帧数 + public long FrameDropped { get; set; } + + public long Hits { get; set; } + public string? LastError { get; set; } +} + +/// +/// 面单摄像头识别的整体状态(配置拉取 + 每路运行状态)。 +/// 文案里不含录像机密码。 +/// +public sealed class AgentLabelScanStatus +{ + public bool Pulled { get; set; } + public DateTime? PulledAt { get; set; } + public string Revision { get; set; } = ""; + public string StatusText { get; set; } = ""; + public string? Error { get; set; } + + /// 每路的运行状态(最近条码、状态、错误) + public List Items { get; set; } = new(); + + /// 服务端给的提示(例如工作台没绑本机通道) + public List Warnings { get; set; } = new(); +} + /// 桌面端 → 后台服务的一次性命令(写文件,服务每秒轮询) public sealed class AgentCommand { @@ -257,7 +353,9 @@ public static class AgentFiles try { if (!File.Exists(path)) return null; - using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); + // FileShare.Delete 不能少:写方是「先写 .tmp 再原子替换」, + // 替换时要求目标文件允许删除共享,否则这边读着的那一瞬间写方会「拒绝访问」。 + using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete); using var reader = new StreamReader(stream); var text = reader.ReadToEnd(); return string.IsNullOrWhiteSpace(text) ? null : JsonSerializer.Deserialize(text, Options); @@ -270,18 +368,31 @@ public static class AgentFiles private static void Write(string path, T value) { - try - { - var dir = Path.GetDirectoryName(path); - if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir); + var json = JsonSerializer.Serialize(value, Options); - var temp = path + ".tmp"; - File.WriteAllText(temp, JsonSerializer.Serialize(value, Options)); - File.Move(temp, path, overwrite: true); - } - catch (Exception ex) + // 对方(桌面端界面)会频繁读同一个文件,原子替换偶尔会撞上「拒绝访问」: + // 这里重试几次,不要因为一次碰撞就丢掉这轮状态。 + for (var attempt = 1; ; attempt++) { - AppLog.Write($"[agent] 写文件失败({path}):{ex.Message}"); + try + { + var dir = Path.GetDirectoryName(path); + if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir); + + var temp = path + ".tmp"; + File.WriteAllText(temp, json); + File.Move(temp, path, overwrite: true); + return; + } + catch (Exception ex) when (attempt < 5 && ex is IOException or UnauthorizedAccessException) + { + Thread.Sleep(20); + } + catch (Exception ex) + { + AppLog.Write($"[agent] 写文件失败({path}):{ex.Message}"); + return; + } } } } diff --git a/desktop/Services/Agent/AgentHost.cs b/desktop/Services/Agent/AgentHost.cs index 19e81a5..f4cd559 100644 --- a/desktop/Services/Agent/AgentHost.cs +++ b/desktop/Services/Agent/AgentHost.cs @@ -194,11 +194,13 @@ public static class AgentHost // 边缘任务通道:设备主动出站长轮询领任务(跨公司取流用)。 // 与扫码链路完全解耦:这里出错只记日志,不影响收码上报。 - _ = Task.Run(() => RunEdgeTaskLoopAsync(api, settings, hikWorker, ct), CancellationToken.None); + _ = Task.Run(() => RunEdgeTaskLoopAsync(api, settings, hikWorker, scan, ct), CancellationToken.None); while (!ct.IsCancellationRequested) { - if (!await DelayAsync(TimeSpan.FromSeconds(1), ct).ConfigureAwait(false)) break; + // 400ms 一轮:状态文件写得及时,桌面端才能尽快看到「刚识别到的条码」 + // (识别本身是毫秒级,慢在拉流和解码,不该再被状态刷新拖 1 秒) + if (!await DelayAsync(TimeSpan.FromMilliseconds(400), ct).ConfigureAwait(false)) break; // ① 配置变了(换令牌 / 换服务器 / 改 NTP)→ 外层重建链路 var newConfigTime = AgentFiles.FileTime(AgentPaths.ConfigFile); @@ -499,6 +501,46 @@ public static class AgentHost }).ToList(), LastError = ntp.Error, Hik = hik, + LabelScan = new AgentLabelScanStatus + { + Pulled = scan.LabelScan.Snapshot.PulledAt is not null, + PulledAt = scan.LabelScan.Snapshot.PulledAt, + Revision = scan.LabelScan.Snapshot.Revision, + StatusText = scan.LabelScan.Snapshot.StatusText, + Error = scan.LabelScan.Snapshot.Error, + Items = scan.LabelScan.Runtimes.Select(runtime => new AgentLabelCameraStatus + { + WorkstationId = runtime.WorkstationId, + CameraId = runtime.CameraId, + WorkstationName = runtime.WorkstationName, + CameraName = runtime.CameraName, + ChannelId = runtime.ChannelId, + ChannelName = runtime.ChannelName, + Summary = runtime.Summary, + StateText = runtime.StateText, + LastCode = runtime.LastCode, + LastCodeAt = runtime.LastCodeAt, + LastHitAt = runtime.LastHitAt, + StreamText = runtime.StreamText, + LastDecodeMs = runtime.LastDecodeMs, + LastCvMs = runtime.LastCvMs, + LastPath = runtime.LastPath, + RoiFailStreak = runtime.RoiFailStreak, + SteadyHits = runtime.SteadyHits, + FramesRead = runtime.FramesRead, + FrameThrottled = runtime.FrameThrottled, + FramesDecoded = runtime.FramesDecoded, + LastWaitMs = runtime.LastWaitMs, + LastLoopMs = runtime.LastLoopMs, + RoiText = runtime.RoiText, + RoiRatio = runtime.RoiRatio, + FrameLag = runtime.FrameLag, + FrameDropped = runtime.FrameDropped, + Hits = runtime.Hits, + LastError = runtime.LastError, + }).ToList(), + Warnings = scan.LabelScan.Snapshot.Warnings.Select(item => item.Display).ToList(), + }, LogDropped = AppLog.Dropped, LogLastDroppedAt = AppLog.LastDroppedAt, NtpLastSyncAt = ntp.LastSyncAt, @@ -515,7 +557,7 @@ public static class AgentHost /// 这里任何异常都只记日志并退避重试,绝不影响扫码链路。 /// private static async Task RunEdgeTaskLoopAsync(ApiClient api, AppSettings settings, - HikWorkerSupervisor worker, CancellationToken ct) + HikWorkerSupervisor worker, ScanService scan, CancellationToken ct) { var retryMs = 1000; @@ -530,7 +572,7 @@ public static class AgentHost AppLog.Write($"[edge] 领到任务 {task.Id}({task.Type})"); - var (result, ok) = await ExecuteEdgeTaskAsync(api, settings, worker, task, ct).ConfigureAwait(false); + var (result, ok) = await ExecuteEdgeTaskAsync(api, settings, worker, scan, task, ct).ConfigureAwait(false); await api.SubmitEdgeTaskResultAsync(settings.DeviceToken, task.Id, result, ct) .ConfigureAwait(false); @@ -551,12 +593,26 @@ public static class AgentHost /// 执行一个边缘任务;返回要回传给云端的结果对象 private static async Task<(object Result, bool Ok)> ExecuteEdgeTaskAsync(ApiClient api, AppSettings settings, - HikWorkerSupervisor worker, ApiClient.EdgeTask task, CancellationToken ct) + HikWorkerSupervisor worker, ScanService scan, ApiClient.EdgeTask task, CancellationToken ct) { try { switch (task.Type) { + case "labelScan.refresh": + { + // 只是「叫醒」:真正的配置以 GET /api/scanner/label-cameras 为准 + await scan.LabelScan.RefreshAsync("服务端通知变更", ct).ConfigureAwait(false); + var snapshot = scan.LabelScan.Snapshot; + return (new + { + ok = string.IsNullOrWhiteSpace(snapshot.Error), + count = snapshot.Items.Count, + revision = snapshot.Revision, + error = snapshot.Error, + }, string.IsNullOrWhiteSpace(snapshot.Error)); + } + case "check": { var data = await worker.CheckAsync(task.Payload, ct).ConfigureAwait(false); diff --git a/desktop/Services/DeviceService.cs b/desktop/Services/DeviceService.cs index 98cba16..5b3f20a 100644 --- a/desktop/Services/DeviceService.cs +++ b/desktop/Services/DeviceService.cs @@ -58,6 +58,14 @@ public sealed class DeviceService // 这种事件不能每条都写日志,否则一天几万行;同一个 通道+条码 5 分钟记一次。 private static readonly ConcurrentDictionary TouchedLogAt = new(); + /// 散单通道「同一张面单还在扫」的判定窗口:这之内再扫到同一个码只算一次 + private static readonly TimeSpan FirstSeenGap = TimeSpan.FromSeconds(5); + + // 散单通道的在场记录:key = 通道|条码 → (首次扫到, 最近扫到) + private readonly Dictionary _firstSeen = + new(StringComparer.OrdinalIgnoreCase); + private readonly object _firstSeenGate = new(); + private static bool ShouldLogTouched(string channel, string code) { var key = $"{channel}|{code}"; @@ -239,6 +247,14 @@ public sealed class DeviceService _settings.Save(); } + /// + /// 通道 → 工作台类型(1 散单 / 2 团购 / 0 未知),由 注入。 + /// + /// 散单的扫码枪也按「时间取**第一次** + 立即上报」记(和散单面单摄像头一致); + /// 团购(或未知)仍按「静默 5 秒、时间取最后一次」。 + /// + public Func? ChannelModeOf { get; set; } + /// /// 上报一条扫码记录(fire-and-forget 的**入队**版本)。 /// @@ -257,6 +273,9 @@ public sealed class DeviceService /// /// **延迟上报**:扫到后 5 秒没再扫到同一个码才真正上报(见 /// ),上报的是最后一次扫描时间。 + /// + /// **散单通道例外**( 返回 1):时间取**第一次**、**立即上报**, + /// 和散单面单摄像头的规则一致;5 秒内重复扫同一个码只算一次(连续扫描帧)。 /// /// true = 一次新的扫码事件(连续扫描的重复帧返回 false,界面不用重查) public bool ReportOnChannel(string channelId, string channelName, string code) @@ -267,6 +286,8 @@ public sealed class DeviceService var channel = string.IsNullOrWhiteSpace(channelId) ? LocalChannelId : channelId; var name = string.IsNullOrWhiteSpace(channelName) ? channel : channelName; + if ((ChannelModeOf?.Invoke(channel) ?? 0) == 1) return ReportFirstSeen(channel, name, barcode); + // 没开设备服务也照样记本地:开起来之后会把积压的自动补上去(断网/未开启期间不丢码) var result = ScanRecordStore.Add(channel, name, barcode, DateTime.Now); if (result.Item is null || result.Kind == ScanAddKind.Repeated) return false; @@ -289,10 +310,66 @@ public sealed class DeviceService return true; } + /// + /// **散单通道**的扫码枪记录:时间取第一次、立即上报(和散单面单摄像头一致)。 + /// + /// 扫码枪连续模式下同一个码每 ~80ms 报一次,所以这里做「在场」去重: + /// 内又扫到同一个码只算一次,不会把记录反复挂回队列。 + /// + private bool ReportFirstSeen(string channel, string name, string barcode) + { + var now = DateTime.Now; + var key = $"{channel}|{barcode}"; + var repeated = false; + + lock (_firstSeenGate) + { + PruneFirstSeen(now); + + if (_firstSeen.TryGetValue(key, out var seen) && now - seen.LastHitAt <= FirstSeenGap) + { + _firstSeen[key] = (seen.FirstSeenAt, now); + repeated = true; + } + else + { + _firstSeen[key] = (now, now); + } + } + + if (repeated) return false; + + var result = ScanRecordStore.AddCamera(channel, name, barcode, now); + if (result.Item is null || !result.IsScanEvent) return false; + + AppLog.Write($"[scan] 通道 {channel} 扫码:{barcode}(散单:取第一次识别时间,立即上报)"); + + if (!Enabled) return true; + EnsureUploadLoop(); + SignalUpload(); + return true; + } + + /// 清掉 24 小时没再命中的在场记录(防字典无限增长) + private void PruneFirstSeen(DateTime now) + { + if (_firstSeen.Count == 0) return; + + var stale = _firstSeen + .Where(pair => now - pair.Value.LastHitAt > TimeSpan.FromHours(24)) + .Select(pair => pair.Key) + .ToList(); + foreach (var key in stale) _firstSeen.Remove(key); + } + /// 查服务器上当前中控已登记的通道(用于确认同步) public Task> ChannelsAsync(CancellationToken ct = default) => _api.ChannelsAsync(_settings.DeviceToken, ct); + /// 拉取本机的面单摄像头识别配置(`GET /api/scanner/label-cameras`) + public Task FetchLabelCamerasAsync(CancellationToken ct = default) + => _api.GetLabelCamerasAsync(_settings.DeviceToken, ct); + /// 立即触发一次上报(界面的「立即上传」) public void TriggerUpload() { diff --git a/desktop/Services/Scan/ChannelConnection.cs b/desktop/Services/Scan/ChannelConnection.cs index b231baa..608b4e5 100644 --- a/desktop/Services/Scan/ChannelConnection.cs +++ b/desktop/Services/Scan/ChannelConnection.cs @@ -1,7 +1,10 @@ using System; +using System.Collections.Concurrent; +using System.Collections.Generic; using System.IO; using System.Net.Sockets; using System.Text; +using System.Text.Json; using System.Threading; using System.Threading.Tasks; @@ -24,12 +27,31 @@ public sealed class ChannelConnection : IDisposable /// 单行上限(字节):不带分隔符时也要能吐出去 private const int MaxLineBytes = 256; + /// 控制帧起始字节(RS):桌面端 → 设备 / 设备 → 桌面端共用,不会出现在条码里 + private const byte ControlMark = 0x1E; + + /// 单条控制帧上限(异常数据保护) + private const int MaxControlBytes = 2048; + + /// + /// 等安卓端确认「扫码成功通知」的超时(设备就在同一局域网,正常 10ms 级)。 + /// 这个等待现在跑在**后台播报泵**里,不再占用面单摄像头的解码循环,所以可以给足余量, + /// 让重连/网络抖动时也能补上这一声。 + /// + private const int ScanNoticeAckTimeoutMs = 1200; + + /// 通知重试次数(含首次):第一次没回执就再发一次,避免单包丢失被判失败 + private const int ScanNoticeAttempts = 2; + private readonly ScanChannel _channel; private readonly CancellationTokenSource _cts = new(); /// 串行化写:下发扫码枪设置要一次写完,不能被重连/其它写方打新 private readonly SemaphoreSlim _writeGate = new(1, 1); + /// 等待设备回执的「扫码成功通知」:id → 完成源(设备的 ack 帧来兑现) + private readonly ConcurrentDictionary> _scanNotices = new(); + /// 当前连接(静音切换时要主动关掉它,让循环重新连并重新下发设置) private TcpClient? _client; @@ -250,6 +272,122 @@ public sealed class ChannelConnection : IDisposable } } + /// + /// 给**安卓扫码端**下发一条「扫码成功」通知,并**等待它的回执**。 + /// + /// 为什么必须确认:现场要让操作员听到播报,通知丢了就静默失败; + /// 只有设备回了 {"cmd":"ack","id":...} 才算成功(超时重发一次)。 + /// + /// 为什么只给安卓通道发:网口扫码枪/中控盒**没有语音能力**,收到也没有事情可做, + /// 还会被透传到枪的串口,所以这类通道一律不发。 + /// + /// ⚠️ 这是**通知**,不是上报:条码本身已经写进待上报队列(见 + /// ScanService.ReportCameraScanAsync),本方法失败**不影响记录**。 + /// + /// 帧格式 0x1E + UTF-8 JSON + '\n':以 0x1E 开头, + /// 和 9/10 字节的扫码枪设置指令、普通条码行都不会冲突;设备回执用同样的帧格式。 + /// + /// true = 设备已确认收到(会播报) + public async Task SendScanNoticeAsync(string code) + { + if (!_channel.IsAndroidStation || string.IsNullOrWhiteSpace(code)) return false; + + for (var attempt = 1; attempt <= ScanNoticeAttempts; attempt++) + { + var client = _client; + if (client is null) return false; + + var id = Guid.NewGuid().ToString("N")[..12]; + var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + _scanNotices[id] = completion; + + try + { + var payload = JsonSerializer.SerializeToUtf8Bytes(new { cmd = "scan", id, code }); + var frame = BuildControlFrame(payload); + + var stream = client.GetStream(); + await _writeGate.WaitAsync().ConfigureAwait(false); + try + { + await stream.WriteAsync(frame).ConfigureAwait(false); + await stream.FlushAsync().ConfigureAwait(false); + } + finally + { + _writeGate.Release(); + } + + var acked = await completion.Task.WaitAsync(TimeSpan.FromMilliseconds(ScanNoticeAckTimeoutMs)) + .ConfigureAwait(false); + if (acked) + { + AppLog.Write($"[scan] 通道 {_channel.Number} 安卓端已确认播报:{code}"); + return true; + } + } + catch (TimeoutException) + { + AppLog.Write($"[scan] 通道 {_channel.Number} 安卓端没回执(第 {attempt}/{ScanNoticeAttempts} 次):{code}"); + } + catch (Exception ex) + { + AppLog.Write($"[scan] 通道 {_channel.Number} 通知安卓端失败(不影响上报):{ex.Message}"); + return false; + } + finally + { + _scanNotices.TryRemove(id, out _); + } + } + + AppLog.Write($"[scan] 通道 {_channel.Number} 通知未确认(记录已入队,不影响上报):{code}"); + return false; + } + + /// 拼一条控制帧:0x1E + JSON + '\n' + private static byte[] BuildControlFrame(byte[] payload) + { + var frame = new byte[payload.Length + 2]; + frame[0] = ControlMark; + Buffer.BlockCopy(payload, 0, frame, 1, payload.Length); + frame[^1] = (byte)'\n'; + return frame; + } + + /// 设备的控制帧(目前只有 {"cmd":"ack","id":...}):兑现等待中的通知 + private void HandleControlFrame(byte[] json) + { + try + { + using var doc = JsonDocument.Parse(json); + var root = doc.RootElement; + if (!root.TryGetProperty("cmd", out var cmd) || cmd.ValueKind != JsonValueKind.String) return; + if (!string.Equals(cmd.GetString(), "ack", StringComparison.OrdinalIgnoreCase)) return; + + var id = root.TryGetProperty("id", out var idElement) && idElement.ValueKind == JsonValueKind.String + ? idElement.GetString() + : null; + if (string.IsNullOrEmpty(id)) return; + + if (_scanNotices.TryGetValue(id, out var completion)) completion.TrySetResult(true); + } + catch (Exception ex) + { + AppLog.Write($"[scan] 通道 {_channel.Number} 控制帧解析失败:{ex.Message}"); + } + } + + /// 连接断开时让所有等待回执的通知立刻失败(不要干等超时) + private void FailPendingScanNotices() + { + foreach (var pair in _scanNotices) + { + pair.Value.TrySetResult(false); + } + _scanNotices.Clear(); + } + /// /// 连上之后立刻把扫码枪配成「连续扫描 + 间隔 0s + 静音状态」(9 + 9 + 10 = 28 字节一次写完)。 /// @@ -299,6 +437,8 @@ public sealed class ChannelConnection : IDisposable var pending = new MemoryStream(); var noiseBytes = 0; var noiseLogged = false; + // 正在收控制帧时的缓冲(0x1E 开头);null = 当前不在控制帧里 + MemoryStream? control = null; try { @@ -312,6 +452,32 @@ public sealed class ChannelConnection : IDisposable for (var i = 0; i < read; i++) { var b = buffer[i]; + + // 控制帧(安卓端的 ack):和条码混在同一条 TCP 里,按 0x1E .. CR/LF 收 + if (control is not null) + { + if (b is (byte)'\n' or (byte)'\r') + { + if (control.Length > 0) HandleControlFrame(control.ToArray()); + control = null; + } + else if (control.Length < MaxControlBytes) + { + control.WriteByte(b); + } + else + { + control = null; // 超长丢帧 + } + continue; + } + + if (b == ControlMark) + { + control = new MemoryStream(256); + continue; + } + if (b is (byte)'\n' or (byte)'\r') { Flush(pending); @@ -366,6 +532,8 @@ public sealed class ChannelConnection : IDisposable private void SetState(bool connected) { + if (!connected) FailPendingScanNotices(); // 断了就别让通知干等超时 + if (_channel.Connected == connected) return; _channel.Connected = connected; diff --git a/desktop/Services/Scan/DeviceScanner.cs b/desktop/Services/Scan/DeviceScanner.cs index e71f837..234bc6d 100644 --- a/desktop/Services/Scan/DeviceScanner.cs +++ b/desktop/Services/Scan/DeviceScanner.cs @@ -15,6 +15,12 @@ namespace YuncangTrace.LocalService.Services.Scan; public sealed record DiscoveredDevice(string Mac, string Ip, string HostName, string Model, string Version, string State) { public string Display => $"{HostName}({(string.IsNullOrEmpty(Ip) ? "?" : Ip)} · {Mac} · {Model})"; + + /// 是否安卓扫码通道(AndroidStation) + public bool IsAndroidStation => ScanDeviceKind.IsAndroidStation(Model); + + /// 界面上的类型标注 + public string KindText => ScanDeviceKind.Describe(Model); } /// 设备 SYS 段配置(JCMD 10003 读回) diff --git a/desktop/Services/Scan/LabelScanMonitor.cs b/desktop/Services/Scan/LabelScanMonitor.cs new file mode 100644 index 0000000..eb08d9f --- /dev/null +++ b/desktop/Services/Scan/LabelScanMonitor.cs @@ -0,0 +1,420 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Threading; +using System.Threading.Tasks; +using YuncangTrace.LocalService.Services.Scan; + +namespace YuncangTrace.LocalService.Services.Scan; + +/// 一路面单识别任务(服务端下发):工作台 → 面单摄像头 → 上报通道 → 录像机凭据 +public sealed class LabelCameraTarget +{ + public int WorkstationId { get; init; } + public string WorkstationCode { get; init; } = string.Empty; + public string WorkstationName { get; init; } = string.Empty; + + /// + /// 工作台类型:**1 散单 / 2 团购**。决定识别结果的记录规则: + /// 散单 = 时间取第一次 + 立即上报;团购 = 和扫码枪一样静默 5 秒、时间取最后一次。 + /// + public int WsType { get; init; } = 1; + + /// 识别结果按这个通道上报(必须是本机自己的扫码通道) + public string ChannelId { get; init; } = string.Empty; + public string ChannelName { get; init; } = string.Empty; + + /// + /// true = 这条通道是**虚拟通道**(`CAM-<工作台id>`):工作台只设了面单摄像头、没接扫码枪, + /// 服务端自动给它一条通道用来上报(不占真实通道、也不会通知安卓端播报)。 + /// + public bool VirtualChannel { get; init; } + + public int CameraId { get; init; } + public string CameraName { get; init; } = string.Empty; + + /// 海康**设备通道号**(数字通道从 33 起);RTSP 路径要再换算成 1 起序号 + public int CameraChannelNo { get; init; } + + public bool CameraEnabled { get; init; } + + /// + /// 0 主码流 / 1 子码流(**只用于回放/预览**;识别会自己挑:子码流够大才用,见 LabelScanWorker) + /// + public int StreamType { get; init; } + + public int NvrId { get; init; } + public string NvrName { get; init; } = string.Empty; + public string NvrHost { get; init; } = string.Empty; + public int NvrPort { get; init; } = 8000; + public string NvrUsername { get; init; } = "admin"; + public string NvrPassword { get; init; } = string.Empty; + + /// 界面上一行文案(**不含密码**;码流由识别端自己挑,这里不写死) + public string Summary => + $"{(string.IsNullOrWhiteSpace(WorkstationName) ? WorkstationCode : WorkstationName)} → " + + $"{CameraName}({(string.IsNullOrWhiteSpace(NvrName) ? NvrHost : NvrName)} 通道 {CameraChannelNo})" + + $"→ 上报通道 {ChannelId}" + + (string.IsNullOrWhiteSpace(ChannelName) ? string.Empty : $"「{ChannelName}」") + + (VirtualChannel ? "(虚拟通道:工作台没接扫码枪)" : string.Empty); +} + +/// 服务端给的提示(例如:面单摄像头设了,但工作台没绑本机通道) +public sealed class LabelCameraWarning +{ + public int WorkstationId { get; init; } + public string WorkstationName { get; init; } = string.Empty; + public string Message { get; init; } = string.Empty; + + public string Display => string.IsNullOrWhiteSpace(WorkstationName) + ? Message + : $"「{WorkstationName}」{Message}"; +} + +/// 一次拉取的结果快照(界面/日志都用它) +public sealed class LabelScanSnapshot +{ + public DateTime? PulledAt { get; set; } + public string Revision { get; set; } = string.Empty; + public string? Error { get; set; } + public List Items { get; set; } = new(); + public List Warnings { get; set; } = new(); + + /// 状态行一句话(**不含密码**) + public string StatusText + { + get + { + if (!string.IsNullOrWhiteSpace(Error)) return $"拉取失败:{Error}"; + if (PulledAt is null) return "还没拉取过(服务启动后自动拉取)"; + + var text = Items.Count == 0 + ? "已拉取:没有需要识别的面单摄像头" + : $"已拉取 {Items.Count} 路 · {PulledAt:HH:mm:ss}"; + + if (Warnings.Count > 0) text += $" · {Warnings.Count} 条提示"; + return text; + } + } +} + +/// +/// 面单识别配置的**拉取 + 对账 + 识别**层。 +/// +/// - 配置:服务启动拉一次,之后每 1 分钟兜底;收到 `labelScan.refresh` 立即拉 +/// (Web 端改面单摄像头/工作台/上报通道时服务端会推这个通知); +/// - 识别:配置到手后由 按路拉流解码,命中后 +/// 交回 (写记录 + 立即上报 + 通知安卓播报); +/// - 快照里**含录像机密码**:只放内存,不落盘、不写日志、界面文案里不显示。 +/// +public sealed class LabelScanMonitor : IDisposable +{ + /// + /// 兜底轮询间隔。 + /// + /// 正常变更靠服务端推 `labelScan.refresh`(Web 端改完面单摄像头/工作台/通道后立刻到), + /// 但推送可能丢(设备正好离线、任务 TTL 过期、服务端推送失败),所以这里还有一个兜底: + /// 间距必须**短到现场感知不到**——以前是 5 分钟,网页上改完要等好几分钟才生效, + /// 表现就是「取消的那路还在跑、新增的那路不启动」。1 分钟足够便宜(一两个小 JSON)。 + /// + private static readonly TimeSpan RefreshInterval = TimeSpan.FromMinutes(1); + + private readonly DeviceService _device; + private readonly LabelScanWorker _worker; + private readonly object _gate = new(); + private Timer? _timer; + private bool _refreshing; + private bool _disposed; + + /// 通道 → 工作台类型(1 散单 / 2 团购)。扫码枪那条记录规则也按它决定。 + private Dictionary _channelModes = new(StringComparer.OrdinalIgnoreCase); + + private Dictionary _channelModesLogged = new(StringComparer.OrdinalIgnoreCase); + + public LabelScanMonitor(DeviceService device, Func> report) + { + _device = device; + _worker = new LabelScanWorker(report); + _worker.Changed += () => Changed?.Invoke(); + } + + /// + /// 某条通道对应的工作台类型:1 散单 / 2 团购 / 0 未知(没被任何工作台绑定)。 + /// + /// 散单:记录时间取**第一次**、立即上报;团购:和扫码枪一样静默 5 秒、取**最后一次**。 + /// + public int ModeOf(string channelId) + { + var key = (channelId ?? string.Empty).Trim(); + if (key.Length == 0) return 0; + var modes = _channelModes; + return modes.TryGetValue(key, out var wsType) ? wsType : 0; + } + + public LabelScanSnapshot Snapshot { get; private set; } = new(); + + /// + /// 面单识别配置里这条通道的名字。 + /// + /// 虚拟通道(`CAM-<工作台id>`)不在本机通道列表里,`ScanService.ChannelNameOf` 查不到, + /// 所以要靠这里补上「面单摄像头·摄像头名」,否则本地记录/日志只能显示一个 `CAM-3`。 + /// + public string ChannelNameOf(string channelId) + { + var key = (channelId ?? string.Empty).Trim(); + if (key.Length == 0) return string.Empty; + + foreach (var item in Snapshot.Items) + { + if (string.Equals(item.ChannelId, key, StringComparison.OrdinalIgnoreCase)) return item.ChannelName; + } + return string.Empty; + } + + /// 每个识别任务的运行状态(最近条码/状态/错误),界面直接用 + public IReadOnlyList Runtimes => _worker.Runtimes; + + /// 快照有变化(界面据此刷新) + public event Action? Changed; + + /// 是否正在拉取 + public bool Refreshing + { + get + { + lock (_gate) return _refreshing; + } + } + + /// 开始兜底轮询(服务启动时调用) + public void Start() + { + if (_disposed) return; + + lock (_gate) + { + _timer ??= new Timer(_ => _ = RefreshAsync("定时刷新"), null, Timeout.Infinite, Timeout.Infinite); + _timer.Change(TimeSpan.Zero, RefreshInterval); + } + } + + /// 停掉轮询(保留最后一次快照,界面还能看到上次拉到什么) + public void Stop() + { + lock (_gate) + { + _timer?.Change(Timeout.Infinite, Timeout.Infinite); + } + _worker.StopAll(); + } + + /// + /// 拉一次配置。任何异常都只记日志 + 落在 , + /// **不影响扫码/上报链路**。 + /// + public async Task RefreshAsync(string reason, CancellationToken ct = default) + { + lock (_gate) + { + if (_refreshing) return; // 上一轮还没回来 + _refreshing = true; + } + + try + { + if (!_device.Enabled) + { + Update(snapshot => snapshot.Error = "设备服务未开启(开启后才会拉取)"); + return; + } + + var data = await _device.FetchLabelCamerasAsync(ct).ConfigureAwait(false); + var parsed = Parse(data); + + var previousRevision = Snapshot.Revision; + Update(snapshot => + { + snapshot.PulledAt = DateTime.Now; + snapshot.Revision = parsed.Revision; + snapshot.Items = parsed.Items; + snapshot.Warnings = parsed.Warnings; + snapshot.Error = null; + }); + _channelModes = parsed.Channels; + + var changed = !string.Equals(previousRevision, parsed.Revision, StringComparison.Ordinal); + + // 兜底轮询现在是 1 分钟一次,内容没变就别每分钟刷一遍(一天上千行会把有用日志顶没)。 + // 启动 / 手动刷新 / 服务端通知 / 内容变了 → 都要留痕。 + var verbose = changed || !string.Equals(reason, "定时刷新", StringComparison.Ordinal); + + if (verbose) + { + AppLog.Write($"[label-scan] 已拉取面单识别配置({reason}):{parsed.Items.Count} 路," + + $"revision={parsed.Revision}" + + (changed && previousRevision.Length > 0 ? $"(变更:{previousRevision} → {parsed.Revision})" : string.Empty)); + + LogChannelModes(parsed.Channels); + + foreach (var target in parsed.Items) + { + // 只打工作台/摄像头/通道,不打印录像机密码 + AppLog.Write($"[label-scan] {target.Summary}"); + } + foreach (var warning in parsed.Warnings) + { + AppLog.Write($"[label-scan] [WARN] {warning.Display}"); + } + } + + // 按最新配置对账:新增的启动、变了的重建、消失的停掉(没变的不打断) + _worker.Apply(parsed.Items); + } + catch (OperationCanceledException) + { + // 退出/重连中,忽略 + } + catch (Exception ex) + { + Update(snapshot => snapshot.Error = ex.Message); + AppLog.Write($"[label-scan] 拉取面单识别配置失败({reason}):{ex.Message}"); + } + finally + { + lock (_gate) _refreshing = false; + Changed?.Invoke(); + } + } + + private void Update(Action mutate) + { + mutate(Snapshot); + } + + /// 通道模式变了才打一行(散单/团购决定记录时间规则,出问题时要能一眼看出来) + private void LogChannelModes(Dictionary modes) + { + if (modes.Count == _channelModesLogged.Count) + { + var same = true; + foreach (var pair in modes) + { + if (!_channelModesLogged.TryGetValue(pair.Key, out var previous) || previous != pair.Value) + { + same = false; + break; + } + } + if (same) return; + } + + _channelModesLogged = new Dictionary(modes, StringComparer.OrdinalIgnoreCase); + if (modes.Count == 0) return; + + var parts = new List(modes.Count); + foreach (var pair in modes) + { + parts.Add($"{pair.Key}→{(pair.Value == 1 ? "散单(取第一次)" : "团购(取最后一次)")}"); + } + AppLog.Write($"[label-scan] 通道记录规则:{string.Join(",", parts)}"); + } + + /// 解析服务端返回的 `{ revision, items, channels, warnings }` + private static ParsedConfig Parse(JsonElement data) + { + var items = new List(); + var warnings = new List(); + var channels = new Dictionary(StringComparer.OrdinalIgnoreCase); + var revision = string.Empty; + + if (data.ValueKind == JsonValueKind.Object) + { + revision = ReadString(data, "revision") ?? string.Empty; + + if (data.TryGetProperty("channels", out var channelArray) && channelArray.ValueKind == JsonValueKind.Array) + { + foreach (var item in channelArray.EnumerateArray()) + { + if (item.ValueKind != JsonValueKind.Object) continue; + var channelId = (ReadString(item, "channelId") ?? string.Empty).Trim(); + if (channelId.Length == 0) continue; + channels[channelId] = ReadInt(item, "wsType") == 1 ? 1 : 2; + } + } + + if (data.TryGetProperty("items", out var itemArray) && itemArray.ValueKind == JsonValueKind.Array) + { + foreach (var item in itemArray.EnumerateArray()) + { + if (item.ValueKind != JsonValueKind.Object) continue; + + var nvr = item.TryGetProperty("nvr", out var nvrElement) && nvrElement.ValueKind == JsonValueKind.Object + ? nvrElement + : default; + + items.Add(new LabelCameraTarget + { + WorkstationId = ReadInt(item, "workstationId"), + WorkstationCode = ReadString(item, "workstationCode") ?? string.Empty, + WorkstationName = ReadString(item, "workstationName") ?? string.Empty, + WsType = ReadInt(item, "wsType") == 2 ? 2 : 1, + ChannelId = ReadString(item, "channelId") ?? string.Empty, + ChannelName = ReadString(item, "channelName") ?? string.Empty, + VirtualChannel = item.TryGetProperty("virtualChannel", out var virtualFlag) && virtualFlag.ValueKind == JsonValueKind.True, + CameraId = ReadInt(item, "cameraId"), + CameraName = ReadString(item, "cameraName") ?? string.Empty, + CameraChannelNo = ReadInt(item, "cameraChannelNo"), + CameraEnabled = !item.TryGetProperty("cameraEnabled", out var enabled) || enabled.ValueKind != JsonValueKind.False, + StreamType = ReadInt(item, "streamType"), + NvrId = nvr.ValueKind == JsonValueKind.Object ? ReadInt(nvr, "id") : 0, + NvrName = nvr.ValueKind == JsonValueKind.Object ? ReadString(nvr, "name") ?? string.Empty : string.Empty, + NvrHost = nvr.ValueKind == JsonValueKind.Object ? ReadString(nvr, "host") ?? string.Empty : string.Empty, + NvrPort = nvr.ValueKind == JsonValueKind.Object ? ReadInt(nvr, "port") : 8000, + NvrUsername = nvr.ValueKind == JsonValueKind.Object ? ReadString(nvr, "username") ?? "admin" : "admin", + NvrPassword = nvr.ValueKind == JsonValueKind.Object ? ReadString(nvr, "password") ?? string.Empty : string.Empty, + }); + } + } + + if (data.TryGetProperty("warnings", out var warningArray) && warningArray.ValueKind == JsonValueKind.Array) + { + foreach (var warning in warningArray.EnumerateArray()) + { + if (warning.ValueKind != JsonValueKind.Object) continue; + warnings.Add(new LabelCameraWarning + { + WorkstationId = ReadInt(warning, "workstationId"), + WorkstationName = ReadString(warning, "workstationName") ?? string.Empty, + Message = ReadString(warning, "message") ?? string.Empty, + }); + } + } + } + + return new ParsedConfig(revision, items, warnings, channels); + } + + /// 解析结果(`channels` 是通道 → 工作台类型,决定扫码枪那条记录规则) + private sealed record ParsedConfig( + string Revision, + List Items, + List Warnings, + Dictionary Channels); + + private static string? ReadString(JsonElement element, string name) + => element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String + ? value.GetString() + : null; + + private static int ReadInt(JsonElement element, string name) + => element.TryGetProperty(name, out var value) && value.TryGetInt32(out var number) ? number : 0; + + public void Dispose() + { + _disposed = true; + Stop(); + _worker.Dispose(); + _timer?.Dispose(); + _timer = null; + } +} diff --git a/desktop/Services/Scan/LabelScanWorker.cs b/desktop/Services/Scan/LabelScanWorker.cs new file mode 100644 index 0000000..23e2c26 --- /dev/null +++ b/desktop/Services/Scan/LabelScanWorker.cs @@ -0,0 +1,1221 @@ +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; +using System.Threading; +using System.Threading.Tasks; +using YuncangTrace.LocalService.Services.Hik; +using ZXing; +using ZXing.Common; + +namespace YuncangTrace.LocalService.Services.Scan; + +/// 一路面单摄像头的运行状态(界面展示用) +public sealed class LabelCameraRuntime +{ + public int WorkstationId { get; init; } + public int CameraId { get; init; } + public string WorkstationName { get; init; } = string.Empty; + public string CameraName { get; init; } = string.Empty; + public string ChannelId { get; init; } = string.Empty; + public string ChannelName { get; init; } = string.Empty; + + /// 工作台 → 摄像头 → 上报通道(**不含密码**) + public string Summary { get; init; } = string.Empty; + + /// stopped / starting / running / error + public string State { get; set; } = "stopped"; + + public string StateText => State switch + { + "running" => "识别中", + "starting" => "启动中…", + "error" => "异常", + _ => "已停止", + }; + + /// 最近识别到的条码 + public string LastCode { get; set; } = string.Empty; + + /// + /// **首次识别时间**:也就是这条记录真正上报/落库用的时间。 + /// 面单一直摆在拍摄区不会刷新(重复命中不改时间),避免界面看起来「时间一直在跳」。 + /// + public DateTime? LastCodeAt { get; set; } + + /// 最近一次命中的时间(同一张面单每秒都在刷新,只用于排障看摄像头是否在扫) + public DateTime? LastHitAt { get; set; } + + /// 当前用的码流(主/子 + 分辨率),例如「主码流 2304x1296」 + public string StreamText { get; set; } = string.Empty; + + /// 最近一帧的解码耗时(毫秒,含透视矫正 + ZXing 解码;用来看机器吃不吃得消) + public double LastDecodeMs { get; set; } + + /// 最近一帧的 CV 定位耗时(毫秒:找条码横带 + 估倾角;不含解码) + public double LastCvMs { get; set; } + + /// 最近一帧走的是哪条路径(ROI / 退避跳过 / 整帧 / 扫角…):用来定位耗时尖峰 + public string LastPath { get; set; } = string.Empty; + + /// ROI 连续解失败次数(≥3 时进入隔帧退避) + public int RoiFailStreak { get; set; } + + /// 同一个码连续解出的次数(≥3 时进入稳态退避,画面一变就清零) + public int SteadyHits { get; set; } + + /// 从管道读到的总帧数(ffmpeg 实际产出,用来核对 `fps=8` 是否生效) + public long FramesRead { get; set; } + + /// 读帧线程按 DecodeFps 限速后丢弃的帧数 + public long FrameThrottled { get; set; } + + /// 解码循环总共处理了多少帧 + public long FramesDecoded { get; set; } + + /// 等新帧花了多久(毫秒):≈ 1000/实际处理帧率 说明是「帧不够」,否则是处理慢 + public double LastWaitMs { get; set; } + + /// 两次取帧之间的完整周期(毫秒):含 CV、解码、上报等全部开销 + public double LastLoopMs { get; set; } + + /// 最近一帧自动定位到的条码区域(ROI w x h;定位失败时为「未定位」) + public string RoiText { get; set; } = string.Empty; + + /// 最近一帧「透视矫正 + ZXing 解码」耗时(毫秒) + public double RoiRatio { get; set; } + + /// 最近一次取到帧时积压了几帧(0=实时;>0 说明解码跟不上、这些旧帧被丢了) + public long FrameLag { get; set; } + + /// 累计丢弃的旧帧数(读帧线程只保留最新一帧) + public long FrameDropped { get; set; } + + /// 累计命中次数(含重复帧合并后的上报次数) + public long Hits { get; set; } + + public string? LastError { get; set; } + + public string LastCodeAtText => LastCodeAt?.ToString("MM-dd HH:mm:ss") ?? "—"; + + /// 最近一次命中的时间(精确到毫秒:面单每秒都在刷新,用来判断刷新是否及时) + public string LastHitAtText => LastHitAt?.ToString("HH:mm:ss.fff") ?? "—"; +} + +/// +/// 面单摄像头识别 worker:按服务端下发的配置**拉流 → 解码 → 识别 → 上报**。 +/// +/// 链路(全部在后台服务进程里跑,与扫码枪链路互不影响): +/// +/// ffmpeg(RTSP) → 原始灰度帧 → 条带裁剪 → ZXing 解码 +/// → ScanService.ReportCameraScanAsync(写记录 + 立即上报 + 通知安卓播报) +/// +/// +/// 为什么用 ffmpeg 而不是 8000 私有协议:录像机/摄像头型号杂,RTSP 最通用, +/// 且 ffmpeg 已经随安装包发布(回放校验/合并也在用),不需要再引解码器。 +/// +/// 为什么要试多个通道号:RTSP 的通道序号是「1 起的相对序号」,而库里存的是**设备通道号** +/// (数字通道从 33 起)。换算需要问录像机(SDK 只有取流子进程能做), +/// 所以这里按候选依次试(`channelNo-32` → `channelNo`),成功后**记住**用过的序号。 +/// +public sealed class LabelScanWorker : IDisposable +{ + /// + /// 画面里「连续一段时间没有任何条码」超过这个时长,就认为面单真的被拿走了。 + /// + /// **这是「面单是否离开过」的唯一判据**,两个地方都用它: + /// - 识别线程:判断重新出现的是不是新一轮打包(), + /// 决定记录时间用新的还是沿用本轮首次; + /// - :判断要不要重新上报/播报(`CameraPresenceGap`)。 + /// + /// 为什么用「画面里有没有条码」而不是「有没有解出码」:接入 OpenCV 后 无候选 是可信的 + /// (面单在视野里就一定有候选),而「解不出」还会发生在面单明明在场的时候(反光、遮一角)。 + /// + /// 数值 45 秒:正常打包时手挡、侧身取件一般不会让面单整个离开画面这么久; + /// 而开箱换货再封箱通常要一分钟以上,能识别成新一轮打包。 + /// + internal static readonly TimeSpan RepackAbsence = TimeSpan.FromSeconds(45); + + /// 解码帧率:面单放进去会停住,6fps 足够,也不至于把机器 CPU 吃满 + private const int DecodeFps = 6; + + /// 条码合法性:4~64 位、只含常见条码字符、至少 6 位数字(压掉误识别噪声) + private static readonly Regex AllowPattern = new("^[0-9A-Za-z][0-9A-Za-z\\-_/]{3,63}$", RegexOptions.Compiled); + + private readonly Func> _report; + private readonly Dictionary _runners = new(StringComparer.OrdinalIgnoreCase); + private readonly List _runtimes = new(); + private readonly object _gate = new(); + private bool _disposed; + + /// 命中回调:(channelId, barcode, wsType) → 负责写入记录并通知安卓 + public LabelScanWorker(Func> report) + { + _report = report; + } + + /// 当前所有识别任务的状态(按 target 顺序) + public IReadOnlyList Runtimes + { + get + { + lock (_gate) return _runtimes.ToList(); + } + } + + /// 运行时状态变了(界面/状态文件据此刷新) + public event Action? Changed; + + /// + /// 按最新配置对账:新增的启动、配置变了的重建、消失的停掉。 + /// 配置没变的不会被打断(拉配置每 5 分钟一次,不能每次都断流)。 + /// + public void Apply(IReadOnlyList targets) + { + if (_disposed) return; + + var wanted = new HashSet(StringComparer.OrdinalIgnoreCase); + var runtimes = new List(); + + foreach (var target in targets) + { + // 摄像头停用/没有上报通道的直接跳过(服务端已经过滤过一遍,这里再兜一次) + if (!target.CameraEnabled || string.IsNullOrWhiteSpace(target.ChannelId)) + { + AppLog.Write($"[label-scan] 跳过(摄像头停用或没有上报通道):{target.Summary}"); + continue; + } + + var key = KeyOf(target); + wanted.Add(key); + + try + { + LabelCameraRunner runner; + var started = false; + lock (_gate) + { + if (!_runners.TryGetValue(key, out runner!) || !runner.Matches(target)) + { + runner?.Stop(); + _runners.Remove(key); + runner = new LabelCameraRunner(target, _report, RaiseChanged); + _runners[key] = runner; + started = true; + } + } + + // 启动放在锁外:某一路拉流/建线程出问题,不能把整轮对账卡死或连累其它路 + if (started) + { + runner.Start(); + AppLog.Write($"[label-scan] 开始识别:{runner.Runtime.Summary}"); + } + + runtimes.Add(runner.Runtime); + } + catch (Exception ex) + { + // 一路失败不影响其它路:把半成品清掉,下一轮拉取会再试 + lock (_gate) _runners.Remove(key); + AppLog.Write($"[label-scan] 启动识别失败:{target.Summary}:{ex.Message}"); + } + } + + List stale; + lock (_gate) + { + stale = _runners.Where(pair => !wanted.Contains(pair.Key)).Select(pair => pair.Value).ToList(); + foreach (var key in _runners.Keys.Where(key => !wanted.Contains(key)).ToList()) _runners.Remove(key); + + _runtimes.Clear(); + _runtimes.AddRange(runtimes); + } + + foreach (var runner in stale) + { + runner.Stop(); + AppLog.Write($"[label-scan] 停止识别:{runner.Runtime.Summary}"); + } + + RaiseChanged(); + } + + /// 全部停掉(服务停止/关闭设备服务) + public void StopAll() + { + List all; + lock (_gate) + { + all = _runners.Values.ToList(); + _runners.Clear(); + _runtimes.Clear(); + } + foreach (var runner in all) runner.Stop(); + RaiseChanged(); + } + + private void RaiseChanged() => Changed?.Invoke(); + + private static string KeyOf(LabelCameraTarget target) => $"{target.WorkstationId}|{target.CameraId}|{target.ChannelId}"; + + /// 条码过滤(与扫码枪不同:摄像头误识别更多,所以字符集和长度都卡一下) + internal static string? CleanBarcode(string? raw) + { + if (string.IsNullOrWhiteSpace(raw)) return null; + + var text = raw.Trim(); + if (!AllowPattern.IsMatch(text)) return null; + + var digits = text.Count(char.IsDigit); + return digits >= 6 ? text : null; + } + + public void Dispose() + { + if (_disposed) return; + _disposed = true; + StopAll(); + } +} + +/// 一路摄像头的拉流 + 识别循环(ffmpeg 子进程 + 独立线程) +internal sealed class LabelCameraRunner +{ + private const int ConnectTimeoutMs = 6000; + private const int ReconnectDelayMs = 3000; + + /// + /// 解码帧率:面单放进去会停住,8fps 足够(主码流单帧解码+识别约 15~45ms,吃得下)。 + /// 帧率越高,面单放上去到识别的延迟越小。 + /// + private const int DecodeFps = 8; + + /// + /// 命中后连续多少帧「还是同一张面单」就进入稳态退避(隔帧检测)。 + /// 面单一直摆着不动时每帧都跑检测是白花的。 + /// + private const int SteadyBackoffAfter = 3; + + /// + /// 连续多少帧「检测/解码都没结果」就进入失败退避(隔帧检测)。 + /// 画面里没面单时不必每帧都跑完整的检测 + 解码。 + /// + private const int FailBackoffAfter = 3; + + /// + /// 退避时每 N 帧只检 N-1 帧之外的奇数帧(隔帧)。 + /// 用帧序号的奇偶而不是时间:解码本身耗时稳定,帧序号更简单也更好预测。 + /// + private const int BackoffFrameModulo = 2; + + /// + /// 画面变化检测:整帧压成 32x18 块均值。退避期间靠它判断「有东西放进来/面单被拿走」, + /// 一旦变化就立刻恢复每帧检测,不会因为退避而漏掉新面单。 + /// + private const int SceneGridX = 32; + private const int SceneGridY = 18; + private const int SceneCellSamples = 4; + + /// + /// 缩略图平均灰度差超过这个值就认为画面变了。 + /// 实测:传感器噪声 1.97~2.11;有物体进入画面 12.09。取 6.0 两头都留了余量。 + /// + private const double SceneChangeMeanDiff = 6.0; + + /// 主码流 / 子码流的 RTSP 后缀(`Streaming/Channels/{序号}01|02`) + private const string MainStreamSuffix = "01"; + private const string SubStreamSuffix = "02"; + + /// + /// 子码流能用多小:实测这台录像机子码流是 800x448,条码只有 1.8px/模块,**读不出来**; + /// 1152x648 / 1280x720 能读。所以宽度够 1080 才用子码流(拉流解码开销只有主码流的 1/7)。 + /// + private const int MinSubStreamWidth = 1080; + + /// 数字通道偏移:设备通道号从 33 起 → 64 号通道通常是 RTSP 第 32 路 + private const int DigitalChannelOffset = 32; + + private readonly LabelCameraTarget _target; + private readonly Func> _report; + private readonly Action _changed; + private readonly CancellationTokenSource _cts = new(); + private Thread? _thread; + + /// + /// 命中后要上报的条码队列(**扫描线程只入队,不等结果**)。 + /// 上报里有写记录文件、触发上传、通知安卓等动作,任何一个慢都不该拖住拉流和识别。 + /// 容量小 + 满了丢最旧:识别出来的是「面单」,积压的旧事件没有价值。 + /// + private readonly BlockingCollection _pendingReports = new(new ConcurrentQueue(), 8); + + private Thread? _reportThread; + + /// 当前正在跑的 ffmpeg 子进程( 要能立刻把它杀掉) + private Process? _process; + + /// 一条待上报的识别结果 + /// 这张面单是从「画面里一段时间没有任何条码」之后重新出现的(真重新打包) + private readonly record struct PendingReport(string Code, double DecodeMs, double CvMs, bool AfterAbsence); + + /// 已确认可用的码流(成功后固定,重连不再重新探测——每次探测要 1 秒以上) + private static readonly Dictionary StreamCache = new(StringComparer.OrdinalIgnoreCase); + + /// 选中的码流:RTSP 序号 + 主/子后缀 + 分辨率 + private sealed record StreamChoice(int Index, string Suffix, int Width, int Height) + { + public string Profile => Suffix == SubStreamSuffix ? "子码流" : "主码流"; + + public string Text => $"{Profile} {Width}x{Height}"; + } + + /// 上一次命中的条码与时间(同一张面单连续命中时做节流) + private string _lastSeenCode = string.Empty; + private DateTime _lastReportAt = DateTime.MinValue; + + /// 上一次真正写日志的条码(同一张面单每秒命中一次,不能每次都刷日志) + private string _lastLoggedCode = string.Empty; + + + /// 同一个码连续命中次数(达到 后隔帧检测) + private int _steadyHits; + + /// + /// 画面里「上一次有条码」的时刻(含解不出的候选)。 + /// 用它判断面单是否真的离开过:离开超过 再回来, + /// 就是新一轮打包(装错了重新打包),记录时间要用新的。 + /// + private DateTime? _barcodeVisibleAt; + + /// + /// 检测到「面单离开过又回来」的时刻(锁存到第一次成功解码上报为止)。 + /// 面单刚回到画面时可能连续几帧「有候选但解不出」,不能因此丢掉重新打包的标记。 + /// + private DateTime? _repackDetectedAt; + + /// 连续多少帧没结果就隔帧检测(见 ) + private int _failStreak; + + /// 上一次成功解出的条码(用于判断「还是同一张面单」) + private string _lastHitCode = string.Empty; + + public LabelCameraRunner(LabelCameraTarget target, Func> report, Action changed) + { + _target = target; + _report = report; + _changed = changed; + Runtime = new LabelCameraRuntime + { + WorkstationId = target.WorkstationId, + CameraId = target.CameraId, + WorkstationName = target.WorkstationName, + CameraName = target.CameraName, + ChannelId = target.ChannelId, + ChannelName = target.ChannelName, + Summary = target.Summary, + }; + } + + public LabelCameraRuntime Runtime { get; } + + /// 配置是否一致(不一致就重建:换了 NVR/通道/码流都要重启) + public bool Matches(LabelCameraTarget target) + => target.CameraId == _target.CameraId + && target.ChannelId == _target.ChannelId + && target.NvrHost == _target.NvrHost + && target.NvrPort == _target.NvrPort + && target.NvrUsername == _target.NvrUsername + && target.NvrPassword == _target.NvrPassword + && target.CameraChannelNo == _target.CameraChannelNo + && target.StreamType == _target.StreamType; + + public void Start() + { + // 扫描任务独占一条线程:拉流读取、识别、上报各走各的线程,谁慢都不拖别人 + _thread = new Thread(() => LoopAsync().GetAwaiter().GetResult()) + { + IsBackground = true, + Name = $"label-scan-{_target.CameraId}", + }; + _thread.Start(); + + _reportThread = new Thread(ReportLoop) { IsBackground = true, Name = $"label-report-{_target.CameraId}" }; + _reportThread.Start(); + } + + public void Stop() + { + try + { + _cts.Cancel(); + // 直接杀掉 ffmpeg:只 Cancel 的话读帧线程还挂在管道读上, + // 要等下一帧/超时才退出——现场表现就是「取消掉的那路还在跑一会儿」。 + TryKill(_process); + _pendingReports.CompleteAdding(); + } + catch + { + // 忽略 + } + + SetState("stopped", null); + } + + /// + /// 上报线程:串行消费命中结果。 + /// 扫描线程只负责 TryAdd,永远不等这一环(写记录、上报、通知安卓都可能慢)。 + /// + private void ReportLoop() + { + try + { + foreach (var pending in _pendingReports.GetConsumingEnumerable(_cts.Token)) + { + try + { + var result = _report(_target.ChannelId, pending.Code, _target.WsType, pending.AfterAbsence).GetAwaiter().GetResult(); + if (result.ScanTime is DateTime scanTime) Runtime.LastCodeAt = scanTime; + if (result.NewScan) Runtime.Hits++; + _changed(); + + if (result.NewScan || !string.Equals(pending.Code, _lastLoggedCode, StringComparison.Ordinal)) + { + _lastLoggedCode = pending.Code; + AppLog.Write($"[label-scan] 识别到条码:{pending.Code}(通道 {_target.ChannelId}" + + $",首次 {Runtime.LastCodeAtText},检测 {pending.CvMs:0.0}ms" + + $",新记录={result.NewScan})"); + } + } + catch (Exception ex) + { + AppLog.Write($"[label-scan] {Runtime.Summary} 上报识别结果失败:{ex.Message}"); + } + } + } + catch (OperationCanceledException) + { + // 停机 + } + catch (ObjectDisposedException) + { + // 停机 + } + } + + /// 把一次命中丢进上报队列(满了丢最旧的,扫描线程不阻塞) + private void EnqueueReport(string code, double decodeMs, double cvMs, bool afterAbsence) + { + if (_pendingReports.IsAddingCompleted) return; + + var item = new PendingReport(code, decodeMs, cvMs, afterAbsence); + while (!_pendingReports.TryAdd(item)) + { + if (!_pendingReports.TryTake(out _)) break; // 丢掉最旧的一条后再试 + if (_pendingReports.IsAddingCompleted) return; + } + } + + private async Task LoopAsync() + { + var ct = _cts.Token; + var attempts = 0; + + while (!ct.IsCancellationRequested) + { + Process? process = null; + try + { + SetState("starting", null); + var stream = await ResolveAndProbeAsync(ct).ConfigureAwait(false); + if (stream.Width <= 0 || stream.Height <= 0) throw new InvalidOperationException("拿不到码流分辨率"); + + Runtime.StreamText = stream.Text; + process = StartFfmpeg(stream); + _process = process; + SetState("running", null); + if (attempts > 0) AppLog.Write($"[label-scan] {Runtime.Summary} 已重新连上码流({stream.Text})"); + attempts = 0; + + DecodeLoop(process, stream, ct); + if (ct.IsCancellationRequested) break; + throw new InvalidOperationException("码流已断开"); + } + catch (OperationCanceledException) + { + break; + } + catch (Exception ex) + { + attempts++; + SetState("error", ex.Message); + if (attempts <= 3 || attempts % 10 == 0) + { + AppLog.Write($"[label-scan] {Runtime.Summary} 识别失败({ex.Message}),{ReconnectDelayMs / 1000} 秒后重试" + + (attempts > 1 ? $";已重试 {attempts} 次" : string.Empty)); + } + } + finally + { + if (ReferenceEquals(_process, process)) _process = null; + TryKill(process); + } + + try + { + await Task.Delay(ReconnectDelayMs, ct).ConfigureAwait(false); + } + catch (OperationCanceledException) + { + break; + } + } + + SetState("stopped", null); + } + + /// + /// 选码流 + 找到可用的 RTSP 序号 + 拿分辨率。 + /// + /// 选流规则:**子码流够大就用子码流**(拉流解码开销只有主码流的 1/7,识别更快也更省 CPU), + /// 太小就退回主码流 —— 条码像素不够时子码流根本解不出来 + /// (实测这台录像机子码流 800x448,条码只有 1.8px/模块,读不出;1152x648 / 1280x720 能读)。 + /// + /// 序号要按候选试(见类注释),结果缓存起来,重连不再重新探测(每次探测要 1 秒以上)。 + /// + private async Task ResolveAndProbeAsync(CancellationToken ct) + { + var cacheKey = $"{_target.NvrHost}|{_target.NvrPort}|{_target.CameraChannelNo}"; + + if (StreamCache.TryGetValue(cacheKey, out var cached)) + { + try + { + var size = await ProbeSizeAsync(BuildRtspUrl(cached.Index, cached.Suffix), ct).ConfigureAwait(false); + if (size.Width == cached.Width && size.Height == cached.Height) return cached; + } + catch + { + // 探测失败就重新走一遍候选 + } + } + + Exception? lastError = null; + foreach (var index in Candidates()) + { + foreach (var suffix in new[] { SubStreamSuffix, MainStreamSuffix }) + { + ct.ThrowIfCancellationRequested(); + var url = BuildRtspUrl(index, suffix); + try + { + var size = await ProbeSizeAsync(url, ct).ConfigureAwait(false); + if (size.Width <= 0 || size.Height <= 0) + { + lastError = new InvalidOperationException($"序号 {index}{suffix} 没有取到画面"); + continue; + } + + if (suffix == SubStreamSuffix && size.Width < MinSubStreamWidth) + { + AppLog.Write($"[label-scan] {Runtime.Summary} 子码流只有 {size.Width}x{size.Height}" + + "(条码像素不够,读不出来),改用主码流"); + continue; + } + + var choice = new StreamChoice(index, suffix, size.Width, size.Height); + StreamCache[cacheKey] = choice; + AppLog.Write($"[label-scan] {Runtime.Summary} 码流就绪:{choice.Text}(序号 {index}{suffix})"); + return choice; + } + catch (Exception ex) + { + lastError = ex; + } + } + } + + throw new InvalidOperationException(lastError?.Message ?? "所有通道序号都取不到码流"); + } + + /// 候选 RTSP 序号:先按「数字通道从 33 起」换算,再退回用原始通道号 + private IEnumerable Candidates() + { + var channelNo = _target.CameraChannelNo; + var logical = channelNo - DigitalChannelOffset; + + if (logical > 0 && logical != channelNo) yield return logical; + if (channelNo > 0) yield return channelNo; + } + + /// ******host:554/Streaming/Channels/{序号}{01|02} + private string BuildRtspUrl(int streamIndex, string suffix) + => $"rtsp://{Uri.EscapeDataString(_target.NvrUsername)}:{Uri.EscapeDataString(_target.NvrPassword)}" + + $"@{_target.NvrHost}:554/Streaming/Channels/{streamIndex}{suffix}"; + + /// 用 ffmpeg 打开一次流,从 stderr 里读出分辨率(拿不到就当失败) + private static async Task<(int Width, int Height)> ProbeSizeAsync(string url, CancellationToken ct) + { + var ffmpeg = HikFfmpegService.ResolveFfmpeg() + ?? throw new InvalidOperationException("未找到 ffmpeg(安装目录 native\\ffmpeg\\ffmpeg.exe 缺失)"); + + using var process = NewProcess(ffmpeg, new[] + { + "-hide_banner", "-nostdin", "-rtsp_transport", "tcp", "-timeout", "5000000", + "-loglevel", "info", "-i", url, + }); + process.StartInfo.RedirectStandardError = true; + + var text = new StringBuilder(); + process.ErrorDataReceived += (_, e) => + { + if (e.Data is not null && text.Length < 64 * 1024) text.AppendLine(e.Data); + }; + process.Start(); + process.BeginErrorReadLine(); + + using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct); + timeout.CancelAfter(ConnectTimeoutMs); + try + { + await process.WaitForExitAsync(timeout.Token).ConfigureAwait(false); + } + catch (OperationCanceledException) + { + TryKill(process); + throw new InvalidOperationException("连接码流超时"); + } + + var matched = Regex.Match(text.ToString(), @"Video:.*?,\s*(\d{2,5})x(\d{2,5})"); + if (!matched.Success) return (0, 0); + + return (int.Parse(matched.Groups[1].Value), int.Parse(matched.Groups[2].Value)); + } + + private Process StartFfmpeg(StreamChoice stream) + { + var ffmpeg = HikFfmpegService.ResolveFfmpeg() + ?? throw new InvalidOperationException("未找到 ffmpeg"); + + var args = new List + { + "-hide_banner", "-nostdin", "-loglevel", "error", + "-rtsp_transport", "tcp", "-timeout", "5000000", + // 只开 2 个解码线程:默认的帧级多线程会把输出往后压好几帧 + // (实测同一条流:默认线程 OSD 到本机 2.6s,2 线程只要 0.5s)。 + // 输入 20fps、我们只要 8fps,单帧解码慢一点完全够。 + "-threads", "2", + "-i", BuildRtspUrl(stream.Index, stream.Suffix), + "-an", + // 抽帧 + 转灰度 rawvideo 从 stdout 吐出:每帧正好 width*height 字节 + "-vf", $"fps={DecodeFps}", + "-f", "rawvideo", "-pix_fmt", "gray", + "-s", $"{stream.Width}x{stream.Height}", + "pipe:1", + }; + + var process = NewProcess(ffmpeg, args); + process.StartInfo.RedirectStandardOutput = true; + process.StartInfo.RedirectStandardError = true; + process.Start(); + + // stderr 必须读掉,否则管道满了 ffmpeg 会卡住 + process.ErrorDataReceived += (_, e) => + { + if (string.IsNullOrWhiteSpace(e.Data) || IsNoisyFfmpegLine(e.Data)) return; + AppLog.Write($"[label-scan] ffmpeg({Runtime.CameraName}):{e.Data}"); + }; + process.BeginErrorReadLine(); + + return process; + } + + /// + /// 这台录像机的 HEVC 码流本身就会吐这些告警(画面照常解出来), + /// 不滤掉的话每帧刷屏、把有用的日志顶没了。 + /// + private static bool IsNoisyFfmpegLine(string line) + => line.Contains("hevc @", StringComparison.OrdinalIgnoreCase) + || line.Contains("Error constructing the frame RPS", StringComparison.OrdinalIgnoreCase) + || line.Contains("Could not find ref with POC", StringComparison.OrdinalIgnoreCase) + || line.Contains("PPS id out of range", StringComparison.OrdinalIgnoreCase) + || line.Contains("Last message repeated", StringComparison.OrdinalIgnoreCase); + + /// 逐帧读灰度图并识别(帧不完整/超时就当断流) + private void DecodeLoop(Process process, StreamChoice choice, CancellationToken ct) + { + var width = choice.Width; + var height = choice.Height; + var frameBytes = width * height; + var stream = process.StandardOutput.BaseStream; + var frameIndex = 0; + var decodeWatch = new Stopwatch(); + + // 三块缓冲轮转:pending(读帧线程写) / latest(最新一帧) / buffer(解码用),靠交换引用避免每帧 2MB 拷贝 + var buffer = new byte[frameBytes]; + var pending = new byte[frameBytes]; + var latest = new byte[frameBytes]; + var frameGate = new object(); + var frameReady = false; + var readerDone = false; + long produced = 0; + long consumed = 0; + var frameSignal = new SemaphoreSlim(0, 1); + + // ffmpeg 的 `-vf fps=8` 是生效的(实测管道里就是 8 帧/秒),这里的限速只用于 + // 兜住「某些流真的吐出更多帧」的情况。留 20% 容差:帧间隔实测 119~125ms, + // 若按严格的 125ms 判定,会每两帧才放过一帧(把 8fps 砍成 4fps)。 + var publishIntervalMs = 1000.0 / DecodeFps; + var publishThresholdMs = publishIntervalMs * 0.8; + + // 常驻读帧线程(独占线程,不占线程池):始终把管道读空,只保留最新一帧,旧帧直接丢弃。 + // 不这样做的话:解码一帧要 10~380ms,而管道里每秒有 20~30 帧, + // 帧会越积越多,等解码器拿到时画面已经是几秒前的了(现场出现过 >3 秒延迟)。 + var readerThread = new Thread(ReadFrames) + { + IsBackground = true, + Name = $"label-reader-{_target.CameraId}", + }; + + void ReadFrames() + { + var lastPublish = Stopwatch.GetTimestamp(); + try + { + while (!ct.IsCancellationRequested) + { + var filled = 0; + while (filled < frameBytes) + { + var read = stream.Read(pending, filled, frameBytes - filled); + if (read <= 0) return; + filled += read; + } + + Runtime.FramesRead++; + + var elapsedMs = (Stopwatch.GetTimestamp() - lastPublish) * 1000.0 / Stopwatch.Frequency; + if (elapsedMs < publishThresholdMs) + { + // 还没到下一个解码时刻:这帧只读不用 + Runtime.FrameThrottled++; + continue; + } + + lastPublish = Stopwatch.GetTimestamp(); + + lock (frameGate) + { + (pending, latest) = (latest, pending); + frameReady = true; + produced++; + } + + if (frameSignal.CurrentCount == 0) frameSignal.Release(); + } + } + catch + { + // 断流 / 按取消 / 进程被杀:交给解码循环退出 + } + finally + { + lock (frameGate) readerDone = true; + try { if (frameSignal.CurrentCount == 0) frameSignal.Release(); } catch { /* 已释放 */ } + } + } + + readerThread.Start(); + + // 画面变化检测的缩略图(32x18),用于退避期间判断什么时候该恢复全帧率 + var sceneNow = new byte[SceneGridX * SceneGridY]; + var scenePrev = new byte[SceneGridX * SceneGridY]; + var hasScene = false; + + // 每次(重)连上码流都重置:重连期间看不到画面,不能算成「面单离开过」 + _barcodeVisibleAt = null; + _repackDetectedAt = null; + + // OpenCV 条码检测器:整图输入,直接给出条码的四角点(带旋转/透视)。 + // 复用同一个 Mat 承接每帧灰度数据(SetArray 是 2MB memcpy,约 0.2ms),避免每帧分配。 + using var detector = new OpenCvSharp.BarcodeDetector(); + using var frameMat = new OpenCvSharp.Mat(height, width, OpenCvSharp.MatType.CV_8UC1); + + // ZXing 只负责解「已矫正成轴对齐」的条码小图,输入很小,所以选项可以全开 + var reader = new BarcodeReaderGeneric + { + AutoRotate = true, + Options = new DecodingOptions + { + TryHarder = true, + // 只认 Code128:运单条码都是 Code128。开启 EAN13 会把包裹/商品上的 + // 商品条码也读进来(实测读到过 13 位商品码),属于误报。 + PossibleFormats = new[] { BarcodeFormat.CODE_128 }, + }, + }; + + var lastConsumeAt = 0L; + while (!ct.IsCancellationRequested) + { + var waitStart = Stopwatch.GetTimestamp(); + // 同步等待(不 await):整块扫描任务始终跑在自己的独占线程上, + // 不会被切到线程池去排队,线程池忙也影响不到识别。 + frameSignal.Wait(ct); + Runtime.LastWaitMs = (Stopwatch.GetTimestamp() - waitStart) * 1000.0 / Stopwatch.Frequency; + + // 与「上一帧被取走」的间隔 = 完整的循环周期(含上报等所有开销) + var nowTicks = Stopwatch.GetTimestamp(); + if (lastConsumeAt != 0) + { + Runtime.LastLoopMs = (nowTicks - lastConsumeAt) * 1000.0 / Stopwatch.Frequency; + } + + lastConsumeAt = nowTicks; + Runtime.FramesDecoded++; + + long lag; + lock (frameGate) + { + if (!frameReady) + { + if (readerDone) return; + continue; + } + + (latest, buffer) = (buffer, latest); + frameReady = false; + lag = produced - consumed - 1; + consumed++; + } + + // lag = 这一帧之前被丢掉了几帧:0 表示实时,越大说明解码越跟不上 + Runtime.FrameLag = lag > 0 ? lag : 0; + if (lag > 0) Runtime.FrameDropped += lag; + + frameIndex++; + decodeWatch.Restart(); + + // 画面变化检测(很便宜,整帧采样约 9000 个点):退避期间靠它判断什么时候恢复全帧率。 + // 面单拿走/换新/有人手伸进来都会让它变化,于是立刻恢复每帧检测。 + CaptureScene(buffer, width, height, sceneNow); + var sceneChanged = hasScene && SceneDiff(scenePrev, sceneNow) > SceneChangeMeanDiff; + if (sceneChanged) + { + _steadyHits = 0; + _failStreak = 0; + } + + Buffer.BlockCopy(sceneNow, 0, scenePrev, 0, sceneNow.Length); + hasScene = true; + + // 退避:① 同一个码连续命中(面单没动)② 连续没结果(画面里没面单)。 + // 两种都隔帧检测;画面一变立刻恢复。 + var backoffSkipped = frameIndex % BackoffFrameModulo != 0 + && (_steadyHits >= SteadyBackoffAfter || _failStreak >= FailBackoffAfter); + + string? code = null; + var path = "退避"; + var candidates = 0; + + if (!backoffSkipped) + { + decodeWatch.Restart(); + + // 整图检测:OpenCvSharp 的 BarcodeDetector 内部做梯度/多尺度搜索, + // 输出每个条码的 4 个角点(8 个 float 一组),天然带旋转和透视。 + frameMat.SetArray(buffer); + detector.DetectAndDecode(frameMat, out var points, out _, out _); + candidates = points is null ? 0 : points.Length / 4; + + // 「画面里有没有条码」是判断面单是否真的离开的唯一可靠信号(OpenCV 的 无候选 可信)。 + // 离开超过 RepackAbsence 才重新出现 → 认定为真正的新一轮打包(例如装错了重新打包)。 + var visibleAt = DateTime.Now; + if (candidates > 0) + { + if (_barcodeVisibleAt is DateTime lastVisible + && visibleAt - lastVisible >= LabelScanWorker.RepackAbsence) + { + // 锁存:面单刚回来那几帧可能「有候选但解不出」(运动模糊), + // 不能因为后面又检测到就丢掉这个标记。 + _repackDetectedAt = visibleAt; + } + + _barcodeVisibleAt = visibleAt; + } + + Runtime.LastCvMs = decodeWatch.Elapsed.TotalMilliseconds; + decodeWatch.Restart(); + + for (var i = 0; i < candidates && code is null; i++) + { + var text = DecodeQuad(reader, frameMat, points!, i, + out var warpW, out var warpH, out var rasterMs, out var decodeMs); + + // 与扫码枪同一条合法性校验:条码长度/字符集不合规的不算命中(压掉误读) + code = LabelScanWorker.CleanBarcode(text); + if (code is not null) + { + decodeWatch.Stop(); + Runtime.LastDecodeMs = decodeWatch.Elapsed.TotalMilliseconds; + Runtime.RoiText = $"条码 {warpW}x{warpH}"; + Runtime.RoiRatio = Math.Round(rasterMs + decodeMs, 2); + path = "OpenCV解码"; + } + } + + if (code is null) + { + decodeWatch.Stop(); + Runtime.LastDecodeMs = decodeWatch.Elapsed.TotalMilliseconds; + Runtime.RoiText = candidates == 0 ? "无候选" : $"候选{candidates}个未解出"; + Runtime.RoiRatio = 0; + path = candidates == 0 ? "无候选" : "候选未解出"; + } + } + + if (backoffSkipped) + { + path = _steadyHits >= SteadyBackoffAfter ? "稳态退避" : "失败退避"; + } + + // 计数维护:命中就累计稳态、清失败;真跑过但没结果就累计失败、清稳态 + if (code is not null) + { + _steadyHits = string.Equals(code, _lastHitCode, StringComparison.Ordinal) ? _steadyHits + 1 : 1; + _lastHitCode = code; + _failStreak = 0; + } + else if (!backoffSkipped && !sceneChanged) + { + _failStreak++; + _steadyHits = 0; + } + + Runtime.LastPath = path; + Runtime.RoiFailStreak = _failStreak; + Runtime.SteadyHits = _steadyHits; + + if (code is null) continue; + + // 同一张面单在视野里会连续命中:节流到 500ms 一次,足够维持「在场」状态又不刷上报 + var now = DateTime.Now; + if (code == _lastSeenCode && (now - _lastReportAt).TotalMilliseconds < 500) continue; + _lastSeenCode = code; + _lastReportAt = now; + + // 这一条是不是「面单离开过、刚回来」后的第一次上报(真正的新一轮打包)。 + // 锁存时间最多认 60 秒:超过说明中间又走了别的流程,不再算这次重新打包。 + var afterAbsence = _repackDetectedAt is DateTime repackAt + && now >= repackAt + && now - repackAt <= TimeSpan.FromSeconds(60); + if (afterAbsence) _repackDetectedAt = null; + + // 最近命中/最近条码每次都刷新,但「首次识别时间」只认记录里的时间(面单不拿走就不变) + Runtime.LastCode = code; + Runtime.LastHitAt = now; + Runtime.LastError = null; + + // 上报丢给独立线程:扫描线程只入队,不等写记录/上报/通知安卓的结果。 + // 这就是「管道 + 缓冲层 + 不关心是否到底」的做法:任何一环慢都只影响上报,不拖识别。 + EnqueueReport(code, Runtime.LastDecodeMs, Runtime.LastCvMs, afterAbsence); + } + } + + /// + /// 把 OpenCV 检测到的第 index 个四角点区域做透视矫正,交给 ZXing 解 Code128。 + /// + /// 为什么必须矫正:现场面单是**竖放或斜着**摆的(实测四角点 (433,602)(450,514)(1371,685)(1354,774)), + /// 1D 码要求扫描线完整穿过整条,轴对齐裁剪会把条码截断 → 必然解不出。 + /// 矫正成轴对齐后条码完整,ZXing 一次就能读出。 + /// + private static string? DecodeQuad( + BarcodeReaderGeneric reader, + OpenCvSharp.Mat frame, + OpenCvSharp.Point2f[] points, + int index, + out int warpedWidth, + out int warpedHeight, + out double rasterMs, + out double decodeMs) + { + warpedWidth = 0; + warpedHeight = 0; + rasterMs = 0; + decodeMs = 0; + + try + { + var offset = index * 4; + var quad = OrderCorners( + points[offset], points[offset + 1], points[offset + 2], points[offset + 3]); + + var wTop = Distance(quad[0], quad[1]); + var wBottom = Distance(quad[3], quad[2]); + var hLeft = Distance(quad[0], quad[3]); + var hRight = Distance(quad[1], quad[2]); + var outW = Math.Max(8, (int)Math.Round(Math.Max(wTop, wBottom))); + var outH = Math.Max(8, (int)Math.Round(Math.Max(hLeft, hRight))); + + // 太小的框是误检(实测真实条码矫正后约 937x90) + if (outW < 40 || outH < 20) return null; + + warpedWidth = outW; + warpedHeight = outH; + + var rasterWatch = Stopwatch.StartNew(); + var source = new[] { quad[0], quad[1], quad[2], quad[3] }; + var target = new[] + { + new OpenCvSharp.Point2f(0, 0), + new OpenCvSharp.Point2f(outW - 1, 0), + new OpenCvSharp.Point2f(outW - 1, outH - 1), + new OpenCvSharp.Point2f(0, outH - 1), + }; + + using var transform = OpenCvSharp.Cv2.GetPerspectiveTransform(source, target); + using var warped = new OpenCvSharp.Mat(); + OpenCvSharp.Cv2.WarpPerspective(frame, warped, transform, new OpenCvSharp.Size(outW, outH)); + + warped.GetArray(out byte[] raster); + rasterWatch.Stop(); + rasterMs = rasterWatch.Elapsed.TotalMilliseconds; + + var decodeWatch = Stopwatch.StartNew(); + var text = reader.Decode(new PlanarYUVLuminanceSource(raster, outW, outH, 0, 0, outW, outH, false))?.Text; + decodeWatch.Stop(); + decodeMs = decodeWatch.Elapsed.TotalMilliseconds; + + return text; + } + catch + { + return null; + } + } + + private static double Distance(OpenCvSharp.Point2f a, OpenCvSharp.Point2f b) + => Math.Sqrt(Math.Pow(a.X - b.X, 2) + Math.Pow(a.Y - b.Y, 2)); + + /// 把 4 个角点排成「左上、右上、右下、左下」,保证透视变换不翻面 + private static OpenCvSharp.Point2f[] OrderCorners( + OpenCvSharp.Point2f p0, OpenCvSharp.Point2f p1, OpenCvSharp.Point2f p2, OpenCvSharp.Point2f p3) + { + var points = new[] { p0, p1, p2, p3 }; + OpenCvSharp.Point2f topLeft = points[0], topRight = points[0], bottomRight = points[0], bottomLeft = points[0]; + + var minSum = double.MaxValue; + var maxSum = double.MinValue; + var minDiff = double.MaxValue; + var maxDiff = double.MinValue; + + foreach (var point in points) + { + var sum = point.X + point.Y; + var diff = point.Y - point.X; + + if (sum < minSum) { minSum = sum; topLeft = point; } + if (sum > maxSum) { maxSum = sum; bottomRight = point; } + if (diff < minDiff) { minDiff = diff; topRight = point; } + if (diff > maxDiff) { maxDiff = diff; bottomLeft = point; } + } + + return new[] { topLeft, topRight, bottomRight, bottomLeft }; + } + + /// + /// 把整帧压成 32x18 的块均值缩略图(每格 4x4 采样取平均,约 9000 个采样点,<0.1ms)。 + /// 只用来判断「画面有没有变化」,不参与识别。 + /// + private static void CaptureScene(byte[] frame, int width, int height, byte[] target) + { + var cellWidth = Math.Max(1, width / SceneGridX); + var cellHeight = Math.Max(1, height / SceneGridY); + var stepX = Math.Max(1, cellWidth / SceneCellSamples); + var stepY = Math.Max(1, cellHeight / SceneCellSamples); + + for (var gy = 0; gy < SceneGridY; gy++) + { + var y0 = gy * cellHeight; + var yEnd = Math.Min(y0 + cellHeight, height); + for (var gx = 0; gx < SceneGridX; gx++) + { + var x0 = gx * cellWidth; + var xEnd = Math.Min(x0 + cellWidth, width); + var sum = 0; + var count = 0; + for (var y = y0; y < yEnd; y += stepY) + { + var rowBase = y * width; + for (var x = x0; x < xEnd; x += stepX) + { + sum += frame[rowBase + x]; + count++; + } + } + + target[gy * SceneGridX + gx] = count > 0 ? (byte)(sum / count) : (byte)0; + } + } + } + + /// 两张缩略图的平均灰度差(0~255) + private static double SceneDiff(byte[] previous, byte[] current) + { + var sum = 0; + for (var i = 0; i < previous.Length; i++) + { + var delta = previous[i] - current[i]; + sum += delta < 0 ? -delta : delta; + } + + return (double)sum / previous.Length; + } + + private void SetState(string state, string? error) + { + var changed = Runtime.State != state || Runtime.LastError != error; + Runtime.State = state; + Runtime.LastError = error; + if (changed) _changed(); + } + + private static Process NewProcess(string fileName, IEnumerable args) + { + var info = new ProcessStartInfo(fileName) + { + // stdout/stderr 都由调用方按需打开;stdin 一定要重定向,避免子进程读控制台卡住 + RedirectStandardInput = true, + UseShellExecute = false, + CreateNoWindow = true, + }; + foreach (var arg in args) info.ArgumentList.Add(arg); + return new Process { StartInfo = info }; + } + + private static void TryKill(Process? process) + { + if (process is null) return; + try + { + if (!process.HasExited) process.Kill(entireProcessTree: true); + } + catch + { + // 忽略 + } + finally + { + try + { + process.Dispose(); + } + catch + { + // 忽略 + } + } + } +} diff --git a/desktop/Services/Scan/ScanChannel.cs b/desktop/Services/Scan/ScanChannel.cs index 8d7112c..c305a2f 100644 --- a/desktop/Services/Scan/ScanChannel.cs +++ b/desktop/Services/Scan/ScanChannel.cs @@ -30,6 +30,12 @@ public sealed class ScanChannel /// 最后一次见到的 IP public string LastIp { get; set; } = string.Empty; + /// + /// 设备型号(UDP 发现应答的 Type / CustomerID)。 + /// AndroidStation = 安卓扫描通道:桌面端识别到条码后需要通知它播报「扫码成功」。 + /// + public string Model { get; set; } = string.Empty; + /// 设备 TCP 端口(设备当服务端;桌面端用 8087,避开 Android 中控的 8086) public int TcpPort { get; set; } = ScanProtocol.TcpPort; @@ -66,6 +72,10 @@ public sealed class ScanChannel /// 上报给服务端的 channelId(用通道号,稳定且短) [System.Text.Json.Serialization.JsonIgnore] public string ChannelId => Number.ToString(); + + /// 是否安卓扫描通道(只有它需要收到「扫码成功」通知去播报) + [System.Text.Json.Serialization.JsonIgnore] + public bool IsAndroidStation => ScanDeviceKind.IsAndroidStation(Model); } /// 通道配置读写(普通模式 `%LOCALAPPDATA%\YuncangTrace\channels.json`;服务模式 `%ProgramData%\YuncangTrace\channels.json`) diff --git a/desktop/Services/Scan/ScanDeviceKind.cs b/desktop/Services/Scan/ScanDeviceKind.cs new file mode 100644 index 0000000..5e84efc --- /dev/null +++ b/desktop/Services/Scan/ScanDeviceKind.cs @@ -0,0 +1,30 @@ +using System; + +namespace YuncangTrace.LocalService.Services.Scan; + +/// +/// 扫码设备类型判定。 +/// +/// AndroidStation 是我们自己的安卓扫码端(UDP 发现应答的型号固定为 +/// )。桌面端识别到条码后,只有这类通道**需要**收到 +/// 「扫码成功」通知(它会在现有 TCP 连接上解析控制帧并播报语音)。 +/// 网口扫码枪/中控盒没有语音能力,收到通知也无事可做,而且下行字节会被透传到枪的串口, +/// 所以一律不发。 +/// +/// ⚠️ 这条判定**只影响通知**,不影响扫码记录:记录一律先写进待上报队列, +/// 与通道类型、设备是否在线都无关。 +/// +public static class ScanDeviceKind +{ + /// 安卓扫码端的型号(见 AndroidStation 的 StationIdentity.MODEL) + public const string AndroidStation = "AndroidStation"; + + /// 是否安卓扫码通道(型号大小写不敏感) + public static bool IsAndroidStation(string? model) + => !string.IsNullOrWhiteSpace(model) + && model.Trim().Equals(AndroidStation, StringComparison.OrdinalIgnoreCase); + + /// 界面上的类型标注 + public static string Describe(string? model) + => IsAndroidStation(model) ? "安卓扫描通道" : "扫码枪"; +} diff --git a/desktop/Services/Scan/ScanRecordStore.cs b/desktop/Services/Scan/ScanRecordStore.cs index 752da5e..bf57eb0 100644 --- a/desktop/Services/Scan/ScanRecordStore.cs +++ b/desktop/Services/Scan/ScanRecordStore.cs @@ -30,13 +30,24 @@ public sealed class ScanRecordItem public string Code { get; set; } = string.Empty; /// - /// **最近一次**扫到这个条码的时间(本地时间)。 + /// 这条记录用的时间(本地时间;也是上报给服务端、用来定位录像的时间)。 /// - /// 连续扫描时同一个码会反复扫到,这里一直刷新成最后一次; + /// 扫码枪:连续扫描时同一个码会反复扫到,这里一直刷新成最后一次; /// 停 没再扫到才上报,上报的就是这个时间。 + /// + /// 摄像头识别():一轮打包内**不刷新**(取第一次识别), + /// 只有「上次这条记录之后通道上又扫过别的包裹」时,才在重新扫到时更新成这一次的时间。 /// public DateTime ScannedAt { get; set; } + /// + /// 立即上报(摄像头识别专用):不做 静默等待。 + /// + /// 摄像头场景里「面单放进去」那一刻就要定位录像,等 5 秒静默再上报没有意义; + /// 而扫码枪要等包裹离开(最后扫描时间)才对得上录像,所以两者必须分开。 + /// + public bool Immediate { get; set; } + /// 服务器是否已确认收到 public bool Uploaded { get; set; } @@ -99,12 +110,15 @@ public readonly record struct ScanAddResult(ScanAddKind Kind, ScanRecordItem? It /// - **通道回放**:现场要能翻「这台设备刚才扫了什么」,不能只留一条「最近条码」; /// - **连续扫描去重**:同一个码每 ~80ms 报一次,只刷新「最近一次扫到的时间」, /// 不新增记录(所以「A A A B A」记成 A、B 两条,A 的时间是最后一次扫到的时刻); -/// - **延迟上报**:扫到后 (5 秒)内没再扫到才进上报队列, -/// 上报的是**最后一次**扫描时间。面单一直放在扫码器上时,时间会一直往后刷, -/// 直到面单被贴走/拿开,这才是包裹真正离开工作台的时刻; +/// - **两种上报时机**: +/// - 扫码枪():扫到后 (5 秒)内没再扫到才进上报队列, +/// 上报的是**最后一次**扫描时间(面单压在扫码器上时,时间一直往后刷,直到包裹离开); +/// - 面单摄像头():**写入即上报**(), +/// 一轮打包内时间取**第一次**识别到的时刻(面单放进拍摄区后不会马上拿走); +/// 重新打包(上次这条记录之后通道上又扫过别的包裹)时,更新成这一次的时间; /// - 同一个码在 24 小时内再次扫到时会**复用/重新激活同一条本地记录**(不新增行), -/// 5 秒静默后重新上报,**服务器侧覆盖**原来那条记录的时间和工作台快照 -/// (不再像旧版本那样「24 小时内重复的不上报」)。 +/// 重新上报后**服务器侧覆盖**原来那条记录的工作台快照 +/// (不再像旧版本那样「24 小时内重复的不上报」); /// /// 全部操作加锁:调用方既有收条码的连接线程,也有界面线程和上报重试线程。 /// @@ -312,6 +326,80 @@ public static class ScanRecordStore return result; } + /// + /// 记一条**摄像头识别**到的条码(面单摄像头)。 + /// + /// 与扫码枪的 有三点不同,都是现场场景决定的: + /// 1. **时间取第一次识别**:面单放进拍摄区就不会马上拿走(等打包完才取), + /// 所以不能用「最后一次扫描时间」;这里传进来的 一律写入, + /// 后续同一面单在视野里的重复命中**不会**改时间; + /// 2. **立即上报**:写入即进上报队列(), + /// 不等 5 秒静默 —— 包裹一进面单区就要能把录像定位到那一刻; + /// 3. **24 小时内复用同一条记录**(本地不堆重复行),但时间分两种: + /// - 上次这条记录之后,通道上**没有**别的码 → 还是同一轮打包(面单一直摆着/刚走又放回), + /// 保留**第一次**识别时间,只重新挂回待上报; + /// - 上次这条记录之后,通道上**已经扫过别的包裹**(本轮已经往下走了)→ 这是**重新打包**, + /// 用这一次的识别时间更新原来那条(服务端把同运单覆盖成新时间,录像定位到最新这次打包)。 + /// + /// 本次「进入视野」的时间(调用方按在场判定,见 ScanService) + public static ScanAddResult AddCamera(string channelId, string channelName, string code, DateTime firstSeenAt) + { + var key = (channelId ?? string.Empty).Trim(); + var text = (code ?? string.Empty).Trim(); + if (key.Length == 0 || text.Length == 0) return new ScanAddResult(ScanAddKind.Invalid, null); + + ScanAddResult result; + lock (Gate) + { + EnsureLoaded(); + + var name = (channelName ?? string.Empty).Trim(); + var windowStart = DateTime.Now - MergeWindow; + + // 24 小时内同一个码(同通道)→ 复用那条 + var existing = _items + .Where(item => item.ChannelId.Equals(key, StringComparison.OrdinalIgnoreCase) + && item.Code.Equals(text, StringComparison.Ordinal) + && item.ScannedAt > windowStart) + .OrderByDescending(item => item.ScannedAt) + .ThenByDescending(item => item.Id) + .FirstOrDefault(); + + if (existing is not null) + { + // 这条面单上次记录之后,通道上又出现了别的码(别的包裹已经走过这一轮)→ + // 说明这次是**重新打包**,时间要用这一次的 + var repacked = _items.Any(item => item.Id > existing.Id + && item.ChannelId.Equals(key, StringComparison.OrdinalIgnoreCase) + && !item.Code.Equals(text, StringComparison.Ordinal)); + + var wasPending = !existing.Uploaded && !existing.Suppressed; + if (repacked) Reopen(existing, firstSeenAt, name); + + if (!string.IsNullOrWhiteSpace(name)) existing.ChannelName = name; + existing.Immediate = true; + existing.Suppressed = false; + // 已上报过的重新挂回队列:中间没别的包裹就用**同一时间**覆盖(快照更新,录像定位不变), + // 重新打包则用**这次的结果时间**覆盖(录像定位到新的一次) + existing.Uploaded = false; + existing.UploadedAt = null; + _dirty = true; + result = new ScanAddResult(repacked ? ScanAddKind.Touched + : wasPending ? ScanAddKind.Repeated : ScanAddKind.Touched, existing); + } + else + { + var created = Create(key, name, text, firstSeenAt); + created.Immediate = true; + result = new ScanAddResult(ScanAddKind.Created, created); + } + } + + SaveThrottled(); + if (result.IsScanEvent) Changed?.Invoke(); + return result; + } + /// 新建一条待上报记录(调用方已加锁) private static ScanRecordItem Create(string channelId, string channelName, string code, DateTime scannedAt) { @@ -380,8 +468,11 @@ public static class ScanRecordStore { EnsureLoaded(); return _items - .Where(item => !item.Uploaded && !item.Suppressed && item.ScannedAt <= cutoff) - .OrderBy(item => item.Id) + // 摄像头识别的记录(Immediate)不等静默窗口,落了就上报; + // 并且**排在最前面**:积压很多时也要先把它推出去(它决定录像定位) + .Where(item => !item.Uploaded && !item.Suppressed && (item.Immediate || item.ScannedAt <= cutoff)) + .OrderBy(item => item.Immediate ? 0 : 1) + .ThenBy(item => item.Id) .Take(limit) .ToList(); } @@ -397,14 +488,15 @@ public static class ScanRecordStore } } - /// 已经静默满 5 秒、可以真正上报的条数 + /// 已经静默满 5 秒(或摄像头识别的立即上报)可以真正上报的条数 public static int ReadyCount() { var cutoff = DateTime.Now - SettleDelay; lock (Gate) { EnsureLoaded(); - return _items.Count(item => !item.Uploaded && !item.Suppressed && item.ScannedAt <= cutoff); + return _items.Count(item => !item.Uploaded && !item.Suppressed + && (item.Immediate || item.ScannedAt <= cutoff)); } } diff --git a/desktop/Services/Scan/ScanService.cs b/desktop/Services/Scan/ScanService.cs index 0b7f410..4ed4f3b 100644 --- a/desktop/Services/Scan/ScanService.cs +++ b/desktop/Services/Scan/ScanService.cs @@ -1,4 +1,5 @@ using System; +using System.Collections.Concurrent; using System.Collections.Generic; using System.Linq; using System.Threading; @@ -84,10 +85,32 @@ public sealed class ScanService public ScanService(DeviceService device) { _device = device; + LabelScan = new LabelScanMonitor(device, (channelId, code, wsType, afterAbsence) => + ReportCameraScanAsync(channelId, ChannelNameOf(channelId), code, wsType, afterAbsence)); + // 扫码枪那条路也要按「通道 → 工作台类型」决定记录规则(散单取第一次、团购取最后一次) + device.ChannelModeOf = LabelScan.ModeOf; // 主体续期/恢复后补一次通道对账(暂停期间通道变动不会推上去) _device.SubjectResumed += () => RequestChannelSync(); } + /// 通道显示名(面单摄像头识别结果落本地记录时用;查不到就用通道号) + private string ChannelNameOf(string channelId) + { + var key = (channelId ?? string.Empty).Trim(); + // 虚拟通道(面单摄像头自己用的 `CAM-<工作台id>`)不在本机通道列表里,名字从面单配置里取 + var labelName = LabelScan.ChannelNameOf(key); + if (!string.IsNullOrWhiteSpace(labelName)) return labelName; + + var channel = Channels.FirstOrDefault(item => item.ChannelId.Equals(key, StringComparison.OrdinalIgnoreCase)); + return channel?.DisplayName ?? key; + } + + /// + /// 面单识别配置的拉取/对账层(**只拉配置,不做识别**)。 + /// 服务启动时自动拉一次 + 每 5 分钟兜底;收到 `labelScan.refresh` 时立即拉。 + /// + public LabelScanMonitor LabelScan { get; } + /// 通道同步状态(给界面看的一句话) public string ChannelSyncStatus { get; private set; } = string.Empty; @@ -139,24 +162,35 @@ public sealed class ScanService /// /// 设备 DHCP 换 IP 后必须重连:通道靠 MAC 绑定,`LastIp` 只是缓存, /// 不刷新的话会一直重连一个旧地址(Android 侧 `Connection#setIp` 就是干这个的)。 + /// + /// 顺带把设备型号补进通道配置:老通道(本次改动前添加的)没有型号, + /// 发现到之后就知道它是不是「安卓扫描通道」。 /// private void ApplyDiscoveredIps(IReadOnlyList devices) { var changed = new List(); + var metadataChanged = false; foreach (var device in devices) { - if (string.IsNullOrWhiteSpace(device.Ip)) continue; - var channel = Channels.FirstOrDefault(item => item.Mac.Equals(device.Mac, StringComparison.OrdinalIgnoreCase)); - if (channel is null || channel.LastIp.Equals(device.Ip, StringComparison.Ordinal)) continue; + if (channel is null) continue; + + var model = (device.Model ?? string.Empty).Trim(); + if (model.Length > 0 && !channel.Model.Equals(model, StringComparison.Ordinal)) + { + channel.Model = model; + metadataChanged = true; + } + + if (string.IsNullOrWhiteSpace(device.Ip) || channel.LastIp.Equals(device.Ip, StringComparison.Ordinal)) continue; AppLog.Write($"[scan] 通道 {channel.Number} 设备 IP 变了:{channel.LastIp} → {device.Ip},重新连接"); channel.LastIp = device.Ip; changed.Add(channel); } - if (changed.Count == 0) return; + if (!metadataChanged && changed.Count == 0) return; SaveChannels(); Changed?.Invoke(); @@ -174,6 +208,280 @@ public sealed class ScanService return await connection.SendRawAsync(payload).ConfigureAwait(false); } + /// 面单摄像头的「在场」状态:同一张面单一直摆在拍摄区时只算一次进入,记录时间取**第一次**识别 + private sealed class CameraPresence + { + /// 这张面单的时间(首次识别时刻,写进记录后**永不刷新**) + public DateTime? ScanTime { get; set; } + + public DateTime LastHitAt { get; set; } + } + + /// + /// 多久没有新的识别命中,就认为面单已经离开了拍摄区。 + /// + /// 直接复用识别线程的 :**判定「面单离开」只有这一个阈值**, + /// 两处各写一个的话会出现「算重新进去了、但时间没更新」的漏洞。 + /// + /// 注意在场状态是**按「通道|条码」**记的,所以换一张新面单永远是新建记录、不受这个值影响; + /// 它只决定「同一张面单」重新被识别时算不算新的一次进入(要不要重新上报/播报 + 时间要不要更新)。 + /// + private static readonly TimeSpan CameraPresenceGap = LabelScanWorker.RepackAbsence; + + /// 首次识别时间的保留时长(与后端 24 小时合并窗口一致) + private static readonly TimeSpan CameraPresenceTtl = TimeSpan.FromHours(24); + + private readonly Dictionary _cameraPresence = new(StringComparer.OrdinalIgnoreCase); + private readonly object _cameraPresenceGate = new(); + + /// 待通知安卓播报的条码(按通道只保留最新一条:播报是「叮」一声,旧的无意义) + private readonly ConcurrentDictionary _pendingNotices = new(StringComparer.OrdinalIgnoreCase); + + /// 后台播报泵是否在跑(0/1,避免每条命中都起一个任务) + private int _noticePumpRunning; + + /// + /// 面单摄像头识别到一条条码:**先落待上报记录(立即上报),再通知安卓端播报(等回执)**。 + /// + /// 与扫码枪的区别(摄像头场景:面单放进拍摄区 → 开始打包 → 打包完才取走): + /// 1. **取第一次识别的时间**,不用「最后一次命中」——面单会在视野里停留很久; + /// 2. **写入即上报**,不等 5 秒静默:一进面单区就要能把录像定位到那一刻; + /// 3. 同一张面单在视野里的重复帧**什么都不做**(不改时间、不重复上报、不重复播报); + /// 4. 面单一直摆着、中途出现识别空档(手挡/移位/反光)→ **仍算同一轮打包,时间不前移**; + /// 只有「画面里连 45 秒没有任何条码」之后重新识别到(真的拿走再放回,例如装错了重新打包) + /// 才用**这次**的时间。 + /// + /// 不能用「这中间通道上又扫过别的包裹」当判据:两张面单轮流进入视野就会命中, + /// 但那两张都没离开过,属于误判(现场就是因此把打包时间推后了)。 + /// + /// **团购工作台不一样**(`wsType = 2`):和扫码枪同一套规则 —— 静默 5 秒后上报、 + /// 时间取**最后一次**命中(见 )。 + /// + /// 记录与通知解耦:**记录永远写**(与通道类型、安卓是否在线、设备服务是否开启无关), + /// 通知失败只体现在 。 + /// + /// 1 散单(取第一次 + 立即上报)/ 2 团购(静默 5 秒取最后一次)/ 0 未知按散单 + /// + /// 这张面单是从「画面里连一段时间没有任何条码」之后重新出现的 —— 即真的被拿走再放回来 + /// (装错了重新打包)。为 true 时记录时间用**这次**的,否则沿用本轮首次识别时间。 + /// + public async Task ReportCameraScanAsync(string channelId, string channelName, string code, + int wsType = 1, bool afterAbsence = false) + { + var key = (channelId ?? string.Empty).Trim(); + var text = (code ?? string.Empty).Trim(); + if (key.Length == 0 || text.Length == 0) return new CameraScanResult(false, false); + + var now = DateTime.Now; + var presenceKey = $"{key}|{text}"; + bool firstInView; + DateTime? knownScanTime = null; + + lock (_cameraPresenceGate) + { + PruneCameraPresence(now); + + if (_cameraPresence.TryGetValue(presenceKey, out var presence)) + { + // 还在视野里(距上次命中没超过 Gap)→ 只刷新命中时间,其余什么都不做 + firstInView = now - presence.LastHitAt > CameraPresenceGap; + presence.LastHitAt = now; + knownScanTime = presence.ScanTime; + } + else + { + firstInView = true; + _cameraPresence[presenceKey] = new CameraPresence { LastHitAt = now }; + } + } + + if (wsType == 2) + { + return await ReportGroupBuyCameraScanAsync(key, channelName, text, now, presenceKey, firstInView).ConfigureAwait(false); + } + + if (!firstInView) return new CameraScanResult(false, false, knownScanTime); + + // ⚠️ 同一轮打包内重新识别到同一张面单时,时间必须是**最初那次**: + // 面单一直摆在拍摄区,中间被手挡住/移位一会儿就可能出现识别空档, + // 若用 now 就会把打包时间整体往后推(实测出现过「开始打包 30 秒之后」)。 + var recordAt = ResolveCameraScanTime(now, knownScanTime, afterAbsence); + + // ① 记录:时间固定取第一次识别(AddCamera 内部 24 小时复用同一条,不会新增行) + var added = ScanRecordStore.AddCamera(key, channelName, text, recordAt); + + // 记录里那条的时间才是唯一真值(命中已有记录时就是当初那次的时间), + // 界面/上报都以它为准,所以面单一直不拿走也不会越刷越新 + var scanTime = added.Item?.ScannedAt ?? now; + lock (_cameraPresenceGate) + { + if (_cameraPresence.TryGetValue(presenceKey, out var presence)) presence.ScanTime = scanTime; + } + + if (added.IsScanEvent) + { + // 立即上报(不等静默窗口;未开启设备服务时只留在本地队列) + _device.TriggerUpload(); + var channel = Channels.FirstOrDefault(item => item.ChannelId.Equals(key, StringComparison.OrdinalIgnoreCase)); + if (channel is not null) Barcode?.Invoke(channel, text); + Changed?.Invoke(); + } + + // ② 通知安卓端播报「扫码成功」:**丢后台,不等回执**。 + // 回执只是让安卓「叮」一声,等它会把面单摄像头的解码循环堵住 + // (实测 1200ms×2 次重试 → 8fps 的画面在管道里堆到 2.6 秒,拿到的是几秒前的帧)。 + QueueScanNotice(key, text); + + return new CameraScanResult(added.IsScanEvent, false, scanTime); + } + + /// + /// 团购工作台的面单摄像头识别结果:**和扫码枪同一套规则** —— 记录时间取最后一次命中, + /// 静默 (5 秒)没再认出同一个码才进上报队列。 + /// + /// 播报仍然只在「刚进入视野」时发一次(码可能在视野里停很久,不能每帧都播)。 + /// + /// 团购工作台的识别结果:**同步完成**(不再等安卓回执,播报丢后台) + private Task ReportGroupBuyCameraScanAsync( + string channelId, + string channelName, + string code, + DateTime now, + string presenceKey, + bool firstInView) + { + if (!firstInView) + { + // 还在视野里:刷新「最后一次」时间,静默窗口重新计时(与扫码枪连续扫描一致) + var touched = ScanRecordStore.Add(channelId, channelName, code, now); + lock (_cameraPresenceGate) + { + if (_cameraPresence.TryGetValue(presenceKey, out var presence)) presence.ScanTime = touched.Item?.ScannedAt ?? now; + } + if (touched.IsScanEvent) Changed?.Invoke(); + return Task.FromResult(new CameraScanResult(touched.IsScanEvent, false, touched.Item?.ScannedAt)); + } + + var added = ScanRecordStore.Add(channelId, channelName, code, now); + var scanTime = added.Item?.ScannedAt ?? now; + lock (_cameraPresenceGate) + { + if (_cameraPresence.TryGetValue(presenceKey, out var presence)) presence.ScanTime = scanTime; + } + + if (added.IsScanEvent) + { + var channel = Channels.FirstOrDefault(item => item.ChannelId.Equals(channelId, StringComparison.OrdinalIgnoreCase)); + if (channel is not null) Barcode?.Invoke(channel, code); + Changed?.Invoke(); + } + + // 团购也要播报,但只是「出现了」这一下;后续重复命中不再播。同样丢后台不等回执。 + QueueScanNotice(channelId, code); + return Task.FromResult(new CameraScanResult(added.IsScanEvent, false, scanTime)); + } + + /// + /// 把「通知安卓播报」丢到后台执行,扫码流不等回执。 + /// + /// 同一通道只保留**最新一条**:播报就是「叮」一声,排队等旧的没有意义, + /// 这样即使安卓一直不回执,队列也不会无限增长。 + /// + public void QueueScanNotice(string channelId, string code) + { + var key = (channelId ?? string.Empty).Trim(); + if (key.Length == 0 || string.IsNullOrWhiteSpace(code)) return; + + _pendingNotices[key] = code; + StartNoticePump(); + } + + /// 后台播报泵:串行消化 ,自身异常不影响扫码流 + private void StartNoticePump() + { + if (Interlocked.CompareExchange(ref _noticePumpRunning, 1, 0) != 0) return; + + _ = Task.Run(async () => + { + try + { + while (!_pendingNotices.IsEmpty) + { + foreach (var key in _pendingNotices.Keys.ToList()) + { + if (!_pendingNotices.TryRemove(key, out var code)) continue; + try + { + await NotifyScanSuccessAsync(key, code).ConfigureAwait(false); + } + catch (Exception ex) + { + AppLog.Write($"[scan] 通知安卓播报失败:{ex.Message}"); + } + } + } + } + finally + { + Interlocked.Exchange(ref _noticePumpRunning, 0); + // 收尾瞬间可能又进来一条,补拉一次泵 + if (!_pendingNotices.IsEmpty) StartNoticePump(); + } + }); + } + + /// + /// 决定这条面单记录该用哪个时间。 + /// + /// 判据只有一个:**面单有没有真的离开过画面**(, + /// 由识别线程按「画面里连一段时间没有任何条码」得出)。 + /// + /// - 没离开(面单一直摆着,中途被手挡住/移位/反光):**沿用最初那次**。 + /// 否则打包时间会被推后 —— 现场实测出现过「变成开始打包 30 秒之后」,录像定位整体偏移; + /// - 真的离开又回来(装错了重新打包、20 分钟后重新称重发现装错再包一遍):用**这次**的时间。 + /// + /// 为什么不再用「这中间通道上又扫过别的包裹」当判据:两张面单轮流进入视野就会命中, + /// 但那两张面单都没离开过,属于误判。 + /// + internal static DateTime ResolveCameraScanTime(DateTime now, DateTime? knownScanTime, bool afterAbsence) + { + if (afterAbsence) return now; + if (knownScanTime is DateTime firstSeen && now >= firstSeen) return firstSeen; + return now; + } + + /// 清掉 24 小时没再出现过的在场记录(防止字典无限增长) + private void PruneCameraPresence(DateTime now) + { + if (_cameraPresence.Count == 0) return; + + var stale = _cameraPresence + .Where(pair => now - pair.Value.LastHitAt > CameraPresenceTtl) + .Select(pair => pair.Key) + .ToList(); + foreach (var key in stale) _cameraPresence.Remove(key); + } + + /// + /// 通知某条通道的安卓设备「扫码成功」(让它播报语音),并等它回执。 + /// + /// **只对安卓扫描通道发**:网口扫码枪/中控盒没有语音能力,收到也无事可做。 + /// 返回 false 只表示「没确认收到」,不是错误 —— 记录已在 里落好。 + /// + public async Task NotifyScanSuccessAsync(string channelId, string code) + { + var key = (channelId ?? string.Empty).Trim(); + if (key.Length == 0) return false; + + var channel = Channels.FirstOrDefault(item => + item.ChannelId.Equals(key, StringComparison.OrdinalIgnoreCase) + || item.Mac.Equals(key, StringComparison.OrdinalIgnoreCase)); + if (channel is null || !channel.IsAndroidStation) return false; + if (!_connections.TryGetValue(channel.Mac, out var connection)) return false; + + return await connection.SendScanNoticeAsync(code).ConfigureAwait(false); + } + /// /// 切换某条通道的扫码枪静音(与 AndroidScanCenter 一致): /// **只存本地 + 让这条连接重新走一遍**,不在现有 socket 上补写指令 —— @@ -227,19 +535,22 @@ public sealed class ScanService /// 回滚本地行不通:中间设备名可能已经写上去了,回滚只能回一半。 /// /// 指定通道号(<=0 或被占用时退回最小空号) + /// 设备型号(UDP 发现应答的 Type/CustomerID;AndroidStation = 安卓扫描通道) /// 进度文案回调(界面显示用) public async Task AddChannelAsync(string mac, string name, string ip, int number, - string? reportedHostName = null, Action? stage = null, CancellationToken ct = default) + string? reportedHostName = null, string? model = null, Action? stage = null, CancellationToken ct = default) { var key = (mac ?? string.Empty).Trim().ToUpperInvariant(); var trimmed = (name ?? string.Empty).Trim(); + var deviceModel = (model ?? string.Empty).Trim(); - // 已存在:只更新名字/IP/通道号,不重配设备 + // 已存在:只更新名字/IP/型号/通道号,不重配设备 var existing = Channels.FirstOrDefault(item => item.Mac.Equals(key, StringComparison.OrdinalIgnoreCase)); if (existing is not null) { existing.LastIp = string.IsNullOrWhiteSpace(ip) ? existing.LastIp : ip; if (trimmed.Length > 0) existing.Name = trimmed; + if (deviceModel.Length > 0) existing.Model = deviceModel; if (number > 0 && ChannelStore.FindByNumber(Channels, number, existing.Mac) is null) existing.Number = number; SaveChannels(); Changed?.Invoke(); @@ -270,6 +581,7 @@ public sealed class ScanService Mac = key, Name = trimmed.Length > 0 ? trimmed : key, LastIp = ip, + Model = deviceModel, Number = wanted, TcpPort = ScanProtocol.TcpPort, SockName = ensure.SockName, @@ -354,6 +666,7 @@ public sealed class ScanService RequestChannelSync(); EnsureWatchdog(); + LabelScan.Start(); // 面单识别配置:启动拉一次 + 每 5 分钟兜底 AppLog.Write($"[scan] 扫码服务已启动,通道 {Channels.Count} 个"); Changed?.Invoke(); return Task.CompletedTask; @@ -389,6 +702,7 @@ public sealed class ScanService _watchdogTask = null; StopDiscovery(); + LabelScan.Stop(); AppLog.Write("[scan] 扫码服务已停止"); Changed?.Invoke(); @@ -721,3 +1035,15 @@ public sealed record AddChannelResult( /// 改通道名的结果( 是给用户看的一句话) public sealed record RenameChannelResult(bool Ok, string Message); + +/// +/// 面单摄像头识别结果的处理结果。 +/// +/// 只影响界面是否重查; 只表示「安卓端有没有收到播报通知」, +/// **不代表记录是否入队** —— 记录一定已写入待上报队列。 +/// +/// 是这条记录**真正的时间**:第一次识别到的那一刻, +/// 面单不拿走也不会变(界面显示「首次识别」用它,不能用当前的命中时间)。 +/// +/// 面单摄像头识别结果( 恒为 false:播报已改为后台异步,不再等回执) +public sealed record CameraScanResult(bool NewScan, bool Notified, DateTime? ScanTime = null); diff --git a/desktop/Services/SingleInstance.cs b/desktop/Services/SingleInstance.cs index f781c02..c2255aa 100644 --- a/desktop/Services/SingleInstance.cs +++ b/desktop/Services/SingleInstance.cs @@ -16,6 +16,9 @@ namespace YuncangTrace.LocalService.Services; /// public sealed class SingleInstance : IDisposable { + /// 第二个实例「只想把界面叫出来」(双击快捷方式,没带任何参数) + public const string ShowCommand = "--show"; + private readonly Mutex _mutex; private readonly string _pipeName; private readonly Action _onArgs; @@ -50,10 +53,13 @@ public sealed class SingleInstance : IDisposable /// /// 第二个实例调用:把命令行参数送给已运行的实例。 /// 返回 false = 送不出去(常见原因:第一个实例是**管理员权限**,中完整性的第二个实例写不进它的管道)。 + /// + /// ⚠️ 没有参数(双击快捷方式)也要送一条 :以前这里直接 return true 什么都不发, + /// 第二个实例紧接着就退出 → 用户看到的就是「点图标没反应,主界面打不开」。 /// public bool SendArgs(string[] args) { - if (args.Length == 0) return true; + var payload = args is { Length: > 0 } ? args : new[] { ShowCommand }; try { @@ -61,7 +67,7 @@ public sealed class SingleInstance : IDisposable client.Connect(1500); using var writer = new StreamWriter(client, new UTF8Encoding(false)) { AutoFlush = true }; - foreach (var arg in args) writer.WriteLine(arg); + foreach (var arg in payload) writer.WriteLine(arg); return true; } catch (Exception ex) diff --git a/desktop/Views/AddChannelWindow.xaml b/desktop/Views/AddChannelWindow.xaml index 0bd0e13..6a2887b 100644 --- a/desktop/Views/AddChannelWindow.xaml +++ b/desktop/Views/AddChannelWindow.xaml @@ -13,7 +13,12 @@ + Foreground="{StaticResource MutedBrush}" Margin="0,4,0,8" TextWrapping="Wrap" /> + + + + + + + + +
+ 登录时间 + + 至 + + + +
+ +

+ 成员用手机微信扫「扫码登入」里生成的二维码即可登入本工作台(二维码一次有效,由微信登录网关下发); + 名字取「主体成员姓名(工号)」,不是主体成员时取自己设置的昵称。 + 微信需要先在自己的账号里绑定(个人中心 → 微信绑定)。 +

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
名字账号登录时间下线时间状态操作
{{ row.name || '—' }}{{ row.user?.nickname || row.user?.username || `#${row.userId}` }}{{ formatTime(row.loginAt) }}{{ row.logoutAt ? formatTime(row.logoutAt) : '—' }} + + {{ Number(row.status) === 1 ? '在线' : offlineLabel(row.logoutReason) }} + + + + — +
+ {{ membersIncludeHistory ? '还没有登录记录。' : '当前没有在线成员。' }} +
+
+ + + + + + + + + + + @@ -702,6 +1071,57 @@ onMounted(() => load(1)); white-space: nowrap; } +/* 扫码登入弹窗 */ +.login-qr { + display: flex; + flex-direction: column; + align-items: center; + gap: 10px; +} + +.qr-img { + width: 200px; + height: 200px; + padding: 6px; + border: 1px solid var(--border); + border-radius: 10px; + background: #fff; +} + +/* 成员弹窗:顶部状态栏 */ +.member-bar { + display: flex; + align-items: center; + gap: 12px; + flex-wrap: wrap; + margin-bottom: 6px; +} + +.member-bar-actions { + margin-left: auto; + display: inline-flex; + align-items: center; + gap: 8px; +} + +.member-toggle { + display: inline-flex; + align-items: center; + gap: 4px; + font-size: 13px; + color: #475569; +} + +.member-filter { + gap: 8px; + margin-bottom: 10px; +} + +.member-filter input[type='datetime-local'] { + font-size: 13px; + padding: 4px 6px; +} + .bind-list { list-style: none; margin: 0; @@ -729,6 +1149,18 @@ onMounted(() => load(1)); font-weight: 600; } +/* 面单摄像头标记(仅散单工作台) */ +.label-tag { + flex: none; + padding: 1px 6px; + border-radius: 4px; + background: #fef3c7; + border: 1px solid #fcd34d; + color: #92400e; + font-size: 12px; + line-height: 18px; +} + .bind-list .hint { margin-left: auto; margin-right: 8px; @@ -774,6 +1206,33 @@ onMounted(() => load(1)); background: #f8fafc; } +/* 面单摄像头设了但没绑扫码通道:走虚拟通道,说明一下即可 */ +.label-note { + margin: 6px 0 0; + padding: 6px 10px; + border-radius: 6px; + background: #eff6ff; + border: 1px solid #bfdbfe; + color: #1d4ed8; + font-size: 12px; +} + +.label-note code, +.virtual-tag { + font-family: ui-monospace, SFMono-Regular, Menlo, monospace; +} + +/* 虚拟通道(面单摄像头自动占用)标记 */ +.virtual-tag { + background: #eff6ff; + color: #1d4ed8; + border: 1px solid #bfdbfe; + border-radius: 4px; + padding: 0 6px; + font-size: 12px; + white-space: nowrap; +} + .pick-badge { color: #b45309; background: #fff7ed;