packServer/desktop/Services/Scan/ScanRecordStore.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

727 lines
30 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

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

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">每页条数(&lt;=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}");
}
}
}