修复工单Bug

This commit is contained in:
chfei committed 2026-10-19 14:35:25 +08:00
1 parent 7982f7e348
commit 8e0cc20649
12 files changed
+602 -236

No files matched your search

@@ -12,7 +12,7 @@ namespace OrderSupportTicket.Services;
/// 基于 LaunchDarkly.EventSource 的 SSE 客户端。
/// net462 可使用;断线自动退避重连,并携带服务端事件 ID 进行补偿。
/// </summary>
public sealed class EventSourceTicketRealtimeService : ITicketRealtimeService
public sealed class EventSourceTicketRealtimeService
{
private const string EventsPath = "/api/open/v2/customer-work-orders/events";
private readonly object _sync = new object();
@@ -1,87 +0,0 @@
using OrderSupportTicket.Models;
using OrderSupportTicket.Models.Api;
using System.Threading.Tasks;
namespace OrderSupportTicket.Services;
/// <summary>
/// 客户工单 v2 接口。
/// </summary>
public interface ITicketApiService
{
/// <summary>
/// 查询工单摘要列表。
/// </summary>
Task<WorkOrderListResponse> GetWorkOrdersAsync(
TicketClientOptions options,
string wechatOrderId = null,
string status = null,
int limit = 20,
string cursor = null);
/// <summary>
/// 查询指定订单的公开留言板。
/// </summary>
Task<WorkOrderMessagesResponse> GetMessagesAsync(
TicketClientOptions options,
string appId,
string wechatOrderId,
string before = null,
int limit = 50);
/// <summary>
/// 提交问题或创建工单。
/// </summary>
Task<CreateWorkOrderResponse> CreateWorkOrderAsync(
TicketClientOptions options,
TicketOrderOption order,
string description,
string clientRequestId = null);
/// <summary>
/// 提交客户留言。
/// </summary>
Task<SendMessageResponse> SendMessageAsync(
TicketClientOptions options,
WorkOrderSummaryDto workOrder,
string text,
string clientMessageId);
/// <summary>
/// 标记当前订单留言已读。
/// </summary>
Task MarkReadAsync(
TicketClientOptions options,
string appId,
string wechatOrderId,
int throughSequenceNo);
}
/// <summary>
/// 工单接口调用失败时返回的异常。
/// </summary>
public sealed class TicketApiException : System.Exception
{
/// <summary>
/// 创建工单接口异常。
/// </summary>
public TicketApiException(
int statusCode,
string message,
string responseBody = null)
: base(message)
{
StatusCode = statusCode;
ResponseBody = responseBody;
}
/// <summary>
/// 服务端返回的状态码;无法从 GetHtml 响应中识别时为 0。
/// </summary>
public int StatusCode { get; }
/// <summary>
/// 服务端返回的原始响应正文。
/// </summary>
public string ResponseBody { get; }
}
@@ -1,36 +0,0 @@
using OrderSupportTicket.Models;
using System;
using System.Threading.Tasks;
namespace OrderSupportTicket.Services;
/// <summary>
/// 工单 SSE 实时通知服务。
/// </summary>
public interface ITicketRealtimeService : IDisposable
{
/// <summary>
/// 收到工单变更摘要通知时触发。
/// </summary>
event EventHandler<TicketRealtimeNotificationEventArgs> NotificationReceived;
/// <summary>
/// SSE 连接状态变化时触发。
/// </summary>
event EventHandler<TicketRealtimeStateChangedEventArgs> StateChanged;
/// <summary>
/// 当前 SSE 连接状态。
/// </summary>
TicketRealtimeState State { get; }
/// <summary>
/// 使用指定工单参数建立 SSE 连接。
/// </summary>
void Start(TicketClientOptions options);
/// <summary>
/// 停止 SSE 连接。
/// </summary>
Task StopAsync();
}
@@ -0,0 +1,32 @@
using System;
namespace OrderSupportTicket.Services;
/// <summary>
/// 工单接口调用失败时返回的异常。
/// </summary>
public sealed class TicketApiException : Exception
{
/// <summary>
/// 创建工单接口异常。
/// </summary>
public TicketApiException(
int statusCode,
string message,
string responseBody = null)
: base(message)
{
StatusCode = statusCode;
ResponseBody = responseBody;
}
/// <summary>
/// 服务端返回的状态码;无法从 GetHtml 响应中识别时为 0。
/// </summary>
public int StatusCode { get; }
/// <summary>
/// 服务端返回的原始响应正文。
/// </summary>
public string ResponseBody { get; }
}
@@ -15,7 +15,7 @@ namespace OrderSupportTicket.Services;
/// <summary>
/// 拍单软件工单 API v2 客户端。对应 CLIENT-TICKET-API-V2 正式订单协议。
/// </summary>
public sealed class TicketApiService : ITicketApiService
public sealed class TicketApiService
{
internal static string ServerUrl = "https://ai.e57.cn";
private const string ApiRoot = "/api/open/v2/customer-work-orders";
@@ -40,7 +40,7 @@ public sealed class TicketRealtimeMonitor : IDisposable
/// <summary>
/// 供工单页复用的实时服务,避免重复建立 SSE 连接。
/// </summary>
public ITicketRealtimeService RealtimeService { get; }
public EventSourceTicketRealtimeService RealtimeService { get; }
/// <summary>
/// 收到新的工单留言通知时触发。
@@ -132,6 +132,38 @@ public sealed class TicketRealtimeMonitor : IDisposable
RaiseUnreadCountChanged();
}
/// <summary>
/// 合并历史未读数据。与实时事件产生的未读取较大值,避免重复计数。
/// </summary>
/// <param name="unreadByTicket">
/// 键为 "appId|wechatOrderId",值为该工单的未读消息数。
/// </param>
public void MergeUnread(IDictionary<string, int> unreadByTicket)
{
if (unreadByTicket == null || unreadByTicket.Count == 0)
return;
var changed = false;
lock (_sync)
{
foreach (var item in unreadByTicket)
{
if (string.IsNullOrWhiteSpace(item.Key) || item.Value <= 0)
continue;
_unreadMessages.TryGetValue(item.Key, out var current);
if (item.Value <= current)
continue;
_unreadMessages[item.Key] = item.Value;
changed = true;
}
}
if (changed)
RaiseUnreadCountChanged();
}
/// <summary>
/// 清空全部未读提示。
/// </summary>
@@ -0,0 +1,229 @@
using OrderSupportTicket.Models;
using OrderSupportTicket.Models.Api;
using System;
using System.Threading.Tasks;
namespace OrderSupportTicket.Services;
/// <summary>
/// 工单业务服务,聚合工单 API 客户端与 SSE 实时服务。
/// </summary>
public sealed class TicketService : IDisposable
{
private readonly TicketApiService _api;
private readonly EventSourceTicketRealtimeService _realtime;
private bool _disposed;
/// <summary>
/// 创建使用默认依赖的工单业务服务。
/// </summary>
public TicketService(bool ownsRealtime = true)
: this(
new TicketApiService(),
new EventSourceTicketRealtimeService(),
ownsRealtime)
{
}
/// <summary>
/// 创建工单业务服务。
/// </summary>
/// <param name="api">工单 API 客户端。</param>
/// <param name="realtime">工单实时通知服务。</param>
/// <param name="ownsRealtime">
/// 是否由当前实例负责实时连接的停止与释放;共享连接应传入 false。
/// </param>
public TicketService(
TicketApiService api,
EventSourceTicketRealtimeService realtime,
bool ownsRealtime = true)
{
_api = api ?? throw new ArgumentNullException(nameof(api));
_realtime = realtime ?? throw new ArgumentNullException(nameof(realtime));
OwnsRealtime = ownsRealtime;
_realtime.NotificationReceived += OnNotificationReceived;
_realtime.StateChanged += OnStateChanged;
}
/// <summary>
/// 收到工单变更摘要通知时触发。
/// </summary>
public event EventHandler<TicketRealtimeNotificationEventArgs> NotificationReceived;
/// <summary>
/// SSE 连接状态变化时触发。
/// </summary>
public event EventHandler<TicketRealtimeStateChangedEventArgs> StateChanged;
/// <summary>
/// 当前 SSE 连接状态。
/// </summary>
public TicketRealtimeState RealtimeState => _realtime.State;
/// <summary>
/// 是否由当前服务实例管理实时连接的生命周期。
/// </summary>
public bool OwnsRealtime { get; }
/// <summary>
/// 校验工单页运行参数。
/// </summary>
public void ValidateOptions(TicketClientOptions options)
{
ThrowIfDisposed();
TicketApiService.ValidateOptions(options);
}
/// <summary>
/// 查询工单摘要列表。
/// </summary>
public Task<WorkOrderListResponse> GetWorkOrdersAsync(
TicketClientOptions options,
string wechatOrderId = null,
string status = null,
int limit = 20,
string cursor = null)
{
ThrowIfDisposed();
return _api.GetWorkOrdersAsync(
options,
wechatOrderId,
status,
limit,
cursor);
}
/// <summary>
/// 查询指定订单的公开留言板。
/// </summary>
public Task<WorkOrderMessagesResponse> GetMessagesAsync(
TicketClientOptions options,
string appId,
string wechatOrderId,
string before = null,
int limit = 50)
{
ThrowIfDisposed();
return _api.GetMessagesAsync(
options,
appId,
wechatOrderId,
before,
limit);
}
/// <summary>
/// 提交问题或创建工单。
/// </summary>
public Task<CreateWorkOrderResponse> CreateWorkOrderAsync(
TicketClientOptions options,
TicketOrderOption order,
string description,
string clientRequestId = null)
{
ThrowIfDisposed();
return _api.CreateWorkOrderAsync(
options,
order,
description,
clientRequestId);
}
/// <summary>
/// 提交客户留言。
/// </summary>
public Task<SendMessageResponse> SendMessageAsync(
TicketClientOptions options,
WorkOrderSummaryDto workOrder,
string text,
string clientMessageId)
{
ThrowIfDisposed();
return _api.SendMessageAsync(
options,
workOrder,
text,
clientMessageId);
}
/// <summary>
/// 标记当前订单留言已读。
/// </summary>
public Task MarkReadAsync(
TicketClientOptions options,
string appId,
string wechatOrderId,
int throughSequenceNo)
{
ThrowIfDisposed();
return _api.MarkReadAsync(
options,
appId,
wechatOrderId,
throughSequenceNo);
}
/// <summary>
/// 使用指定工单参数建立 SSE 连接。
/// </summary>
public void StartRealtime(TicketClientOptions options)
{
ThrowIfDisposed();
ValidateOptions(options);
_realtime.Start(options);
}
/// <summary>
/// 停止 SSE 连接;共享连接由宿主管理时,调用方应先检查 <see cref="OwnsRealtime"/>。
/// </summary>
public Task StopRealtimeAsync()
{
ThrowIfDisposed();
return _realtime.StopAsync();
}
/// <summary>
/// 停止并重新建立 SSE 连接。
/// </summary>
public async Task RestartRealtimeAsync(TicketClientOptions options)
{
ThrowIfDisposed();
await _realtime.StopAsync();
ThrowIfDisposed();
StartRealtime(options);
}
public void Dispose()
{
if (_disposed)
return;
_disposed = true;
_realtime.NotificationReceived -= OnNotificationReceived;
_realtime.StateChanged -= OnStateChanged;
if (OwnsRealtime)
_realtime.Dispose();
}
private void OnNotificationReceived(
object sender,
TicketRealtimeNotificationEventArgs args)
{
NotificationReceived?.Invoke(this, args);
}
private void OnStateChanged(
object sender,
TicketRealtimeStateChangedEventArgs args)
{
StateChanged?.Invoke(this, args);
}
private void ThrowIfDisposed()
{
if (_disposed)
throw new ObjectDisposedException(nameof(TicketService));
}
}
@@ -0,0 +1,149 @@
using OrderSupportTicket.Models;
using OrderSupportTicket.Models.Api;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
namespace OrderSupportTicket.Services;
/// <summary>
/// 工单列表本地缓存的读取与未读比较。
/// </summary>
public sealed class WorkOrderCacheService
{
private const string ConfigName = "ordersupportticket";
private static readonly object SyncRoot = new object();
/// <summary>
/// 读取指定账号的工单列表缓存。
/// </summary>
public WorkOrderListCache Load(string userName)
{
if (string.IsNullOrWhiteSpace(userName))
return null;
try
{
lock (SyncRoot)
{
var path = NaiBa.Util.Helper.ConfigHelper.GetConfigUserPath(ConfigName);
if (!File.Exists(path))
return null;
var cache = NaiBa.Util.Helper.ConfigHelper
.LoadConfig<WorkOrderListCache>(ConfigName);
if (cache?.Items == null)
return null;
if (!string.Equals(cache.UserName, userName, StringComparison.Ordinal))
return null;
return cache;
}
}
catch
{
// 本地缓存损坏或读取失败时按无缓存处理。
return null;
}
}
/// <summary>
/// 保存工单列表缓存。
/// </summary>
public void Save(WorkOrderListCache cache)
{
if (cache == null)
throw new ArgumentNullException(nameof(cache));
if (string.IsNullOrWhiteSpace(cache.UserName))
throw new ArgumentException("缓存缺少登录账号。", nameof(cache));
lock (SyncRoot)
{
NaiBa.Util.Helper.ConfigHelper.SaveConfig(ConfigName, cache);
}
}
/// <summary>
/// 根据服务端工单列表和历史缓存计算每个工单的未读消息数。
/// 返回值的键为 "appId|wechatOrderId"。
/// </summary>
public Dictionary<string, int> BuildUnreadMap(
IEnumerable<WorkOrderSummaryDto> workOrders,
WorkOrderListCache cache)
{
var result = new Dictionary<string, int>(StringComparer.Ordinal);
var savedItems = (cache?.Items ?? new List<WorkOrderListCacheItem>())
.Where(item => item != null && !string.IsNullOrWhiteSpace(item.OrderId))
.GroupBy(item => item.OrderId, StringComparer.Ordinal)
.ToDictionary(
group => group.Key,
group => group.First(),
StringComparer.Ordinal);
var hasSavedCache = cache?.Items != null && cache.Items.Count > 0;
foreach (var dto in workOrders ?? Enumerable.Empty<WorkOrderSummaryDto>())
{
if (dto == null
|| string.IsNullOrWhiteSpace(dto.AppId)
|| string.IsNullOrWhiteSpace(dto.WechatOrderId))
{
continue;
}
var hasNewMessage = !hasSavedCache;
if (hasSavedCache)
{
if (savedItems.TryGetValue(dto.WechatOrderId, out var saved))
{
hasNewMessage = ParseTimestamp(dto.LastMessageAt) > saved.LastMessageAt;
}
else
{
// 缓存中没有该工单,说明是新增工单。
hasNewMessage = true;
}
}
if (!hasNewMessage)
continue;
// 有历史基线时,时间更新但服务端未读数为 0 也按 1 条提示;
// 首次运行没有基线时只信任服务端未读数,避免把历史工单全部标成未读。
var unreadCount = hasSavedCache
? Math.Max(1, dto.UnreadCount)
: dto.UnreadCount;
if (unreadCount <= 0)
continue;
result[BuildTicketKey(dto.AppId, dto.WechatOrderId)] = unreadCount;
}
return result;
}
/// <summary>
/// 构建工单实时通知使用的唯一键。
/// </summary>
public static string BuildTicketKey(string appId, string wechatOrderId)
{
return appId + "|" + wechatOrderId;
}
/// <summary>
/// 解析服务端 ISO 8601 时间字符串。
/// </summary>
public static DateTimeOffset ParseTimestamp(string value)
{
if (DateTimeOffset.TryParse(
value,
CultureInfo.InvariantCulture,
DateTimeStyles.AssumeUniversal,
out var parsed))
{
return parsed;
}
return default;
}
}
@@ -0,0 +1,75 @@
using OrderSupportTicket.Models;
using OrderSupportTicket.Models.Api;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace OrderSupportTicket.Services;
/// <summary>
/// 启动时从服务端工单列表和历史本地缓存计算未读消息。
/// </summary>
public sealed class WorkOrderUnreadService
{
private const int PageSize = 100;
private const int MaxPages = 20;
private readonly TicketApiService _api;
private readonly WorkOrderCacheService _cache;
/// <summary>
/// 使用默认工单 API 和缓存服务创建未读计算服务。
/// </summary>
public WorkOrderUnreadService()
: this(new TicketApiService(), new WorkOrderCacheService())
{
}
/// <summary>
/// 创建未读计算服务。
/// </summary>
public WorkOrderUnreadService(
TicketApiService api,
WorkOrderCacheService cache)
{
_api = api ?? throw new ArgumentNullException(nameof(api));
_cache = cache ?? throw new ArgumentNullException(nameof(cache));
}
/// <summary>
/// 获取每个工单的未读消息数。返回值的键为 "appId|wechatOrderId"。
/// </summary>
public async Task<Dictionary<string, int>> GetUnreadByTicketAsync(
TicketClientOptions options)
{
if (options == null)
throw new ArgumentNullException(nameof(options));
TicketApiService.ValidateOptions(options);
var cache = _cache.Load(options.UserName);
var workOrders = new List<WorkOrderSummaryDto>();
string cursor = null;
var page = 0;
do
{
var response = await _api.GetWorkOrdersAsync(
options,
limit: PageSize,
cursor: cursor).ConfigureAwait(false);
if (response?.Items != null)
workOrders.AddRange(response.Items);
cursor = response?.NextCursor;
page++;
if (response == null
|| !response.HasMore
|| string.IsNullOrWhiteSpace(cursor))
{
break;
}
}
while (page < MaxPages);
return _cache.BuildUnreadMap(workOrders, cache);
}
}