feat(工作台): 成员扫码登入、面单摄像头与虚拟通道

- 工作台成员扫码登入: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>
This commit is contained in:
liufumingren 2026-10-29 17:19:24 +08:00
parent b135ef09d4
commit f8aa4c4899
44 changed files with 5709 additions and 95 deletions

View File

@ -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;

View File

@ -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;

View File

@ -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,
};

View File

@ -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 || '',

View File

@ -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;

View File

@ -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,

View File

@ -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;
};

View File

@ -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;
},
};
};

View File

@ -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;

View File

@ -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<object>} { 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<number>} 通知到的设备数
*/
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;

View File

@ -114,6 +114,7 @@ class PackService extends Service {
* @return {Promise<object>} { 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');

View File

@ -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<object>} { 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<object>} { 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-<id>`)没用了,顺手清掉
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<number>} 解绑的绑定行数
*/
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}%` } },

View File

@ -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<object>} { 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<object>} { 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<number>} 受影响条数
*/
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<object>} { 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<Map<*, Array<object>>>} 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;

View File

@ -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');
},
};

View File

@ -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');
},
};

View File

@ -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');
},
};

View File

@ -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));
});
});

View File

@ -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));
});
});

View File

@ -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,不向调用方抛异常');
});
});
});

View File

@ -53,6 +53,9 @@ public partial class App : Application
/// <summary>正在检查 / 正在弹更新窗:避免自动检查与菜单「检查更新」并发弹两个窗</summary>
private bool _updatePrompting;
/// <summary>登录窗还没关时查到的更新:等主窗口显示完再弹(不能塞在登录窗的模态循环里)</summary>
private (UpdateInfo Info, Version Current)? _pendingUpdate;
/// <summary>NTP 定时校时(运行期间周期性把本机时钟校准到 NTP)</summary>
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();
}
}
/// <summary>
@ -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
}
}
/// <summary>
/// 弹出更新窗(下载 + 安装)。**只允许在没有其他模态窗时调用**(见 <see cref="CheckUpdatesAsync"/>)。
/// </summary>
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;
}
/// <summary>
/// 把 <c>yuncang://open?code=xxx</c> 的注册表项校正到当前 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();
});

View File

@ -149,6 +149,10 @@
<TabItem x:Name="RecordsTab" Header="扫码记录" Visibility="Collapsed">
<ContentControl x:Name="RecordsTabHost" />
</TabItem>
<TabItem x:Name="LabelCameraTab" Header="面单摄像头" Visibility="Collapsed">
<ContentControl x:Name="LabelCameraTabHost" />
</TabItem>
</TabControl>
</Grid>
</Grid>

View File

@ -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;
/// <summary>运单回放查询(后端 `/api/web/pack-query`,用当前主体的用户令牌)</summary>
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;
// 服务主体不一致:统一显示在页签上方(不弹窗,正常进界面)

View File

@ -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
/// <summary>取流子进程(--hik-worker)状态;没有取流能力时 <see cref="AgentHikStatus.Available"/> 为 false</summary>
public AgentHikStatus Hik { get; set; } = new();
/// <summary>面单识别配置的拉取状态(只拉配置,识别 worker 还没接)</summary>
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; }
}
/// <summary>一路面单摄像头的运行状态(桌面端只读展示)</summary>
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; } = "";
/// <summary>工作台 → 摄像头 → 上报通道(**不含密码**)</summary>
public string Summary { get; set; } = "";
/// <summary>识别中 / 启动中… / 异常 / 已停止</summary>
public string StateText { get; set; } = "";
public string LastCode { get; set; } = "";
/// <summary>首次识别时间(记录真正用的时间,不会随重复命中刷新)</summary>
public DateTime? LastCodeAt { get; set; }
/// <summary>最近一次命中时间(只用于看摄像头是否在扫)</summary>
public DateTime? LastHitAt { get; set; }
/// <summary>当前码流(主/子 + 分辨率)</summary>
public string StreamText { get; set; } = "";
/// <summary>最近一帧解码耗时(毫秒,含倾斜补偿)</summary>
public double LastDecodeMs { get; set; }
/// <summary>最近一帧 CV 定位耗时(毫秒,不含解码)</summary>
public double LastCvMs { get; set; }
/// <summary>最近一帧走的路径(ROI / 退避跳过 / 整帧 / 扫角…)</summary>
public string LastPath { get; set; } = "";
/// <summary>ROI 连续解失败次数(≥3 时进入隔帧退避)</summary>
public int RoiFailStreak { get; set; }
/// <summary>同一个码连续解出的次数(≥3 时进入稳态退避)</summary>
public int SteadyHits { get; set; }
/// <summary>从管道读到的总帧数(ffmpeg 实际产出)</summary>
public long FramesRead { get; set; }
/// <summary>按 DecodeFps 限速后丢弃的帧数</summary>
public long FrameThrottled { get; set; }
/// <summary>解码循环处理的帧总数</summary>
public long FramesDecoded { get; set; }
/// <summary>等新帧耗时(毫秒)</summary>
public double LastWaitMs { get; set; }
/// <summary>两次取帧之间的完整周期(毫秒)</summary>
public double LastLoopMs { get; set; }
/// <summary>最近一帧自动定位到的条码区域(ROI w x h;未定位时为空文案)</summary>
public string RoiText { get; set; } = "";
/// <summary>最近一帧「透视矫正 + ZXing 解码」耗时(毫秒)</summary>
public double RoiRatio { get; set; }
/// <summary>最近一次取到帧时积压了几帧(0=实时;&gt;0 说明解码跟不上、旧帧被丢弃)</summary>
public long FrameLag { get; set; }
/// <summary>累计丢弃的旧帧数</summary>
public long FrameDropped { get; set; }
public long Hits { get; set; }
public string? LastError { get; set; }
}
/// <summary>
/// 面单摄像头识别的整体状态(配置拉取 + 每路运行状态)。
/// 文案里不含录像机密码。
/// </summary>
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; }
/// <summary>每路的运行状态(最近条码、状态、错误)</summary>
public List<AgentLabelCameraStatus> Items { get; set; } = new();
/// <summary>服务端给的提示(例如工作台没绑本机通道)</summary>
public List<string> Warnings { get; set; } = new();
}
/// <summary>桌面端 → 后台服务的一次性命令(写文件,服务每秒轮询)</summary>
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<T>(text, Options);
@ -270,18 +368,31 @@ public static class AgentFiles
private static void Write<T>(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;
}
}
}
}

View File

@ -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
/// 这里任何异常都只记日志并退避重试,绝不影响扫码链路。
/// </summary>
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
/// <summary>执行一个边缘任务;返回要回传给云端的结果对象</summary>
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);

View File

@ -58,6 +58,14 @@ public sealed class DeviceService
// 这种事件不能每条都写日志,否则一天几万行;同一个 通道+条码 5 分钟记一次。
private static readonly ConcurrentDictionary<string, DateTime> TouchedLogAt = new();
/// <summary>散单通道「同一张面单还在扫」的判定窗口:这之内再扫到同一个码只算一次</summary>
private static readonly TimeSpan FirstSeenGap = TimeSpan.FromSeconds(5);
// 散单通道的在场记录:key = 通道|条码 → (首次扫到, 最近扫到)
private readonly Dictionary<string, (DateTime FirstSeenAt, DateTime LastHitAt)> _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();
}
/// <summary>
/// 通道 → 工作台类型(1 散单 / 2 团购 / 0 未知),由 <see cref="Scan.ScanService"/> 注入。
///
/// 散单的扫码枪也按「时间取**第一次** + 立即上报」记(和散单面单摄像头一致);
/// 团购(或未知)仍按「静默 5 秒、时间取最后一次」。
/// </summary>
public Func<string, int>? ChannelModeOf { get; set; }
/// <summary>
/// 上报一条扫码记录(fire-and-forget 的**入队**版本)。
///
@ -257,6 +273,9 @@ public sealed class DeviceService
///
/// **延迟上报**:扫到后 5 秒没再扫到同一个码才真正上报(见
/// <see cref="ScanRecordStore.SettleDelay"/>),上报的是最后一次扫描时间。
///
/// **散单通道例外**(<see cref="ChannelModeOf"/> 返回 1):时间取**第一次**、**立即上报**,
/// 和散单面单摄像头的规则一致;5 秒内重复扫同一个码只算一次(连续扫描帧)。
/// </summary>
/// <returns>true = 一次新的扫码事件(连续扫描的重复帧返回 false,界面不用重查)</returns>
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;
}
/// <summary>
/// **散单通道**的扫码枪记录:时间取第一次、立即上报(和散单面单摄像头一致)。
///
/// 扫码枪连续模式下同一个码每 ~80ms 报一次,所以这里做「在场」去重:
/// <see cref="FirstSeenGap"/> 内又扫到同一个码只算一次,不会把记录反复挂回队列。
/// </summary>
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;
}
/// <summary>清掉 24 小时没再命中的在场记录(防字典无限增长)</summary>
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);
}
/// <summary>查服务器上当前中控已登记的通道(用于确认同步)</summary>
public Task<HashSet<string>> ChannelsAsync(CancellationToken ct = default)
=> _api.ChannelsAsync(_settings.DeviceToken, ct);
/// <summary>拉取本机的面单摄像头识别配置(`GET /api/scanner/label-cameras`)</summary>
public Task<System.Text.Json.JsonElement> FetchLabelCamerasAsync(CancellationToken ct = default)
=> _api.GetLabelCamerasAsync(_settings.DeviceToken, ct);
/// <summary>立即触发一次上报(界面的「立即上传」)</summary>
public void TriggerUpload()
{

View File

@ -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
/// <summary>单行上限(字节):不带分隔符时也要能吐出去</summary>
private const int MaxLineBytes = 256;
/// <summary>控制帧起始字节(RS):桌面端 → 设备 / 设备 → 桌面端共用,不会出现在条码里</summary>
private const byte ControlMark = 0x1E;
/// <summary>单条控制帧上限(异常数据保护)</summary>
private const int MaxControlBytes = 2048;
/// <summary>
/// 等安卓端确认「扫码成功通知」的超时(设备就在同一局域网,正常 10ms 级)。
/// 这个等待现在跑在**后台播报泵**里,不再占用面单摄像头的解码循环,所以可以给足余量,
/// 让重连/网络抖动时也能补上这一声。
/// </summary>
private const int ScanNoticeAckTimeoutMs = 1200;
/// <summary>通知重试次数(含首次):第一次没回执就再发一次,避免单包丢失被判失败</summary>
private const int ScanNoticeAttempts = 2;
private readonly ScanChannel _channel;
private readonly CancellationTokenSource _cts = new();
/// <summary>串行化写:下发扫码枪设置要一次写完,不能被重连/其它写方打新</summary>
private readonly SemaphoreSlim _writeGate = new(1, 1);
/// <summary>等待设备回执的「扫码成功通知」:id → 完成源(设备的 ack 帧来兑现)</summary>
private readonly ConcurrentDictionary<string, TaskCompletionSource<bool>> _scanNotices = new();
/// <summary>当前连接(静音切换时要主动关掉它,让循环重新连并重新下发设置)</summary>
private TcpClient? _client;
@ -250,6 +272,122 @@ public sealed class ChannelConnection : IDisposable
}
}
/// <summary>
/// 给**安卓扫码端**下发一条「扫码成功」通知,并**等待它的回执**。
///
/// 为什么必须确认:现场要让操作员听到播报,通知丢了就静默失败;
/// 只有设备回了 <c>{"cmd":"ack","id":...}</c> 才算成功(超时重发一次)。
///
/// 为什么只给安卓通道发:网口扫码枪/中控盒**没有语音能力**,收到也没有事情可做,
/// 还会被透传到枪的串口,所以这类通道一律不发。
///
/// ⚠️ 这是**通知**,不是上报:条码本身已经写进待上报队列(见
/// <c>ScanService.ReportCameraScanAsync</c>),本方法失败**不影响记录**。
///
/// 帧格式 <c>0x1E + UTF-8 JSON + '\n'</c>:以 0x1E 开头,
/// 和 9/10 字节的扫码枪设置指令、普通条码行都不会冲突;设备回执用同样的帧格式。
/// </summary>
/// <returns>true = 设备已确认收到(会播报)</returns>
public async Task<bool> 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<bool>(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;
}
/// <summary>拼一条控制帧:0x1E + JSON + '\n'</summary>
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;
}
/// <summary>设备的控制帧(目前只有 <c>{"cmd":"ack","id":...}</c>):兑现等待中的通知</summary>
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}");
}
}
/// <summary>连接断开时让所有等待回执的通知立刻失败(不要干等超时)</summary>
private void FailPendingScanNotices()
{
foreach (var pair in _scanNotices)
{
pair.Value.TrySetResult(false);
}
_scanNotices.Clear();
}
/// <summary>
/// 连上之后立刻把扫码枪配成「连续扫描 + 间隔 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;

