packServer/desktop/Services/Scan/ScanRecordStore.cs

632 lines
24 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"/> 没再扫到才上报,上报的就是这个时间。
/// </summary>
public DateTime ScannedAt { 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="SettleDelay"/>(5 分钟)内没再扫到才进上报队列,
/// 上报的是**最后一次**扫描时间。面单一直放在扫码器上时,时间会一直往后刷,
/// 直到面单被贴走/拿开,这才是包裹真正离开工作台的时刻;
/// - 同一个码在 24 小时内再次扫到时会**复用/重新激活同一条本地记录**(不新增行),
/// 5 分钟静默后重新上报,**服务器侧覆盖**原来那条记录的时间和工作台快照
/// (不再像旧版本那样「24 小时内重复的不上报」)。
///
/// 全部操作加锁:调用方既有收条码的连接线程,也有界面线程和上报重试线程。
/// </summary>
public static class ScanRecordStore
{
/// <summary>每个通道最多保留多少条(不封顶的话文件会一直长;删最旧的)</summary>
private const int MaxPerChannel = 5000;
/// <summary>
/// 延迟上报的静默窗口:扫到后这么久没再扫到同一个码,才允许上报。
/// 连续扫描时每次扫到都会把时间往后推,所以上报的是「最后一次扫描」。
/// </summary>
public static readonly TimeSpan SettleDelay = TimeSpan.FromMinutes(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>新建一条待上报记录(调用方已加锁)</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
.Where(item => !item.Uploaded && !item.Suppressed && item.ScannedAt <= cutoff)
.OrderBy(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.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}");
}
}
}