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; /// /// 一条扫码记录(本地库,也是上报队列的元素)。 /// /// 与 AndroidScanCenter 的 scan_record 表对应:先落本地、再上报, /// **上报成功(服务器确认)才把 置 true**,失败的下一轮重试, /// 所以断网期间的条码不会丢。 /// public sealed class ScanRecordItem { /// 自增序号(= 写入顺序,去重和分页都靠它) public long Id { get; set; } /// 通道号(上报时的 channelId) public string ChannelId { get; set; } = string.Empty; /// 通道名(记录用;通道改名后老记录保持当时的名字) public string ChannelName { get; set; } = string.Empty; /// 条码 public string Code { get; set; } = string.Empty; /// /// **最近一次**扫到这个条码的时间(本地时间)。 /// /// 连续扫描时同一个码会反复扫到,这里一直刷新成最后一次; /// 停 没再扫到才上报,上报的就是这个时间。 /// public DateTime ScannedAt { get; set; } /// 服务器是否已确认收到 public bool Uploaded { get; set; } /// /// 旧版本「24 小时内重复扫描、不上报」留下的标记(只为兼容历史本地库)。 /// /// 新规则不再产生这种记录:同一运单在服务器侧只保留一条, /// 后扫到的时间会覆盖前一次,所以这里只为让老记录继续显示成「重复·不上报」。 /// public bool Suppressed { get; set; } /// 确认时间 public DateTime? UploadedAt { get; set; } /// 上次落盘时的 (连续扫描时省得每 80ms 写一次盘) [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"); } /// 新增/刷新一条扫码记录的结果类型 public enum ScanAddKind { /// 条码为空等非法输入,没落库 Invalid, /// 连续扫描:跟该通道上一次是同一个码,只刷新了最近扫描时间,界面不用重查 Repeated, /// 新建了一条待上报记录 Created, /// /// 刷新了已有记录的时间:同一个码还有未上报的记录,或已上报的记录被重新激活 /// (扫码枪范围大、多个面单轮流被扫到时走这条)。 /// Touched, } /// 的结果 public readonly record struct ScanAddResult(ScanAddKind Kind, ScanRecordItem? Item) { /// 是否是一次「新的扫码事件」(连续扫描的重复帧不算) public bool IsScanEvent => Kind is ScanAddKind.Created or ScanAddKind.Touched; } /// /// 本地扫码记录库(`%LOCALAPPDATA%\YuncangTrace\scan-records.json`)。 /// /// 为什么要有它(照搬 AndroidScanCenter 的经验): /// - **断网不丢**:条码先落本地,服务器确认后才标记已上传,否则一直重试; /// - **通道回放**:现场要能翻「这台设备刚才扫了什么」,不能只留一条「最近条码」; /// - **连续扫描去重**:同一个码每 ~80ms 报一次,只刷新「最近一次扫到的时间」, /// 不新增记录(所以「A A A B A」记成 A、B 两条,A 的时间是最后一次扫到的时刻); /// - **延迟上报**:扫到后 (5 分钟)内没再扫到才进上报队列, /// 上报的是**最后一次**扫描时间。面单一直放在扫码器上时,时间会一直往后刷, /// 直到面单被贴走/拿开,这才是包裹真正离开工作台的时刻; /// - 同一个码在 24 小时内再次扫到时会**复用/重新激活同一条本地记录**(不新增行), /// 5 分钟静默后重新上报,**服务器侧覆盖**原来那条记录的时间和工作台快照 /// (不再像旧版本那样「24 小时内重复的不上报」)。 /// /// 全部操作加锁:调用方既有收条码的连接线程,也有界面线程和上报重试线程。 /// public static class ScanRecordStore { /// 每个通道最多保留多少条(不封顶的话文件会一直长;删最旧的) private const int MaxPerChannel = 5000; /// /// 延迟上报的静默窗口:扫到后这么久没再扫到同一个码,才允许上报。 /// 连续扫描时每次扫到都会把时间往后推,所以上报的是「最后一次扫描」。 /// public static readonly TimeSpan SettleDelay = TimeSpan.FromMinutes(5); /// /// 同一运单在本地复用同一条记录的窗口(与后端的合并窗口一致:24 小时)。 /// /// 已上报的记录又被扫到(扫码枪范围大、两个面单轮流被扫)时, /// **重新激活这一条**而不是新增一行,避免同一个运单在本地堆出多条; /// 超过 24 小时再扫,才算一条新的记录。 /// public static readonly TimeSpan MergeWindow = TimeSpan.FromHours(24); /// 连续扫描时最多多久落一次盘(本地库是整文件重写,不能每 80ms 写一次) private static readonly TimeSpan PersistInterval = TimeSpan.FromSeconds(30); private static readonly object Gate = new(); private static List _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; /// 记录有变化(新增 / 标记已上传 / 清空),界面据此刷新 public static event Action? Changed; /// /// 扫码记录**上报成功**(服务器已确认)。参数 = 这批记录里新上传的条码(已去重)。 /// /// 桌面端用它来补一次「扫码时查不到(还没上报)→ 上报成功后自动重查」。 /// public static event Action>? 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, }; /// 读盘(只读一次;读不到就当空库,绝不抛) 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(); _nextId = 1; _loadedWriteTime = DateTime.MinValue; return; } var list = JsonSerializer.Deserialize>(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}"); } } /// 别的进程(后台服务)写过文件了就重新加载(只在服务模式的桌面端调用) 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(); } /// /// 记一条扫码记录。 /// /// - 连续扫描(跟该通道上一条是同一个码、且还没上报)→ 只刷新 , /// 返回 (界面不用重查,避免刷屏); /// - 同一个码还有一条没上报的记录(例如 A B A)→ 刷新那条的时间,返回 ; /// - 同一个码 24 小时内**已经上报过**、现在又被扫到(扫码枪范围大 / 两个面单轮流被扫)→ /// **重新激活原来那条**(不新增行),静默 5 分钟后再上报覆盖服务器记录; /// - 其它情况新建一条记录。 /// 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; } /// 新建一条待上报记录(调用方已加锁) 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; } /// /// 把记录的「最近扫描时间」刷新到最新(调用方已加锁)。 /// 落盘做 30 秒节流:连续扫描时内存里每次都要更新,但没必要每 80ms 重写整个文件。 /// 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; } } /// /// 重新激活一条**已上报**(或旧规则标记为重复)的记录(调用方已加锁)。 /// /// 扫码枪范围太大时,两个面单会轮流被扫:A 刚上报完、过一会儿又被扫到。 /// 这时不新增本地行,而是把原来那条改回「待上传」并刷新时间, /// 静默 5 分钟后再上报 —— 后端会把同一条记录覆盖成最新扫描时间。 /// 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; } /// /// 可以上报的一批(按写入顺序,头进头出)。 /// /// **默认只返回静默满 (5 分钟)的记录**:扫到后 5 分钟内又扫到同一个码, /// 会被刷新,这条就继续等,不会提前上报。 /// public static List Pending(int limit) => Pending(limit, SettleDelay); /// 可以上报的一批(指定静默窗口;调试/测试可传 ) public static List Pending(int limit, TimeSpan settle) { var cutoff = DateTime.Now - settle; lock (Gate) { EnsureLoaded(); return _items .Where(item => !item.Uploaded && !item.Suppressed && item.ScannedAt <= cutoff) .OrderBy(item => item.Id) .Take(limit) .ToList(); } } /// 待上报条数(含还在静默期的记录;不含旧版本标记的重复记录) public static int PendingCount() { lock (Gate) { EnsureLoaded(); return _items.Count(item => !item.Uploaded && !item.Suppressed); } } /// 已经静默满 5 分钟、可以真正上报的条数 public static int ReadyCount() { var cutoff = DateTime.Now - SettleDelay; lock (Gate) { EnsureLoaded(); return _items.Count(item => !item.Uploaded && !item.Suppressed && item.ScannedAt <= cutoff); } } /// 这个条码是否有「还没上报」的本地记录(桌面端用来提示“等待上报后自动查询”) 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)); } } /// 某通道(null/空 = 全部)最近的记录,新的一头在前 public static List 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(); } } /// /// 分页取记录(新的一头在前) /// /// 本地库每通道最多 5000 条,全塞进 ListView 会卡;界面按页取(默认 200 条/页)。 /// /// null/空 = 全部通道 /// 页码,0 起 /// 每页条数(<=0 时按 200) /// 当前页记录 / 总条数(用于算页数) public static (List 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); } } /// 总条数 / 待上传条数(界面统计用;含还在 5 分钟静默期的记录) public static (int Total, int Pending) Stats() { lock (Gate) { EnsureLoaded(); return (_items.Count, _items.Count(item => !item.Uploaded && !item.Suppressed)); } } /// /// 服务器确认收到:标记为已上传(**只在拿到成功响应后调用**)。 /// /// 传入每条记录**上报时**的扫描时间:如果上报期间又扫到了同一个码 /// ( 已经更新),这条保持「待上传」, /// 下一轮会带着最新时间再上报一次,避免最新时间被这次成功回执覆盖掉。 /// 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(); 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); } /// 清空(channelId 为空 = 清全部) public static int Clear(string? channelId = null) { int removed; lock (Gate) { EnsureLoaded(); if (string.IsNullOrWhiteSpace(channelId)) { removed = _items.Count; _items = new List(); } 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; } /// 强制落盘(退出前调用) public static void Flush() { lock (Gate) { EnsureLoaded(); // 连续扫描时 ScannedAt 可能还没到落盘间隔 → 退出前把最新的也写下去 if (!_dirty && _items.All(item => item.PersistedScannedAt == item.ScannedAt)) return; } Save(force: true); } /// 每个通道的超额部分(最旧的)删掉 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(mine.Skip(MaxPerChannel).Select(item => item.Id)); _items.RemoveAll(item => drop.Contains(item.Id)); } /// /// 写盘节流:连续扫码时不要每条都整表重写(最多 2 秒一次)。 /// ⚠️ 被节流掉的那次**必须补写**,否则「已上传」标记会丢在内存里 —— /// 重启后记录又变回待上传(虽然服务端会去重,但状态就是错的)。 /// private static void SaveThrottled() { bool wait; lock (Gate) { if (!_dirty) return; // 连续扫描只刷了时间、还没到落盘间隔 → 不用写 wait = (DateTime.Now - _lastSaveAt).TotalSeconds < 2; } if (wait) { ScheduleDelayedFlush(); return; } Save(force: false); } /// 被节流后补一次写盘(只排一个定时器,不堆积) 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}"); } } }