View File

@ -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})";
/// <summary>是否安卓扫码通道(AndroidStation)</summary>
public bool IsAndroidStation => ScanDeviceKind.IsAndroidStation(Model);
/// <summary>界面上的类型标注</summary>
public string KindText => ScanDeviceKind.Describe(Model);
}
/// <summary>设备 SYS 段配置(JCMD 10003 读回)</summary>

View File

@ -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;
/// <summary>一路面单识别任务(服务端下发):工作台 → 面单摄像头 → 上报通道 → 录像机凭据</summary>
public sealed class LabelCameraTarget
{
public int WorkstationId { get; init; }
public string WorkstationCode { get; init; } = string.Empty;
public string WorkstationName { get; init; } = string.Empty;
/// <summary>
/// 工作台类型:**1 散单 / 2 团购**。决定识别结果的记录规则:
/// 散单 = 时间取第一次 + 立即上报;团购 = 和扫码枪一样静默 5 秒、时间取最后一次。
/// </summary>
public int WsType { get; init; } = 1;
/// <summary>识别结果按这个通道上报(必须是本机自己的扫码通道)</summary>
public string ChannelId { get; init; } = string.Empty;
public string ChannelName { get; init; } = string.Empty;
/// <summary>
/// true = 这条通道是**虚拟通道**(`CAM-<工作台id>`):工作台只设了面单摄像头、没接扫码枪,
/// 服务端自动给它一条通道用来上报(不占真实通道、也不会通知安卓端播报)。
/// </summary>
public bool VirtualChannel { get; init; }
public int CameraId { get; init; }
public string CameraName { get; init; } = string.Empty;
/// <summary>海康**设备通道号**(数字通道从 33 起);RTSP 路径要再换算成 1 起序号</summary>
public int CameraChannelNo { get; init; }
public bool CameraEnabled { get; init; }
/// <summary>
/// 0 主码流 / 1 子码流(**只用于回放/预览**;识别会自己挑:子码流够大才用,见 LabelScanWorker)
/// </summary>
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;
/// <summary>界面上一行文案(**不含密码**;码流由识别端自己挑,这里不写死)</summary>
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);
}
/// <summary>服务端给的提示(例如:面单摄像头设了,但工作台没绑本机通道)</summary>
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}";
}
/// <summary>一次拉取的结果快照(界面/日志都用它)</summary>
public sealed class LabelScanSnapshot
{
public DateTime? PulledAt { get; set; }
public string Revision { get; set; } = string.Empty;
public string? Error { get; set; }
public List<LabelCameraTarget> Items { get; set; } = new();
public List<LabelCameraWarning> Warnings { get; set; } = new();
/// <summary>状态行一句话(**不含密码**)</summary>
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;
}
}
}
/// <summary>
/// 面单识别配置的**拉取 + 对账 + 识别**层。
///
/// - 配置:服务启动拉一次,之后每 1 分钟兜底;收到 `labelScan.refresh` 立即拉
/// (Web 端改面单摄像头/工作台/上报通道时服务端会推这个通知);
/// - 识别:配置到手后由 <see cref="LabelScanWorker"/> 按路拉流解码,命中后
/// 交回 <see cref="ScanService.ReportCameraScanAsync"/>(写记录 + 立即上报 + 通知安卓播报);
/// - 快照里**含录像机密码**:只放内存,不落盘、不写日志、界面文案里不显示。
/// </summary>
public sealed class LabelScanMonitor : IDisposable
{
/// <summary>
/// 兜底轮询间隔。
///
/// 正常变更靠服务端推 `labelScan.refresh`(Web 端改完面单摄像头/工作台/通道后立刻到),
/// 但推送可能丢(设备正好离线、任务 TTL 过期、服务端推送失败),所以这里还有一个兜底:
/// 间距必须**短到现场感知不到**——以前是 5 分钟,网页上改完要等好几分钟才生效,
/// 表现就是「取消的那路还在跑、新增的那路不启动」。1 分钟足够便宜(一两个小 JSON)。
/// </summary>
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;
/// <summary>通道 → 工作台类型(1 散单 / 2 团购)。扫码枪那条记录规则也按它决定。</summary>
private Dictionary<string, int> _channelModes = new(StringComparer.OrdinalIgnoreCase);
private Dictionary<string, int> _channelModesLogged = new(StringComparer.OrdinalIgnoreCase);
public LabelScanMonitor(DeviceService device, Func<string, string, int, bool, Task<CameraScanResult>> report)
{
_device = device;
_worker = new LabelScanWorker(report);
_worker.Changed += () => Changed?.Invoke();
}
/// <summary>
/// 某条通道对应的工作台类型:1 散单 / 2 团购 / 0 未知(没被任何工作台绑定)。
///
/// 散单:记录时间取**第一次**、立即上报;团购:和扫码枪一样静默 5 秒、取**最后一次**。
/// </summary>
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();
/// <summary>
/// 面单识别配置里这条通道的名字。
///
/// 虚拟通道(`CAM-&lt;工作台id&gt;`)不在本机通道列表里,`ScanService.ChannelNameOf` 查不到,
/// 所以要靠这里补上「面单摄像头·摄像头名」,否则本地记录/日志只能显示一个 `CAM-3`。
/// </summary>
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;
}
/// <summary>每个识别任务的运行状态(最近条码/状态/错误),界面直接用</summary>
public IReadOnlyList<LabelCameraRuntime> Runtimes => _worker.Runtimes;
/// <summary>快照有变化(界面据此刷新)</summary>
public event Action? Changed;
/// <summary>是否正在拉取</summary>
public bool Refreshing
{
get
{
lock (_gate) return _refreshing;
}
}
/// <summary>开始兜底轮询(服务启动时调用)</summary>
public void Start()
{
if (_disposed) return;
lock (_gate)
{
_timer ??= new Timer(_ => _ = RefreshAsync("定时刷新"), null, Timeout.Infinite, Timeout.Infinite);
_timer.Change(TimeSpan.Zero, RefreshInterval);
}
}
/// <summary>停掉轮询(保留最后一次快照,界面还能看到上次拉到什么)</summary>
public void Stop()
{
lock (_gate)
{
_timer?.Change(Timeout.Infinite, Timeout.Infinite);
}
_worker.StopAll();
}
/// <summary>
/// 拉一次配置。任何异常都只记日志 + 落在 <see cref="LabelScanSnapshot.Error"/>,
/// **不影响扫码/上报链路**。
/// </summary>
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<LabelScanSnapshot> mutate)
{
mutate(Snapshot);
}
/// <summary>通道模式变了才打一行(散单/团购决定记录时间规则,出问题时要能一眼看出来)</summary>
private void LogChannelModes(Dictionary<string, int> 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<string, int>(modes, StringComparer.OrdinalIgnoreCase);
if (modes.Count == 0) return;
var parts = new List<string>(modes.Count);
foreach (var pair in modes)
{
parts.Add($"{pair.Key}→{(pair.Value == 1 ? "散单(取第一次)" : "团购(取最后一次)")}");
}
AppLog.Write($"[label-scan] 通道记录规则:{string.Join(",", parts)}");
}
/// <summary>解析服务端返回的 `{ revision, items, channels, warnings }`</summary>
private static ParsedConfig Parse(JsonElement data)
{
var items = new List<LabelCameraTarget>();
var warnings = new List<LabelCameraWarning>();
var channels = new Dictionary<string, int>(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);
}
/// <summary>解析结果(`channels` 是通道 → 工作台类型,决定扫码枪那条记录规则)</summary>
private sealed record ParsedConfig(
string Revision,
List<LabelCameraTarget> Items,
List<LabelCameraWarning> Warnings,
Dictionary<string, int> 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;
}
}

File diff suppressed because it is too large Load Diff

View File

@ -30,6 +30,12 @@ public sealed class ScanChannel
/// <summary>最后一次见到的 IP</summary>
public string LastIp { get; set; } = string.Empty;
/// <summary>
/// 设备型号(UDP 发现应答的 Type / CustomerID)。
/// <c>AndroidStation</c> = 安卓扫描通道:桌面端识别到条码后需要通知它播报「扫码成功」。
/// </summary>
public string Model { get; set; } = string.Empty;
/// <summary>设备 TCP 端口(设备当服务端;桌面端用 8087,避开 Android 中控的 8086)</summary>
public int TcpPort { get; set; } = ScanProtocol.TcpPort;
@ -66,6 +72,10 @@ public sealed class ScanChannel
/// <summary>上报给服务端的 channelId(用通道号,稳定且短)</summary>
[System.Text.Json.Serialization.JsonIgnore]
public string ChannelId => Number.ToString();
/// <summary>是否安卓扫描通道(只有它需要收到「扫码成功」通知去播报)</summary>
[System.Text.Json.Serialization.JsonIgnore]
public bool IsAndroidStation => ScanDeviceKind.IsAndroidStation(Model);
}
/// <summary>通道配置读写(普通模式 `%LOCALAPPDATA%\YuncangTrace\channels.json`;服务模式 `%ProgramData%\YuncangTrace\channels.json`)</summary>

View File

