Add reactions, reliable push & session checks

Implements message reactions and reaction packs (domain models, services, admin HTTP API, media processing via ImageSharp and limits) and adds reliable push delivery (ChatPushNotification, ChatPushDispatcher, ChatPushWorker, improved ChatNotificationService). Enhances message reading (ReadChat API, unread counts, concurrency-safe receipts) and tightens session security (access-token session validation in JWT, hub filter, SessionAuthorization). Improves SignalR behavior (session groups, reaction/channel events, hub/error mappings). Adds EF migrations, many controller fixes (Forbid handling, password API), tests (Govor.Server.Tests), docs, CI and tooling updates (Dockerfile → .NET 10, GH Actions matrix for sqlite/postgres, Govor.Server.slnx, global.json), and small infra changes (AutoMapper bump, NullPushProvider, storage/token handling).
This commit is contained in:
Artemy
2026-10-03 17:42:24 +07:00
parent 4603be9f71
commit 29cc51ee0c
127 changed files with 7290 additions and 2488 deletions
+24
View File
@@ -0,0 +1,24 @@
using Govor.Domain;
using Govor.Domain.Models.Messages;
using Microsoft.EntityFrameworkCore;
namespace Govor.Application.Messages;
public static class ChatAccess
{
public static Task<bool> HasChatAccessAsync(this GovorDbContext context,
Guid userId, Guid chatId, RecipientType type)
{
if (userId == Guid.Empty || chatId == Guid.Empty)
return Task.FromResult(false);
return type switch
{
RecipientType.User => context.PrivateChats.AnyAsync(c => c.Id == chatId &&
(c.UserAId == userId || c.UserBId == userId)),
RecipientType.Group => context.GroupMemberships.AnyAsync(m =>
m.GroupId == chatId && m.UserId == userId && !m.IsBanned),
_ => Task.FromResult(false)
};
}
}
@@ -1,10 +1,14 @@
using Govor.Domain.Common;
using Govor.Domain.Models.Messages;
using SmartRes;
using ChatReadResult = Govor.Application.Messages.Parameters.ChatReadResult;
namespace Govor.Application.Messages;
public interface IMessageReadingService
{
Task<Result<Message, Error>> ReadMessageAsync(Guid readerId, Guid messageId);
}
Task<Result<ChatReadResult, Error>> ReadChatAsync(Guid readerId, Guid chatId,
RecipientType type, IReadOnlyCollection<Guid>? messageIds = null, Guid? upToMessageId = null);
Task<Result<int, Error>> GetUnreadCountAsync(Guid readerId, Guid chatId, RecipientType type);
}
@@ -37,7 +37,8 @@ public class MessageEditingService : IMessageEditingService
null);
}
if (message.SenderId != editParams.EditorId)
if (message.SenderId != editParams.EditorId || !await _dbContext.HasChatAccessAsync(
editParams.EditorId, message.RecipientId, message.RecipientType))
{
_logger.LogWarning(
"User {EditorId} unauthorized to edit message {MessageId}",
@@ -52,7 +53,7 @@ public class MessageEditingService : IMessageEditingService
}
// Проверяем время, прошедшее с момента отправки
var now = DateTime.UtcNow;
var now = editParams.EditedAt;
var editDeadline = message.SentAt.AddMinutes(
_options.MaxEditTimeMinutes);
@@ -83,6 +84,10 @@ public class MessageEditingService : IMessageEditingService
MediaAttachments = message.MediaAttachments?.ToList() ?? []
};
if (editParams.NewContent is null || editParams.NewContent.Length > 50_000 ||
(string.IsNullOrWhiteSpace(editParams.NewContent) && message.MediaAttachments.Count == 0))
return new EditMessageResult(false, new ArgumentException("Invalid message content."), null);
message.EncryptedContent = editParams.NewContent;
message.IsEdited = true;
message.EditedAt = editParams.EditedAt;
@@ -98,4 +103,4 @@ public class MessageEditingService : IMessageEditingService
null,
originalMessageSnapshot);
}
}
}
@@ -1,4 +1,5 @@
using Govor.Application.Infrastructure.Common;
using ChatReadResult = Govor.Application.Messages.Parameters.ChatReadResult;
using Govor.Domain;
using Govor.Domain.Common;
using Govor.Domain.Models.Messages;
@@ -14,10 +15,7 @@ public class MessageReadingService : IMessageReadingService
private readonly ILogger<MessageReadingService> _logger;
private readonly INowDateTimeProvider _dateTimeProvider;
public MessageReadingService(
GovorDbContext dbContext,
ILogger<MessageReadingService> logger,
public MessageReadingService(GovorDbContext dbContext, ILogger<MessageReadingService> logger,
INowDateTimeProvider dateTimeProvider)
{
_dbContext = dbContext;
@@ -27,46 +25,127 @@ public class MessageReadingService : IMessageReadingService
public async Task<Result<Message, Error>> ReadMessageAsync(Guid readerId, Guid messageId)
{
var message = await _dbContext.Messages
.Include(msg => msg.MessageViews)
.FirstOrDefaultAsync(msg => msg.Id == messageId);
if(message is null)
return Result<Message, Error>.Failure(Error.NotFound(
"Message not found",
"Message with id: " + messageId + " was not found.")
);
var message = await _dbContext.Messages.AsNoTracking()
.FirstOrDefaultAsync(m => m.Id == messageId);
if (message is null)
return Result.Failure<Message>(Error.NotFound("Message.NotFound", "Message not found."));
if (CanReadMessage(readerId, message))
{
var view = new MessageView()
{
Id = Guid.NewGuid(),
MessageId = messageId,
UserId = readerId,
ViewedAt = _dateTimeProvider.Now,
};
_dbContext.MessageViews.Add(view);
await _dbContext.SaveChangesAsync();
_logger.LogInformation("Message with id: {Id} was read by user {user} at {time}", view.Id, view.UserId, view.ViewedAt);
}
return message;
var result = await ReadChatAsync(readerId, message.RecipientId,
message.RecipientType, new[] { messageId });
if (result.IsFailure)
return Result.Failure<Message>(result.Error);
// Fresh query also returns the existing receipt on repeated calls.
var readMessage = await _dbContext.Messages.AsNoTracking().Include(m => m.MessageViews)
.FirstOrDefaultAsync(m => m.Id == messageId);
return readMessage is null
? Result.Failure<Message>(Error.NotFound("Message.NotFound", "Message was removed."))
: Result<Message, Error>.Success(readMessage);
}
private bool CanReadMessage(Guid readerId, Message message)
public async Task<Result<ChatReadResult, Error>> ReadChatAsync(Guid readerId, Guid chatId,
RecipientType type, IReadOnlyCollection<Guid>? messageIds = null, Guid? upToMessageId = null)
{
if (message.RecipientType == RecipientType.User)
if (!await _dbContext.HasChatAccessAsync(readerId, chatId, type))
return Result.Failure<ChatReadResult>(Denied());
if (messageIds is not null && (messageIds.Count == 0 || messageIds.Count > 100 ||
messageIds.Contains(Guid.Empty) || upToMessageId.HasValue))
return Result.Failure<ChatReadResult>(Error.Validation("Message.Read.InvalidSelection",
"Provide 1 to 100 message IDs or an inclusive message boundary, not both."));
var chat = _dbContext.Messages.AsNoTracking()
.Where(m => m.RecipientId == chatId && m.RecipientType == type);
Guid[]? ids = messageIds?.Distinct().ToArray();
Message? boundary = null;
if (ids is not null)
{
return _dbContext.PrivateChats.Any(pr => pr.UserAId == readerId || pr.UserBId == readerId) &&
message.MessageViews.All(mv => mv.UserId != readerId);
// Validate the whole selection before writing any receipt.
if (await chat.CountAsync(m => ids.Contains(m.Id)) != ids.Length)
return Result.Failure<ChatReadResult>(Error.NotFound("Message.Read.InvalidSelection",
"One or more messages do not belong to this chat."));
if (await chat.AnyAsync(m => ids.Contains(m.Id) && m.SenderId == readerId))
return Result.Failure<ChatReadResult>(Error.Validation("Message.Read.OwnMessage",
"Only incoming messages can be marked as read."));
}
else
{
return false;
boundary = upToMessageId.HasValue
? await chat.FirstOrDefaultAsync(m => m.Id == upToMessageId.Value)
: await chat.OrderByDescending(m => m.SentAt).ThenByDescending(m => m.Id)
.FirstOrDefaultAsync();
if (upToMessageId.HasValue && boundary is null)
return Result.Failure<ChatReadResult>(Error.NotFound("Message.Read.BoundaryNotFound",
"The boundary message does not belong to this chat."));
}
var readAt = _dateTimeProvider.Now;
var readCount = 0;
var selected = chat.Where(m => m.SenderId != readerId);
if (ids is not null)
selected = selected.Where(m => ids.Contains(m.Id));
else if (boundary is not null)
{
var sentAt = boundary.SentAt;
var id = boundary.Id;
selected = selected.Where(m => m.SentAt < sentAt ||
(m.SentAt == sentAt && m.Id.CompareTo(id) <= 0));
}
else
selected = selected.Where(m => false);
// Small bounded batches; PostgreSQL/SQLite ON CONFLICT handles concurrent devices
// against the existing unique (MessageId, UserId) index without losing receipts.
while (true)
{
var pending = await selected.Where(m => !_dbContext.MessageViews
.Any(v => v.MessageId == m.Id && v.UserId == readerId))
.Select(m => m.Id).Take(200).ToListAsync();
if (pending.Count == 0)
break;
var values = new List<string>();
var parameters = new List<object>();
using var command = _dbContext.Database.GetDbConnection().CreateCommand();
foreach (var id in pending)
{
var names = new List<string>();
foreach (var value in new object[] { Guid.NewGuid(), id, readerId, readAt })
{
var parameter = command.CreateParameter();
parameter.ParameterName = "p" + parameters.Count;
parameter.Value = value;
parameters.Add(parameter);
names.Add("@" + parameter.ParameterName);
}
values.Add("SELECT " + string.Join(", ", names) +
" WHERE EXISTS (SELECT 1 FROM \"Messages\" WHERE \"Id\" = " + names[1] + ")");
}
var sql = "INSERT INTO \"MessageViews\" (\"Id\", \"MessageId\", \"UserId\", \"ViewedAt\") " +
string.Join(" UNION ALL ", values) + " ON CONFLICT (\"MessageId\", \"UserId\") DO NOTHING";
readCount += await _dbContext.Database.ExecuteSqlRawAsync(sql, parameters);
}
var unreadCount = await CountUnreadAsync(readerId, chat);
_logger.LogInformation("User {ReaderId} marked {Count} messages read in chat {ChatId}",
readerId, readCount, chatId);
return new ChatReadResult(chatId, type, readerId, readAt,
boundary?.Id, boundary?.SentAt, ids, readCount, unreadCount);
}
}
public async Task<Result<int, Error>> GetUnreadCountAsync(Guid readerId, Guid chatId, RecipientType type)
{
if (!await _dbContext.HasChatAccessAsync(readerId, chatId, type))
return Result.Failure<int>(Denied());
return await CountUnreadAsync(readerId, _dbContext.Messages.AsNoTracking()
.Where(m => m.RecipientId == chatId && m.RecipientType == type));
}
private Task<int> CountUnreadAsync(Guid readerId, IQueryable<Message> chat) =>
chat.CountAsync(m => m.SenderId != readerId &&
!_dbContext.MessageViews.Any(v => v.MessageId == m.Id && v.UserId == readerId));
private static Error Denied() => Error.Forbidden("Chat.AccessDenied",
"You are not a member of this chat.");
}
@@ -1,4 +1,4 @@
using Govor.Application.Messages.Parameters;
using DeleteMessage = Govor.Application.Messages.Parameters.DeleteMessage;
using Govor.Domain;
using Govor.Domain.Common;
using Govor.Domain.Models.Messages;
@@ -13,75 +13,38 @@ public class MessageRemovingService : IMessageRemovingService
private readonly GovorDbContext _govorDbContext;
private readonly ILogger<MessageRemovingService> _logger;
public MessageRemovingService
(GovorDbContext govorDbContext,
ILogger<MessageRemovingService> logger)
public MessageRemovingService(GovorDbContext govorDbContext, ILogger<MessageRemovingService> logger)
{
_govorDbContext = govorDbContext;
_logger = logger;
}
public async Task<Result<Message,Error>> DeleteMessageAsync(DeleteMessage deleteParams)
public async Task<Result<Message, Error>> DeleteMessageAsync(DeleteMessage deleteParams)
{
var message = await _govorDbContext.Messages.FirstOrDefaultAsync(m => m.Id == deleteParams.MessageId);
if (message == null)
return Result<Message, Error>.Failure(
Error.NotFound(
"MessageRemoving",
"Message with given id doesn't exist")
);
var message = await _govorDbContext.Messages.FirstOrDefaultAsync(m => m.Id == deleteParams.MessageId);
if (message is null)
return Result.Failure<Message>(Error.NotFound("Message.NotFound", "Message not found."));
var result = message.RecipientType switch
{
RecipientType.Group => await ValidateGroupRecipientAsync(message, deleteParams),
RecipientType.User => await ValidateUserRecipientAsync(message, deleteParams),
_ => Result<Message, Error>.Failure(Error.Failure(
"MessageRemoving.ArgumentOutOfRangeException",
$"Argument out of range: {nameof(message.RecipientType)}"
)
)
};
return result;
}
if (!await _govorDbContext.HasChatAccessAsync(deleteParams.DeleterId,
message.RecipientId, message.RecipientType))
return Result.Failure<Message>(Error.Forbidden("Chat.AccessDenied", "You are not a member of this chat."));
private async Task<Result<Message,Error>> ValidateGroupRecipientAsync(Message message, DeleteMessage deleteParams)
{
if (deleteParams.DeleterId == message.RecipientId)
{
return await ForceRemoveAsync(message);
}
else
{
// TODO made admin rules
return Result<Message, Error>.Failure(Error.Failure("MessageRemoving.HaveNoPermission",
$"You do not have permission to delete message {message.Id}"
));
}
}
// Do not silently turn a local hide into deletion for everyone.
if (!deleteParams.ForceRemove)
return Result.Failure<Message>(Error.Validation("Message.HideNotSupported",
"HideForMe is not supported. Use ForceRemove to delete a message for everyone."));
private async Task<Result<Message,Error>> ValidateUserRecipientAsync(Message message, DeleteMessage deleteParams)
{
if (deleteParams.DeleterId == message.SenderId)
{
return await ForceRemoveAsync(message);
}
else
{
// TODO made hide rules
return Result<Message, Error>.Failure(Error.Failure("MessageRemoving.HaveNoPermission",
$"You do not have permission to delete message {message.Id}"
));
}
}
var canDelete = message.SenderId == deleteParams.DeleterId ||
(message.RecipientType == RecipientType.Group &&
await _govorDbContext.GroupAdmins.AnyAsync(a =>
a.GroupId == message.RecipientId && a.UserId == deleteParams.DeleterId));
if (!canDelete)
return Result.Failure<Message>(Error.Forbidden("Message.Remove.AccessDenied",
"Only the author or a group administrator can delete this message."));
private async Task<Result<Message, Error>> ForceRemoveAsync(Message message)
{
_govorDbContext.Messages.Remove(message);
await _govorDbContext.SaveChangesAsync();
_logger.LogInformation("Message {MessageId} removed by {UserId}", message.Id, deleteParams.DeleterId);
return message;
}
}
}
@@ -2,6 +2,7 @@ using Govor.Application.Messages.Parameters;
using Microsoft.EntityFrameworkCore;
using Govor.Domain;
using Govor.Domain.Models.Messages;
using Govor.Domain.Models;
using Microsoft.Extensions.Logging;
namespace Govor.Application.Messages;
@@ -19,9 +20,14 @@ public class MessageSendingService : IMessageSendingService
public async Task<SendMessageResult> SendMessageAsync(SendMessage sendParams)
{
var media = sendParams.Media?.ToArray() ?? [];
if ((string.IsNullOrWhiteSpace(sendParams.EncryptContent) && media.Length == 0) ||
(sendParams.EncryptContent?.Length ?? 0) > 50_000 || media.Length > 100)
return new SendMessageResult(false, new ArgumentException("Invalid message content or attachment count."), default);
var validationResult = sendParams.RecipientType switch
{
RecipientType.User => await ValidateUserRecipientAsync(sendParams.RecipientId),
RecipientType.User => await ValidateUserRecipientAsync(sendParams.FromUserId, sendParams.RecipientId),
RecipientType.Group => await ValidateGroupRecipientAsync(sendParams.FromUserId, sendParams.RecipientId),
_ => (Success: false, Error: "Invalid recipient type.")
};
@@ -29,9 +35,20 @@ public class MessageSendingService : IMessageSendingService
if (!validationResult.Success)
{
_logger.LogWarning("Message send failed: {Error}", validationResult.Error);
return new SendMessageResult(false, new InvalidOperationException(validationResult.Error), default);
return new SendMessageResult(false, new UnauthorizedAccessException(validationResult.Error), default);
}
var mediaIds = media.Select(m => m.MediaId).Distinct().ToArray();
var files = await _dbContext.MediaFiles.Where(m => mediaIds.Contains(m.Id) &&
m.UploaderId == sendParams.FromUserId && m.OwnerType == MediaOwnerType.Message).ToListAsync();
if (files.Count != mediaIds.Length)
return new SendMessageResult(false, new UnauthorizedAccessException("Invalid media ownership."), default);
if (sendParams.ReplyToMessageId.HasValue && !await _dbContext.Messages.AnyAsync(m =>
m.Id == sendParams.ReplyToMessageId && m.RecipientId == sendParams.RecipientId &&
m.RecipientType == sendParams.RecipientType))
return new SendMessageResult(false, new ArgumentException("Reply must belong to the same chat."), default);
var messageId = Guid.NewGuid();
var message = new Message
{
@@ -39,38 +56,51 @@ public class MessageSendingService : IMessageSendingService
SenderId = sendParams.FromUserId,
RecipientId = sendParams.RecipientId,
RecipientType = sendParams.RecipientType,
EncryptedContent = sendParams.EncryptContent,
EncryptedContent = sendParams.EncryptContent ?? string.Empty,
SentAt = sendParams.SendAt,
IsEdited = false,
ReplyToMessageId = sendParams.ReplyToMessageId,
MediaAttachments = sendParams.Media?.Select(m => new MediaAttachments
MediaAttachments = files.Select(file => new MediaAttachments
{
Id = Guid.NewGuid(),
MessageId = messageId,
MediaFileId = m.MediaId
}).ToList() ?? []
MediaFileId = file.Id,
MediaFile = file
}).ToList()
};
await _dbContext.Messages.AddAsync(message);
// Save message and pending push atomically so a restart/provider outage cannot lose the push.
_dbContext.ChatPushNotifications.Add(new ChatPushNotification
{ MessageId = messageId, NextAttemptAt = DateTime.UtcNow });
await _dbContext.SaveChangesAsync();
_logger.LogInformation("Message {MessageId} sent successfully.", messageId);
return new SendMessageResult(true, null, message);
}
private async Task<(bool Success, string Error)> ValidateUserRecipientAsync(Guid chatId)
private async Task<(bool Success, string Error)> ValidateUserRecipientAsync(Guid userId, Guid chatId)
{
var chatExists = await _dbContext.PrivateChats.AnyAsync(c => c.Id == chatId);
return chatExists ? (true, null) : (false, $"Private chat {chatId} not found.");
var chat = await _dbContext.PrivateChats.AsNoTracking().FirstOrDefaultAsync(c => c.Id == chatId &&
(c.UserAId == userId || c.UserBId == userId));
if (chat is null)
return (false, "You are not a member of this chat.");
var blocked = await _dbContext.Friendships.AnyAsync(f => f.Status == FriendshipStatus.Blocked &&
((f.RequesterId == chat.UserAId && f.AddresseeId == chat.UserBId) ||
(f.RequesterId == chat.UserBId && f.AddresseeId == chat.UserAId)));
return blocked ? (false, "This conversation is blocked.") : (true, null);
}
private async Task<(bool Success, string Error)> ValidateGroupRecipientAsync(Guid userId, Guid groupId)
{
var groupExists = await _dbContext.ChatGroups.AnyAsync(g => g.Id == groupId);
if (!groupExists) return (false, $"Group {groupId} not found.");
var group = await _dbContext.ChatGroups.AsNoTracking().FirstOrDefaultAsync(g => g.Id == groupId);
if (group is null) return (false, "Group not found.");
var isMember = await _dbContext.GroupMemberships.AnyAsync(gm => gm.UserId == userId && gm.GroupId == groupId);
var isMember = await _dbContext.GroupMemberships.AnyAsync(gm => gm.UserId == userId && gm.GroupId == groupId && !gm.IsBanned);
if (!isMember) return (false, "Sender is not a member of the group.");
if (group.IsChannel && !await _dbContext.GroupAdmins.AnyAsync(a =>
a.GroupId == groupId && a.UserId == userId))
return (false, "Only channel administrators can send messages.");
return (true, null);
}
+17 -8
View File
@@ -26,12 +26,13 @@ public class MessagesLoader : IMessagesLoader
if (privateChatId == Guid.Empty)
return Result.Failure<List<Message>>(Error.Failure(nameof(ArgumentException),"PrivateChatId id cannot be empty."));
var chatExists = await _dbContext.PrivateChats.AnyAsync(c => c.Id == privateChatId);
if (!chatExists)
return new List<Message>(0);
if (!await _dbContext.HasChatAccessAsync(currentUser, privateChatId, RecipientType.User))
return Result.Failure<List<Message>>(Error.Forbidden("Chat.AccessDenied", "You are not a member of this chat."));
var query = _dbContext.Messages
.AsNoTracking()
.Include(m => m.MessageViews)
.Include(m => m.Reactions)
.Include(m => m.MediaAttachments)
.ThenInclude(m => m.MediaFile)
.Where(m => m.RecipientType == RecipientType.User && m.RecipientId == privateChatId);
@@ -50,13 +51,15 @@ public class MessagesLoader : IMessagesLoader
return Result.Failure<List<Message>>(Error.Failure(nameof(ArgumentException),"Chat id cannot be empty."));
var isMember = await _dbContext.GroupMemberships
.AnyAsync(gm => gm.UserId == currentUser && gm.GroupId == chatId);
.AnyAsync(gm => gm.UserId == currentUser && gm.GroupId == chatId && !gm.IsBanned);
if (!isMember)
return new List<Message>(0);
if (!isMember)
return Result.Failure<List<Message>>(Error.Forbidden("Chat.AccessDenied", "You are not a member of this chat."));
var query = _dbContext.Messages
.AsNoTracking()
.Include(m => m.MessageViews)
.Include(m => m.Reactions)
.Include(m => m.MediaAttachments)
.ThenInclude(m => m.MediaFile)
.AsSplitQuery()
@@ -75,8 +78,10 @@ public class MessagesLoader : IMessagesLoader
{
return await baseQuery
.OrderByDescending(m => m.SentAt)
.ThenByDescending(m => m.Id)
.Take(before)
.OrderBy(m => m.SentAt)
.ThenBy(m => m.Id)
.ToListAsync();
}
@@ -85,14 +90,18 @@ public class MessagesLoader : IMessagesLoader
return [];
var beforeMessages = await baseQuery
.Where(m => m.SentAt < startMessage.SentAt)
.Where(m => m.SentAt < startMessage.SentAt ||
(m.SentAt == startMessage.SentAt && m.Id.CompareTo(startMessage.Id) < 0))
.OrderByDescending(m => m.SentAt)
.ThenByDescending(m => m.Id)
.Take(before)
.ToListAsync();
var afterMessages = await baseQuery
.Where(m => m.SentAt > startMessage.SentAt)
.Where(m => m.SentAt > startMessage.SentAt ||
(m.SentAt == startMessage.SentAt && m.Id.CompareTo(startMessage.Id) > 0))
.OrderBy(m => m.SentAt)
.ThenBy(m => m.Id)
.Take(after)
.ToListAsync();
@@ -0,0 +1,7 @@
using Govor.Domain.Models.Messages;
namespace Govor.Application.Messages.Parameters;
public record ChatReadResult(Guid ChatId, RecipientType RecipientType, Guid ReaderId,
DateTime ReadAt, Guid? UpToMessageId, DateTime? UpToSentAt,
IReadOnlyList<Guid>? MessageIds, int ReadCount, int UnreadCount);