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;
///
/// 延迟上报的静默窗口:扫到后这么久没再扫到同一个码,才允许上报。
/// 连续扫描时每次扫到都会把时间往后推,所以上报的是「最后一次扫描」。
///
/// ⚠️ 这个值要和 DeviceService 上报循环的轮询间隔一起看:
/// 静默期只有 5 秒,循环必须更频繁地检查,否则上报会被拖到下一次唤醒。
///
public static readonly TimeSpan SettleDelay = TimeSpan.FromSeconds(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}");
}
}
}