@ -0,0 +1,30 @@
using System;
namespace YuncangTrace.LocalService.Services.Scan;
/// <summary>
/// 扫码设备类型判定。
///
/// <c>AndroidStation</c> 是我们自己的安卓扫码端(UDP 发现应答的型号固定为
/// <see cref="AndroidStation"/>)。桌面端识别到条码后,只有这类通道**需要**收到
/// 「扫码成功」通知(它会在现有 TCP 连接上解析控制帧并播报语音)。
/// 网口扫码枪/中控盒没有语音能力,收到通知也无事可做,而且下行字节会被透传到枪的串口,
/// 所以一律不发。
///
/// ⚠️ 这条判定**只影响通知**,不影响扫码记录:记录一律先写进待上报队列,
/// 与通道类型、设备是否在线都无关。
/// </summary>
public static class ScanDeviceKind
{
/// <summary>安卓扫码端的型号(见 AndroidStation 的 StationIdentity.MODEL)</summary>
public const string AndroidStation = "AndroidStation";
/// <summary>是否安卓扫码通道(型号大小写不敏感)</summary>
public static bool IsAndroidStation(string? model)
=> !string.IsNullOrWhiteSpace(model)
&& model.Trim().Equals(AndroidStation, StringComparison.OrdinalIgnoreCase);
/// <summary>界面上的类型标注</summary>
public static string Describe(string? model)
=> IsAndroidStation(model) ? "安卓扫描通道" : "扫码枪";
}

View File

@ -30,13 +30,24 @@ public sealed class ScanRecordItem
public string Code { get; set; } = string.Empty;
/// <summary>
/// **最近一次**扫到这个条码的时间(本地时间)。
/// 这条记录用的时间(本地时间;也是上报给服务端、用来定位录像的时间)。
///
/// 连续扫描时同一个码会反复扫到,这里一直刷新成最后一次;
/// 扫码枪:连续扫描时同一个码会反复扫到,这里一直刷新成最后一次;
/// 停 <see cref="ScanRecordStore.SettleDelay"/> 没再扫到才上报,上报的就是这个时间。
///
/// 摄像头识别(<see cref="ScanRecordStore.AddCamera"/>):一轮打包内**不刷新**(取第一次识别),
/// 只有「上次这条记录之后通道上又扫过别的包裹」时,才在重新扫到时更新成这一次的时间。
/// </summary>
public DateTime ScannedAt { get; set; }
/// <summary>
/// 立即上报(摄像头识别专用):不做 <see cref="ScanRecordStore.SettleDelay"/> 静默等待。
///
/// 摄像头场景里「面单放进去」那一刻就要定位录像,等 5 秒静默再上报没有意义;
/// 而扫码枪要等包裹离开(最后扫描时间)才对得上录像,所以两者必须分开。
/// </summary>
public bool Immediate { get; set; }
/// <summary>服务器是否已确认收到</summary>
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 的时间是最后一次扫到的时刻);
/// - **延迟上报**:扫到后 <see cref="SettleDelay"/>(5 秒)内没再扫到才进上报队列,
/// 上报的是**最后一次**扫描时间。面单一直放在扫码器上时,时间会一直往后刷,
/// 直到面单被贴走/拿开,这才是包裹真正离开工作台的时刻;
/// - **两种上报时机**:
/// - 扫码枪(<see cref="Add"/>):扫到后 <see cref="SettleDelay"/>(5 秒)内没再扫到才进上报队列,
/// 上报的是**最后一次**扫描时间(面单压在扫码器上时,时间一直往后刷,直到包裹离开);
/// - 面单摄像头(<see cref="AddCamera"/>):**写入即上报**(<see cref="ScanRecordItem.Immediate"/>),
/// 一轮打包内时间取**第一次**识别到的时刻(面单放进拍摄区后不会马上拿走);
/// 重新打包(上次这条记录之后通道上又扫过别的包裹)时,更新成这一次的时间;
/// - 同一个码在 24 小时内再次扫到时会**复用/重新激活同一条本地记录**(不新增行),
/// 5 秒静默后重新上报,**服务器侧覆盖**原来那条记录的时间和工作台快照
/// (不再像旧版本那样「24 小时内重复的不上报」)。
/// 重新上报后**服务器侧覆盖**原来那条记录的工作台快照
/// (不再像旧版本那样「24 小时内重复的不上报」);
///
/// 全部操作加锁:调用方既有收条码的连接线程,也有界面线程和上报重试线程。
/// </summary>
@ -312,6 +326,80 @@ public static class ScanRecordStore
return result;
}
/// <summary>
/// 记一条**摄像头识别**到的条码(面单摄像头)。
///
/// 与扫码枪的 <see cref="Add"/> 有三点不同,都是现场场景决定的:
/// 1. **时间取第一次识别**:面单放进拍摄区就不会马上拿走(等打包完才取),
/// 所以不能用「最后一次扫描时间」;这里传进来的 <paramref name="firstSeenAt"/> 一律写入,
/// 后续同一面单在视野里的重复命中**不会**改时间;
/// 2. **立即上报**:写入即进上报队列(<see cref="ScanRecordItem.Immediate"/>),
/// 不等 5 秒静默 —— 包裹一进面单区就要能把录像定位到那一刻;
/// 3. **24 小时内复用同一条记录**(本地不堆重复行),但时间分两种:
/// - 上次这条记录之后,通道上**没有**别的码 → 还是同一轮打包(面单一直摆着/刚走又放回),
/// 保留**第一次**识别时间,只重新挂回待上报;
/// - 上次这条记录之后,通道上**已经扫过别的包裹**(本轮已经往下走了)→ 这是**重新打包**,
/// 用这一次的识别时间更新原来那条(服务端把同运单覆盖成新时间,录像定位到最新这次打包)。
/// </summary>
/// <param name="firstSeenAt">本次「进入视野」的时间(调用方按在场判定,见 ScanService)</param>
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;
}
/// <summary>新建一条待上报记录(调用方已加锁)</summary>
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
}
}
/// <summary>已经静默满 5 秒、可以真正上报的条数</summary>
/// <summary>已经静默满 5 秒(或摄像头识别的立即上报)可以真正上报的条数</summary>
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));
}
}

View File

