Перепиливание под чистый DDD

2026-03-22 23:59:33 +03:00
parent 5da1a2f45d
commit 6e532b021d
302 changed files with 3595 additions and 3679 deletions
@@ -0,0 +1,130 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Knot.Shared.Kernel;
+using Knot.Shared.Kernel.Storage;
+using Knot.Modules.Conversations.Domain;
+using Knot.Modules.Conversations.Application.Abstractions;
+using MediatR;
+using System.Linq;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Processing;
+
+namespace Knot.Modules.Conversations.Application.Chats.Avatar;
+
+public record UploadGroupAvatarCommand(Guid ChatId, Guid UserId, string FileName, string ContentType, Stream FileStream) : ICommand<Guid>;
+
+internal sealed class UploadGroupAvatarCommandHandler : ICommandHandler<UploadGroupAvatarCommand, Guid>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IChatsUnitOfWork _uow;
+    private readonly IFileStorageService _fileStorage;
+
+    public UploadGroupAvatarCommandHandler(IChatRepository chatRepository, IChatsUnitOfWork uow, IFileStorageService fileStorage)
+    {
+        _chatRepository = chatRepository;
+        _uow = uow;
+        _fileStorage = fileStorage;
+    }
+
+    public async Task<Result<Guid>> Handle(UploadGroupAvatarCommand request, CancellationToken cancellationToken)
+    {
+        var chat = await _chatRepository.GetByIdAsync(request.ChatId, cancellationToken);
+        if (chat == null || !chat.Members.Any(m => m.UserId == request.UserId))
+        {
+            return Result.Failure<Guid>(ChatErrors.ChatNotFound);
+        }
+
+        var fileId = await _fileStorage.UploadFileAsync(request.FileStream, request.FileName, request.ContentType);
+        var url = $"/api/files/{fileId}";
+
+        chat.UpdateAvatar(url);
+        _chatRepository.Update(chat);
+        await _uow.SaveChangesAsync(cancellationToken);
+
+        return Result.Success(request.ChatId);
+    }
+}
+
+public record CropGroupAvatarCommand(Guid ChatId, Guid UserId, string FileName, string ContentType, Stream FileStream, int X, int Y, int Width, int Height) : ICommand<Guid>;
+
+internal sealed class CropGroupAvatarCommandHandler : ICommandHandler<CropGroupAvatarCommand, Guid>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IChatsUnitOfWork _uow;
+    private readonly IFileStorageService _fileStorage;
+
+    public CropGroupAvatarCommandHandler(IChatRepository chatRepository, IChatsUnitOfWork uow, IFileStorageService fileStorage)
+    {
+        _chatRepository = chatRepository;
+        _uow = uow;
+        _fileStorage = fileStorage;
+    }
+
+    public async Task<Result<Guid>> Handle(CropGroupAvatarCommand request, CancellationToken cancellationToken)
+    {
+        var chat = await _chatRepository.GetByIdAsync(request.ChatId, cancellationToken);
+        if (chat == null || !chat.Members.Any(m => m.UserId == request.UserId))
+        {
+            return Result.Failure<Guid>(ChatErrors.ChatNotFound);
+        }
+
+        string url;
+
+        using (var image = await SixLabors.ImageSharp.Image.LoadAsync(request.FileStream))
+        {
+            int startX = Math.Max(0, Math.Min(request.X, image.Width - 1));
+            int startY = Math.Max(0, Math.Min(request.Y, image.Height - 1));
+            int rectWidth = Math.Max(1, Math.Min(request.Width, image.Width - startX));
+            int rectHeight = Math.Max(1, Math.Min(request.Height, image.Height - startY));
+
+            image.Mutate(ctx => ctx.Crop(new SixLabors.ImageSharp.Rectangle(startX, startY, rectWidth, rectHeight)));
+            image.Mutate(ctx => ctx.Resize(400, 400));
+
+            using var outStream = new MemoryStream();
+            await image.SaveAsJpegAsync(outStream, cancellationToken);
+            outStream.Position = 0;
+
+            var fileName = request.FileName ?? "avatar.jpg";
+            var fileId = await _fileStorage.UploadFileAsync(outStream, fileName, "image/jpeg");
+            url = $"/api/files/{fileId}";
+        }
+
+        chat.UpdateAvatar(url);
+        _chatRepository.Update(chat);
+        await _uow.SaveChangesAsync(cancellationToken);
+
+        return Result.Success(request.ChatId);
+    }
+}
+
+public record RemoveGroupAvatarCommand(Guid ChatId, Guid UserId) : ICommand<Guid>;
+
+internal sealed class RemoveGroupAvatarCommandHandler : ICommandHandler<RemoveGroupAvatarCommand, Guid>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IChatsUnitOfWork _uow;
+
+    public RemoveGroupAvatarCommandHandler(IChatRepository chatRepository, IChatsUnitOfWork uow)
+    {
+        _chatRepository = chatRepository;
+        _uow = uow;
+    }
+
+    public async Task<Result<Guid>> Handle(RemoveGroupAvatarCommand request, CancellationToken cancellationToken)
+    {
+        var chat = await _chatRepository.GetByIdAsync(request.ChatId, cancellationToken);
+        if (chat == null || !chat.Members.Any(m => m.UserId == request.UserId))
+        {
+            return Result.Failure<Guid>(ChatErrors.ChatNotFound);
+        }
+
+        chat.UpdateAvatar(null);
+        _chatRepository.Update(chat);
+        await _uow.SaveChangesAsync(cancellationToken);
+
+        return Result.Success(request.ChatId);
+    }
+}
+
@@ -0,0 +1,35 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Knot.Shared.Kernel;
+using Knot.Modules.Conversations.Domain;
+using Knot.Modules.Conversations.Application.Abstractions;
+using MediatR;
+using System.Linq;
+
+namespace Knot.Modules.Conversations.Application.Chats.Clear;
+
+public record ClearChatCommand(Guid ChatId, Guid UserId) : ICommand<MessageResponse>;
+
+internal sealed class ClearChatCommandHandler : ICommandHandler<ClearChatCommand, MessageResponse>
+{
+    private readonly IChatRepository _chatRepository;
+
+    public ClearChatCommandHandler(IChatRepository chatRepository)
+    {
+        _chatRepository = chatRepository;
+    }
+
+    public async Task<Result<MessageResponse>> Handle(ClearChatCommand request, CancellationToken cancellationToken)
+    {
+        var chat = await _chatRepository.GetByIdAsync(request.ChatId, cancellationToken);
+        if (chat == null || !chat.Members.Any(m => m.UserId == request.UserId))
+        {
+            return Result.Failure<MessageResponse>(ChatErrors.ChatNotFound);
+        }
+
+        // Currently a placeholder
+        return Result.Success(new MessageResponse("Cleared"));
+    }
+}
+
@@ -0,0 +1,44 @@
+using Knot.Modules.Conversations.Domain;
+using Knot.Shared.Kernel;
+
+using Knot.Modules.Conversations.Application.Abstractions;
+
+namespace Knot.Modules.Conversations.Application.Chats.Create;
+
+/// <summary>
+/// Команда для создания чата.
+/// </summary>
+public sealed record CreateChatCommand(
+    string Name,
+    ChatType Type,
+    List<Guid> MemberIds) : ICommand<Guid>;
+
+public sealed class CreateChatCommandHandler : ICommandHandler<CreateChatCommand, Guid>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IChatsUnitOfWork _unitOfWork;
+
+    public CreateChatCommandHandler(IChatRepository chatRepository, IChatsUnitOfWork unitOfWork)
+    {
+        _chatRepository = chatRepository;
+        _unitOfWork = unitOfWork;
+    }
+
+    public async Task<Result<Guid>> Handle(CreateChatCommand request, CancellationToken cancellationToken)
+    {
+        var chat = Chat.Create(request.Name, request.Type);
+
+        for (int i = 0; i < request.MemberIds.Count; i++)
+        {
+            var userId = request.MemberIds[i];
+            var role = (i == 0) ? ChatRole.Owner : ChatRole.Member;
+            chat.AddMember(userId, role);
+        }
+
+        _chatRepository.Add(chat);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
+
+        return Result.Success(chat.Id);
+    }
+}
+
@@ -0,0 +1,159 @@
+using Knot.Modules.Messaging.Application.Abstractions;
+using Knot.Modules.Messaging.Domain;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediatR;
+using Knot.Shared.Kernel;
+using Knot.Modules.Conversations.Application.DTOs;
+using Knot.Modules.Conversations.Domain;
+using Knot.Modules.Conversations.Application.Abstractions;
+
+namespace Knot.Modules.Conversations.Application.Chats.GetChatById;
+
+public record GetChatByIdQuery(Guid UserId, Guid ChatId) : IQuery<ChatDto?>;
+
+internal sealed class GetChatByIdQueryHandler : IQueryHandler<GetChatByIdQuery, ChatDto?>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IUserDisplayNameProvider _userProvider;
+    private readonly IMessageRepository _messageRepository;
+    private readonly IMessageReactionRepository _reactionRepository;
+
+    public GetChatByIdQueryHandler(IChatRepository chatRepository, IUserDisplayNameProvider userProvider, IMessageRepository messageRepository, IMessageReactionRepository reactionRepository)
+    {
+        _chatRepository = chatRepository;
+        _userProvider = userProvider;
+        _messageRepository = messageRepository;
+        _reactionRepository = reactionRepository;
+    }
+
+    public async Task<Result<ChatDto?>> Handle(GetChatByIdQuery request, CancellationToken cancellationToken)
+    {
+        var chat = await _chatRepository.GetByIdAsync(request.ChatId, cancellationToken);
+        if (chat == null)
+        {
+            return Result.Success<ChatDto?>(null);
+        }
+
+        if (!chat.Members.Any(m => m.UserId == request.UserId))
+        {
+            return Result.Failure<ChatDto?>(ChatErrors.ChatsForbidden);
+        }
+
+        var userIdsToFetch = new HashSet<Guid>();
+        foreach (var member in chat.Members)
+        {
+            userIdsToFetch.Add(member.UserId);
+        }
+
+        var latestMessage = await _messageRepository.GetLatestChatMessageAsync(chat.Id, cancellationToken);
+        var latestReactions = latestMessage != null 
+            ? await _reactionRepository.GetReactionsForMessageAsync(latestMessage.Id, cancellationToken) 
+            : new List<MessageReaction>();
+
+        if (latestMessage != null)
+        {
+            userIdsToFetch.Add(latestMessage.SenderId);
+            foreach (var reaction in latestReactions)
+            {
+                userIdsToFetch.Add(reaction.UserId);
+            }
+        }
+
+        var usersInfo = await _userProvider.GetUsersInfoAsync(userIdsToFetch, cancellationToken);
+
+        var members = new List<ChatMemberDto>();
+        foreach (var member in chat.Members)
+        {
+            usersInfo.TryGetValue(member.UserId, out var user);
+            members.Add(new ChatMemberDto(
+                member.Id,
+                member.UserId,
+                member.Role,
+                member.IsPinned,
+                user != null ? new ChatUserDto(
+                    user.Id,
+                    user.Username,
+                    user.DisplayName,
+                    user.Avatar,
+                    false,
+                    DateTime.UtcNow
+                ) : null
+            ));
+        }
+
+        var messagesList = new List<ChatMessageDto>();
+        if (latestMessage != null)
+        {
+            usersInfo.TryGetValue(latestMessage.SenderId, out var senderObj);
+
+            var reactionsWithUser = new List<ReactionDto>();
+            foreach (var reaction in latestReactions)
+            {
+                usersInfo.TryGetValue(reaction.UserId, out var reactionUser);
+                reactionsWithUser.Add(new ReactionDto(
+                    reaction.Id,
+                    reaction.Emoji,
+                    reaction.UserId,
+                    reactionUser != null
+                        ? new MessageSenderDto(reactionUser.Id, reactionUser.Username, reactionUser.DisplayName, reactionUser.Avatar)
+                        : new MessageSenderDto(reaction.UserId, "unknown", "Unknown", null)
+                ));
+            }
+
+            var readByList = chat.Members
+                .Where(m => m.LastReadSequenceId >= latestMessage.SequenceId && m.UserId != latestMessage.SenderId)
+                .Select(m => new ReadByDto(m.UserId))
+                .ToList();
+
+            messagesList.Add(new ChatMessageDto(
+                latestMessage.Id,
+                latestMessage.ChatId,
+                latestMessage.SenderId,
+                latestMessage.Content,
+                latestMessage.Type,
+                latestMessage.ReplyToId,
+                latestMessage.Quote,
+                latestMessage.StoryId,
+                latestMessage.StoryMediaUrl,
+                latestMessage.StoryMediaType,
+                latestMessage.IsEdited,
+                latestMessage.IsDeleted,
+                latestMessage.CreatedAt,
+                latestMessage.SequenceId,
+                latestMessage.Media.Select(media => new MediaDto(media.Id, media.Type, media.Url, media.Filename, media.Size)).ToList(),
+                senderObj != null ? new MessageSenderDto(
+                    senderObj.Id,
+                    senderObj.Username,
+                    senderObj.DisplayName,
+                    senderObj.Avatar
+                ) : new MessageSenderDto(latestMessage.SenderId, "unknown", "Unknown", null),
+                reactionsWithUser,
+                readByList
+            ));
+        }
+
+        var currentMember = chat.Members.First(m => m.UserId == request.UserId);
+        var unreadCount = (int)Math.Max(0, chat.LastMessageSequenceId - currentMember.LastReadSequenceId);
+
+        var dto = new ChatDto(
+            chat.Id,
+            chat.Type.ToString().ToLowerInvariant(),
+            chat.Type == ChatType.Favorites ? "Избранное" : (chat.Type == ChatType.Personal ? null : chat.Name),
+            chat.Description,
+            chat.Avatar,
+            chat.CreatedAt,
+            members,
+            messagesList,
+            unreadCount
+        );
+
+        return Result.Success<ChatDto?>(dto);
+    }
+}
+
+
+
@@ -0,0 +1,153 @@
+using Knot.Modules.Messaging.Application.Abstractions;
+using Knot.Modules.Messaging.Domain;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediatR;
+using Knot.Shared.Kernel;
+using Knot.Modules.Conversations.Application.DTOs;
+using Knot.Modules.Conversations.Domain;
+using Knot.Modules.Conversations.Application.Abstractions;
+
+
+namespace Knot.Modules.Conversations.Application.Chats.GetChats;
+
+public record GetChatsQuery(Guid UserId) : IQuery<List<ChatDto>>;
+
+internal sealed class GetChatsQueryHandler : IQueryHandler<GetChatsQuery, List<ChatDto>>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IUserDisplayNameProvider _userProvider;
+    private readonly IMessageRepository _messageRepository;
+    private readonly IMessageReactionRepository _reactionRepository;
+
+    public GetChatsQueryHandler(IChatRepository chatRepository, IUserDisplayNameProvider userProvider, IMessageRepository messageRepository, IMessageReactionRepository reactionRepository)
+    {
+        _chatRepository = chatRepository;
+        _userProvider = userProvider;
+        _messageRepository = messageRepository;
+        _reactionRepository = reactionRepository;
+    }
+
+    public async Task<Result<List<ChatDto>>> Handle(GetChatsQuery request, CancellationToken cancellationToken)
+    {
+        var userChats = await _chatRepository.GetUserChatsAsync(request.UserId, cancellationToken);
+        var dtos = new List<ChatDto>();
+
+        foreach (var chat in userChats)
+        {
+            var latestMessage = await _messageRepository.GetLatestChatMessageAsync(chat.Id, cancellationToken);
+            var latestReactions = latestMessage != null 
+                ? await _reactionRepository.GetReactionsForMessageAsync(latestMessage.Id, cancellationToken)
+                : new List<MessageReaction>();
+
+            var userIdsToFetch = new HashSet<Guid>();
+            
+            foreach (var member in chat.Members)
+            {
+                userIdsToFetch.Add(member.UserId);
+            }
+
+            if (latestMessage != null)
+            {
+                userIdsToFetch.Add(latestMessage.SenderId);
+                foreach (var r in latestReactions)
+                {
+                    userIdsToFetch.Add(r.UserId);
+                }
+            }
+
+            var usersInfo = await _userProvider.GetUsersInfoAsync(userIdsToFetch, cancellationToken);
+
+            var members = new List<ChatMemberDto>();
+            foreach (var member in chat.Members)
+            {
+                usersInfo.TryGetValue(member.UserId, out var user);
+                members.Add(new ChatMemberDto(
+                    member.Id,
+                    member.UserId,
+                    member.Role,
+                    member.IsPinned,
+                    user != null ? new ChatUserDto(
+                        user.Id,
+                        user.Username,
+                        user.DisplayName,
+                        user.Avatar,
+                        false,
+                        DateTime.UtcNow
+                    ) : null
+                ));
+            }
+
+            var messagesList = new List<ChatMessageDto>();
+
+            if (latestMessage != null)
+            {
+                usersInfo.TryGetValue(latestMessage.SenderId, out var senderObj);
+
+                var reactionsWithUser = new List<ReactionDto>();
+                foreach (var reaction in latestReactions)
+                {
+                    usersInfo.TryGetValue(reaction.UserId, out var reactionUser);
+                    reactionsWithUser.Add(new ReactionDto(
+                        reaction.Id,
+                        reaction.Emoji,
+                        reaction.UserId,
+                        reactionUser != null
+                            ? new MessageSenderDto(reactionUser.Id, reactionUser.Username, reactionUser.DisplayName, reactionUser.Avatar)
+                            : new MessageSenderDto(reaction.UserId, "unknown", "Unknown", null)
+                    ));
+                }
+
+                messagesList.Add(new ChatMessageDto(
+                    latestMessage.Id,
+                    latestMessage.ChatId,
+                    latestMessage.SenderId,
+                    latestMessage.Content,
+                    latestMessage.Type,
+                    latestMessage.ReplyToId,
+                    latestMessage.Quote,
+                    latestMessage.StoryId,
+                    latestMessage.StoryMediaUrl,
+                    latestMessage.StoryMediaType,
+                    latestMessage.IsEdited,
+                    latestMessage.IsDeleted,
+                    latestMessage.CreatedAt,
+                    latestMessage.SequenceId,
+                    latestMessage.Media.Select(media => new MediaDto(media.Id, media.Type, media.Url, media.Filename, media.Size)).ToList(),
+                    senderObj != null ? new MessageSenderDto(
+                        senderObj.Id,
+                        senderObj.Username,
+                        senderObj.DisplayName,
+                        senderObj.Avatar
+                    ) : new MessageSenderDto(latestMessage.SenderId, "unknown", "Unknown", null),
+                    reactionsWithUser,
+                    chat.Members.Where(m => m.LastReadSequenceId >= latestMessage.SequenceId && m.UserId != latestMessage.SenderId).Select(m => new ReadByDto(m.UserId)).ToList()
+                ));
+            }
+
+            var currentMember = chat.Members.FirstOrDefault(m => m.UserId == request.UserId);
+            var unreadCount = currentMember != null ? (int)Math.Max(0, chat.LastMessageSequenceId - currentMember.LastReadSequenceId) : 0;
+
+            dtos.Add(new ChatDto(
+                chat.Id,
+                chat.Type.ToString().ToLowerInvariant(),
+                chat.Type == ChatType.Favorites ? "Избранное" : (chat.Type == ChatType.Personal ? null : chat.Name),
+                chat.Description,
+                chat.Avatar,
+                chat.CreatedAt,
+                members,
+                messagesList,
+                unreadCount
+            ));
+        }
+
+        var sorted = dtos.OrderByDescending(d => d.Messages.FirstOrDefault()?.CreatedAt ?? d.CreatedAt).ToList();
+        return Result.Success(sorted);
+    }
+}
+
+
+
@@ -0,0 +1,39 @@
+using Knot.Modules.Conversations.Domain;
+using Knot.Shared.Kernel;
+using Knot.Modules.Conversations.Application.Abstractions;
+
+namespace Knot.Modules.Conversations.Application.Chats.GetOrCreateFavorites;
+
+public sealed record GetOrCreateFavoritesCommand(Guid UserId) : ICommand<Guid>;
+
+public sealed class GetOrCreateFavoritesCommandHandler : ICommandHandler<GetOrCreateFavoritesCommand, Guid>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IChatsUnitOfWork _unitOfWork;
+
+    public GetOrCreateFavoritesCommandHandler(IChatRepository chatRepository, IChatsUnitOfWork unitOfWork)
+    {
+        _chatRepository = chatRepository;
+        _unitOfWork = unitOfWork;
+    }
+
+    public async Task<Result<Guid>> Handle(GetOrCreateFavoritesCommand request, CancellationToken cancellationToken)
+    {
+        var favorites = await _chatRepository.GetFavoritesAsync(request.UserId, cancellationToken);
+
+        if (favorites != null)
+        {
+            return Result.Success(favorites.Id);
+        }
+
+        // Create new favorites chat
+        var chat = Chat.Create("Избранное", ChatType.Favorites);
+        chat.AddMember(request.UserId, ChatRole.Owner);
+
+        _chatRepository.Add(chat);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
+
+        return Result.Success(chat.Id);
+    }
+}
+
@@ -0,0 +1,54 @@
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Knot.Shared.Kernel;
+using Knot.Modules.Conversations.Domain;
+using Knot.Modules.Conversations.Application.Abstractions;
+using MediatR;
+using System.Linq;
+
+namespace Knot.Modules.Conversations.Application.Chats.LeaveOrDelete;
+
+public record LeaveOrDeleteChatCommand(Guid ChatId, Guid UserId) : ICommand<SuccessResponse>;
+
+internal sealed class LeaveOrDeleteChatCommandHandler : ICommandHandler<LeaveOrDeleteChatCommand, SuccessResponse>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IChatsUnitOfWork _uow;
+
+    public LeaveOrDeleteChatCommandHandler(IChatRepository chatRepository, IChatsUnitOfWork uow)
+    {
+        _chatRepository = chatRepository;
+        _uow = uow;
+    }
+
+    public async Task<Result<SuccessResponse>> Handle(LeaveOrDeleteChatCommand request, CancellationToken cancellationToken)
+    {
+        var chat = await _chatRepository.GetByIdAsync(request.ChatId, cancellationToken);
+        if (chat == null)
+        {
+            return Result.Success(new SuccessResponse(true));
+        }
+
+        if (!chat.Members.Any(m => m.UserId == request.UserId))
+        {
+            return Result.Failure<SuccessResponse>(ChatErrors.Unauthorized);
+        }
+
+        if (chat.Type == ChatType.Group)
+        {
+            chat.RemoveMember(request.UserId);
+            _chatRepository.Update(chat);
+        }
+        else
+        {
+            _chatRepository.Remove(chat);
+        }
+
+        await _uow.SaveChangesAsync(cancellationToken);
+
+        return Result.Success(new SuccessResponse(true));
+    }
+}
+
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Knot.Shared.Kernel;
+using Knot.Modules.Conversations.Domain;
+using Knot.Modules.Conversations.Application.Abstractions;
+using MediatR;
+using System.Linq;
+
+namespace Knot.Modules.Conversations.Application.Chats.Members;
+
+public record AddMembersCommand(Guid ChatId, Guid UserId, List<Guid> UserIdsToAdd) : ICommand<Guid>;
+
+internal sealed class AddMembersCommandHandler : ICommandHandler<AddMembersCommand, Guid>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IChatsUnitOfWork _uow;
+
+    public AddMembersCommandHandler(IChatRepository chatRepository, IChatsUnitOfWork uow)
+    {
+        _chatRepository = chatRepository;
+        _uow = uow;
+    }
+
+    public async Task<Result<Guid>> Handle(AddMembersCommand request, CancellationToken cancellationToken)
+    {
+        var chat = await _chatRepository.GetByIdAsync(request.ChatId, cancellationToken);
+        if (chat == null || !chat.Members.Any(m => m.UserId == request.UserId))
+        {
+            return Result.Failure<Guid>(ChatErrors.ChatNotFound);
+        }
+
+        foreach (var userId in request.UserIdsToAdd)
+        {
+            chat.AddMember(userId);
+        }
+        _chatRepository.Update(chat);
+        await _uow.SaveChangesAsync(cancellationToken);
+
+        return Result.Success(request.ChatId);
+    }
+}
+
+public record RemoveMemberCommand(Guid ChatId, Guid UserId, Guid UserIdToRemove) : ICommand<Guid>;
+
+internal sealed class RemoveMemberCommandHandler : ICommandHandler<RemoveMemberCommand, Guid>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IChatsUnitOfWork _uow;
+
+    public RemoveMemberCommandHandler(IChatRepository chatRepository, IChatsUnitOfWork uow)
+    {
+        _chatRepository = chatRepository;
+        _uow = uow;
+    }
+
+    public async Task<Result<Guid>> Handle(RemoveMemberCommand request, CancellationToken cancellationToken)
+    {
+        var chat = await _chatRepository.GetByIdAsync(request.ChatId, cancellationToken);
+        if (chat == null || !chat.Members.Any(m => m.UserId == request.UserId))
+        {
+            return Result.Failure<Guid>(ChatErrors.ChatNotFound);
+        }
+
+        chat.RemoveMember(request.UserIdToRemove);
+        _chatRepository.Update(chat);
+        await _uow.SaveChangesAsync(cancellationToken);
+
+        return Result.Success(request.ChatId);
+    }
+}
+
@@ -0,0 +1,47 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Knot.Shared.Kernel;
+using Knot.Modules.Conversations.Domain;
+using Knot.Modules.Conversations.Application.Abstractions;
+using Knot.Modules.Conversations.Application.DTOs;
+using MediatR;
+using System.Linq;
+
+namespace Knot.Modules.Conversations.Application.Chats.TogglePin;
+
+public record TogglePinCommand(Guid ChatId, Guid UserId) : ICommand<TogglePinResponse>;
+
+internal sealed class TogglePinCommandHandler : ICommandHandler<TogglePinCommand, TogglePinResponse>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IChatsUnitOfWork _uow;
+
+    public TogglePinCommandHandler(IChatRepository chatRepository, IChatsUnitOfWork uow)
+    {
+        _chatRepository = chatRepository;
+        _uow = uow;
+    }
+
+    public async Task<Result<TogglePinResponse>> Handle(TogglePinCommand request, CancellationToken cancellationToken)
+    {
+        var chat = await _chatRepository.GetByIdAsync(request.ChatId, cancellationToken);
+        if (chat == null)
+        {
+            return Result.Failure<TogglePinResponse>(ChatErrors.ChatNotFound);
+        }
+
+        var member = chat.Members.FirstOrDefault(m => m.UserId == request.UserId);
+        if (member == null)
+        {
+            return Result.Failure<TogglePinResponse>(ChatErrors.ChatNotFound);
+        }
+
+        member.TogglePin();
+        _chatRepository.Update(chat);
+        await _uow.SaveChangesAsync(cancellationToken);
+
+        return Result.Success(new TogglePinResponse(member.IsPinned));
+    }
+}
+
@@ -0,0 +1,49 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Knot.Shared.Kernel;
+using Knot.Modules.Conversations.Domain;
+using Knot.Modules.Conversations.Application.Abstractions;
+using MediatR;
+using System.Linq;
+
+namespace Knot.Modules.Conversations.Application.Chats.Update;
+
+public record UpdateChatCommand(Guid ChatId, Guid UserId, string? Name, string? Description) : ICommand<Guid>;
+
+internal sealed class UpdateChatCommandHandler : ICommandHandler<UpdateChatCommand, Guid>
+{
+    private readonly IChatRepository _chatRepository;
+    private readonly IChatsUnitOfWork _uow;
+
+    public UpdateChatCommandHandler(IChatRepository chatRepository, IChatsUnitOfWork uow)
+    {
+        _chatRepository = chatRepository;
+        _uow = uow;
+    }
+
+    public async Task<Result<Guid>> Handle(UpdateChatCommand request, CancellationToken cancellationToken)
+    {
+        var chat = await _chatRepository.GetByIdAsync(request.ChatId, cancellationToken);
+        if (chat == null || !chat.Members.Any(m => m.UserId == request.UserId))
+        {
+            return Result.Failure<Guid>(ChatErrors.ChatNotFound);
+        }
+
+        if (request.Name != null)
+        {
+            chat.UpdateName(request.Name);
+        }
+
+        if (request.Description != null)
+        {
+            chat.UpdateDescription(request.Description);
+        }
+
+        _chatRepository.Update(chat);
+        await _uow.SaveChangesAsync(cancellationToken);
+
+        return Result.Success(chat.Id);
+    }
+}
+