sevenhill
1436 lines
55 KiB
C#
1436 lines
55 KiB
C#
using Microsoft.AspNetCore.SignalR;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Options;
|
|
using QMax.Api.Configuration;
|
|
using QMax.Api.Contracts;
|
|
using QMax.Api.Data;
|
|
using QMax.Api.Data.Entities;
|
|
using QMax.Api.Infrastructure.Hubs;
|
|
using QMax.Api.Infrastructure.Max;
|
|
using QMax.Api.Infrastructure.Storage;
|
|
using System.Collections.Concurrent;
|
|
using System.Text;
|
|
|
|
namespace QMax.Api.Services;
|
|
|
|
public sealed class MaxBridgeSyncService(
|
|
IServiceScopeFactory scopeFactory,
|
|
IMaxBridgeClient maxBridgeClient,
|
|
IHubContext<QMaxHub> hubContext,
|
|
ILogger<MaxBridgeSyncService> logger)
|
|
{
|
|
private const string PreviewExternalIdPrefix = "preview:";
|
|
private static readonly ConcurrentDictionary<string, DateTimeOffset> PreviewNotifications = new();
|
|
|
|
public async Task<int> SyncOnceAsync(CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
var updates = await maxBridgeClient.FetchUpdatesAsync(cancellationToken);
|
|
return await ApplyUpdatesAsync(updates, incrementUnread: true, sendPushNotifications: true, cancellationToken);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.LogWarning(ex, "MAX sync failed.");
|
|
await PublishCurrentMaxStatusAsync(cancellationToken);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private async Task PublishCurrentMaxStatusAsync(CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
var status = await maxBridgeClient.GetStatusAsync(cancellationToken);
|
|
await using var scope = scopeFactory.CreateAsyncScope();
|
|
var db = scope.ServiceProvider.GetRequiredService<QMaxDbContext>();
|
|
var options = scope.ServiceProvider.GetRequiredService<IOptions<QMaxOptions>>().Value;
|
|
var state = await db.MaxAccountStates.FirstOrDefaultAsync(x => x.Id == 1, cancellationToken);
|
|
if (state is null)
|
|
{
|
|
state = new MaxAccountState { Id = 1 };
|
|
db.MaxAccountStates.Add(state);
|
|
}
|
|
|
|
state.PhoneNumber = options.MaxPhoneNumber;
|
|
state.Status = status.Status;
|
|
state.IsAuthorized = status.IsAuthorized;
|
|
state.LastUrl = status.Url;
|
|
state.LastError = status.LastError;
|
|
state.UpdatedAt = DateTimeOffset.UtcNow;
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
await hubContext.Clients.All.SendAsync("MaxStatusChanged", ToDto(status), cancellationToken);
|
|
}
|
|
catch (Exception statusError)
|
|
{
|
|
logger.LogDebug(statusError, "Unable to publish current MAX status after sync failure.");
|
|
}
|
|
}
|
|
|
|
public async Task<int> SyncChatHistoryAsync(string externalChatId, string? chatUrl, CancellationToken cancellationToken)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(externalChatId))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
try
|
|
{
|
|
var update = await maxBridgeClient.FetchChatHistoryAsync(externalChatId, chatUrl, cancellationToken);
|
|
return update is null
|
|
? 0
|
|
: await ApplyUpdatesAsync(
|
|
[update],
|
|
incrementUnread: false,
|
|
sendPushNotifications: false,
|
|
cancellationToken,
|
|
allowGenericMediaHistoryFetch: false);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.LogWarning(ex, "MAX chat history sync failed for {ExternalChatId}.", externalChatId);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private async Task<int> ApplyUpdatesAsync(
|
|
IReadOnlyList<MaxChatUpdate> updates,
|
|
bool incrementUnread,
|
|
bool sendPushNotifications,
|
|
CancellationToken cancellationToken,
|
|
bool allowGenericMediaHistoryFetch = true)
|
|
{
|
|
if (updates.Count == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
await using var scope = scopeFactory.CreateAsyncScope();
|
|
var db = scope.ServiceProvider.GetRequiredService<QMaxDbContext>();
|
|
var projection = scope.ServiceProvider.GetRequiredService<ChatProjectionService>();
|
|
var pushNotifications = scope.ServiceProvider.GetRequiredService<IPushNotificationService>();
|
|
var storage = scope.ServiceProvider.GetRequiredService<IAttachmentStorageService>();
|
|
var changed = 0;
|
|
var createdMessages = new List<(Chat Chat, Message Message)>();
|
|
var updatedMessages = new List<(Chat Chat, Message Message)>();
|
|
var previewNotificationMessages = new List<(Chat Chat, Message Message)>();
|
|
var genericMediaHistoryRequests = new List<(string ExternalChatId, string? ChatUrl, DateTimeOffset PreviewAt, bool IncrementUnread)>();
|
|
var trackedChatsByExternalId = new Dictionary<string, Chat>(StringComparer.Ordinal);
|
|
|
|
foreach (var update in updates)
|
|
{
|
|
var nextWebUrl = CleanWebUrl(update.ChatUrl);
|
|
var nextKind = ResolveChatKind(update.Kind);
|
|
if (!trackedChatsByExternalId.TryGetValue(update.ExternalId, out var chat))
|
|
{
|
|
chat = await db.Chats
|
|
.FirstOrDefaultAsync(x => x.ExternalId == update.ExternalId, cancellationToken);
|
|
if (chat is null && !string.IsNullOrWhiteSpace(nextWebUrl))
|
|
{
|
|
chat = await db.Chats
|
|
.FirstOrDefaultAsync(x => x.WebUrl == nextWebUrl, cancellationToken);
|
|
}
|
|
if (chat is null)
|
|
{
|
|
chat = await FindDeletedChatTombstoneAsync(db, update, nextWebUrl, cancellationToken);
|
|
}
|
|
}
|
|
|
|
if (chat?.DeletedAt is not null)
|
|
{
|
|
trackedChatsByExternalId[update.ExternalId] = chat;
|
|
continue;
|
|
}
|
|
|
|
var chatWasCreated = chat is null;
|
|
if (chat is null)
|
|
{
|
|
chat = new Chat
|
|
{
|
|
ExternalId = update.ExternalId,
|
|
Title = update.Title,
|
|
AvatarUrl = update.AvatarUrl,
|
|
WebUrl = nextWebUrl,
|
|
Kind = nextKind ?? ChatKind.MaxDialog
|
|
};
|
|
db.Chats.Add(chat);
|
|
changed++;
|
|
}
|
|
|
|
trackedChatsByExternalId[update.ExternalId] = chat;
|
|
|
|
var nextAvatarUrl = string.IsNullOrWhiteSpace(update.AvatarUrl)
|
|
? chat.AvatarUrl
|
|
: update.AvatarUrl;
|
|
nextWebUrl ??= chat.WebUrl;
|
|
var metadataChanged = false;
|
|
if (!string.Equals(chat.ExternalId, update.ExternalId, StringComparison.Ordinal))
|
|
{
|
|
chat.ExternalId = update.ExternalId;
|
|
metadataChanged = true;
|
|
}
|
|
|
|
if (!string.Equals(chat.Title, update.Title, StringComparison.Ordinal))
|
|
{
|
|
chat.Title = update.Title;
|
|
metadataChanged = true;
|
|
}
|
|
|
|
if (!string.Equals(chat.AvatarUrl, nextAvatarUrl, StringComparison.Ordinal))
|
|
{
|
|
chat.AvatarUrl = nextAvatarUrl;
|
|
metadataChanged = true;
|
|
}
|
|
|
|
if (!string.Equals(chat.WebUrl, nextWebUrl, StringComparison.Ordinal))
|
|
{
|
|
chat.WebUrl = nextWebUrl;
|
|
metadataChanged = true;
|
|
}
|
|
|
|
if (nextKind is { } resolvedKind && chat.Kind != resolvedKind)
|
|
{
|
|
chat.Kind = resolvedKind;
|
|
metadataChanged = true;
|
|
}
|
|
|
|
if (metadataChanged)
|
|
{
|
|
chat.UpdatedAt = DateTimeOffset.UtcNow;
|
|
changed++;
|
|
}
|
|
|
|
var previewHint = MessageTextSanitizer.CleanChatPreview(update.LastMessagePreview);
|
|
var shouldLoadLastKnownMessage = !chatWasCreated &&
|
|
!string.IsNullOrWhiteSpace(previewHint) &&
|
|
update.LastMessageIsOutgoing != true &&
|
|
update.Messages.Count == 0 &&
|
|
HasListClockTime(update.LastMessageTimeText);
|
|
var lastKnownOutgoingCandidates = !shouldLoadLastKnownMessage
|
|
? []
|
|
: await db.Messages
|
|
.AsNoTracking()
|
|
.Include(x => x.Attachments)
|
|
.Where(x =>
|
|
x.ChatId == chat.Id &&
|
|
x.DeletedAt == null &&
|
|
x.Direction == MessageDirection.Outgoing)
|
|
.ToListAsync(cancellationToken);
|
|
var lastKnownOutgoingMessages = lastKnownOutgoingCandidates
|
|
.OrderByDescending(x => x.SentAt)
|
|
.Take(5)
|
|
.ToList();
|
|
var lastKnownMessage = lastKnownOutgoingMessages
|
|
.Select(x => new LastKnownMessageSnapshot(
|
|
x.Direction,
|
|
x.Text,
|
|
LastMessagePreview(x.Text, x.Attachments),
|
|
x.Attachments.Count > 0,
|
|
x.SentAt))
|
|
.FirstOrDefault();
|
|
|
|
var previewResult = ApplyListPreview(
|
|
update,
|
|
chat,
|
|
chatWasCreated,
|
|
incrementUnread,
|
|
lastKnownMessage,
|
|
createPreviewMessages: chat.Kind != ChatKind.Channel,
|
|
incrementGenericMediaUnread: chat.Kind == ChatKind.Channel);
|
|
if (previewResult.Message is not null)
|
|
{
|
|
if (!await HasPreviewPlaceholderAsync(db, chat.Id, previewResult.Message, cancellationToken))
|
|
{
|
|
db.Messages.Add(previewResult.Message);
|
|
createdMessages.Add((chat, previewResult.Message));
|
|
}
|
|
}
|
|
if (previewResult.NotificationMessage is not null)
|
|
{
|
|
previewNotificationMessages.Add((chat, previewResult.NotificationMessage));
|
|
}
|
|
|
|
var shouldFetchHistory = previewResult.ShouldFetchHistory ||
|
|
(chat.Kind == ChatKind.Channel &&
|
|
previewResult.PreviewAt is not null &&
|
|
update.Messages.Count == 0 &&
|
|
HasListClockTime(update.LastMessageTimeText));
|
|
if (allowGenericMediaHistoryFetch &&
|
|
shouldFetchHistory &&
|
|
previewResult.PreviewAt is { } previewAt &&
|
|
!await HasMessageAtOrAfterAsync(db, chat.Id, previewAt, cancellationToken))
|
|
{
|
|
genericMediaHistoryRequests.Add((
|
|
update.ExternalId,
|
|
nextWebUrl ?? chat.WebUrl,
|
|
previewAt,
|
|
IncrementUnread: chat.Kind != ChatKind.Channel));
|
|
}
|
|
|
|
if (previewResult.Changed)
|
|
{
|
|
changed++;
|
|
}
|
|
|
|
foreach (var incoming in update.Messages)
|
|
{
|
|
if (IsPreviewOnlyMessage(incoming.ExternalId))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (chat.HistoryClearedAt is { } historyClearedAt && incoming.SentAt <= historyClearedAt)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (IsPresencePreview(incoming.Text) && (incoming.Attachments?.Count ?? 0) == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var existing = await db.Messages
|
|
.Include(x => x.Attachments)
|
|
.FirstOrDefaultAsync(
|
|
x => x.ChatId == chat.Id &&
|
|
x.ExternalId == incoming.ExternalId,
|
|
cancellationToken);
|
|
if (existing is not null)
|
|
{
|
|
var merge = await MergeExistingMessageAsync(
|
|
db,
|
|
existing,
|
|
incoming,
|
|
maxBridgeClient,
|
|
storage,
|
|
cancellationToken);
|
|
if (merge.Changed)
|
|
{
|
|
updatedMessages.Add((chat, existing));
|
|
if (chat.LastMessageAt is null || existing.SentAt >= chat.LastMessageAt)
|
|
{
|
|
chat.LastMessagePreview = LastMessagePreview(existing.Text, existing.Attachments.Concat(merge.AddedAttachments));
|
|
chat.LastMessageAt = existing.SentAt;
|
|
}
|
|
|
|
changed++;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
var pendingOutgoing = await FindPendingOutgoingEchoAsync(db, chat.Id, incoming, cancellationToken);
|
|
if (pendingOutgoing is not null)
|
|
{
|
|
var merge = await MergeExistingMessageAsync(
|
|
db,
|
|
pendingOutgoing,
|
|
incoming,
|
|
maxBridgeClient,
|
|
storage,
|
|
cancellationToken);
|
|
if (!string.Equals(pendingOutgoing.ExternalId, incoming.ExternalId, StringComparison.Ordinal))
|
|
{
|
|
pendingOutgoing.ExternalId = incoming.ExternalId;
|
|
merge = merge with { Changed = true };
|
|
}
|
|
|
|
if (merge.Changed)
|
|
{
|
|
updatedMessages.Add((chat, pendingOutgoing));
|
|
if (chat.LastMessageAt is null || pendingOutgoing.SentAt >= chat.LastMessageAt)
|
|
{
|
|
chat.LastMessagePreview = LastMessagePreview(pendingOutgoing.Text, pendingOutgoing.Attachments.Concat(merge.AddedAttachments));
|
|
chat.LastMessageAt = pendingOutgoing.SentAt;
|
|
}
|
|
|
|
changed++;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
var previewPlaceholder = await FindPreviewPlaceholderAsync(db, chat.Id, incoming, cancellationToken);
|
|
if (previewPlaceholder is not null)
|
|
{
|
|
var merge = await MergeExistingMessageAsync(
|
|
db,
|
|
previewPlaceholder,
|
|
incoming,
|
|
maxBridgeClient,
|
|
storage,
|
|
cancellationToken);
|
|
if (!string.Equals(previewPlaceholder.ExternalId, incoming.ExternalId, StringComparison.Ordinal))
|
|
{
|
|
previewPlaceholder.ExternalId = incoming.ExternalId;
|
|
merge = merge with { Changed = true };
|
|
}
|
|
|
|
if (merge.Changed)
|
|
{
|
|
updatedMessages.Add((chat, previewPlaceholder));
|
|
if (chat.LastMessageAt is null || previewPlaceholder.SentAt >= chat.LastMessageAt)
|
|
{
|
|
chat.LastMessagePreview = LastMessagePreview(previewPlaceholder.Text, previewPlaceholder.Attachments.Concat(merge.AddedAttachments));
|
|
chat.LastMessageAt = previewPlaceholder.SentAt;
|
|
}
|
|
|
|
changed++;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
var message = new Message
|
|
{
|
|
Chat = chat,
|
|
ExternalId = incoming.ExternalId,
|
|
SenderExternalId = incoming.SenderExternalId,
|
|
SenderName = incoming.SenderName,
|
|
Direction = incoming.IsOutgoing ? MessageDirection.Outgoing : MessageDirection.Incoming,
|
|
Text = MessageTextSanitizer.CleanMessageText(
|
|
incoming.Text,
|
|
incoming.Attachments?.Count > 0),
|
|
SentAt = incoming.SentAt,
|
|
DeliveryState = ResolveDeliveryState(incoming)
|
|
};
|
|
|
|
foreach (var incomingAttachment in DistinctAttachments(incoming.Attachments ?? []))
|
|
{
|
|
var attachment = await CreateAttachmentAsync(incomingAttachment, maxBridgeClient, storage, cancellationToken);
|
|
if (attachment is not null)
|
|
{
|
|
message.Attachments.Add(attachment);
|
|
}
|
|
}
|
|
|
|
if (ShouldDeferMediaOnlyMessage(message, incoming.Attachments ?? []))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
db.Messages.Add(message);
|
|
createdMessages.Add((chat, message));
|
|
chat.LastMessagePreview = LastMessagePreview(incoming.Text, message.Attachments);
|
|
chat.LastMessageAt = incoming.SentAt;
|
|
if (incrementUnread && !incoming.IsOutgoing)
|
|
{
|
|
chat.UnreadCount++;
|
|
}
|
|
changed++;
|
|
}
|
|
}
|
|
|
|
if (changed > 0)
|
|
{
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
foreach (var (chat, message) in createdMessages)
|
|
{
|
|
var dto = projection.ToDto(message);
|
|
await hubContext.Clients.Group($"chat:{chat.Id}").SendAsync("MessageCreated", dto, cancellationToken);
|
|
if (sendPushNotifications && message.Direction == MessageDirection.Incoming && chat.Kind != ChatKind.Channel)
|
|
{
|
|
await pushNotifications.SendNewMessageAsync(chat, message, cancellationToken);
|
|
}
|
|
}
|
|
|
|
foreach (var (chat, message) in previewNotificationMessages)
|
|
{
|
|
if (sendPushNotifications && message.Direction == MessageDirection.Incoming && chat.Kind != ChatKind.Channel)
|
|
{
|
|
await pushNotifications.SendNewMessageAsync(chat, message, cancellationToken);
|
|
}
|
|
}
|
|
|
|
foreach (var (chat, message) in updatedMessages)
|
|
{
|
|
var updated = await db.Messages
|
|
.Include(x => x.Attachments)
|
|
.Include(x => x.Reactions)
|
|
.FirstOrDefaultAsync(x => x.Id == message.Id, cancellationToken);
|
|
if (updated is not null)
|
|
{
|
|
var dto = projection.ToDto(updated);
|
|
await hubContext.Clients.Group($"chat:{chat.Id}").SendAsync("MessageUpdated", dto, cancellationToken);
|
|
}
|
|
}
|
|
|
|
await hubContext.Clients.All.SendAsync("ChatListInvalidated", cancellationToken);
|
|
}
|
|
|
|
foreach (var request in genericMediaHistoryRequests
|
|
.GroupBy(x => x.ExternalChatId, StringComparer.Ordinal)
|
|
.Select(x => x.OrderByDescending(item => item.PreviewAt).First()))
|
|
{
|
|
try
|
|
{
|
|
var history = await maxBridgeClient.FetchChatHistoryAsync(request.ExternalChatId, request.ChatUrl, cancellationToken);
|
|
if (history is not null)
|
|
{
|
|
changed += await ApplyUpdatesAsync(
|
|
[history],
|
|
incrementUnread && request.IncrementUnread,
|
|
sendPushNotifications,
|
|
cancellationToken,
|
|
allowGenericMediaHistoryFetch: false);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.LogWarning(ex, "MAX media preview history fetch failed for {ExternalChatId}.", request.ExternalChatId);
|
|
}
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
private static ListPreviewApplyResult ApplyListPreview(
|
|
MaxChatUpdate update,
|
|
Chat chat,
|
|
bool chatWasCreated,
|
|
bool incrementUnread,
|
|
LastKnownMessageSnapshot? lastKnownMessage,
|
|
bool createPreviewMessages,
|
|
bool incrementGenericMediaUnread)
|
|
{
|
|
var preview = MessageTextSanitizer.CleanChatPreview(update.LastMessagePreview);
|
|
if (string.IsNullOrWhiteSpace(preview))
|
|
{
|
|
return new ListPreviewApplyResult(false, null, null, false, null);
|
|
}
|
|
|
|
if (IsPresencePreview(preview))
|
|
{
|
|
return new ListPreviewApplyResult(false, null, null, false, null);
|
|
}
|
|
|
|
var previousPreview = chat.LastMessagePreview;
|
|
var previousPreviewAt = chat.LastMessageAt;
|
|
var previewAt = ResolveListPreviewAt(update, previousPreviewAt ?? chat.UpdatedAt);
|
|
if (chat.HistoryClearedAt is { } historyClearedAt && previewAt <= historyClearedAt)
|
|
{
|
|
return new ListPreviewApplyResult(false, null, null, false, null);
|
|
}
|
|
|
|
var isGenericMediaPreview = MessageTextSanitizer.IsGenericMediaLabel(preview);
|
|
var shouldFetchHistory = isGenericMediaPreview &&
|
|
update.Messages.Count == 0 &&
|
|
HasListClockTime(update.LastMessageTimeText);
|
|
var samePreview = string.Equals(previousPreview, preview, StringComparison.Ordinal);
|
|
var samePreviewAt = previousPreviewAt is not null &&
|
|
Math.Abs((previousPreviewAt.Value - previewAt).TotalSeconds) < 1;
|
|
if (samePreview && samePreviewAt)
|
|
{
|
|
return new ListPreviewApplyResult(false, null, null, shouldFetchHistory, previewAt);
|
|
}
|
|
|
|
chat.LastMessagePreview = preview;
|
|
chat.LastMessageAt = previewAt;
|
|
chat.UpdatedAt = DateTimeOffset.UtcNow;
|
|
|
|
var echoesKnownOutgoing = IsKnownOutgoingPreviewEcho(lastKnownMessage, preview, previewAt);
|
|
var shouldNotifyCandidate = (chatWasCreated || !string.IsNullOrWhiteSpace(previousPreview)) &&
|
|
!echoesKnownOutgoing &&
|
|
update.LastMessageIsOutgoing != true &&
|
|
update.Messages.Count == 0 &&
|
|
IsFreshListPreview(update, previewAt);
|
|
var shouldNotify = shouldNotifyCandidate &&
|
|
RememberPreviewNotification(chat.Id, preview, previewAt);
|
|
|
|
if (incrementUnread && shouldNotify && (!isGenericMediaPreview || incrementGenericMediaUnread))
|
|
{
|
|
chat.UnreadCount++;
|
|
}
|
|
|
|
var message = shouldNotify && !isGenericMediaPreview && createPreviewMessages
|
|
? CreatePreviewMessage(chat, preview, previewAt)
|
|
: null;
|
|
return new ListPreviewApplyResult(true, message, null, shouldFetchHistory, previewAt);
|
|
}
|
|
|
|
private static bool IsKnownOutgoingPreviewEcho(
|
|
LastKnownMessageSnapshot? lastKnownMessage,
|
|
string preview,
|
|
DateTimeOffset previewAt)
|
|
{
|
|
if (lastKnownMessage is null ||
|
|
lastKnownMessage.Direction != MessageDirection.Outgoing)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var lastPreview = MessageTextSanitizer.CleanChatPreview(lastKnownMessage.Preview ?? lastKnownMessage.Text);
|
|
var previewMatches = string.Equals(lastPreview, preview, StringComparison.Ordinal) ||
|
|
lastKnownMessage.HasAttachments && MessageTextSanitizer.IsGenericMediaLabel(preview);
|
|
if (!previewMatches)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var sentAt = lastKnownMessage.SentAt.ToUniversalTime();
|
|
var previewUtc = previewAt.ToUniversalTime();
|
|
var now = DateTimeOffset.UtcNow;
|
|
return Math.Abs((sentAt - previewUtc).TotalMinutes) <= 30 ||
|
|
sentAt >= now.AddMinutes(-30);
|
|
}
|
|
|
|
private static bool RememberPreviewNotification(Guid chatId, string preview, DateTimeOffset previewAt)
|
|
{
|
|
var now = DateTimeOffset.UtcNow;
|
|
if (PreviewNotifications.Count > 4096)
|
|
{
|
|
var cutoff = now.AddHours(-2);
|
|
foreach (var item in PreviewNotifications)
|
|
{
|
|
if (item.Value < cutoff)
|
|
{
|
|
PreviewNotifications.TryRemove(item.Key, out _);
|
|
}
|
|
}
|
|
}
|
|
|
|
var previewMinute = previewAt.ToUniversalTime().Ticks / TimeSpan.TicksPerMinute;
|
|
var key = $"{chatId:N}|{previewMinute}|{preview.Trim().ToLowerInvariant()}";
|
|
return PreviewNotifications.TryAdd(key, now);
|
|
}
|
|
|
|
private static DateTimeOffset ResolveListPreviewAt(MaxChatUpdate update, DateTimeOffset? fallback = null)
|
|
{
|
|
return TryParseMoscowListTime(update.LastMessageTimeText, out var parsed)
|
|
? parsed
|
|
: fallback ?? (update.Messages.Count > 0 ? update.LastMessageAt : null) ?? update.UpdatedAt;
|
|
}
|
|
|
|
private static bool IsFreshListPreview(MaxChatUpdate update, DateTimeOffset previewAt)
|
|
{
|
|
if (!HasListClockTime(update.LastMessageTimeText))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var now = DateTimeOffset.UtcNow;
|
|
return previewAt >= now.AddMinutes(-15) && previewAt <= now.AddMinutes(10);
|
|
}
|
|
|
|
private static bool HasListClockTime(string? value)
|
|
{
|
|
return System.Text.RegularExpressions.Regex.IsMatch(value?.Trim() ?? "", @"\b\d{1,2}:\d{2}\b");
|
|
}
|
|
|
|
private static bool TryParseMoscowListTime(string? value, out DateTimeOffset parsed)
|
|
{
|
|
parsed = default;
|
|
var text = value?.Trim().ToLowerInvariant();
|
|
if (string.IsNullOrWhiteSpace(text))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var match = System.Text.RegularExpressions.Regex.Match(text, @"\b(?<hour>\d{1,2}):(?<minute>\d{2})\b");
|
|
if (!match.Success)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!int.TryParse(match.Groups["hour"].Value, out var hour) ||
|
|
!int.TryParse(match.Groups["minute"].Value, out var minute) ||
|
|
hour is < 0 or > 23 ||
|
|
minute is < 0 or > 59)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var zone = GetMoscowTimeZone();
|
|
var nowMoscow = TimeZoneInfo.ConvertTime(DateTimeOffset.UtcNow, zone);
|
|
var local = new DateTime(nowMoscow.Year, nowMoscow.Month, nowMoscow.Day, hour, minute, 0, DateTimeKind.Unspecified);
|
|
parsed = new DateTimeOffset(local, zone.GetUtcOffset(local));
|
|
if (parsed > DateTimeOffset.UtcNow.AddMinutes(10))
|
|
{
|
|
parsed = parsed.AddDays(-1);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static TimeZoneInfo GetMoscowTimeZone()
|
|
{
|
|
try
|
|
{
|
|
return TimeZoneInfo.FindSystemTimeZoneById("Europe/Moscow");
|
|
}
|
|
catch (TimeZoneNotFoundException)
|
|
{
|
|
return TimeZoneInfo.FindSystemTimeZoneById("Russian Standard Time");
|
|
}
|
|
}
|
|
|
|
private static bool IsPreviewOnlyMessage(string? externalId)
|
|
{
|
|
return externalId?.StartsWith("dommsg:", StringComparison.OrdinalIgnoreCase) == true;
|
|
}
|
|
|
|
private static bool IsPresencePreview(string? value)
|
|
{
|
|
var text = value?.Trim().ToLowerInvariant();
|
|
if (string.IsNullOrWhiteSpace(text) || text.Length > 120)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
text = text
|
|
.Replace("...", "")
|
|
.Replace("\u2026", "")
|
|
.Trim();
|
|
|
|
if (text.Contains("\u043f\u0435\u0447\u0430\u0442", StringComparison.Ordinal) ||
|
|
text.Contains("\u043d\u0430\u0431\u0438\u0440\u0430", StringComparison.Ordinal) ||
|
|
text.Contains("typing", StringComparison.Ordinal))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
var hasProcessVerb =
|
|
text.Contains("\u043e\u0442\u043f\u0440\u0430\u0432\u043b\u044f\u0435\u0442", StringComparison.Ordinal) ||
|
|
text.Contains("\u0432\u044b\u0431\u0438\u0440\u0430\u0435\u0442", StringComparison.Ordinal) ||
|
|
text.Contains("\u0437\u0430\u0433\u0440\u0443\u0436\u0430\u0435\u0442", StringComparison.Ordinal) ||
|
|
text.Contains("\u043f\u0440\u0438\u043a\u0440\u0435\u043f\u043b\u044f\u0435\u0442", StringComparison.Ordinal) ||
|
|
text.Contains("\u0437\u0430\u043f\u0438\u0441\u044b\u0432\u0430\u0435\u0442", StringComparison.Ordinal) ||
|
|
text.Contains("is sending", StringComparison.Ordinal) ||
|
|
text.Contains("sending", StringComparison.Ordinal) ||
|
|
text.Contains("choosing", StringComparison.Ordinal) ||
|
|
text.Contains("uploading", StringComparison.Ordinal) ||
|
|
text.Contains("recording", StringComparison.Ordinal);
|
|
if (!hasProcessVerb)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return text.Contains("\u0444\u043e\u0442\u043e", StringComparison.Ordinal) ||
|
|
text.Contains("\u0438\u0437\u043e\u0431\u0440\u0430\u0436", StringComparison.Ordinal) ||
|
|
text.Contains("\u043a\u0430\u0440\u0442\u0438\u043d", StringComparison.Ordinal) ||
|
|
text.Contains("\u0432\u0438\u0434\u0435\u043e", StringComparison.Ordinal) ||
|
|
text.Contains("\u0441\u0442\u0438\u043a\u0435\u0440", StringComparison.Ordinal) ||
|
|
text.Contains("\u044d\u043c\u043e\u0434\u0437\u0438", StringComparison.Ordinal) ||
|
|
text.Contains("\u0433\u043e\u043b\u043e\u0441", StringComparison.Ordinal) ||
|
|
text.Contains("\u0430\u0443\u0434\u0438\u043e", StringComparison.Ordinal) ||
|
|
text.Contains("\u0444\u0430\u0439\u043b", StringComparison.Ordinal) ||
|
|
text.Contains("photo", StringComparison.Ordinal) ||
|
|
text.Contains("image", StringComparison.Ordinal) ||
|
|
text.Contains("video", StringComparison.Ordinal) ||
|
|
text.Contains("sticker", StringComparison.Ordinal) ||
|
|
text.Contains("emoji", StringComparison.Ordinal) ||
|
|
text.Contains("voice", StringComparison.Ordinal) ||
|
|
text.Contains("audio", StringComparison.Ordinal) ||
|
|
text.Contains("file", StringComparison.Ordinal);
|
|
}
|
|
|
|
private sealed record ListPreviewApplyResult(
|
|
bool Changed,
|
|
Message? Message,
|
|
Message? NotificationMessage,
|
|
bool ShouldFetchHistory,
|
|
DateTimeOffset? PreviewAt);
|
|
|
|
private sealed record MessageMergeResult(bool Changed, IReadOnlyList<MessageAttachment> AddedAttachments);
|
|
|
|
private static Message CreatePreviewMessage(Chat chat, string preview, DateTimeOffset previewAt)
|
|
{
|
|
return new Message
|
|
{
|
|
ChatId = chat.Id,
|
|
Chat = chat,
|
|
ExternalId = PreviewExternalId(chat.Id, preview, previewAt),
|
|
Direction = MessageDirection.Incoming,
|
|
Text = preview,
|
|
SentAt = previewAt,
|
|
DeliveryState = MessageDeliveryState.Delivered,
|
|
SenderExternalId = chat.ExternalId,
|
|
SenderName = chat.Title
|
|
};
|
|
}
|
|
|
|
private static async Task<Message?> FindPreviewPlaceholderAsync(
|
|
QMaxDbContext db,
|
|
Guid chatId,
|
|
MaxMessageUpdate incoming,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (incoming.IsOutgoing)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var incomingAttachments = DistinctAttachments(incoming.Attachments ?? []);
|
|
var incomingText = MessageTextSanitizer.CleanMessageText(
|
|
incoming.Text,
|
|
incomingAttachments.Count > 0);
|
|
if (string.IsNullOrWhiteSpace(incomingText))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var candidates = await db.Messages
|
|
.Include(x => x.Attachments)
|
|
.Where(x =>
|
|
x.ChatId == chatId &&
|
|
x.DeletedAt == null &&
|
|
x.Direction == MessageDirection.Incoming &&
|
|
x.ExternalId != null &&
|
|
x.ExternalId.StartsWith(PreviewExternalIdPrefix))
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return candidates
|
|
.Where(candidate => candidate.Attachments.Count == 0)
|
|
.Where(candidate => string.Equals(
|
|
MessageTextSanitizer.CleanMessageText(candidate.Text, false),
|
|
incomingText,
|
|
StringComparison.Ordinal))
|
|
.Where(candidate => Math.Abs((candidate.SentAt.ToUniversalTime() - incoming.SentAt.ToUniversalTime()).TotalMinutes) <= 30)
|
|
.OrderBy(candidate => Math.Abs((candidate.SentAt.ToUniversalTime() - incoming.SentAt.ToUniversalTime()).TotalSeconds))
|
|
.FirstOrDefault();
|
|
}
|
|
|
|
private static async Task<bool> HasPreviewPlaceholderAsync(
|
|
QMaxDbContext db,
|
|
Guid chatId,
|
|
Message previewMessage,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var previewText = MessageTextSanitizer.CleanMessageText(previewMessage.Text, false);
|
|
var candidates = await db.Messages
|
|
.AsNoTracking()
|
|
.Where(x =>
|
|
x.ChatId == chatId &&
|
|
x.DeletedAt == null &&
|
|
x.Direction == MessageDirection.Incoming &&
|
|
x.ExternalId != null &&
|
|
x.ExternalId.StartsWith(PreviewExternalIdPrefix))
|
|
.ToArrayAsync(cancellationToken);
|
|
|
|
return candidates.Any(candidate =>
|
|
string.Equals(candidate.ExternalId, previewMessage.ExternalId, StringComparison.Ordinal) ||
|
|
string.Equals(
|
|
MessageTextSanitizer.CleanMessageText(candidate.Text, false),
|
|
previewText,
|
|
StringComparison.Ordinal) &&
|
|
Math.Abs((candidate.SentAt.ToUniversalTime() - previewMessage.SentAt.ToUniversalTime()).TotalMinutes) <= 30);
|
|
}
|
|
|
|
private static async Task<bool> HasMessageAtOrAfterAsync(
|
|
QMaxDbContext db,
|
|
Guid chatId,
|
|
DateTimeOffset previewAt,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var cutoff = previewAt.ToUniversalTime().AddSeconds(-1);
|
|
var sentAtValues = await db.Messages
|
|
.AsNoTracking()
|
|
.Where(x => x.ChatId == chatId && x.DeletedAt == null)
|
|
.Select(x => x.SentAt)
|
|
.ToArrayAsync(cancellationToken);
|
|
|
|
return sentAtValues.Any(sentAt => sentAt.ToUniversalTime() >= cutoff);
|
|
}
|
|
|
|
private static string PreviewExternalId(Guid chatId, string preview, DateTimeOffset previewAt)
|
|
{
|
|
var previewMinute = previewAt.ToUniversalTime().Ticks / TimeSpan.TicksPerMinute;
|
|
return $"{PreviewExternalIdPrefix}{chatId:N}:{previewMinute}:{StableHash(preview.Trim().ToLowerInvariant())}";
|
|
}
|
|
|
|
private static string StableHash(string value)
|
|
{
|
|
var hash = 2166136261u;
|
|
foreach (var character in value)
|
|
{
|
|
hash ^= character;
|
|
hash *= 16777619;
|
|
}
|
|
|
|
return hash.ToString("x8");
|
|
}
|
|
|
|
private static async Task<Message?> FindPendingOutgoingEchoAsync(
|
|
QMaxDbContext db,
|
|
Guid chatId,
|
|
MaxMessageUpdate incoming,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!incoming.IsOutgoing || string.IsNullOrWhiteSpace(incoming.ExternalId))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var candidates = await db.Messages
|
|
.Include(x => x.Attachments)
|
|
.Where(x =>
|
|
x.ChatId == chatId &&
|
|
x.DeletedAt == null &&
|
|
x.Direction == MessageDirection.Outgoing &&
|
|
(x.DeliveryState == MessageDeliveryState.Sending ||
|
|
x.DeliveryState == MessageDeliveryState.Failed) &&
|
|
(x.ExternalId == null || x.ExternalId == ""))
|
|
.ToListAsync(cancellationToken);
|
|
if (candidates.Count == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var incomingAttachments = DistinctAttachments(incoming.Attachments ?? []);
|
|
var incomingText = MessageTextSanitizer.CleanMessageText(
|
|
incoming.Text,
|
|
incomingAttachments.Count > 0);
|
|
|
|
return candidates
|
|
.Where(candidate => IsRecentOutgoingEchoCandidate(candidate, incoming))
|
|
.Where(candidate => IsPendingOutgoingEchoMatch(candidate, incomingAttachments, incomingText))
|
|
.OrderBy(candidate => Math.Abs((candidate.SentAt.ToUniversalTime() - incoming.SentAt.ToUniversalTime()).TotalSeconds))
|
|
.FirstOrDefault();
|
|
}
|
|
|
|
private static bool IsRecentOutgoingEchoCandidate(Message candidate, MaxMessageUpdate incoming)
|
|
{
|
|
var candidateAt = candidate.SentAt.ToUniversalTime();
|
|
var incomingAt = incoming.SentAt.ToUniversalTime();
|
|
return Math.Abs((candidateAt - incomingAt).TotalMinutes) <= 30 ||
|
|
candidateAt >= DateTimeOffset.UtcNow.AddMinutes(-30);
|
|
}
|
|
|
|
private static bool IsPendingOutgoingEchoMatch(
|
|
Message candidate,
|
|
IReadOnlyList<MaxAttachmentUpdate> incomingAttachments,
|
|
string? incomingText)
|
|
{
|
|
var localAttachments = candidate.Attachments.OrderBy(x => x.SortOrder).ToArray();
|
|
var localText = MessageTextSanitizer.CleanMessageText(candidate.Text, localAttachments.Length > 0);
|
|
|
|
if (incomingAttachments.Count == 0)
|
|
{
|
|
return localAttachments.Length == 0 &&
|
|
string.Equals(localText, incomingText, StringComparison.Ordinal);
|
|
}
|
|
|
|
if (localAttachments.Length == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(localText) &&
|
|
!string.IsNullOrWhiteSpace(incomingText) &&
|
|
!string.Equals(localText, incomingText, StringComparison.Ordinal))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return incomingAttachments.All(incomingAttachment =>
|
|
{
|
|
var kind = ResolveKind(incomingAttachment) ?? AttachmentKind.File;
|
|
return localAttachments.Any(localAttachment =>
|
|
localAttachment.Kind == kind &&
|
|
(localAttachment.SortOrder == incomingAttachment.SortOrder ||
|
|
localAttachments.Length == 1 ||
|
|
incomingAttachments.Count == 1));
|
|
});
|
|
}
|
|
|
|
private static async Task<MessageMergeResult> MergeExistingMessageAsync(
|
|
QMaxDbContext db,
|
|
Message message,
|
|
MaxMessageUpdate incoming,
|
|
IMaxBridgeClient maxBridgeClient,
|
|
IAttachmentStorageService storage,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var changed = false;
|
|
var metadataChanged = false;
|
|
var addedAttachments = new List<MessageAttachment>();
|
|
var knownAttachments = message.Attachments.ToList();
|
|
var incomingAttachments = DistinctAttachments(incoming.Attachments ?? []);
|
|
var cleanText = MessageTextSanitizer.CleanMessageText(
|
|
incoming.Text,
|
|
incomingAttachments.Count > 0 || message.Attachments.Count > 0);
|
|
|
|
if (!string.Equals(message.Text, cleanText, StringComparison.Ordinal))
|
|
{
|
|
message.Text = cleanText;
|
|
changed = true;
|
|
metadataChanged = true;
|
|
}
|
|
|
|
var senderName = string.IsNullOrWhiteSpace(incoming.SenderName) ? null : incoming.SenderName;
|
|
if (!string.Equals(message.SenderName, senderName, StringComparison.Ordinal))
|
|
{
|
|
message.SenderName = senderName;
|
|
changed = true;
|
|
metadataChanged = true;
|
|
}
|
|
|
|
if (!string.Equals(message.SenderExternalId, incoming.SenderExternalId, StringComparison.Ordinal))
|
|
{
|
|
message.SenderExternalId = incoming.SenderExternalId;
|
|
changed = true;
|
|
metadataChanged = true;
|
|
}
|
|
|
|
var direction = incoming.IsOutgoing ? MessageDirection.Outgoing : MessageDirection.Incoming;
|
|
if (message.Direction != direction)
|
|
{
|
|
message.Direction = direction;
|
|
changed = true;
|
|
metadataChanged = true;
|
|
}
|
|
|
|
if (message.SentAt != incoming.SentAt)
|
|
{
|
|
message.SentAt = incoming.SentAt;
|
|
changed = true;
|
|
metadataChanged = true;
|
|
}
|
|
|
|
var deliveryState = ResolveDeliveryState(incoming);
|
|
if (message.DeliveryState != deliveryState)
|
|
{
|
|
message.DeliveryState = deliveryState;
|
|
changed = true;
|
|
metadataChanged = true;
|
|
}
|
|
|
|
if (metadataChanged)
|
|
{
|
|
await db.Messages
|
|
.Where(x => x.Id == message.Id)
|
|
.ExecuteUpdateAsync(setters => setters
|
|
.SetProperty(x => x.Text, cleanText)
|
|
.SetProperty(x => x.SenderName, senderName)
|
|
.SetProperty(x => x.SenderExternalId, incoming.SenderExternalId)
|
|
.SetProperty(x => x.Direction, direction)
|
|
.SetProperty(x => x.SentAt, incoming.SentAt)
|
|
.SetProperty(x => x.DeliveryState, deliveryState),
|
|
cancellationToken);
|
|
db.Entry(message).State = EntityState.Unchanged;
|
|
}
|
|
|
|
foreach (var incomingAttachment in incomingAttachments)
|
|
{
|
|
if (TryMergeOutgoingRemoteEchoIntoLocalAttachment(
|
|
message,
|
|
incoming,
|
|
knownAttachments,
|
|
incomingAttachment,
|
|
out var echoChanged))
|
|
{
|
|
changed |= echoChanged;
|
|
continue;
|
|
}
|
|
|
|
var existingAttachment = FindMatchingAttachment(knownAttachments, incomingAttachment);
|
|
if (existingAttachment is not null)
|
|
{
|
|
if (IsUncachedRemotePlaceholder(existingAttachment) &&
|
|
RequiresCachedRemoteMedia(existingAttachment.Kind) &&
|
|
await TryHydrateRemoteAttachmentAsync(existingAttachment, incomingAttachment, maxBridgeClient, storage, cancellationToken))
|
|
{
|
|
changed = true;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
var attachment = await CreateAttachmentAsync(incomingAttachment, maxBridgeClient, storage, cancellationToken);
|
|
if (attachment is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
attachment.MessageId = message.Id;
|
|
db.MessageAttachments.Add(attachment);
|
|
knownAttachments.Add(attachment);
|
|
addedAttachments.Add(attachment);
|
|
changed = true;
|
|
}
|
|
|
|
return new MessageMergeResult(changed, addedAttachments);
|
|
}
|
|
|
|
private static bool TryMergeOutgoingRemoteEchoIntoLocalAttachment(
|
|
Message message,
|
|
MaxMessageUpdate incoming,
|
|
IEnumerable<MessageAttachment> attachments,
|
|
MaxAttachmentUpdate incomingAttachment,
|
|
out bool changed)
|
|
{
|
|
changed = false;
|
|
if (message.Direction != MessageDirection.Outgoing || !incoming.IsOutgoing)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(incomingAttachment.ExternalId) &&
|
|
string.IsNullOrWhiteSpace(incomingAttachment.RemoteUrl))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var kind = ResolveKind(incomingAttachment) ?? AttachmentKind.File;
|
|
var localUpload = attachments.FirstOrDefault(attachment =>
|
|
attachment.SortOrder == incomingAttachment.SortOrder &&
|
|
attachment.Kind == kind &&
|
|
string.IsNullOrWhiteSpace(attachment.ExternalId) &&
|
|
string.IsNullOrWhiteSpace(attachment.RemoteUrl));
|
|
|
|
if (localUpload is null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(incomingAttachment.ExternalId) &&
|
|
!string.Equals(localUpload.ExternalId, incomingAttachment.ExternalId, StringComparison.Ordinal))
|
|
{
|
|
localUpload.ExternalId = incomingAttachment.ExternalId;
|
|
changed = true;
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(incomingAttachment.RemoteUrl) &&
|
|
!string.Equals(localUpload.RemoteUrl, incomingAttachment.RemoteUrl, StringComparison.Ordinal))
|
|
{
|
|
localUpload.RemoteUrl = incomingAttachment.RemoteUrl;
|
|
changed = true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static IReadOnlyList<MaxAttachmentUpdate> DistinctAttachments(IReadOnlyList<MaxAttachmentUpdate> attachments)
|
|
{
|
|
if (attachments.Count <= 1)
|
|
{
|
|
return attachments;
|
|
}
|
|
|
|
var seen = new HashSet<string>(StringComparer.Ordinal);
|
|
var result = new List<MaxAttachmentUpdate>(attachments.Count);
|
|
foreach (var attachment in attachments)
|
|
{
|
|
if (seen.Add(AttachmentIdentity(attachment)))
|
|
{
|
|
result.Add(attachment);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static string AttachmentIdentity(MaxAttachmentUpdate attachment)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(attachment.ExternalId))
|
|
{
|
|
return $"external:{attachment.ExternalId}";
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(attachment.RemoteUrl))
|
|
{
|
|
return $"remote:{attachment.RemoteUrl}";
|
|
}
|
|
|
|
return $"fallback:{attachment.Kind}:{attachment.FileName}:{attachment.SortOrder}:{attachment.TextContent?.Length ?? 0}";
|
|
}
|
|
|
|
private static async Task<MessageAttachment?> CreateAttachmentAsync(
|
|
MaxAttachmentUpdate incoming,
|
|
IMaxBridgeClient maxBridgeClient,
|
|
IAttachmentStorageService storage,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var kind = ResolveKind(incoming);
|
|
var remoteUrl = incoming.RemoteUrl;
|
|
if (!string.IsNullOrWhiteSpace(incoming.TextContent))
|
|
{
|
|
var contentType = string.IsNullOrWhiteSpace(incoming.ContentType)
|
|
? "text/vcard; charset=utf-8"
|
|
: incoming.ContentType;
|
|
var bytes = Encoding.UTF8.GetBytes(incoming.TextContent);
|
|
await using var stream = new MemoryStream(bytes);
|
|
var stored = await storage.SaveRemoteAsync(
|
|
incoming.FileName,
|
|
contentType,
|
|
stream,
|
|
bytes.Length,
|
|
kind,
|
|
cancellationToken);
|
|
|
|
return new MessageAttachment
|
|
{
|
|
ExternalId = incoming.ExternalId,
|
|
OriginalFileName = stored.OriginalFileName,
|
|
StorageFileName = stored.StorageFileName,
|
|
ContentType = stored.ContentType,
|
|
FileSizeBytes = stored.FileSizeBytes,
|
|
Sha256 = stored.Sha256,
|
|
Kind = stored.Kind,
|
|
SortOrder = incoming.SortOrder,
|
|
RemoteUrl = remoteUrl
|
|
};
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(remoteUrl))
|
|
{
|
|
try
|
|
{
|
|
var download = await maxBridgeClient.DownloadMediaAsync(remoteUrl, cancellationToken);
|
|
if (download is not null)
|
|
{
|
|
await using (download.Stream)
|
|
{
|
|
var stored = await storage.SaveRemoteAsync(
|
|
incoming.FileName,
|
|
download.ContentType,
|
|
download.Stream,
|
|
download.ContentLength ?? incoming.FileSizeBytes,
|
|
kind,
|
|
cancellationToken);
|
|
|
|
return new MessageAttachment
|
|
{
|
|
ExternalId = incoming.ExternalId,
|
|
OriginalFileName = stored.OriginalFileName,
|
|
StorageFileName = stored.StorageFileName,
|
|
ContentType = stored.ContentType,
|
|
FileSizeBytes = stored.FileSizeBytes,
|
|
Sha256 = stored.Sha256,
|
|
Kind = stored.Kind,
|
|
SortOrder = incoming.SortOrder,
|
|
RemoteUrl = remoteUrl
|
|
};
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// Non-visual files can stay as deferred downloads; inline media must be cached before it is shown.
|
|
}
|
|
|
|
if (RequiresCachedRemoteMedia(kind))
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return new MessageAttachment
|
|
{
|
|
ExternalId = incoming.ExternalId,
|
|
OriginalFileName = AttachmentStorageService.NormalizeRemoteFileName(incoming.FileName, incoming.ContentType, kind),
|
|
StorageFileName = $"remote-{Guid.NewGuid():N}",
|
|
ContentType = string.IsNullOrWhiteSpace(incoming.ContentType) ? "application/octet-stream" : incoming.ContentType,
|
|
FileSizeBytes = incoming.FileSizeBytes ?? 0,
|
|
Kind = kind ?? AttachmentKind.File,
|
|
SortOrder = incoming.SortOrder,
|
|
RemoteUrl = remoteUrl
|
|
};
|
|
}
|
|
|
|
private static MessageAttachment? FindMatchingAttachment(IEnumerable<MessageAttachment> attachments, MaxAttachmentUpdate incoming)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(incoming.ExternalId) &&
|
|
attachments.FirstOrDefault(x => string.Equals(x.ExternalId, incoming.ExternalId, StringComparison.Ordinal)) is { } externalMatch)
|
|
{
|
|
return externalMatch;
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(incoming.RemoteUrl) &&
|
|
attachments.FirstOrDefault(x => string.Equals(x.RemoteUrl, incoming.RemoteUrl, StringComparison.Ordinal)) is { } remoteMatch)
|
|
{
|
|
return remoteMatch;
|
|
}
|
|
|
|
var kind = ResolveKind(incoming) ?? AttachmentKind.File;
|
|
var normalizedFileName = AttachmentStorageService.NormalizeRemoteFileName(incoming.FileName, incoming.ContentType, kind);
|
|
return attachments.FirstOrDefault(x =>
|
|
x.SortOrder == incoming.SortOrder &&
|
|
x.Kind == kind &&
|
|
string.Equals(x.OriginalFileName, normalizedFileName, StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
|
|
private static bool ShouldDeferMediaOnlyMessage(Message message, IReadOnlyList<MaxAttachmentUpdate> incomingAttachments)
|
|
{
|
|
return incomingAttachments.Count > 0 &&
|
|
message.Attachments.Count == 0 &&
|
|
string.IsNullOrWhiteSpace(message.Text) &&
|
|
incomingAttachments.Any(attachment => RequiresCachedRemoteMedia(ResolveKind(attachment)));
|
|
}
|
|
|
|
private static bool RequiresCachedRemoteMedia(AttachmentKind? kind)
|
|
{
|
|
return kind is AttachmentKind.Image or
|
|
AttachmentKind.Gif or
|
|
AttachmentKind.Video or
|
|
AttachmentKind.VoiceNote or
|
|
AttachmentKind.Sticker;
|
|
}
|
|
|
|
private static bool IsUncachedRemotePlaceholder(MessageAttachment attachment)
|
|
{
|
|
return !string.IsNullOrWhiteSpace(attachment.RemoteUrl) &&
|
|
attachment.StorageFileName.StartsWith("remote-", StringComparison.Ordinal) &&
|
|
(attachment.FileSizeBytes <= 0 || string.IsNullOrWhiteSpace(attachment.Sha256));
|
|
}
|
|
|
|
private static async Task<bool> TryHydrateRemoteAttachmentAsync(
|
|
MessageAttachment attachment,
|
|
MaxAttachmentUpdate incoming,
|
|
IMaxBridgeClient maxBridgeClient,
|
|
IAttachmentStorageService storage,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var remoteUrl = string.IsNullOrWhiteSpace(incoming.RemoteUrl) ? attachment.RemoteUrl : incoming.RemoteUrl;
|
|
if (string.IsNullOrWhiteSpace(remoteUrl))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var kind = ResolveKind(incoming) ?? attachment.Kind;
|
|
try
|
|
{
|
|
var download = await maxBridgeClient.DownloadMediaAsync(remoteUrl, cancellationToken);
|
|
if (download is null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
await using (download.Stream)
|
|
{
|
|
var stored = await storage.SaveRemoteAsync(
|
|
incoming.FileName,
|
|
download.ContentType,
|
|
download.Stream,
|
|
download.ContentLength ?? incoming.FileSizeBytes,
|
|
kind,
|
|
cancellationToken);
|
|
|
|
attachment.ExternalId = string.IsNullOrWhiteSpace(incoming.ExternalId) ? attachment.ExternalId : incoming.ExternalId;
|
|
attachment.OriginalFileName = stored.OriginalFileName;
|
|
attachment.StorageFileName = stored.StorageFileName;
|
|
attachment.ContentType = stored.ContentType;
|
|
attachment.FileSizeBytes = stored.FileSizeBytes;
|
|
attachment.Sha256 = stored.Sha256;
|
|
attachment.Kind = stored.Kind;
|
|
attachment.SortOrder = incoming.SortOrder;
|
|
attachment.RemoteUrl = remoteUrl;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static AttachmentKind? ResolveKind(MaxAttachmentUpdate attachment)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(attachment.Kind) &&
|
|
Enum.TryParse<AttachmentKind>(attachment.Kind, ignoreCase: true, out var parsed))
|
|
{
|
|
return parsed;
|
|
}
|
|
|
|
var extension = Path.GetExtension(attachment.FileName);
|
|
return AttachmentStorageService.GuessKind(attachment.ContentType, extension);
|
|
}
|
|
|
|
private static MessageDeliveryState ResolveDeliveryState(MaxMessageUpdate incoming)
|
|
{
|
|
if (!incoming.IsOutgoing)
|
|
{
|
|
return MessageDeliveryState.Delivered;
|
|
}
|
|
|
|
return Enum.TryParse<MessageDeliveryState>(incoming.DeliveryState, ignoreCase: true, out var parsed)
|
|
? parsed
|
|
: MessageDeliveryState.Sent;
|
|
}
|
|
|
|
private static string? CleanWebUrl(string? value)
|
|
{
|
|
var trimmed = value?.Trim();
|
|
return string.IsNullOrWhiteSpace(trimmed) ? null : trimmed;
|
|
}
|
|
|
|
private static ChatKind? ResolveChatKind(string? value)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(value))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return Enum.TryParse<ChatKind>(value.Trim(), ignoreCase: true, out var parsed)
|
|
? parsed
|
|
: null;
|
|
}
|
|
|
|
private static async Task<Chat?> FindDeletedChatTombstoneAsync(
|
|
QMaxDbContext db,
|
|
MaxChatUpdate update,
|
|
string? nextWebUrl,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(update.Title))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var deletedChats = db.Chats
|
|
.Where(x => x.DeletedAt != null && x.Title == update.Title);
|
|
|
|
if (!string.IsNullOrWhiteSpace(nextWebUrl))
|
|
{
|
|
return await deletedChats.FirstOrDefaultAsync(x => x.WebUrl == nextWebUrl, cancellationToken);
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(update.AvatarUrl))
|
|
{
|
|
return await deletedChats.FirstOrDefaultAsync(x => x.AvatarUrl == update.AvatarUrl, cancellationToken);
|
|
}
|
|
|
|
var titleMatches = await deletedChats
|
|
.OrderByDescending(x => x.DeletedAt)
|
|
.Take(2)
|
|
.ToListAsync(cancellationToken);
|
|
return titleMatches.Count == 1 ? titleMatches[0] : null;
|
|
}
|
|
|
|
private static string? LastMessagePreview(string? text, IEnumerable<MessageAttachment> attachments)
|
|
{
|
|
var orderedAttachments = attachments.OrderBy(x => x.SortOrder).ToArray();
|
|
if (!string.IsNullOrWhiteSpace(text) &&
|
|
(orderedAttachments.Length == 0 || !MessageTextSanitizer.IsGenericAttachmentLabel(text)))
|
|
{
|
|
return MessageTextSanitizer.CleanChatPreview(text);
|
|
}
|
|
|
|
var first = orderedAttachments.FirstOrDefault();
|
|
return first?.Kind switch
|
|
{
|
|
AttachmentKind.Image => "\u041c\u0435\u0434\u0438\u0430",
|
|
AttachmentKind.Gif => "\u041c\u0435\u0434\u0438\u0430",
|
|
AttachmentKind.Video => "\u041c\u0435\u0434\u0438\u0430",
|
|
AttachmentKind.VoiceNote => "\u0413\u043e\u043b\u043e\u0441\u043e\u0432\u043e\u0435 \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0435",
|
|
AttachmentKind.Sticker => "\u041c\u0435\u0434\u0438\u0430",
|
|
AttachmentKind.Contact => "\u041a\u043e\u043d\u0442\u0430\u043a\u0442",
|
|
AttachmentKind.File => first.OriginalFileName,
|
|
_ => null
|
|
};
|
|
}
|
|
|
|
private static MaxBridgeStatusDto ToDto(MaxBridgeStatus status)
|
|
{
|
|
return new MaxBridgeStatusDto(status.Mode, status.IsAuthorized, status.LoginStage, status.Status, status.Url, status.Title, status.LastError, status.UpdatedAt);
|
|
}
|
|
|
|
private sealed record LastKnownMessageSnapshot(
|
|
MessageDirection Direction,
|
|
string? Text,
|
|
string? Preview,
|
|
bool HasAttachments,
|
|
DateTimeOffset SentAt);
|
|
}
|