@ -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();
}
/// <summary>通道显示名(面单摄像头识别结果落本地记录时用;查不到就用通道号)</summary>
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;
}
/// <summary>
/// 面单识别配置的拉取/对账层(**只拉配置,不做识别**)。
/// 服务启动时自动拉一次 + 每 5 分钟兜底;收到 `labelScan.refresh` 时立即拉。
/// </summary>
public LabelScanMonitor LabelScan { get; }
/// <summary>通道同步状态(给界面看的一句话)</summary>
public string ChannelSyncStatus { get; private set; } = string.Empty;
@ -139,24 +162,35 @@ public sealed class ScanService
/// <summary>
/// 设备 DHCP 换 IP 后必须重连:通道靠 MAC 绑定,`LastIp` 只是缓存,
/// 不刷新的话会一直重连一个旧地址(Android 侧 `Connection#setIp` 就是干这个的)。
///
/// 顺带把设备型号补进通道配置:老通道(本次改动前添加的)没有型号,
/// 发现到之后就知道它是不是「安卓扫描通道」。
/// </summary>
private void ApplyDiscoveredIps(IReadOnlyList<DiscoveredDevice> devices)
{
var changed = new List<ScanChannel>();
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);
}
/// <summary>面单摄像头的「在场」状态:同一张面单一直摆在拍摄区时只算一次进入,记录时间取**第一次**识别</summary>
private sealed class CameraPresence
{
/// <summary>这张面单的时间(首次识别时刻,写进记录后**永不刷新**)</summary>
public DateTime? ScanTime { get; set; }
public DateTime LastHitAt { get; set; }
}
/// <summary>
/// 多久没有新的识别命中,就认为面单已经离开了拍摄区。
///
/// 直接复用识别线程的 <see cref="LabelScanWorker.RepackAbsence"/>:**判定「面单离开」只有这一个阈值**,
/// 两处各写一个的话会出现「算重新进去了、但时间没更新」的漏洞。
///
/// 注意在场状态是**按「通道|条码」**记的,所以换一张新面单永远是新建记录、不受这个值影响;
/// 它只决定「同一张面单」重新被识别时算不算新的一次进入(要不要重新上报/播报 + 时间要不要更新)。
/// </summary>
private static readonly TimeSpan CameraPresenceGap = LabelScanWorker.RepackAbsence;
/// <summary>首次识别时间的保留时长(与后端 24 小时合并窗口一致)</summary>
private static readonly TimeSpan CameraPresenceTtl = TimeSpan.FromHours(24);
private readonly Dictionary<string, CameraPresence> _cameraPresence = new(StringComparer.OrdinalIgnoreCase);
private readonly object _cameraPresenceGate = new();
/// <summary>待通知安卓播报的条码(按通道只保留最新一条:播报是「叮」一声,旧的无意义)</summary>
private readonly ConcurrentDictionary<string, string> _pendingNotices = new(StringComparer.OrdinalIgnoreCase);
/// <summary>后台播报泵是否在跑(0/1,避免每条命中都起一个任务)</summary>
private int _noticePumpRunning;
/// <summary>
/// 面单摄像头识别到一条条码:**先落待上报记录(立即上报),再通知安卓端播报(等回执)**。
///
/// 与扫码枪的区别(摄像头场景:面单放进拍摄区 → 开始打包 → 打包完才取走):
/// 1. **取第一次识别的时间**,不用「最后一次命中」——面单会在视野里停留很久;
/// 2. **写入即上报**,不等 5 秒静默:一进面单区就要能把录像定位到那一刻;
/// 3. 同一张面单在视野里的重复帧**什么都不做**(不改时间、不重复上报、不重复播报);
/// 4. 面单一直摆着、中途出现识别空档(手挡/移位/反光)→ **仍算同一轮打包,时间不前移**;
/// 只有「画面里连 45 秒没有任何条码」之后重新识别到(真的拿走再放回,例如装错了重新打包)
/// 才用**这次**的时间。
///
/// 不能用「这中间通道上又扫过别的包裹」当判据:两张面单轮流进入视野就会命中,
/// 但那两张都没离开过,属于误判(现场就是因此把打包时间推后了)。
///
/// **团购工作台不一样**(`wsType = 2`):和扫码枪同一套规则 —— 静默 5 秒后上报、
/// 时间取**最后一次**命中(见 <see cref="ScanRecordStore.Add"/>)。
///
/// 记录与通知解耦:**记录永远写**(与通道类型、安卓是否在线、设备服务是否开启无关),
/// 通知失败只体现在 <see cref="CameraScanResult.Notified"/>。
/// </summary>
/// <param name="wsType">1 散单(取第一次 + 立即上报)/ 2 团购(静默 5 秒取最后一次)/ 0 未知按散单</param>
/// <param name="afterAbsence">
/// 这张面单是从「画面里连一段时间没有任何条码」之后重新出现的 —— 即真的被拿走再放回来
/// (装错了重新打包)。为 true 时记录时间用**这次**的,否则沿用本轮首次识别时间。
/// </param>
public async Task<CameraScanResult> 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);
}
/// <summary>
/// 团购工作台的面单摄像头识别结果:**和扫码枪同一套规则** —— 记录时间取最后一次命中,
/// 静默 <see cref="ScanRecordStore.SettleDelay"/>(5 秒)没再认出同一个码才进上报队列。
///
/// 播报仍然只在「刚进入视野」时发一次(码可能在视野里停很久,不能每帧都播)。
/// </summary>
/// <summary>团购工作台的识别结果:**同步完成**(不再等安卓回执,播报丢后台)</summary>
private Task<CameraScanResult> 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));
}
/// <summary>
/// 把「通知安卓播报」丢到后台执行,扫码流不等回执。
///
/// 同一通道只保留**最新一条**:播报就是「叮」一声,排队等旧的没有意义,
/// 这样即使安卓一直不回执,队列也不会无限增长。
/// </summary>
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();
}
/// <summary>后台播报泵:串行消化 <see cref="_pendingNotices"/>,自身异常不影响扫码流</summary>
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();
}
});
}
/// <summary>
/// 决定这条面单记录该用哪个时间。
///
/// 判据只有一个:**面单有没有真的离开过画面**(<paramref name="afterAbsence"/>,
/// 由识别线程按「画面里连一段时间没有任何条码」得出)。
///
/// - 没离开(面单一直摆着,中途被手挡住/移位/反光):**沿用最初那次**。
/// 否则打包时间会被推后 —— 现场实测出现过「变成开始打包 30 秒之后」,录像定位整体偏移;
/// - 真的离开又回来(装错了重新打包、20 分钟后重新称重发现装错再包一遍):用**这次**的时间。
///
/// 为什么不再用「这中间通道上又扫过别的包裹」当判据:两张面单轮流进入视野就会命中,
/// 但那两张面单都没离开过,属于误判。
/// </summary>
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;
}
/// <summary>清掉 24 小时没再出现过的在场记录(防止字典无限增长)</summary>
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);
}
/// <summary>
/// 通知某条通道的安卓设备「扫码成功」(让它播报语音),并等它回执。
///
/// **只对安卓扫描通道发**:网口扫码枪/中控盒没有语音能力,收到也无事可做。
/// 返回 false 只表示「没确认收到」,不是错误 —— 记录已在 <see cref="ReportCameraScanAsync"/> 里落好。
/// </summary>
public async Task<bool> 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);
}
/// <summary>
/// 切换某条通道的扫码枪静音(与 AndroidScanCenter 一致):
/// **只存本地 + 让这条连接重新走一遍**,不在现有 socket 上补写指令 ——
@ -227,19 +535,22 @@ public sealed class ScanService
/// 回滚本地行不通:中间设备名可能已经写上去了,回滚只能回一半。
/// </summary>
/// <param name="number">指定通道号(&lt;=0 或被占用时退回最小空号)</param>
/// <param name="model">设备型号(UDP 发现应答的 Type/CustomerID;AndroidStation = 安卓扫描通道)</param>
/// <param name="stage">进度文案回调(界面显示用)</param>
public async Task<AddChannelResult> AddChannelAsync(string mac, string name, string ip, int number,
string? reportedHostName = null, Action<string>? stage = null, CancellationToken ct = default)
string? reportedHostName = null, string? model = null, Action<string>? 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(
/// <summary>改通道名的结果(<see cref="Message"/> 是给用户看的一句话)</summary>
public sealed record RenameChannelResult(bool Ok, string Message);
/// <summary>
/// 面单摄像头识别结果的处理结果。
///
/// <see cref="NewScan"/> 只影响界面是否重查;<see cref="Notified"/> 只表示「安卓端有没有收到播报通知」,
/// **不代表记录是否入队** —— 记录一定已写入待上报队列。
///
/// <see cref="ScanTime"/> 是这条记录**真正的时间**:第一次识别到的那一刻,
/// 面单不拿走也不会变(界面显示「首次识别」用它,不能用当前的命中时间)。
/// </summary>
/// <summary>面单摄像头识别结果(<paramref name="Notified"/> 恒为 false:播报已改为后台异步,不再等回执)</summary>
public sealed record CameraScanResult(bool NewScan, bool Notified, DateTime? ScanTime = null);

View File

@ -16,6 +16,9 @@ namespace YuncangTrace.LocalService.Services;
/// </summary>
public sealed class SingleInstance : IDisposable
{
/// <summary>第二个实例「只想把界面叫出来」(双击快捷方式,没带任何参数)</summary>
public const string ShowCommand = "--show";
private readonly Mutex _mutex;
private readonly string _pipeName;
private readonly Action<string[]> _onArgs;
@ -50,10 +53,13 @@ public sealed class SingleInstance : IDisposable
/// <summary>
/// 第二个实例调用:把命令行参数送给已运行的实例。
/// 返回 false = 送不出去(常见原因:第一个实例是**管理员权限**,中完整性的第二个实例写不进它的管道)。
///
/// ⚠️ 没有参数(双击快捷方式)也要送一条 <see cref="ShowCommand"/>:以前这里直接 return true 什么都不发,
/// 第二个实例紧接着就退出 → 用户看到的就是「点图标没反应,主界面打不开」。
/// </summary>
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)

View File

@ -13,7 +13,12 @@
<DockPanel>
<TextBlock DockPanel.Dock="Top" Text="添加扫码通道" FontSize="15" FontWeight="SemiBold" />
<TextBlock x:Name="DeviceText" DockPanel.Dock="Top" FontSize="12"
Foreground="{StaticResource MutedBrush}" Margin="0,4,0,12" TextWrapping="Wrap" />
Foreground="{StaticResource MutedBrush}" Margin="0,4,0,8" TextWrapping="Wrap" />
<Border x:Name="KindBadge" DockPanel.Dock="Top" Background="#EFF6FF" BorderBrush="#BFDBFE"
BorderThickness="1" CornerRadius="6" Padding="8,5" Margin="0,0,0,12">
<TextBlock x:Name="KindText" FontSize="12" Foreground="#1D4ED8" TextWrapping="Wrap"
Text="扫码枪通道" />
</Border>
<StackPanel DockPanel.Dock="Bottom" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,14,0,0">
<Button Content="取消" Padding="14,5" IsCancel="True" Click="Cancel_Click" />

View File

@ -2,6 +2,7 @@ using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Media;
using YuncangTrace.LocalService.Services.Scan;
namespace YuncangTrace.LocalService;
@ -36,6 +37,21 @@ public partial class AddChannelWindow : Window
? $"{device.Mac} · {device.Ip} · {device.Model}"
: $"{reported}({device.Mac} · {device.Ip} · {device.Model})";
if (device.IsAndroidStation)
{
KindBadge.Background = new SolidColorBrush(Color.FromRgb(0xEF, 0xF6, 0xFF));
KindBadge.BorderBrush = new SolidColorBrush(Color.FromRgb(0xBF, 0xDB, 0xFE));
KindText.Foreground = new SolidColorBrush(Color.FromRgb(0x1D, 0x4E, 0xD8));
KindText.Text = "安卓扫描通道 · 摄像头识别到条码时会收到通知并播报「扫码成功」";
}
else
{
KindBadge.Background = new SolidColorBrush(Color.FromRgb(0xF8, 0xFA, 0xFC));
KindBadge.BorderBrush = new SolidColorBrush(Color.FromRgb(0xE2, 0xE8, 0xF0));
KindText.Foreground = new SolidColorBrush(Color.FromRgb(0x64, 0x74, 0x8B));
KindText.Text = "普通扫码枪通道 · 设备无语音能力,不发通知(扫码记录照常上报)";
}
// 默认名:设备自报的 HostName(通常就是工位名),没有就用 MAC
var defaultName = reported.Length == 0 ? device.Mac : reported;
NameBox.Text = defaultName;

View File

@ -0,0 +1,75 @@
<UserControl x:Class="YuncangTrace.LocalService.Views.LabelCameraView"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
FontFamily="Microsoft YaHei UI, Segoe UI" FontSize="13">
<UserControl.Resources>
<!-- 识别中绿色、异常红色;其余灰色 -->
<Style x:Key="LabelStateStyle" TargetType="TextBlock">
<Setter Property="Foreground" Value="#64748B" />
<Setter Property="VerticalAlignment" Value="Center" />
<Style.Triggers>
<DataTrigger Binding="{Binding StateText}" Value="识别中">
<Setter Property="Foreground" Value="#047857" />
<Setter Property="FontWeight" Value="SemiBold" />
</DataTrigger>
<DataTrigger Binding="{Binding StateText}" Value="异常">
<Setter Property="Foreground" Value="#B91C1C" />
<Setter Property="FontWeight" Value="SemiBold" />
</DataTrigger>
<DataTrigger Binding="{Binding StateText}" Value="启动中…">
<Setter Property="Foreground" Value="#2563EB" />
</DataTrigger>
</Style.Triggers>
</Style>
</UserControl.Resources>
<Grid Margin="0,8,0,0">
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="*" />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<!-- 状态 + 操作 -->
<DockPanel Grid.Row="0" Margin="0,0,0,6" LastChildFill="False">
<TextBlock DockPanel.Dock="Left" Text="面单摄像头" FontWeight="SemiBold" VerticalAlignment="Center" />
<Button x:Name="RefreshButton" DockPanel.Dock="Left" Content="刷新配置" Padding="10,3"
Margin="12,0,0,0" Click="Refresh_Click" />
<TextBlock x:Name="StatusText" DockPanel.Dock="Right" Foreground="{StaticResource MutedBrush}"
VerticalAlignment="Center" HorizontalAlignment="Right" TextTrimming="CharacterEllipsis"
Text="还没拉取" />
</DockPanel>
<!-- 每路识别状态 -->
<Border Grid.Row="1" Background="White" BorderBrush="{StaticResource LineBrush}" BorderThickness="1"
CornerRadius="8" Padding="8">
<ListView x:Name="CameraList" BorderThickness="0" SelectionMode="Single">
<ListView.View>
<GridView>
<GridViewColumn Header="工作台" Width="120" DisplayMemberBinding="{Binding WorkstationName}" />
<GridViewColumn Header="摄像头" Width="110" DisplayMemberBinding="{Binding CameraName}" />
<GridViewColumn Header="上报通道" Width="120" DisplayMemberBinding="{Binding ChannelText}" />
<GridViewColumn Header="状态" Width="80">
<GridViewColumn.CellTemplate>
<DataTemplate>
<TextBlock Text="{Binding StateText}" Style="{StaticResource LabelStateStyle}" />
</DataTemplate>
</GridViewColumn.CellTemplate>
</GridViewColumn>
<GridViewColumn Header="最近识别到的条码" Width="160" DisplayMemberBinding="{Binding CodeText}" />
<GridViewColumn Header="首次识别时间" Width="115" DisplayMemberBinding="{Binding FirstSeenText}" />
<GridViewColumn Header="最近命中" Width="110" DisplayMemberBinding="{Binding LastHitText}" />
<GridViewColumn Header="码流" Width="140" DisplayMemberBinding="{Binding StreamText}" />
<GridViewColumn Header="解码耗时" Width="80" DisplayMemberBinding="{Binding DecodeText}" />
<GridViewColumn Header="次数" Width="55" DisplayMemberBinding="{Binding HitsText}" />
<GridViewColumn Header="备注" Width="130" DisplayMemberBinding="{Binding ErrorText}" />
</GridView>
</ListView.View>
</ListView>
</Border>
<!-- 服务端提示(缺通道 / 缺密码等) -->
<TextBlock Grid.Row="2" x:Name="WarnText" FontSize="12" Foreground="#B45309" TextWrapping="Wrap"
Margin="2,8,0,0" />
</Grid>
</UserControl>

View File

@ -0,0 +1,252 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Threading;
using YuncangTrace.LocalService.Services;
using YuncangTrace.LocalService.Services.Scan;
namespace YuncangTrace.LocalService.Views;
/// <summary>
/// 「面单摄像头」页签:每路识别任务的状态 + **最近识别到的条码**。
///
/// 数据来源:
/// - 服务模式(本机跑的就是后台服务):读后台服务写的 <c>agent-status.json</c> 的 <c>LabelScan</c>
/// —— 真正拉流识别的是服务进程,界面只展示;
/// - 普通模式:直接读本进程 <see cref="ScanService.LabelScan"/> 的运行时状态。
///
/// 识别本身在 <see cref="LabelScanWorker"/>:ffmpeg 拉 RTSP → 灰度帧 → ZXing → 上报。
/// </summary>
public partial class LabelCameraView : UserControl
{
private static readonly TimeSpan AgentPollInterval = TimeSpan.FromMilliseconds(300);
private readonly ScanService _scan;
private readonly ObservableCollection<LabelRow> _rows = new();
private readonly DispatcherTimer _agentTimer = new() { Interval = AgentPollInterval };
private DateTime _agentStatusAt;
private bool _refreshing;
private static bool IsAgentMode => AgentPaths.MachineMode && !AgentPaths.IsServiceProcess;
public LabelCameraView(ScanService scan)
{
InitializeComponent();
_scan = scan;
CameraList.ItemsSource = _rows;
// 事件一直挂着(切页签/隐藏到托盘都会触发 Unloaded,退订就再也不刷新了)
_scan.LabelScan.Changed += OnLabelScanChanged;
Loaded += (_, _) => Refresh();
if (IsAgentMode)
{
_agentTimer.Tick += (_, _) => ApplyAgentStatus();
_agentTimer.Start();
}
Refresh();
}
/// <summary>列表行(界面显示用;按 <see cref="Key"/> 原地更新,避免每次命中都清空重画)</summary>
public sealed class LabelRow : INotifyPropertyChanged
{
private string _channelText = string.Empty;
private string _stateText = string.Empty;
private string _codeText = "—";
private string _firstSeenText = "—";
private string _lastHitText = "—";
private string _streamText = "—";
private string _decodeText = "—";
private string _hitsText = "—";
private string _errorText = string.Empty;
public LabelRow(string key)
{
Key = key;
}
/// <summary>工作台|摄像头|通道:配置变了就是新的一行</summary>
public string Key { get; }
public string WorkstationName { get; init; } = string.Empty;
public string CameraName { get; init; } = string.Empty;
public string Summary { get; set; } = string.Empty;
public string ChannelText { get => _channelText; set => Set(ref _channelText, value); }
public string StateText { get => _stateText; set => Set(ref _stateText, value); }
/// <summary>最近识别到的条码(条码本身,不带时间)</summary>
public string CodeText { get => _codeText; set => Set(ref _codeText, value); }
/// <summary>首次识别时间:也就是这条记录真正用的时间,面单不拿走就不变</summary>
public string FirstSeenText { get => _firstSeenText; set => Set(ref _firstSeenText, value); }
/// <summary>最近一次命中时间:每秒都在变,只用来看摄像头有没有在扫</summary>
public string LastHitText { get => _lastHitText; set => Set(ref _lastHitText, value); }
/// <summary>当前码流(主/子 + 分辨率)</summary>
public string StreamText { get => _streamText; set => Set(ref _streamText, value); }
/// <summary>最近一帧解码耗时</summary>
public string DecodeText { get => _decodeText; set => Set(ref _decodeText, value); }
public string HitsText { get => _hitsText; set => Set(ref _hitsText, value); }
public string ErrorText { get => _errorText; set => Set(ref _errorText, value); }
public event PropertyChangedEventHandler? PropertyChanged;
private void Set(ref string field, string value, [CallerMemberName] string? name = null)
{
if (string.Equals(field, value, StringComparison.Ordinal)) return;
field = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}
}
/// <summary>一行要显示的内容(与行对象解耦,方便按 key 比对增量更新)</summary>
private sealed record RowData(
string Key,
string WorkstationName,
string CameraName,
string ChannelText,
string StateText,
string CodeText,
string FirstSeenText,
string LastHitText,
string StreamText,
string DecodeText,
string HitsText,
string ErrorText,
string Summary);
/// <summary>按 key 增量更新列表(新增/删除/原地改),不整体重画</summary>
private void Render(IReadOnlyList<RowData> data)
{
for (var index = _rows.Count - 1; index >= 0; index--)
{
if (data.Any(item => item.Key == _rows[index].Key)) continue;
_rows.RemoveAt(index);
}
for (var index = 0; index < data.Count; index++)
{
var item = data[index];
var row = _rows.FirstOrDefault(existing => existing.Key == item.Key);
if (row is null)
{
row = new LabelRow(item.Key) { WorkstationName = item.WorkstationName, CameraName = item.CameraName };
_rows.Insert(Math.Min(index, _rows.Count), row);
}
row.ChannelText = item.ChannelText;
row.StateText = item.StateText;
row.CodeText = item.CodeText;
row.FirstSeenText = item.FirstSeenText;
row.LastHitText = item.LastHitText;
row.StreamText = item.StreamText;
row.DecodeText = item.DecodeText;
row.HitsText = item.HitsText;
row.ErrorText = item.ErrorText;
row.Summary = item.Summary;
}
}
private void OnLabelScanChanged()
{
if (Dispatcher.CheckAccess()) Refresh();
else Dispatcher.Invoke(Refresh);
}
/// <summary>服务模式:读后台服务写的运行状态(有变化才重画)</summary>
private void ApplyAgentStatus()
{
var status = AgentFiles.LoadStatus();
if (status is null || status.UpdatedAt == _agentStatusAt) return;
_agentStatusAt = status.UpdatedAt;
Refresh();
}
/// <summary>重新渲染(保持选中项不需要:这里只展示)</summary>
public void Refresh()
{
var label = IsAgentMode ? AgentFiles.LoadStatus()?.LabelScan : null;
if (IsAgentMode && label is not null)
{
StatusText.Text = string.IsNullOrWhiteSpace(label.StatusText) ? "还没拉取" : label.StatusText;
SetWarnings(label.Warnings);
RefreshButton.Content = "由后台服务拉取";
RefreshButton.IsEnabled = false;
Render(label.Items.Select(item => new RowData(
$"{item.WorkstationId}|{item.CameraId}|{item.ChannelId}",
string.IsNullOrWhiteSpace(item.WorkstationName) ? "—" : item.WorkstationName,
item.CameraName,
string.IsNullOrWhiteSpace(item.ChannelName) ? item.ChannelId : $"{item.ChannelId}「{item.ChannelName}」",
item.StateText,
string.IsNullOrEmpty(item.LastCode) ? "—" : item.LastCode,
item.LastCodeAt?.ToString("MM-dd HH:mm:ss") ?? "—",
item.LastHitAt?.ToString("HH:mm:ss.fff") ?? "—",
string.IsNullOrWhiteSpace(item.StreamText) ? "—" : item.StreamText,
item.LastDecodeMs > 0 ? $"{item.LastDecodeMs:0}ms" : "—",
item.Hits > 0 ? item.Hits.ToString() : "—",
item.LastError ?? string.Empty,
item.Summary)).ToList());
return;
}
var snapshot = _scan.LabelScan.Snapshot;
StatusText.Text = snapshot.StatusText;
SetWarnings(snapshot.Warnings.Select(item => item.Display).ToList());
RefreshButton.Content = "刷新配置";
RefreshButton.IsEnabled = !_refreshing && !_scan.LabelScan.Refreshing;
Render(_scan.LabelScan.Runtimes.Select(runtime => new RowData(
$"{runtime.WorkstationId}|{runtime.CameraId}|{runtime.ChannelId}",
string.IsNullOrWhiteSpace(runtime.WorkstationName) ? "—" : runtime.WorkstationName,
runtime.CameraName,
string.IsNullOrWhiteSpace(runtime.ChannelName) ? runtime.ChannelId : $"{runtime.ChannelId}「{runtime.ChannelName}」",
runtime.StateText,
string.IsNullOrEmpty(runtime.LastCode) ? "—" : runtime.LastCode,
runtime.LastCodeAt?.ToString("MM-dd HH:mm:ss") ?? "—",
runtime.LastHitAt?.ToString("HH:mm:ss.fff") ?? "—",
string.IsNullOrWhiteSpace(runtime.StreamText) ? "—" : runtime.StreamText,
runtime.LastDecodeMs > 0 ? $"{runtime.LastDecodeMs:0}ms" : "—",
runtime.Hits > 0 ? runtime.Hits.ToString() : "—",
runtime.LastError ?? string.Empty,
runtime.Summary)).ToList());
}
private void SetWarnings(System.Collections.Generic.IReadOnlyList<string> warnings)
{
WarnText.Text = warnings.Count == 0
? string.Empty
: string.Join(Environment.NewLine, warnings.Select(item => $"⚠ {item}"));
}
/// <summary>手动刷新配置(服务模式下由后台服务负责,这里不可用)</summary>
private async void Refresh_Click(object sender, RoutedEventArgs e)
{
_refreshing = true;
RefreshButton.IsEnabled = false;
try
{
await _scan.LabelScan.RefreshAsync("手动刷新");
}
finally
{
_refreshing = false;
Refresh();
}
}
}

View File

@ -1,7 +1,21 @@
<UserControl x:Class="YuncangTrace.LocalService.Views.ScanTabView"
<UserControl x:Class="YuncangTrace.LocalService.Views.ScanTabView"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
FontFamily="Microsoft YaHei UI, Segoe UI" FontSize="13">
<UserControl.Resources>
<!-- 安卓扫描通道用蓝色加粗标出来;普通扫码枪保持灰色 -->
<Style x:Key="KindTextStyle" TargetType="TextBlock">
<Setter Property="Foreground" Value="#64748B" />
<Setter Property="VerticalAlignment" Value="Center" />
<Style.Triggers>
<DataTrigger Binding="{Binding KindText}" Value="安卓扫描通道">
<Setter Property="Foreground" Value="#2563EB" />
<Setter Property="FontWeight" Value="SemiBold" />
</DataTrigger>
</Style.Triggers>
</Style>
</UserControl.Resources>
<Grid Margin="0,8,0,0">
<Grid.RowDefinitions>
<RowDefinition Height="*" />
@ -35,6 +49,14 @@
<GridView>
<GridViewColumn Header="号" Width="46" DisplayMemberBinding="{Binding Number}" />
<GridViewColumn Header="名称" Width="150" DisplayMemberBinding="{Binding DisplayName}" />
<GridViewColumn Header="类型" Width="110">
<GridViewColumn.CellTemplate>
<DataTemplate>
<TextBlock Text="{Binding KindText}" Style="{StaticResource KindTextStyle}"
ToolTip="安卓扫描通道:摄像头识别到条码时会收到「扫码成功」通知并语音播报;扫码枪通道无语音能力,不发通知(记录照常上报)" />
</DataTemplate>
</GridViewColumn.CellTemplate>
</GridViewColumn>
<GridViewColumn Header="MAC" Width="130" DisplayMemberBinding="{Binding Mac}" />
<GridViewColumn Header="IP" Width="120" DisplayMemberBinding="{Binding LastIp}" />
<GridViewColumn Header="状态" Width="70" DisplayMemberBinding="{Binding StateText}" />
@ -65,6 +87,13 @@
<ListView.View>
<GridView>
<GridViewColumn Header="设备名" Width="140" DisplayMemberBinding="{Binding HostName}" />
<GridViewColumn Header="类型" Width="110">
<GridViewColumn.CellTemplate>
<DataTemplate>
<TextBlock Text="{Binding KindText}" Style="{StaticResource KindTextStyle}" />
</DataTemplate>
</GridViewColumn.CellTemplate>
</GridViewColumn>
<GridViewColumn Header="IP" Width="130" DisplayMemberBinding="{Binding Ip}" />
<GridViewColumn Header="MAC" Width="130" DisplayMemberBinding="{Binding Mac}" />
<GridViewColumn Header="型号" Width="90" DisplayMemberBinding="{Binding Model}" />

View File

@ -125,6 +125,8 @@ public partial class ScanTabView : UserControl
{
public int Number { get; init; }
public string DisplayName { get; init; } = string.Empty;
/// <summary>安卓扫描通道 / 扫码枪</summary>
public string KindText { get; init; } = string.Empty;
public string Mac { get; init; } = string.Empty;
public string LastIp { get; init; } = string.Empty;
public string StateText { get; init; } = string.Empty;
@ -162,6 +164,7 @@ public partial class ScanTabView : UserControl
{
Number = channel.Number,
DisplayName = channel.DisplayName,
KindText = ScanDeviceKind.Describe(channel.Model),
Mac = channel.Mac,
LastIp = channel.LastIp,
StateText = channel.Connected ? "在线" : "离线",
@ -298,7 +301,7 @@ public partial class ScanTabView : UserControl
try
{
var result = await _scan.AddChannelAsync(
device.Mac, dialog.ChannelName, device.Ip, dialog.ChannelNumber, device.HostName,
device.Mac, dialog.ChannelName, device.Ip, dialog.ChannelNumber, device.HostName, device.Model,
stage => Dispatcher.Invoke(() => AddChannelWindow_ShowStage(stage)));
Refresh();

View File

@ -1,4 +1,4 @@
<Project Sdk="Microsoft.NET.Sdk">
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>WinExe</OutputType>
@ -110,8 +110,21 @@
<ExcludeFromSingleFile>true</ExcludeFromSingleFile>
</Content>
</ItemGroup>
<PropertyGroup>
<!-- OpenCvSharp 4.13 自带的 Roslyn 分析器是针对更高版本编译器构建的,在当前 SDK 下每次编译
都会报 CS9057(分析器/编译器版本不匹配)。我们只把它当普通库调用、不用它的分析器,
所以按项目关掉这一条警告(ExcludeAssets="analyzers" 对部分 SDK 版本不生效,用 NoWarn 兜底)。 -->
<NoWarn>$(NoWarn);CS9057</NoWarn>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="System.ServiceProcess.ServiceController" Version="8.0.0" />
<PackageReference Include="ZXing.Net" Version="0.16.10" />
<!-- 条码检测(contrib 的 cv::barcode 模块):4.13 起 OpenCvSharp 才封装 BarcodeDetector。
实测 1920x1080 整图检测约 10~15ms,能直接给出条码的四角点(带旋转/透视),
透视矫正后交给 ZXing 解 Code128。 -->
<PackageReference Include="OpenCvSharp4" Version="4.13.0.20260627" ExcludeAssets="analyzers" />
<PackageReference Include="OpenCvSharp4.runtime.win" Version="4.13.0.20260627" />
</ItemGroup>
</Project>

View File

@ -64,6 +64,10 @@ export interface Workstation {
recordAfterSec?: number;
/** 最大录制时长(秒),默认 240 */
recordMaxSec?: number;
/** 最后活跃时间(扫码上报 / 有人登录时刷新) */
lastActiveAt?: string | null;
/** 多少秒不活跃自动下线所有成员(团购 3600 / 散单 1800) */
idleTimeoutSec?: number;
status: number;
remark?: string | null;
/** 合成画布(默认 1920×1080) */
@ -93,6 +97,8 @@ export interface WorkstationCameraLink {
/** 0 主码流 1 子码流 */
streamType?: number;
zIndex?: number;
/** 1 = 面单摄像头(散单/团购都能设,一台工作台最多一路) */
isLabelCamera?: number;
camera?: (Camera & { displayName?: string }) | null;
}
@ -106,6 +112,8 @@ export interface WorkstationScanChannelLink {
sortNo: number;
remark?: string | null;
scanner?: { id: number; sn: string; name?: string | null; status?: number } | null;
/** true = 面单摄像头自动占用的虚拟通道(`CAM-<工作台id>`),服务端维护,不能人工解绑 */
virtual?: boolean;
}
/** 工作台详情 */
@ -124,3 +132,27 @@ export interface AvailableScanChannel {
/** 已被哪个工作台绑定(null = 可绑) */
boundWorkstation?: { id: number; code?: string; name?: string } | null;
}
/**
* 工作台成员登录记录(`workstation_login_records`)
*
* `status = 1` 在线、`0` 已下线;`name` 是登录当时记下的名字
* (主体成员 = 成员姓名/工号,非成员 = 用户昵称)。
*/
export interface WorkstationMember {
id: number;
subjectId: number;
workstationId: number;
userId: number;
memberId?: number | null;
name: string;
/** 1 扫码登录(预留扩展) */
type?: number;
loginAt: string;
logoutAt?: string | null;
status: number;
/** manual / offline_all / reset_code(旧)/ idle_timeout / relogin / workstation_deleted */
logoutReason?: string | null;
loginIp?: string | null;
user?: { id: number; username?: string | null; nickname?: string | null } | null;
}

View File

@ -11,6 +11,7 @@ import type {
Nvr,
Workstation,
WorkstationDetail,
WorkstationMember,
} from '@/api/video';
// ---------------- NVR ----------------
@ -183,6 +184,8 @@ export function createWorkstation(body: {
recordBeforeSec?: number;
recordAfterSec?: number;
recordMaxSec?: number;
/** 多少秒不活跃自动下线所有成员(不传按类型默认:团购 3600 / 散单 1800) */
idleTimeoutSec?: number;
remark?: string;
}): Promise<Workstation> {
return api.post<Workstation>('/api/web/workstations', body);
@ -195,6 +198,7 @@ export function updateWorkstation(id: number, body: {
recordBeforeSec?: number;
recordAfterSec?: number;
recordMaxSec?: number;
idleTimeoutSec?: number;
remark?: string;
status?: number;
}): Promise<Workstation> {
@ -230,6 +234,15 @@ export function updateWorkstationCameraLayout(id: number, cameraId: number, patc
return api.put<WorkstationDetail>(`/api/web/workstations/${id}/cameras/${cameraId}/layout`, patch);
}
/** 设置 / 取消某路摄像头为面单摄像头(仅散单工作台) */
export function setWorkstationLabelCamera(
id: number,
cameraId: number,
isLabelCamera: boolean,
): Promise<WorkstationDetail> {
return api.put<WorkstationDetail>(`/api/web/workstations/${id}/cameras/${cameraId}/label`, { isLabelCamera });
}
/** 追加绑定扫码通道 */
export function bindWorkstationScanChannels(
id: number,
@ -247,3 +260,74 @@ export function fetchAvailableScanChannels(keyword = ''): Promise<{ list: Availa
const qs = keyword ? `?keyword=${encodeURIComponent(keyword)}` : '';
return api.get<{ list: AvailableScanChannel[] }>(`/api/web/workstation-scan-channels${qs}`);
}
// ---------------- 工作台成员登录记录 ----------------
/** 工作台成员列表(status=1 只看在线;不传 = 全部 + 历史;可按登录时间过滤) */
export function fetchWorkstationMembers(id: number, params: {
status?: number | '';
startTime?: string;
endTime?: string;
page?: number;
pageSize?: number;
} = {}): Promise<Paged<WorkstationMember> & { onlineCount: number }> {
const query = new URLSearchParams();
if (params.status !== undefined && params.status !== '') query.set('status', String(params.status));
if (params.startTime) query.set('startTime', params.startTime);
if (params.endTime) query.set('endTime', params.endTime);
if (params.page) query.set('page', String(params.page));
if (params.pageSize) query.set('pageSize', String(params.pageSize));
const qs = query.toString();
return api.get<Paged<WorkstationMember> & { onlineCount: number }>(
`/api/web/workstations/${id}/members${qs ? `?${qs}` : ''}`,
);
}
/** 手动下线某个在线成员(已经下线时接口幂等返回) */
export function offlineWorkstationMember(id: number, recordId: number): Promise<WorkstationMember & { alreadyOffline?: boolean }> {
return api.post<WorkstationMember & { alreadyOffline?: boolean }>(
`/api/web/workstations/${id}/members/${recordId}/offline`,
);
}
/** 把该工作台所有在线成员一键下线 */
export function offlineAllWorkstationMembers(id: number): Promise<{ id: number; offline: number }> {
return api.post<{ id: number; offline: number }>(`/api/web/workstations/${id}/members/offline-all`);
}
/** 扫码登入用的二维码(内容由微信登录网关下发,一次有效) */
export type WorkstationLoginQr = {
workstationId: number;
state: string;
pageUrl: string;
qrUrl: string;
expiresIn: number;
};
/** 申请「扫码登入本工作台」的二维码(微信登录网关) */
export function createWorkstationLoginQr(id: number): Promise<WorkstationLoginQr> {
return api.post<WorkstationLoginQr>(`/api/web/workstations/${id}/login-qr`);
}
/** 扫码登入的长轮询结果 */
export type WorkstationLoginStatus = {
status: 'pending' | 'confirmed' | 'failed' | 'expired';
message?: string;
workstation?: { id: number; code: string; name: string; wsType: number; subjectId: number; subjectName?: string };
isMember?: boolean;
member?: { id: number; name: string; role?: number } | null;
name?: string;
record?: WorkstationMember;
};
/** 长轮询扫码登入结果(`wait` 秒内有人确认就立即返回) */
export function fetchWorkstationLoginStatus(
id: number,
state: string,
wait = 0,
signal?: AbortSignal,
): Promise<WorkstationLoginStatus> {
const query = new URLSearchParams({ state });
if (wait) query.set('wait', String(wait));
return api.get<WorkstationLoginStatus>(`/api/web/workstations/${id}/login-qr/status?${query.toString()}`, { signal });
}

View File

@ -9,7 +9,7 @@
* 绑定/解绑都走后端 `/api/web/workstations/:id/{cameras,scan-channels}`,
* 接口返回绑定后的完整详情,页面直接用它刷新,不用二次查询。
*/
import { computed, onMounted, reactive, ref } from 'vue';
import { computed, onBeforeUnmount, onMounted, reactive, ref } from 'vue';
import AppLayout from '@/components/AppLayout.vue';
import DataPager from '@/components/DataPager.vue';
import ModalBox from '@/components/ModalBox.vue';
@ -19,16 +19,29 @@ import {
bindWorkstationCameras,
bindWorkstationScanChannels,
createWorkstation,
createWorkstationLoginQr,
deleteWorkstation,
fetchAvailableScanChannels,
fetchCameraOptions,
fetchWorkstation,
fetchWorkstationLoginStatus,
fetchWorkstationMembers,
fetchWorkstations,
offlineAllWorkstationMembers,
offlineWorkstationMember,
setWorkstationLabelCamera,
unbindWorkstationCamera,
unbindWorkstationScanChannel,
updateWorkstation,
} from '@/api/videoApi';
import type { AvailableScanChannel, Camera, Workstation, WorkstationDetail } from '@/api/video';
import type {
AvailableScanChannel,
Camera,
Workstation,
WorkstationCameraLink,
WorkstationDetail,
WorkstationMember,
} from '@/api/video';
import { formatTime } from '@/utils/format';
const list = ref<Workstation[]>([]);
@ -56,15 +69,20 @@ const form = reactive({
recordBeforeSec: 60,
recordAfterSec: 60,
recordMaxSec: 240,
/** 多少秒不活跃自动下线所有成员(团购默认 3600 / 散单 1800) */
idleTimeoutSec: 1800,
remark: '',
});
/** 不活跃自动下线的默认秒数(跟着类型走,只在新增 / 切类型时套用) */
const DEFAULT_IDLE_TIMEOUT = { 1: 1800, 2: 3600 };
/** 录制范围的基准点:团购 = 扫码时间,散单 = 任务结束时间 */
const rangeBaseLabel = computed(() => (form.wsType === 2 ? '扫码时间' : '任务结束时间'));
function openCreate() {
editing.value = null;
Object.assign(form, { name: '', wsType: 1, recordBeforeSec: 60, recordAfterSec: 60, recordMaxSec: 240, remark: '' });
Object.assign(form, { name: '', wsType: 1, recordBeforeSec: 60, recordAfterSec: 60, recordMaxSec: 240, idleTimeoutSec: 1800, remark: '' });
formOpen.value = true;
}
@ -76,11 +94,17 @@ function openEdit(item: Workstation) {
recordBeforeSec: Number(item.recordBeforeSec ?? 60),
recordAfterSec: Number(item.recordAfterSec ?? 60),
recordMaxSec: Number(item.recordMaxSec ?? 240),
idleTimeoutSec: Number(item.idleTimeoutSec ?? DEFAULT_IDLE_TIMEOUT[Number(item.wsType) === 2 ? 2 : 1]),
remark: item.remark || '',
});
formOpen.value = true;
}
/** 切换散单/团购时,把不活跃下线时间拨到该类工作台的默认值 */
function onTypeChange() {
form.idleTimeoutSec = DEFAULT_IDLE_TIMEOUT[form.wsType === 2 ? 2 : 1];
}
async function save() {
error.value = '';
okMsg.value = '';
@ -95,6 +119,7 @@ async function save() {
recordAfterSec: Number(form.recordAfterSec) || 0,
// 团购没有独立的「最大录制时长」(= 扫码前 + 扫码后),不传
...(form.wsType === 2 ? {} : { recordMaxSec: Number(form.recordMaxSec) || 240 }),
idleTimeoutSec: Number(form.idleTimeoutSec) || DEFAULT_IDLE_TIMEOUT[form.wsType === 2 ? 2 : 1],
remark: form.remark,
};
@ -161,6 +186,17 @@ const pickedCameras = ref<Set<number>>(new Set());
const pickedChannels = ref<Set<string>>(new Set());
const busy = ref(false);
/** 设了面单摄像头但一条真实扫码通道都没绑:这时摄像头会占用一条虚拟通道(`CAM-<工作台id>`) */
const labelCameraWithoutChannel = computed(() => {
const cameras = detail.value?.cameras || [];
if (!cameras.some(link => Number(link.isLabelCamera) === 1)) return false;
return !(detail.value?.scanChannels || []).some(link => !link.virtual);
});
/** 真实扫码通道数(不含面单摄像头自动占用的虚拟通道) */
const realChannelCount = computed(() => (detail.value?.scanChannels || []).filter(link => !link.virtual).length);
/** 面单摄像头:散单/团购都能设(记录规则的差别在设备端,按 wsType 决定) */
async function openDetail(item: Workstation) {
detailOpen.value = true;
detail.value = null;
@ -301,6 +337,22 @@ function onLayoutChanged(data: WorkstationDetail) {
detail.value = data;
}
/** 设置 / 取消面单摄像头(一台工作台只保留一路,设新的会自动取消旧的) */
async function toggleLabelCamera(link: WorkstationCameraLink) {
if (!detail.value) return;
const next = Number(link.isLabelCamera) !== 1;
busy.value = true;
detailError.value = '';
try {
detail.value = await setWorkstationLabelCamera(detail.value.id, link.cameraId, next);
okMsg.value = next ? '已设为面单摄像头' : '已取消面单摄像头';
} catch (err) {
detailError.value = err instanceof ApiError ? err.message : '设置失败';
} finally {
busy.value = false;
}
}
async function unbindCamera(cameraId: number) {
if (!detail.value) return;
busy.value = true;
@ -327,6 +379,184 @@ async function unbindScan(linkId: number) {
}
}
// ---------------- 成员(工作台登录记录) ----------------
const membersOpen = ref(false);
const membersWorkstation = ref<Workstation | null>(null);
const members = ref<WorkstationMember[]>([]);
const membersTotal = ref(0);
const membersOnlineCount = ref(0);
const membersPage = ref(1);
const membersPageSize = ref(10);
/** 默认只看当前在线;勾上「含历史」= 全部登录记录 */
const membersIncludeHistory = ref(false);
/** 登录时间过滤(datetime-local 的值,后端按本地时间解析) */
const membersFrom = ref('');
const membersTo = ref('');
const membersLoading = ref(false);
const membersError = ref('');
/** 正在下线的记录 id(按钮禁用用) */
const memberBusy = ref(0);
async function openMembers(item: Workstation) {
membersOpen.value = true;
membersWorkstation.value = item;
membersIncludeHistory.value = false;
membersFrom.value = '';
membersTo.value = '';
members.value = [];
membersTotal.value = 0;
membersOnlineCount.value = 0;
membersError.value = '';
await loadMembers(1);
}
async function loadMembers(targetPage = membersPage.value) {
if (!membersWorkstation.value) return;
membersLoading.value = true;
membersError.value = '';
try {
const data = await fetchWorkstationMembers(membersWorkstation.value.id, {
status: membersIncludeHistory.value ? '' : 1,
startTime: membersFrom.value || undefined,
endTime: membersTo.value || undefined,
page: targetPage,
pageSize: membersPageSize.value,
});
members.value = data.list;
membersTotal.value = data.total;
membersOnlineCount.value = data.onlineCount;
membersPage.value = data.page;
} catch (err) {
membersError.value = err instanceof ApiError ? err.message : '成员加载失败';
} finally {
membersLoading.value = false;
}
}
async function offlineMember(record: WorkstationMember) {
if (!membersWorkstation.value) return;
if (!window.confirm(`确认把「${record.name || `用户${record.userId}`}」从工作台下线?`)) return;
memberBusy.value = Number(record.id);
membersError.value = '';
try {
await offlineWorkstationMember(membersWorkstation.value.id, record.id);
okMsg.value = '成员已下线';
await loadMembers();
} catch (err) {
membersError.value = err instanceof ApiError ? err.message : '下线失败';
} finally {
memberBusy.value = 0;
}
}
async function offlineAllMembers() {
const target = membersWorkstation.value;
if (!target) return;
if (!window.confirm('确认把该工作台的所有在线成员下线?')) return;
membersLoading.value = true;
membersError.value = '';
try {
const data = await offlineAllWorkstationMembers(target.id);
okMsg.value = `已下线 ${data.offline} 人`;
await loadMembers(1);
} catch (err) {
membersError.value = err instanceof ApiError ? err.message : '操作失败';
} finally {
membersLoading.value = false;
}
}
// ---------------- 扫码登入(微信登录网关) ----------------
/** 弹窗里的二维码 + 长轮询状态 */
const loginQrOpen = ref(false);
const loginQrUrl = ref('');
const loginQrTip = ref('');
let loginQrPolling = false;
let loginQrAbort: AbortController | null = null;
async function openLoginQr() {
const target = membersWorkstation.value;
if (!target) return;
loginQrOpen.value = true;
loginQrUrl.value = '';
loginQrTip.value = '正在生成二维码…';
try {
const ticket = await createWorkstationLoginQr(target.id);
loginQrUrl.value = ticket.qrUrl;
loginQrTip.value = '请用手机微信扫码,确认后自动登入';
pollLoginQr(target.id, ticket.state);
} catch (err) {
loginQrTip.value = err instanceof ApiError ? err.message : '二维码生成失败';
}
}
/**
* 长轮询:有人确认就刷新成员列表并**自动换下一张二维码**(现场可以把弹窗一直开着当签到屏);
* 二维码过期(expired)同样换一张继续等。
*/
async function pollLoginQr(workstationId: number, state: string) {
loginQrPolling = true;
let current = state;
while (loginQrPolling) {
try {
loginQrAbort = new AbortController();
const data = await fetchWorkstationLoginStatus(workstationId, current, 25, loginQrAbort.signal);
if (!loginQrPolling) return;
if (data.status === 'confirmed') {
loginQrTip.value = `${data.name || '成员'} 已登入,请下一位成员扫码`;
await loadMembers(1);
if (!loginQrPolling) return;
const next = await createWorkstationLoginQr(workstationId);
current = next.state;
loginQrUrl.value = next.qrUrl;
continue;
}
if (data.status === 'failed') {
loginQrPolling = false;
loginQrTip.value = data.message || '登录失败,请重新扫码';
return;
}
if (data.status === 'expired') {
const next = await createWorkstationLoginQr(workstationId);
current = next.state;
loginQrUrl.value = next.qrUrl;
loginQrTip.value = '二维码已刷新,请重新扫码';
}
} catch (err) {
if (!loginQrPolling) return;
loginQrTip.value = err instanceof ApiError ? err.message : '连接中断,正在重试…';
await new Promise(resolve => setTimeout(resolve, 800));
}
}
}
function closeLoginQr() {
loginQrPolling = false;
loginQrAbort?.abort();
loginQrOpen.value = false;
}
/** 下线原因 → 人能看懂的标签 */
const LOGOUT_REASON_LABEL: Record<string, string> = {
manual: '手动下线',
offline_all: '一键全部下线',
reset_code: '登录码重置(旧)',
idle_timeout: '长时间未活跃',
relogin: '重新登录',
workstation_deleted: '工作台已删除',
};
function offlineLabel(reason?: string | null) {
if (!reason) return '已下线';
return LOGOUT_REASON_LABEL[reason] || '已下线';
}
// ---------------- 列表 ----------------
async function load(targetPage = page.value) {
loading.value = true;
@ -353,6 +583,11 @@ function search() {
}
onMounted(() => load(1));
onBeforeUnmount(() => {
loginQrPolling = false;
loginQrAbort?.abort();
});
</script>
<template>
@ -384,7 +619,7 @@ onMounted(() => load(1));
<th>摄像头</th>
<th>扫码通道</th>
<th>创建时间</th>
<th style="width: 260px">操作</th>
<th style="width: 340px">操作</th>
</tr>
</thead>
<tbody>
@ -405,6 +640,7 @@ onMounted(() => load(1));
<td>{{ formatTime(item.created_at || item.createdAt) }}</td>
<td>
<button class="btn btn-sm btn-primary" @click="openMergedPreview(item)">预览</button>
<button class="btn btn-sm" @click="openMembers(item)">成员</button>
<button class="btn btn-sm" @click="openDetail(item)">绑定管理</button>
<button class="btn btn-sm btn-ghost" @click="openEdit(item)">编辑</button>
<button class="btn btn-sm btn-danger" @click="doDelete(item)">删除</button>
@ -427,7 +663,7 @@ onMounted(() => load(1));
<input v-model="form.name" placeholder="例如:1号打包台" />
</label>
<label class="field"><span>类型</span>
<select v-model.number="form.wsType">
<select v-model.number="form.wsType" @change="onTypeChange">
<option :value="1">散单工作台</option>
<option :value="2">团购工作台</option>
</select>
@ -460,6 +696,20 @@ onMounted(() => load(1));
</label>
</div>
</div>
<div class="range-box">
<p class="range-title">成员自动下线(秒)</p>
<p class="range-tip">
工作台在这么多秒内 <strong>没有任何扫码上报</strong>(也没人登录)时,定时任务(每分钟一次)会把该工作台
<strong>所有在线成员自动下线</strong>;默认团购 1 小时(3600)、散单 30 分钟(1800)。
</p>
<div class="range-fields">
<label class="field">
<span>不活跃自动下线</span>
<input v-model.number="form.idleTimeoutSec" type="number" min="60" max="86400" />
</label>
</div>
</div>
<label class="field"><span>备注</span>
<input v-model="form.remark" placeholder="可选" />
</label>
@ -521,14 +771,32 @@ onMounted(() => load(1));
@changed="onLayoutChanged"
/>
<p class="hint">
面单摄像头:从已绑定的摄像头里选一路正对运单的画面;设置新的会自动取消其他摄像头的面单标记
(一台工作台只保留一路)。散单识别取「第一次」时间并立即上报;团购和扫码枪一样,静默 5 秒后取「最后一次」。
没有绑定扫码通道也能用:会自动占一条虚拟通道 <code>CAM-工作台id</code> 来上报识别结果。
</p>
<p v-if="labelCameraWithoutChannel" class="label-note">
ℹ 这个工作台没有绑定扫码通道,面单摄像头会自动占一条虚拟通道
<code>CAM-{{ detail.id }}</code>(名称「面单摄像头·摄像头名」)用来上报识别结果,
无需扫码枪也能用;识别到的条码不会通知安卓端播报(没有对应的扫码工位)。
</p>
<ul class="bind-list">
<li v-for="link in detail.cameras" :key="link.id">
<span class="bind-name">{{ link.camera?.name || `通道${link.camera?.channelNo}` }}</span>
<span v-if="Number(link.isLabelCamera) === 1" class="label-tag">面单</span>
<span class="hint">
{{ link.camera?.nvr?.name || link.camera?.nvr?.host }} · 通道 {{ link.camera?.channelNo }}
<template v-if="link.x !== undefined">· {{ link.width }}×{{ link.height }} @{{ link.x }},{{ link.y }}</template>
· {{ Number(link.streamType) === 1 ? '子码流' : '主码流' }}
</span>
<button class="btn btn-sm"
:disabled="busy"
@click="toggleLabelCamera(link)">
{{ Number(link.isLabelCamera) === 1 ? '取消面单' : '设为面单' }}
</button>
<button class="btn btn-sm btn-danger" :disabled="busy" @click="unbindCamera(link.cameraId)">解绑</button>
</li>
<li v-if="!detail.cameras.length" class="hint">还没有绑定摄像头</li>
@ -538,7 +806,7 @@ onMounted(() => load(1));
<!-- 扫码通道 -->
<section class="bind-section scan-section">
<header class="bind-head">
<strong>扫码通道({{ detail.scanChannels.length }})</strong>
<strong>扫码通道({{ realChannelCount }})</strong>
<button class="btn btn-sm btn-scan" @click="openScanPicker">+ 绑定扫码通道</button>
</header>
@ -572,8 +840,10 @@ onMounted(() => load(1));
<ul class="bind-list">
<li v-for="link in detail.scanChannels" :key="link.id">
<span class="bind-name">{{ link.channelName || link.channelId }}</span>
<span v-if="link.virtual" class="label-tag virtual-tag">虚拟</span>
<span class="hint">{{ link.scanner?.name || link.scanner?.sn || '中控' }} · {{ link.channelId }}</span>
<button class="btn btn-sm btn-danger" :disabled="busy" @click="unbindScan(link.id)">解绑</button>
<button v-if="!link.virtual" class="btn btn-sm btn-danger" :disabled="busy" @click="unbindScan(link.id)">解绑</button>
<span v-else class="hint">面单摄像头自动维护,取消面单摄像头后自动清除</span>
</li>
<li v-if="!detail.scanChannels.length" class="hint">还没有绑定扫码通道</li>
</ul>
@ -607,6 +877,105 @@ onMounted(() => load(1));
<button class="btn btn-ghost" @click="showMergedPreview = false">关闭</button>
</template>
</ModalBox>
<!-- 成员登录记录:当前在线 / 历史 + 扫码登入(网关二维码)+ 手动下线 -->
<ModalBox :open="membersOpen" width="780px"
:title="`成员 · ${membersWorkstation?.name || membersWorkstation?.code || ''}`"
@close="membersOpen = false; closeLoginQr()">
<div v-if="membersError" class="alert alert-error">{{ membersError }}</div>
<div class="member-bar">
<span class="badge badge-ok">在线 {{ membersOnlineCount }}</span>
<span class="member-bar-actions">
<label class="member-toggle">
<input v-model="membersIncludeHistory" type="checkbox" @change="loadMembers(1)" />
含历史记录
</label>
<button class="btn btn-sm btn-primary" @click="openLoginQr">扫码登入</button>
<button class="btn btn-sm btn-ghost" :disabled="membersLoading" @click="loadMembers()">刷新</button>
<button class="btn btn-sm btn-danger" :disabled="membersLoading || !membersOnlineCount"
@click="offlineAllMembers">全部下线</button>
</span>
</div>
<div class="member-bar member-filter">
<span class="hint">登录时间</span>
<input v-model="membersFrom" type="datetime-local" />
<span class="hint">至</span>
<input v-model="membersTo" type="datetime-local" />
<button class="btn btn-sm" :disabled="membersLoading" @click="loadMembers(1)">查询</button>
<button class="btn btn-sm btn-ghost" :disabled="membersLoading"
@click="membersFrom = ''; membersTo = ''; loadMembers(1)">清空时间</button>
</div>
<p class="hint">
成员用手机微信扫「扫码登入」里生成的二维码即可登入本工作台(二维码一次有效,由微信登录网关下发);
名字取「主体成员姓名(工号)」,不是主体成员时取自己设置的昵称。
微信需要先在自己的账号里绑定(个人中心 → 微信绑定)。
</p>
<div class="table-wrap">
<table class="table table-list">
<thead>
<tr>
<th>名字</th>
<th>账号</th>
<th>登录时间</th>
<th>下线时间</th>
<th>状态</th>
<th style="width: 90px">操作</th>
</tr>
</thead>
<tbody>
<tr v-for="row in members" :key="row.id">
<td>{{ row.name || '—' }}</td>
<td>{{ row.user?.nickname || row.user?.username || `#${row.userId}` }}</td>
<td>{{ formatTime(row.loginAt) }}</td>
<td>{{ row.logoutAt ? formatTime(row.logoutAt) : '—' }}</td>
<td>
<span :class="['badge', Number(row.status) === 1 ? 'badge-ok' : 'badge-off']">
{{ Number(row.status) === 1 ? '在线' : offlineLabel(row.logoutReason) }}
</span>
</td>
<td>
<button v-if="Number(row.status) === 1"
class="btn btn-sm btn-danger"
:disabled="memberBusy === Number(row.id)"
@click="offlineMember(row)">
{{ memberBusy === Number(row.id) ? '下线中…' : '下线' }}
</button>
<span v-else class="hint">—</span>
</td>
</tr>
<tr v-if="!members.length && !membersLoading">
<td colspan="6" class="empty">
{{ membersIncludeHistory ? '还没有登录记录。' : '当前没有在线成员。' }}
</td>
</tr>
</tbody>
</table>
</div>
<DataPager :page="membersPage" :page-size="membersPageSize" :total="membersTotal" :loading="membersLoading"
unit="条" @update:page="loadMembers"
@update:page-size="size => { membersPageSize = size; loadMembers(1); }" />
<template #footer>
<button class="btn btn-ghost" @click="membersOpen = false">关闭</button>
</template>
</ModalBox>
<!-- 扫码登入:二维码由微信登录网关下发;确认后自动换下一张(现场可以一直开着当签到屏) -->
<ModalBox :open="loginQrOpen" title="扫码登入工作台" width="360px" @close="closeLoginQr">
<div class="login-qr">
<img v-if="loginQrUrl" class="qr-img" :src="loginQrUrl" width="200" height="200" alt="扫码登入二维码" />
<p v-else class="hint center">二维码生成中…</p>
<p class="hint center">{{ loginQrTip || '使用微信扫码登入' }}</p>
</div>
<template #footer>
<button class="btn btn-ghost" @click="closeLoginQr">关闭</button>
</template>
</ModalBox>
</AppLayout>
</template>
@ -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;