- 工作台成员扫码登入: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>
727 lines
30 KiB
C#
727 lines
30 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Text.Json;
|
||
using System.Text.Json.Serialization;
|
||
using System.Threading;
|
||
|
||
namespace YuncangTrace.LocalService.Services.Scan;
|
||
|
||
/// <summary>
|
||
/// 一条扫码记录(本地库,也是上报队列的元素)。
|
||
///
|
||
/// 与 AndroidScanCenter 的 <c>scan_record</c> 表对应:先落本地、再上报,
|
||
/// **上报成功(服务器确认)才把 <see cref="Uploaded"/> 置 true**,失败的下一轮重试,
|
||
/// 所以断网期间的条码不会丢。
|
||
/// </summary>
|
||
public sealed class ScanRecordItem
|
||
{
|
||
/// <summary>自增序号(= 写入顺序,去重和分页都靠它)</summary>
|
||
public long Id { get; set; }
|
||
|
||
/// <summary>通道号(上报时的 channelId)</summary>
|
||
public string ChannelId { get; set; } = string.Empty;
|
||
|
||
/// <summary>通道名(记录用;通道改名后老记录保持当时的名字)</summary>
|
||
public string ChannelName { get; set; } = string.Empty;
|
||
|
||
/// <summary>条码</summary>
|
||
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; }
|
||
|
||
/// <summary>
|
||
/// 旧版本「24 小时内重复扫描、不上报」留下的标记(只为兼容历史本地库)。
|
||
///
|
||
/// 新规则不再产生这种记录:同一运单在服务器侧只保留一条,
|
||
/// 后扫到的时间会覆盖前一次,所以这里只为让老记录继续显示成「重复·不上报」。
|
||
/// </summary>
|
||
public bool Suppressed { get; set; }
|
||
|
||
/// <summary>确认时间</summary>
|
||
public DateTime? UploadedAt { get; set; }
|
||
|
||
/// <summary>上次落盘时的 <see cref="ScannedAt"/>(连续扫描时省得每 80ms 写一次盘)</summary>
|
||
[JsonIgnore]
|
||
public DateTime? PersistedScannedAt { get; set; }
|
||
|
||
[JsonIgnore]
|
||
public string TimeText => ScannedAt.ToString("MM-dd HH:mm:ss");
|
||
|
||
[JsonIgnore]
|
||
public string UploadText => Uploaded ? "已上传" : Suppressed ? "重复·不上报" : "待上传";
|
||
|
||
[JsonIgnore]
|
||
public string UploadedAtText => UploadedAt is null ? "—" : UploadedAt.Value.ToString("MM-dd HH:mm:ss");
|
||
}
|
||
|
||
/// <summary>新增/刷新一条扫码记录的结果类型</summary>
|
||
public enum ScanAddKind
|
||
{
|
||
/// <summary>条码为空等非法输入,没落库</summary>
|
||
Invalid,
|
||
|
||
/// <summary>连续扫描:跟该通道上一次是同一个码,只刷新了最近扫描时间,界面不用重查</summary>
|
||
Repeated,
|
||
|
||
/// <summary>新建了一条待上报记录</summary>
|
||
Created,
|
||
|
||
/// <summary>
|
||
/// 刷新了已有记录的时间:同一个码还有未上报的记录,或已上报的记录被重新激活
|
||
/// (扫码枪范围大、多个面单轮流被扫到时走这条)。
|
||
/// </summary>
|
||
Touched,
|
||
}
|
||
|
||
/// <summary><see cref="ScanRecordStore.Add"/> 的结果</summary>
|
||
public readonly record struct ScanAddResult(ScanAddKind Kind, ScanRecordItem? Item)
|
||
{
|
||
/// <summary>是否是一次「新的扫码事件」(连续扫描的重复帧不算)</summary>
|
||
public bool IsScanEvent => Kind is ScanAddKind.Created or ScanAddKind.Touched;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 本地扫码记录库(`%LOCALAPPDATA%\YuncangTrace\scan-records.json`)。
|
||
///
|
||
/// 为什么要有它(照搬 AndroidScanCenter 的经验):
|
||
/// - **断网不丢**:条码先落本地,服务器确认后才标记已上传,否则一直重试;
|
||
/// - **通道回放**:现场要能翻「这台设备刚才扫了什么」,不能只留一条「最近条码」;
|
||
/// - **连续扫描去重**:同一个码每 ~80ms 报一次,只刷新「最近一次扫到的时间」,
|
||
/// 不新增记录(所以「A A A B A」记成 A、B 两条,A 的时间是最后一次扫到的时刻);
|
||
/// - **两种上报时机**:
|
||
/// - 扫码枪(<see cref="Add"/>):扫到后 <see cref="SettleDelay"/>(5 秒)内没再扫到才进上报队列,
|
||
/// 上报的是**最后一次**扫描时间(面单压在扫码器上时,时间一直往后刷,直到包裹离开);
|
||
/// - 面单摄像头(<see cref="AddCamera"/>):**写入即上报**(<see cref="ScanRecordItem.Immediate"/>),
|
||
/// 一轮打包内时间取**第一次**识别到的时刻(面单放进拍摄区后不会马上拿走);
|
||
/// 重新打包(上次这条记录之后通道上又扫过别的包裹)时,更新成这一次的时间;
|
||
/// - 同一个码在 24 小时内再次扫到时会**复用/重新激活同一条本地记录**(不新增行),
|
||
/// 重新上报后**服务器侧覆盖**原来那条记录的工作台快照
|
||
/// (不再像旧版本那样「24 小时内重复的不上报」);
|
||
///
|
||
/// 全部操作加锁:调用方既有收条码的连接线程,也有界面线程和上报重试线程。
|
||
/// </summary>
|
||
public static class ScanRecordStore
|
||
{
|
||
/// <summary>每个通道最多保留多少条(不封顶的话文件会一直长;删最旧的)</summary>
|
||
private const int MaxPerChannel = 5000;
|
||
|
||
/// <summary>
|
||
/// 延迟上报的静默窗口:扫到后这么久没再扫到同一个码,才允许上报。
|
||
/// 连续扫描时每次扫到都会把时间往后推,所以上报的是「最后一次扫描」。
|
||
///
|
||
/// ⚠️ 这个值要和 <c>DeviceService</c> 上报循环的轮询间隔一起看:
|
||
/// 静默期只有 5 秒,循环必须更频繁地检查,否则上报会被拖到下一次唤醒。
|
||
/// </summary>
|
||
public static readonly TimeSpan SettleDelay = TimeSpan.FromSeconds(5);
|
||
|
||
/// <summary>
|
||
/// 同一运单在本地复用同一条记录的窗口(与后端的合并窗口一致:24 小时)。
|
||
///
|
||
/// 已上报的记录又被扫到(扫码枪范围大、两个面单轮流被扫)时,
|
||
/// **重新激活这一条**而不是新增一行,避免同一个运单在本地堆出多条;
|
||
/// 超过 24 小时再扫,才算一条新的记录。
|
||
/// </summary>
|
||
public static readonly TimeSpan MergeWindow = TimeSpan.FromHours(24);
|
||
|
||
/// <summary>连续扫描时最多多久落一次盘(本地库是整文件重写,不能每 80ms 写一次)</summary>
|
||
private static readonly TimeSpan PersistInterval = TimeSpan.FromSeconds(30);
|
||
|
||
private static readonly object Gate = new();
|
||
private static List<ScanRecordItem> _items = new();
|
||
private static long _nextId = 1;
|
||
private static bool _loaded;
|
||
private static DateTime _loadedWriteTime = DateTime.MinValue;
|
||
private static bool _dirty;
|
||
private static DateTime _lastSaveAt = DateTime.MinValue;
|
||
private static Timer? _flushTimer;
|
||
|
||
/// <summary>记录有变化(新增 / 标记已上传 / 清空),界面据此刷新</summary>
|
||
public static event Action? Changed;
|
||
|
||
/// <summary>
|
||
/// 扫码记录**上报成功**(服务器已确认)。参数 = 这批记录里新上传的条码(已去重)。
|
||
///
|
||
/// 桌面端用它来补一次「扫码时查不到(还没上报)→ 上报成功后自动重查」。
|
||
/// </summary>
|
||
public static event Action<IReadOnlyList<string>>? Uploaded;
|
||
|
||
private static string Dir => AgentPaths.DataRoot;
|
||
|
||
private static string FilePath => AgentPaths.RecordsFile;
|
||
|
||
private static readonly JsonSerializerOptions Options = new()
|
||
{
|
||
WriteIndented = false,
|
||
Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
|
||
};
|
||
|
||
/// <summary>读盘(只读一次;读不到就当空库,绝不抛)</summary>
|
||
private static void EnsureLoaded()
|
||
{
|
||
if (_loaded)
|
||
{
|
||
// 服务模式:后台服务是**写入方**,桌面端只读展示 → 文件变了就重新加载
|
||
if (AgentPaths.MachineMode && !AgentPaths.IsServiceProcess) ReloadIfChanged();
|
||
return;
|
||
}
|
||
|
||
_loaded = true;
|
||
LoadFromDisk();
|
||
}
|
||
|
||
private static void LoadFromDisk()
|
||
{
|
||
try
|
||
{
|
||
if (!File.Exists(FilePath))
|
||
{
|
||
_items = new List<ScanRecordItem>();
|
||
_nextId = 1;
|
||
_loadedWriteTime = DateTime.MinValue;
|
||
return;
|
||
}
|
||
|
||
var list = JsonSerializer.Deserialize<List<ScanRecordItem>>(File.ReadAllText(FilePath), Options);
|
||
if (list is null) return;
|
||
|
||
_items = list.Where(item => !string.IsNullOrWhiteSpace(item.Code)).ToList();
|
||
foreach (var item in _items) item.PersistedScannedAt = item.ScannedAt;
|
||
_nextId = _items.Count == 0 ? 1 : _items.Max(item => item.Id) + 1;
|
||
_loadedWriteTime = File.GetLastWriteTimeUtc(FilePath);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AppLog.Write($"[scan] 读取扫码记录失败(按空库继续):{ex.Message}");
|
||
}
|
||
}
|
||
|
||
/// <summary>别的进程(后台服务)写过文件了就重新加载(只在服务模式的桌面端调用)</summary>
|
||
private static void ReloadIfChanged()
|
||
{
|
||
DateTime writeTime;
|
||
try
|
||
{
|
||
if (!File.Exists(FilePath)) return;
|
||
writeTime = File.GetLastWriteTimeUtc(FilePath);
|
||
}
|
||
catch
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (writeTime == _loadedWriteTime) return;
|
||
|
||
_dirty = false;
|
||
LoadFromDisk();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 记一条扫码记录。
|
||
///
|
||
/// - 连续扫描(跟该通道上一条是同一个码、且还没上报)→ 只刷新 <see cref="ScanRecordItem.ScannedAt"/>,
|
||
/// 返回 <see cref="ScanAddKind.Repeated"/>(界面不用重查,避免刷屏);
|
||
/// - 同一个码还有一条没上报的记录(例如 A B A)→ 刷新那条的时间,返回 <see cref="ScanAddKind.Touched"/>;
|
||
/// - 同一个码 24 小时内**已经上报过**、现在又被扫到(扫码枪范围大 / 两个面单轮流被扫)→
|
||
/// **重新激活原来那条**(不新增行),静默 5 秒后再上报覆盖服务器记录;
|
||
/// - 其它情况新建一条记录。
|
||
/// </summary>
|
||
public static ScanAddResult Add(string channelId, string channelName, string code, DateTime scannedAt)
|
||
{
|
||
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 = scannedAt - MergeWindow;
|
||
|
||
// 连续扫描:同一个码每 ~80ms 报一次,只把时间刷到最新
|
||
var last = _items.LastOrDefault(item => item.ChannelId.Equals(key, StringComparison.OrdinalIgnoreCase));
|
||
if (last is not null && last.Code.Equals(text, StringComparison.Ordinal))
|
||
{
|
||
if (!last.Uploaded && !last.Suppressed)
|
||
{
|
||
Touch(last, scannedAt, name);
|
||
result = new ScanAddResult(ScanAddKind.Repeated, last);
|
||
}
|
||
else if (last.ScannedAt > windowStart)
|
||
{
|
||
// 已经上报过、24 小时内又被扫到 → 重新激活这一条(不再新增本地行)
|
||
Reopen(last, scannedAt, name);
|
||
result = new ScanAddResult(ScanAddKind.Touched, last);
|
||
}
|
||
else
|
||
{
|
||
result = new ScanAddResult(ScanAddKind.Created, Create(key, name, text, scannedAt));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 同一个码中途又扫到(A B A):优先刷新那条还没上报的记录,
|
||
// 避免同一个包裹在界面上堆出多条。
|
||
var pending = _items.LastOrDefault(item =>
|
||
item.ChannelId.Equals(key, StringComparison.OrdinalIgnoreCase)
|
||
&& item.Code.Equals(text, StringComparison.Ordinal)
|
||
&& !item.Uploaded
|
||
&& !item.Suppressed);
|
||
|
||
if (pending is not null)
|
||
{
|
||
Touch(pending, scannedAt, name);
|
||
result = new ScanAddResult(ScanAddKind.Touched, pending);
|
||
}
|
||
else
|
||
{
|
||
// 已经上报过的同一条码(24 小时内)→ 重新激活原来那条,
|
||
// 静默 5 秒后再上报,后端会覆盖成最新扫描时间 + 工作台快照。
|
||
var uploaded = _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 (uploaded is not null)
|
||
{
|
||
Reopen(uploaded, scannedAt, name);
|
||
result = new ScanAddResult(ScanAddKind.Touched, uploaded);
|
||
}
|
||
else
|
||
{
|
||
result = new ScanAddResult(ScanAddKind.Created, Create(key, name, text, scannedAt));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
SaveThrottled();
|
||
if (result.IsScanEvent) Changed?.Invoke();
|
||
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)
|
||
{
|
||
var added = new ScanRecordItem
|
||
{
|
||
Id = _nextId++,
|
||
ChannelId = channelId,
|
||
ChannelName = channelName,
|
||
Code = code,
|
||
ScannedAt = scannedAt,
|
||
Uploaded = false,
|
||
Suppressed = false,
|
||
};
|
||
_items.Add(added);
|
||
TrimChannel(channelId);
|
||
_dirty = true;
|
||
return added;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 把记录的「最近扫描时间」刷新到最新(调用方已加锁)。
|
||
/// 落盘做 30 秒节流:连续扫描时内存里每次都要更新,但没必要每 80ms 重写整个文件。
|
||
/// </summary>
|
||
private static void Touch(ScanRecordItem item, DateTime scannedAt, string channelName)
|
||
{
|
||
item.ScannedAt = scannedAt;
|
||
if (!string.IsNullOrWhiteSpace(channelName)) item.ChannelName = channelName;
|
||
|
||
if (item.PersistedScannedAt is null
|
||
|| scannedAt - item.PersistedScannedAt.Value >= PersistInterval)
|
||
{
|
||
_dirty = true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 重新激活一条**已上报**(或旧规则标记为重复)的记录(调用方已加锁)。
|
||
///
|
||
/// 扫码枪范围太大时,两个面单会轮流被扫:A 刚上报完、过一会儿又被扫到。
|
||
/// 这时不新增本地行,而是把原来那条改回「待上传」并刷新时间,
|
||
/// 静默 5 秒后再上报 —— 后端会把同一条记录覆盖成最新扫描时间。
|
||
/// </summary>
|
||
private static void Reopen(ScanRecordItem item, DateTime scannedAt, string channelName)
|
||
{
|
||
item.ScannedAt = scannedAt;
|
||
if (!string.IsNullOrWhiteSpace(channelName)) item.ChannelName = channelName;
|
||
item.Uploaded = false;
|
||
item.UploadedAt = null;
|
||
item.Suppressed = false;
|
||
_dirty = true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 可以上报的一批(按写入顺序,头进头出)。
|
||
///
|
||
/// **默认只返回静默满 <see cref="SettleDelay"/>(5 秒)的记录**:扫到后 5 秒内又扫到同一个码,
|
||
/// <see cref="ScanRecordItem.ScannedAt"/> 会被刷新,这条就继续等,不会提前上报。
|
||
/// </summary>
|
||
public static List<ScanRecordItem> Pending(int limit) => Pending(limit, SettleDelay);
|
||
|
||
/// <summary>可以上报的一批(指定静默窗口;调试/测试可传 <see cref="TimeSpan.Zero"/>)</summary>
|
||
public static List<ScanRecordItem> Pending(int limit, TimeSpan settle)
|
||
{
|
||
var cutoff = DateTime.Now - settle;
|
||
lock (Gate)
|
||
{
|
||
EnsureLoaded();
|
||
return _items
|
||
// 摄像头识别的记录(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();
|
||
}
|
||
}
|
||
|
||
/// <summary>待上报条数(含还在静默期的记录;不含旧版本标记的重复记录)</summary>
|
||
public static int PendingCount()
|
||
{
|
||
lock (Gate)
|
||
{
|
||
EnsureLoaded();
|
||
return _items.Count(item => !item.Uploaded && !item.Suppressed);
|
||
}
|
||
}
|
||
|
||
/// <summary>已经静默满 5 秒(或摄像头识别的立即上报)可以真正上报的条数</summary>
|
||
public static int ReadyCount()
|
||
{
|
||
var cutoff = DateTime.Now - SettleDelay;
|
||
lock (Gate)
|
||
{
|
||
EnsureLoaded();
|
||
return _items.Count(item => !item.Uploaded && !item.Suppressed
|
||
&& (item.Immediate || item.ScannedAt <= cutoff));
|
||
}
|
||
}
|
||
|
||
/// <summary>这个条码是否有「还没上报」的本地记录(桌面端用来提示“等待上报后自动查询”)</summary>
|
||
public static bool HasPending(string code)
|
||
{
|
||
var text = (code ?? string.Empty).Trim();
|
||
if (text.Length == 0) return false;
|
||
|
||
lock (Gate)
|
||
{
|
||
EnsureLoaded();
|
||
return _items.Any(item => !item.Uploaded && !item.Suppressed && item.Code.Equals(text, StringComparison.Ordinal));
|
||
}
|
||
}
|
||
|
||
/// <summary>某通道(null/空 = 全部)最近的记录,新的一头在前</summary>
|
||
public static List<ScanRecordItem> Recent(string? channelId, int limit = 500)
|
||
{
|
||
lock (Gate)
|
||
{
|
||
EnsureLoaded();
|
||
var query = _items.AsEnumerable();
|
||
if (!string.IsNullOrWhiteSpace(channelId))
|
||
{
|
||
query = query.Where(item => item.ChannelId.Equals(channelId.Trim(), StringComparison.OrdinalIgnoreCase));
|
||
}
|
||
return query.OrderByDescending(item => item.Id).Take(limit).ToList();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页取记录(新的一头在前)
|
||
///
|
||
/// 本地库每通道最多 5000 条,全塞进 ListView 会卡;界面按页取(默认 200 条/页)。
|
||
/// </summary>
|
||
/// <param name="channelId">null/空 = 全部通道</param>
|
||
/// <param name="page">页码,0 起</param>
|
||
/// <param name="pageSize">每页条数(<=0 时按 200)</param>
|
||
/// <returns>当前页记录 / 总条数(用于算页数)</returns>
|
||
public static (List<ScanRecordItem> Items, int Total) Page(string? channelId, int page, int pageSize = 200)
|
||
{
|
||
if (pageSize <= 0) pageSize = 200;
|
||
if (page < 0) page = 0;
|
||
|
||
lock (Gate)
|
||
{
|
||
EnsureLoaded();
|
||
|
||
var query = _items.AsEnumerable();
|
||
if (!string.IsNullOrWhiteSpace(channelId))
|
||
{
|
||
query = query.Where(item => item.ChannelId.Equals(channelId.Trim(), StringComparison.OrdinalIgnoreCase));
|
||
}
|
||
|
||
var ordered = query.OrderByDescending(item => item.Id).ToList();
|
||
var total = ordered.Count;
|
||
var items = ordered.Skip(page * pageSize).Take(pageSize).ToList();
|
||
return (items, total);
|
||
}
|
||
}
|
||
|
||
/// <summary>总条数 / 待上传条数(界面统计用;含还在 5 秒静默期的记录)</summary>
|
||
public static (int Total, int Pending) Stats()
|
||
{
|
||
lock (Gate)
|
||
{
|
||
EnsureLoaded();
|
||
return (_items.Count, _items.Count(item => !item.Uploaded && !item.Suppressed));
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 服务器确认收到:标记为已上传(**只在拿到成功响应后调用**)。
|
||
///
|
||
/// 传入每条记录**上报时**的扫描时间:如果上报期间又扫到了同一个码
|
||
/// (<see cref="ScanRecordItem.ScannedAt"/> 已经更新),这条保持「待上传」,
|
||
/// 下一轮会带着最新时间再上报一次,避免最新时间被这次成功回执覆盖掉。
|
||
/// </summary>
|
||
public static void MarkUploaded(IEnumerable<(long Id, DateTime ScannedAt)> uploaded)
|
||
{
|
||
var map = uploaded.GroupBy(item => item.Id).ToDictionary(group => group.Key, group => group.First().ScannedAt);
|
||
if (map.Count == 0) return;
|
||
|
||
var codes = new List<string>();
|
||
lock (Gate)
|
||
{
|
||
EnsureLoaded();
|
||
var now = DateTime.Now;
|
||
var marked = 0;
|
||
foreach (var item in _items.Where(item => map.ContainsKey(item.Id) && !item.Uploaded))
|
||
{
|
||
if (item.ScannedAt != map[item.Id]) continue; // 上报期间又扫到,保持待上传
|
||
item.Uploaded = true;
|
||
item.UploadedAt = now;
|
||
marked++;
|
||
if (!codes.Contains(item.Code)) codes.Add(item.Code);
|
||
}
|
||
if (marked == 0) return;
|
||
_dirty = true;
|
||
}
|
||
|
||
SaveThrottled();
|
||
Changed?.Invoke();
|
||
if (codes.Count > 0) Uploaded?.Invoke(codes);
|
||
}
|
||
|
||
/// <summary>清空(channelId 为空 = 清全部)</summary>
|
||
public static int Clear(string? channelId = null)
|
||
{
|
||
int removed;
|
||
lock (Gate)
|
||
{
|
||
EnsureLoaded();
|
||
if (string.IsNullOrWhiteSpace(channelId))
|
||
{
|
||
removed = _items.Count;
|
||
_items = new List<ScanRecordItem>();
|
||
}
|
||
else
|
||
{
|
||
var key = channelId.Trim();
|
||
removed = _items.RemoveAll(item => item.ChannelId.Equals(key, StringComparison.OrdinalIgnoreCase));
|
||
}
|
||
if (removed == 0) return 0;
|
||
_dirty = true;
|
||
}
|
||
|
||
Save(force: true);
|
||
Changed?.Invoke();
|
||
return removed;
|
||
}
|
||
|
||
/// <summary>强制落盘(退出前调用)</summary>
|
||
public static void Flush()
|
||
{
|
||
lock (Gate)
|
||
{
|
||
EnsureLoaded();
|
||
// 连续扫描时 ScannedAt 可能还没到落盘间隔 → 退出前把最新的也写下去
|
||
if (!_dirty && _items.All(item => item.PersistedScannedAt == item.ScannedAt)) return;
|
||
}
|
||
Save(force: true);
|
||
}
|
||
|
||
/// <summary>每个通道的超额部分(最旧的)删掉</summary>
|
||
private static void TrimChannel(string channelId)
|
||
{
|
||
var mine = _items.Where(item => item.ChannelId.Equals(channelId, StringComparison.OrdinalIgnoreCase))
|
||
.OrderByDescending(item => item.Id)
|
||
.ToList();
|
||
if (mine.Count <= MaxPerChannel) return;
|
||
|
||
var drop = new HashSet<long>(mine.Skip(MaxPerChannel).Select(item => item.Id));
|
||
_items.RemoveAll(item => drop.Contains(item.Id));
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写盘节流:连续扫码时不要每条都整表重写(最多 2 秒一次)。
|
||
/// ⚠️ 被节流掉的那次**必须补写**,否则「已上传」标记会丢在内存里 ——
|
||
/// 重启后记录又变回待上传(虽然服务端会去重,但状态就是错的)。
|
||
/// </summary>
|
||
private static void SaveThrottled()
|
||
{
|
||
bool wait;
|
||
lock (Gate)
|
||
{
|
||
if (!_dirty) return; // 连续扫描只刷了时间、还没到落盘间隔 → 不用写
|
||
wait = (DateTime.Now - _lastSaveAt).TotalSeconds < 2;
|
||
}
|
||
|
||
if (wait)
|
||
{
|
||
ScheduleDelayedFlush();
|
||
return;
|
||
}
|
||
|
||
Save(force: false);
|
||
}
|
||
|
||
/// <summary>被节流后补一次写盘(只排一个定时器,不堆积)</summary>
|
||
private static void ScheduleDelayedFlush()
|
||
{
|
||
lock (Gate)
|
||
{
|
||
if (_flushTimer is not null) return;
|
||
|
||
_flushTimer = new Timer(_ =>
|
||
{
|
||
lock (Gate)
|
||
{
|
||
_flushTimer?.Dispose();
|
||
_flushTimer = null;
|
||
}
|
||
Save(force: false);
|
||
}, null, 2200, Timeout.Infinite);
|
||
}
|
||
}
|
||
|
||
private static void Save(bool force)
|
||
{
|
||
string json;
|
||
lock (Gate)
|
||
{
|
||
if (!_dirty && !force) return;
|
||
if (!force && (DateTime.Now - _lastSaveAt).TotalSeconds < 2) return;
|
||
|
||
json = JsonSerializer.Serialize(_items, Options);
|
||
foreach (var item in _items) item.PersistedScannedAt = item.ScannedAt;
|
||
_dirty = false;
|
||
_lastSaveAt = DateTime.Now;
|
||
}
|
||
|
||
try
|
||
{
|
||
Directory.CreateDirectory(Dir);
|
||
var temp = FilePath + ".tmp";
|
||
File.WriteAllText(temp, json);
|
||
File.Copy(temp, FilePath, overwrite: true);
|
||
File.Delete(temp);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AppLog.Write($"[scan] 保存扫码记录失败:{ex.Message}");
|
||
}
|
||
}
|
||
}
|