Українська
Сервіс чатів
Крок 1. DTO та перевірка вхідних даних
Навіщо. Чати показують трьома способами: повністю (ChatDto, заголовок і панель відомостей розмови), як рядок списку чатів (ChatListItemDto) і як результат пошуку (ChatSummaryDto). Кожне DTO несе лише те, що потрібне його екрану. ChatDto.MyRole дорівнює null, коли викликач переглядає публічний чат, не будучи учасником, – тоді клієнт показує кнопку «Приєднатися» замість поля введення повідомлення.
Що зробити.
cs
using Chatex.Core.Users;
using Chatex.Data.Entities;
using Chatex.Data.Models;
namespace Chatex.Core.Chats;
/// <param name="MyRole">Null when the caller is not a member (viewing a public chat).</param>
/// <param name="Peer">The other user of a direct chat; null for groups and channels.</param>
public sealed record ChatDto(
Guid Id,
ChatType Type,
string? Title,
string? Description,
string? PublicHandle,
bool HasAvatar,
DateTimeOffset CreatedAt,
int MemberCount,
ChatMemberRole? MyRole,
bool IsMuted,
UserSummaryDto? Peer);
public sealed record ChatListItemDto(
Guid Id,
ChatType Type,
string? Title,
bool HasAvatar,
DateTimeOffset LastActivityAt,
ChatMemberRole MyRole,
bool IsMuted,
MessagePreviewDto? LastMessage,
int UnreadCount,
UserSummaryDto? Peer);
/// <summary>A public group or channel found by search.</summary>
public sealed record ChatSummaryDto(
Guid Id,
ChatType Type,
string? Title,
string? Description,
string? PublicHandle,
bool HasAvatar);
public sealed record MessagePreviewDto(Guid Id, Guid SenderId, string Body, DateTimeOffset CreatedAt);
public sealed record ChatMemberDto(UserSummaryDto User, ChatMemberRole Role, DateTimeOffset JoinedAt);
/// <param name="Type">Group or Channel; direct chats are opened with <c>OpenDirectAsync</c>.</param>
/// <param name="PublicHandle">Makes the chat public and findable; null keeps it private.</param>
/// <param name="MemberIds">Users to add besides the creator.</param>
public sealed record CreateChatCommand(
ChatType Type,
string Title,
string? Description = null,
string? PublicHandle = null,
IReadOnlyList<Guid>? MemberIds = null);
/// <summary>Replaces the chat's info; a null handle makes the chat private.</summary>
public sealed record UpdateChatCommand(string Title, string? Description, string? PublicHandle);
internal static class ChatMappings
{
public static ChatListItemDto ToDto(this ChatListItem item) => new(
item.Chat.Id,
item.Chat.Type,
item.Chat.Title,
item.Chat.AvatarPath is not null,
item.Chat.LastActivityAt,
item.Role,
item.IsMuted,
item.LastMessage is { } m ? new MessagePreviewDto(m.Id, m.SenderId, m.Body, m.CreatedAt) : null,
item.UnreadCount,
item.Peer?.ToDto());
public static ChatSummaryDto ToSummaryDto(this Chat chat) =>
new(chat.Id, chat.Type, chat.Title, chat.Description, chat.PublicHandle, chat.AvatarPath is not null);
public static ChatMemberDto ToDto(this ChatMember member) =>
new(member.User.ToSummaryDto(), member.Role, member.JoinedAt);
}cs
using Chatex.Core.Common;
using Chatex.Data.Entities;
using FluentValidation;
namespace Chatex.Core.Chats;
internal sealed class CreateChatCommandValidator : AbstractValidator<CreateChatCommand>
{
public CreateChatCommandValidator()
{
RuleFor(c => c.Type)
.Must(t => t is ChatType.Group or ChatType.Channel)
.WithMessage("Only groups and channels can be created; open direct chats instead.");
RuleFor(c => c.Title).NotEmpty().MaximumLength(ChatLimits.MaxTitle);
RuleFor(c => c.Description).MaximumLength(ChatLimits.MaxDescription);
RuleFor(c => c.PublicHandle).Handle(5, 32);
RuleFor(c => c.MemberIds)
.Must(ids => ids is null || ids.Count < ChatLimits.MaxGroupMembers)
.WithMessage($"A chat can start with at most {ChatLimits.MaxGroupMembers - 1} other members.");
}
}
internal sealed class UpdateChatCommandValidator : AbstractValidator<UpdateChatCommand>
{
public UpdateChatCommandValidator()
{
RuleFor(c => c.Title).NotEmpty().MaximumLength(ChatLimits.MaxTitle);
RuleFor(c => c.Description).MaximumLength(ChatLimits.MaxDescription);
RuleFor(c => c.PublicHandle).Handle(5, 32);
}
}- Створювати можна лише групи й канали. Особистий чат відкривають за ідентифікатором іншого користувача; правило типу каже про це у своєму повідомленні.
- Псевдоніми чатів мають 5–32 символи (користувачів – 3–32) і використовують те саме правило
Handleіз теми 7;nullозначає приватний чат. - Новий чат може починатися щонайбільше з 999 інших учасників – разом зі створювачем це дає обмеження групи в 1000.
Крок 2. Сервіс
Що зробити. Сервіс – найдовший файл бізнес-рівня, але кожен його метод має знайому вам форму: перевірити вхідні дані, завантажити з правилами доступу, перевірити дозволи, змінити, зберегти, сповістити, відобразити.
cs
using Chatex.Core.Abstractions;
using Chatex.Core.Common;
using Chatex.Core.Messages;
using Chatex.Core.Users;
using Chatex.Data.Abstractions;
using Chatex.Data.Entities;
using Chatex.Data.Exceptions;
using Chatex.Data.Models;
using FluentValidation;
namespace Chatex.Core.Chats;
public interface IChatService
{
/// <summary>Returns the direct chat with <paramref name="otherUserId"/>, creating it on first use.</summary>
Task<Result<ChatDto>> OpenDirectAsync(Guid userId, Guid otherUserId, CancellationToken cancellationToken = default);
/// <summary>Creates a group or channel owned by the caller.</summary>
Task<Result<ChatDto>> CreateAsync(Guid userId, CreateChatCommand command, CancellationToken cancellationToken = default);
Task<Result<ChatDto>> GetAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default);
/// <summary>The caller's chats, most recently active first.</summary>
Task<Result<PageDto<ChatListItemDto>>> GetMyChatsAsync(
Guid userId, string? cursor, int? limit, CancellationToken cancellationToken = default);
Task<Result<ChatSummaryDto[]>> SearchPublicAsync(string query, int? limit, CancellationToken cancellationToken = default);
Task<Result<ChatDto>> UpdateAsync(Guid userId, Guid chatId, UpdateChatCommand command, CancellationToken cancellationToken = default);
Task<Result<ChatDto>> SetAvatarAsync(Guid userId, Guid chatId, FileUpload upload, CancellationToken cancellationToken = default);
Task<Result<ChatDto>> RemoveAvatarAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default);
Task<Result<Stream>> OpenAvatarAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default);
/// <summary>Owner only. The chat disappears for everyone.</summary>
Task<Result> DeleteAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default);
/// <summary>Joins a public group or channel. Joining twice is not an error.</summary>
Task<Result<ChatDto>> JoinAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default);
Task<Result> LeaveAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default);
/// <summary>Adds users to a group or channel; returns how many were not members yet.</summary>
Task<Result<int>> AddMembersAsync(
Guid userId, Guid chatId, IReadOnlyList<Guid> userIds, CancellationToken cancellationToken = default);
Task<Result> RemoveMemberAsync(Guid userId, Guid chatId, Guid memberUserId, CancellationToken cancellationToken = default);
/// <summary>Owner only. Giving someone <see cref="ChatMemberRole.Owner"/> transfers ownership; the caller becomes an admin.</summary>
Task<Result> ChangeRoleAsync(
Guid userId, Guid chatId, Guid memberUserId, ChatMemberRole role, CancellationToken cancellationToken = default);
Task<Result<PageDto<ChatMemberDto>>> GetMembersAsync(
Guid userId, Guid chatId, string? cursor, int? limit, CancellationToken cancellationToken = default);
Task<Result> SetMutedAsync(Guid userId, Guid chatId, bool muted, CancellationToken cancellationToken = default);
/// <summary>Moves the caller's read position forward to <paramref name="messageId"/>; never backwards.</summary>
Task<Result> MarkReadAsync(Guid userId, Guid chatId, Guid messageId, CancellationToken cancellationToken = default);
/// <summary>Ids of all the user's chats; the SignalR hub joins their groups on connect.</summary>
Task<IReadOnlyList<Guid>> GetMyChatIdsAsync(Guid userId, CancellationToken cancellationToken = default);
Task<bool> IsMemberAsync(Guid chatId, Guid userId, CancellationToken cancellationToken = default);
}
internal sealed class ChatService(
IChatRepository chats,
IChatMemberRepository members,
IUserRepository users,
IMessageRepository messages,
IUnitOfWork unitOfWork,
IFileStorage storage,
ChatAccess chatAccess,
AvatarStore avatars,
IChatNotifier notifier,
TimeProvider timeProvider,
IValidator<CreateChatCommand> createValidator,
IValidator<UpdateChatCommand> updateValidator) : IChatService
{
private const int MinQueryLength = 2;
public async Task<Result<ChatDto>> OpenDirectAsync(Guid userId, Guid otherUserId, CancellationToken cancellationToken = default)
{
if (userId == otherUserId)
{
return ChatErrors.DirectWithSelf;
}
if ((await users.GetExistingIdsAsync([otherUserId], cancellationToken)).Count == 0)
{
return UserErrors.NotFound;
}
var chat = await chats.GetDirectAsync(userId, otherUserId, cancellationToken);
if (chat is null)
{
chat = new Chat
{
Type = ChatType.Direct,
DirectKey = Chat.MakeDirectKey(userId, otherUserId),
CreatedById = userId,
};
chat.Members.Add(new ChatMember { UserId = userId, Role = ChatMemberRole.Member });
chat.Members.Add(new ChatMember { UserId = otherUserId, Role = ChatMemberRole.Member });
chats.Add(chat);
try
{
await unitOfWork.SaveChangesAsync(cancellationToken);
await notifier.MembersAddedAsync(chat.Id, [userId, otherUserId], cancellationToken);
}
catch (UniqueConstraintException)
{
// A concurrent request created the chat first; use that one.
chat = await chats.GetDirectAsync(userId, otherUserId, cancellationToken)
?? throw new InvalidOperationException("The direct chat exists but could not be loaded.");
}
}
var member = await members.GetAsync(chat.Id, userId, cancellationToken);
return await ToDtoAsync(chat, member, userId, cancellationToken);
}
public async Task<Result<ChatDto>> CreateAsync(Guid userId, CreateChatCommand command, CancellationToken cancellationToken = default)
{
if (await createValidator.ValidateToErrorAsync(command, cancellationToken) is { } invalid)
{
return invalid;
}
var memberIds = (command.MemberIds ?? []).Where(id => id != userId).Distinct().ToList();
if (memberIds.Count > 0 && (await users.GetExistingIdsAsync(memberIds, cancellationToken)).Count != memberIds.Count)
{
return ChatErrors.UnknownUsers;
}
var handle = command.PublicHandle?.ToLowerInvariant();
if (handle is not null && await chats.GetByHandleAsync(handle, cancellationToken) is not null)
{
return ChatErrors.HandleTaken;
}
var chat = new Chat
{
Type = command.Type,
Title = command.Title.Trim(),
Description = NullIfBlank(command.Description),
PublicHandle = handle,
CreatedById = userId,
};
var owner = new ChatMember { UserId = userId, Role = ChatMemberRole.Owner };
chat.Members.Add(owner);
var role = ChatPermissions.RegularRole(command.Type);
foreach (var memberId in memberIds)
{
chat.Members.Add(new ChatMember { UserId = memberId, Role = role });
}
chats.Add(chat);
try
{
await unitOfWork.SaveChangesAsync(cancellationToken);
}
catch (UniqueConstraintException)
{
return ChatErrors.HandleTaken;
}
await notifier.MembersAddedAsync(chat.Id, [userId, .. memberIds], cancellationToken);
return await ToDtoAsync(chat, owner, userId, cancellationToken);
}
public async Task<Result<ChatDto>> GetAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default)
{
var access = await chatAccess.GetVisibleAsync(userId, chatId, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
var (chat, member) = access.Value;
return await ToDtoAsync(chat, member, userId, cancellationToken);
}
public async Task<Result<PageDto<ChatListItemDto>>> GetMyChatsAsync(
Guid userId, string? cursor, int? limit, CancellationToken cancellationToken = default)
{
if (!CursorCodec.TryDecode(cursor, out ChatListCursor? after))
{
return Paging.InvalidCursor;
}
var page = await chats.GetUserChatsAsync(userId, after, Paging.Clamp(limit), cancellationToken);
return new PageDto<ChatListItemDto>(page.Items.Select(i => i.ToDto()).ToList(), CursorCodec.Encode(page.NextCursor));
}
public async Task<Result<ChatSummaryDto[]>> SearchPublicAsync(
string query, int? limit, CancellationToken cancellationToken = default)
{
query = query?.Trim() ?? "";
if (query.Length < MinQueryLength)
{
return CommonErrors.QueryTooShort;
}
var found = await chats.SearchPublicAsync(query, Paging.Clamp(limit), cancellationToken);
return found.Select(c => c.ToSummaryDto()).ToArray();
}
public async Task<Result<ChatDto>> UpdateAsync(
Guid userId, Guid chatId, UpdateChatCommand command, CancellationToken cancellationToken = default)
{
if (await updateValidator.ValidateToErrorAsync(command, cancellationToken) is { } invalid)
{
return invalid;
}
var access = await RequireAsync(userId, chatId, ChatPermissions.CanEditInfo, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
var (chat, member) = access.Value;
var handle = command.PublicHandle?.ToLowerInvariant();
if (handle is not null && handle != chat.PublicHandle && await chats.GetByHandleAsync(handle, cancellationToken) is not null)
{
return ChatErrors.HandleTaken;
}
chat.Title = command.Title.Trim();
chat.Description = NullIfBlank(command.Description);
chat.PublicHandle = handle;
try
{
await unitOfWork.SaveChangesAsync(cancellationToken);
}
catch (UniqueConstraintException)
{
return ChatErrors.HandleTaken;
}
await notifier.ChatUpdatedAsync(chatId, cancellationToken);
return await ToDtoAsync(chat, member, userId, cancellationToken);
}
public async Task<Result<ChatDto>> SetAvatarAsync(
Guid userId, Guid chatId, FileUpload upload, CancellationToken cancellationToken = default)
{
var access = await RequireAsync(userId, chatId, ChatPermissions.CanEditInfo, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
var saved = await avatars.SaveAsync(upload, cancellationToken);
if (!saved.IsSuccess)
{
return saved.Error;
}
return await ReplaceAvatarAsync(access.Value.Chat, access.Value.Member, saved.Value, userId, cancellationToken);
}
public async Task<Result<ChatDto>> RemoveAvatarAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default)
{
var access = await RequireAsync(userId, chatId, ChatPermissions.CanEditInfo, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
return await ReplaceAvatarAsync(access.Value.Chat, access.Value.Member, null, userId, cancellationToken);
}
public async Task<Result<Stream>> OpenAvatarAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default)
{
var access = await chatAccess.GetVisibleAsync(userId, chatId, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
if (access.Value.Chat.AvatarPath is not { } path)
{
return CommonErrors.AvatarNotFound;
}
return await storage.OpenReadAsync(path, cancellationToken);
}
public async Task<Result> DeleteAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default)
{
var access = await RequireAsync(userId, chatId, ChatPermissions.CanDelete, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
access.Value.Chat.DeletedAt = timeProvider.GetUtcNow();
await unitOfWork.SaveChangesAsync(cancellationToken);
await notifier.ChatDeletedAsync(chatId, cancellationToken);
return Result.Success;
}
public async Task<Result<ChatDto>> JoinAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default)
{
var chat = await chats.GetByIdAsync(chatId, cancellationToken);
if (chat?.PublicHandle is null)
{
return ChatErrors.NotFound;
}
var member = await members.GetAsync(chatId, userId, cancellationToken);
if (member is null)
{
if (chat.Type == ChatType.Group && await members.CountAsync(chatId, cancellationToken) >= ChatLimits.MaxGroupMembers)
{
return ChatErrors.ChatFull;
}
member = new ChatMember { ChatId = chatId, UserId = userId, Role = ChatPermissions.RegularRole(chat.Type) };
members.Add(member);
try
{
await unitOfWork.SaveChangesAsync(cancellationToken);
await notifier.MembersAddedAsync(chatId, [userId], cancellationToken);
}
catch (UniqueConstraintException)
{
// Joined by a concurrent request; the change tracker was cleared, so reload both.
return await GetAsync(userId, chatId, cancellationToken);
}
}
return await ToDtoAsync(chat, member, userId, cancellationToken);
}
public async Task<Result> LeaveAsync(Guid userId, Guid chatId, CancellationToken cancellationToken = default)
{
var access = await chatAccess.GetMembershipAsync(userId, chatId, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
var (chat, member) = access.Value;
if (chat.Type == ChatType.Direct)
{
return ChatErrors.NotForDirectChats;
}
if (member.Role == ChatMemberRole.Owner)
{
return ChatErrors.OwnerMustTransfer;
}
members.Remove(member);
await unitOfWork.SaveChangesAsync(cancellationToken);
await notifier.MemberRemovedAsync(chatId, userId, cancellationToken);
return Result.Success;
}
public async Task<Result<int>> AddMembersAsync(
Guid userId, Guid chatId, IReadOnlyList<Guid> userIds, CancellationToken cancellationToken = default)
{
if (userIds is not { Count: > 0 and <= ChatLimits.MaxMembersPerRequest })
{
return Error.Validation(
"userIds", "invalid_user_count", $"Add between 1 and {ChatLimits.MaxMembersPerRequest} users at a time.");
}
var access = await RequireAsync(userId, chatId, ChatPermissions.CanManageMembers, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
var chat = access.Value.Chat;
var ids = userIds.Distinct().ToList();
if ((await users.GetExistingIdsAsync(ids, cancellationToken)).Count != ids.Count)
{
return ChatErrors.UnknownUsers;
}
var toAdd = ids.Except(await members.GetExistingUserIdsAsync(chatId, ids, cancellationToken)).ToList();
if (toAdd.Count == 0)
{
return 0;
}
if (chat.Type == ChatType.Group
&& await members.CountAsync(chatId, cancellationToken) + toAdd.Count > ChatLimits.MaxGroupMembers)
{
return ChatErrors.ChatFull;
}
var role = ChatPermissions.RegularRole(chat.Type);
foreach (var id in toAdd)
{
members.Add(new ChatMember { ChatId = chatId, UserId = id, Role = role });
}
await unitOfWork.SaveChangesAsync(cancellationToken);
await notifier.MembersAddedAsync(chatId, toAdd, cancellationToken);
return toAdd.Count;
}
public async Task<Result> RemoveMemberAsync(
Guid userId, Guid chatId, Guid memberUserId, CancellationToken cancellationToken = default)
{
if (memberUserId == userId)
{
return ChatErrors.UseLeave;
}
var access = await RequireAsync(userId, chatId, ChatPermissions.CanManageMembers, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
var target = await members.GetAsync(chatId, memberUserId, cancellationToken);
if (target is null)
{
return ChatErrors.MemberNotFound;
}
if (!ChatPermissions.CanRemove(access.Value.Member, target))
{
return ChatErrors.NotAllowed;
}
members.Remove(target);
await unitOfWork.SaveChangesAsync(cancellationToken);
await notifier.MemberRemovedAsync(chatId, memberUserId, cancellationToken);
return Result.Success;
}
public async Task<Result> ChangeRoleAsync(
Guid userId, Guid chatId, Guid memberUserId, ChatMemberRole role, CancellationToken cancellationToken = default)
{
if (memberUserId == userId)
{
return Error.Validation("userId", "own_role", "You cannot change your own role.");
}
var access = await RequireAsync(
userId, chatId, (chat, member) => chat.Type != ChatType.Direct && member.Role == ChatMemberRole.Owner, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
var (chat, owner) = access.Value;
if (role != ChatMemberRole.Owner && role != ChatMemberRole.Admin && role != ChatPermissions.RegularRole(chat.Type))
{
return ChatErrors.InvalidRole;
}
var target = await members.GetAsync(chatId, memberUserId, cancellationToken);
if (target is null)
{
return ChatErrors.MemberNotFound;
}
target.Role = role;
if (role == ChatMemberRole.Owner)
{
owner.Role = ChatMemberRole.Admin;
}
await unitOfWork.SaveChangesAsync(cancellationToken);
await notifier.ChatUpdatedAsync(chatId, cancellationToken);
return Result.Success;
}
public async Task<Result<PageDto<ChatMemberDto>>> GetMembersAsync(
Guid userId, Guid chatId, string? cursor, int? limit, CancellationToken cancellationToken = default)
{
if (!CursorCodec.TryDecode(cursor, out Guid? after))
{
return Paging.InvalidCursor;
}
var access = await RequireAsync(userId, chatId, ChatPermissions.CanListMembers, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
var page = await members.GetMembersAsync(chatId, after, Paging.Clamp(limit), cancellationToken);
return new PageDto<ChatMemberDto>(page.Items.Select(m => m.ToDto()).ToList(), CursorCodec.Encode(page.NextCursor));
}
public async Task<Result> SetMutedAsync(Guid userId, Guid chatId, bool muted, CancellationToken cancellationToken = default)
{
var access = await chatAccess.GetMembershipAsync(userId, chatId, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
access.Value.Member.IsMuted = muted;
await unitOfWork.SaveChangesAsync(cancellationToken);
return Result.Success;
}
public async Task<Result> MarkReadAsync(Guid userId, Guid chatId, Guid messageId, CancellationToken cancellationToken = default)
{
var access = await chatAccess.GetMembershipAsync(userId, chatId, cancellationToken);
if (!access.IsSuccess)
{
return access.Error;
}
if (!await messages.ExistsInChatAsync(chatId, messageId, cancellationToken))
{
return MessageErrors.NotFound;
}
var moved = await members.MarkReadAsync(chatId, userId, messageId, cancellationToken);
// Channels can have many subscribers; their read positions are private.
if (moved && access.Value.Chat.Type != ChatType.Channel)
{
await notifier.MessagesReadAsync(chatId, userId, messageId, cancellationToken);
}
return Result.Success;
}
public Task<IReadOnlyList<Guid>> GetMyChatIdsAsync(Guid userId, CancellationToken cancellationToken = default) =>
members.GetChatIdsForUserAsync(userId, cancellationToken);
public Task<bool> IsMemberAsync(Guid chatId, Guid userId, CancellationToken cancellationToken = default) =>
members.IsMemberAsync(chatId, userId, cancellationToken);
/// <summary>The caller's membership, failing with NotAllowed (or NotForDirectChats) when <paramref name="allowed"/> says no.</summary>
private async Task<Result<(Chat Chat, ChatMember Member)>> RequireAsync(
Guid userId, Guid chatId, Func<Chat, ChatMember, bool> allowed, CancellationToken cancellationToken)
{
var access = await chatAccess.GetMembershipAsync(userId, chatId, cancellationToken);
if (!access.IsSuccess)
{
return access;
}
var (chat, member) = access.Value;
if (allowed(chat, member))
{
return access;
}
return chat.Type == ChatType.Direct ? ChatErrors.NotForDirectChats : ChatErrors.NotAllowed;
}
private async Task<ChatDto> ReplaceAvatarAsync(
Chat chat, ChatMember member, string? avatarPath, Guid userId, CancellationToken cancellationToken)
{
var previous = chat.AvatarPath;
chat.AvatarPath = avatarPath;
await unitOfWork.SaveChangesAsync(cancellationToken);
await avatars.DeleteAsync(previous, cancellationToken);
await notifier.ChatUpdatedAsync(chat.Id, cancellationToken);
return await ToDtoAsync(chat, member, userId, cancellationToken);
}
private async Task<ChatDto> ToDtoAsync(Chat chat, ChatMember? member, Guid userId, CancellationToken cancellationToken)
{
var memberCount = await members.CountAsync(chat.Id, cancellationToken);
UserSummaryDto? peer = null;
if (chat.Type == ChatType.Direct)
{
var both = await members.GetMembersAsync(chat.Id, null, 2, cancellationToken);
peer = both.Items.FirstOrDefault(m => m.UserId != userId)?.User.ToSummaryDto();
}
return new ChatDto(
chat.Id,
chat.Type,
chat.Title,
chat.Description,
chat.PublicHandle,
chat.AvatarPath is not null,
chat.CreatedAt,
memberCount,
member?.Role,
member?.IsMuted ?? false,
peer);
}
private static string? NullIfBlank(string? value) => string.IsNullOrWhiteSpace(value) ? null : value.Trim();
}Особисті чати й стан гонитви
OpenDirectAsync повертає особистий чат двох користувачів і створює його під час першого використання. Два запити можуть надійти в ту саму мить – Аліса й Боб обоє натискають «Написати» – і обидва бачать «чату ще немає». Обидва намагаються вставити запис; унікальний індекс за direct_key (тема 4) дає перемогти одному, а той, хто програв, отримує від Unit of Work UniqueConstraintException (тема 5). Сервіс перехоплює саме цей виняток і замість помилки завантажує чат переможця. Обоє користувачів потрапляють в один чат, і користувач ніколи не бачить помилки.
Групи й канали
CreateAsync:
- вилучає створювача й дублікати зі списку учасників (
Where(id => id != userId).Distinct()) і перевіряє, що всі інші користувачі існують; - переводить ім’я в нижній регістр і перевіряє, що воно вільне, – і все одно перехоплює
UniqueConstraintExceptionпід час збереження, бо інший запит може зайняти ім’я між перевіркою та вставкою. Перевірка дає швидку відповідь у звичайному випадку; індекс дає гарантію; - робить створювача власником, а всіх інших – звичайною роллю цього типу (
RegularRole); - сповіщує
MembersAddedз усіма учасниками, включно зі створювачем, – вираз колекції[userId, .. memberIds]розгортає список у новий.
Читання й пошук
GetAsyncвикористовуєGetVisibleAsync: учасники й будь-хто для публічних чатів.GetMyChatsAsyncрозкодовує непрозорий курсор із теми 7 (invalid_cursorдля підробленого), просить у репозиторія сторінку й кодує наступний курсор.SearchPublicAsyncшукає лише серед публічних чатів і потребує щонайменше двох символів.
Зміна чату
UpdateAsync,SetAvatarAsyncіRemoveAvatarAsyncвимагаютьCanEditInfoчерез допоміжний методRequireAsync, який приймає дозвіл як делегатFunc<Chat, ChatMember, bool>. ПередачаChatPermissions.CanEditInfoпередає сам метод – групу методів.ChangeRoleAsyncпередає вбудовану лямбду для свого правила лише для власника. В особистому чаті відмовлений дозвіл стаєnot_for_direct_chats, в інших –not_allowed.DeleteAsyncзадаєDeletedAt– м’яке видалення з теми 3 – і сповіщуєChatDeleted.
Членство й ролі
JoinAsyncпрацює лише для публічних чатів (приватний чат – цеchat_not_found, ніби його не існує), відмовляє для повної групи й ідемпотентний: повторне приєднання повертає чат. Одночасне подвійне приєднання перехоплюється так само, як і стан гонитви за особистий чат.LeaveAsync: не в особистих чатах, і власник має спершу передати власність – групою без власника більше ніколи не можна було б керувати.AddMembersAsyncприймає 1–100 ідентифікаторів на запит, перевіряє, що вони існують, пропускає наявних учасників, застосовує обмеження групи й повертає, скільки справді додано. ШаблонuserIds is not { Count: > 0 and <= ChatLimits.MaxMembersPerRequest }перевіряє «список існує, а його довжина в діапазоні» одним виразом.RemoveMemberAsyncвикористовуєCanRemove; вилучення себе – цеuse_leave.ChangeRoleAsync– лише для власника. Роль має бути однією з тих, що є в цьому типі чату (немаєMemberу каналі). Надання комусь роліOwnerпередає власність: колишній власник стає адміністратором, тож власник завжди рівно один.GetMembersAsyncзастосовуєCanListMembers: списки підписників каналів приватні.
Позиції читання
MarkReadAsync перевіряє, що повідомлення належить чату (інакше message_not_found), пересуває позицію читання вперед у репозиторії (тема 5) і сповіщує MessagesRead лише тоді, коли позиція справді змінилася, – і не для каналів, де читання підписників має лишатися приватним.
Відображення на DTO
ToDtoAsync рахує учасників і для особистого чату завантажує обох, щоб знайти співрозмовника – іншого користувача, ім’я якого є назвою чату для викликача.
Крок 3. Зареєструйте сервіс
Що зробити. Розширте AddCore (нові рядки зеленим):
cs
using Chatex.Core.Abstractions;
using Chatex.Core.Auth;
using Chatex.Core.Chats;
using Chatex.Core.Common;
using Chatex.Core.Users;
using Chatex.Data;
using FluentValidation;
using Microsoft.AspNetCore.Identity;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
namespace Chatex.Core;
public static class DependencyInjection
{
public static IServiceCollection AddCore(this IServiceCollection services, IConfiguration configuration)
{
var connectionString = configuration.GetConnectionString("Chatex")
?? throw new InvalidOperationException("Connection string 'Chatex' is not configured.");
services.AddData(connectionString, o => o.RootPath = configuration["Storage:RootPath"] ?? "");
services.AddOptions<JwtOptions>()
.Bind(configuration.GetSection(JwtOptions.Section))
.ValidateDataAnnotations()
.ValidateOnStart();
services.Configure<IdentityOptions>(o =>
{
o.User.RequireUniqueEmail = true;
o.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyz0123456789_";
o.Password.RequiredLength = 8;
o.Password.RequireDigit = true;
o.Password.RequireLowercase = false;
o.Password.RequireUppercase = false;
o.Password.RequireNonAlphanumeric = false;
o.Lockout.MaxFailedAccessAttempts = 5;
o.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(15);
});
services.AddValidatorsFromAssemblyContaining<AuthService>(includeInternalTypes: true);
services.TryAddSingleton<IChatNotifier, NullChatNotifier>();
services.AddSingleton<ITokenService, TokenService>();
services.AddScoped<AvatarStore>();
services.AddScoped<ChatAccess>();
services.AddScoped<IAuthService, AuthService>();
services.AddScoped<IProfileService, ProfileService>();
services.AddScoped<IChatService, ChatService>();
return services;
}
}TryAddSingleton<IChatNotifier, NullChatNotifier>() реєструє Null Object, лише якщо сповіщувач ще не зареєстровано. API (тема 14) реєструє свій сповіщувач SignalR перед викликом AddCore, а тести реєструють підробку-записувач перед AddCore – в обох випадках Null Object поступається місцем.
Перевірка
dotnet build завершується успішно, і 17 бізнес-тестів, як і раніше, проходять.