packServer/desktop/Services/Scan/LabelScanMonitor.cs
liufumingren f8aa4c4899 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>
2026-10-29 17:19:24 +08:00

421 lines
18 KiB
C#
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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