refactor: extract remaining Telegram handlers to platform-neutral contracts

- Extract CreateSessionHandler, ListSessionsHandler, DeleteSessionHandler,
  ExportCalendarHandler, HandleRescheduleTimeInputHandler,
  HandleRescheduleVoteHandler to GmRelay.Shared
- Add IPlatformMessenger methods: SendScheduleAsync, UpdateScheduleAsync,
  SendGroupMessageAsync with actions, CreateThreadAsync, DeleteThreadAsync
- Rewrite Telegram Bot wrappers as thin adapters delegating to shared handlers
- Rewrite DiscordRescheduleVoteHandler to use shared HandleRescheduleVoteHandler
- Update UpdateRouter with explicit type aliases for ambiguous handler names
- Add contract and source-inspection tests for extracted handlers
- Bump version 3.1.1 → 3.2.0

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

src/GmRelay.Bot/Features/Sessions/CreateSession/CreateSessionHandler.cs

@@ -1,294 +1,178 @@
 using Dapper;
 using GmRelay.Shared.Domain;
-using GmRelay.Shared.Rendering;
+using GmRelay.Shared.Platform;
+using GmRelay.Bot.Infrastructure.Telegram;
 using Npgsql;
 using Telegram.Bot;
 using Telegram.Bot.Types;
-using GmRelay.Bot.Infrastructure.Telegram;
 
 namespace GmRelay.Bot.Features.Sessions.CreateSession;
 
-internal sealed record SessionCreationGroupAccessDto(Guid GroupId, bool CanManage);
-
 public sealed class CreateSessionHandler(
+    GmRelay.Shared.Features.Sessions.CreateSession.CreateSessionHandler sharedHandler,
     NpgsqlDataSource dataSource,
-    ITelegramBotClient botClient,
+    IPlatformMessenger messenger,
     ILogger<CreateSessionHandler> logger)
 {
-    public async Task HandleAsync(Message message, CancellationToken cancellationToken)
+    public async Task HandleAsync(Message message, CancellationToken ct)
     {
         var parseResult = NewSessionCommandParser.Parse(message.Text ?? message.Caption, DateTimeOffset.UtcNow);
 
         foreach (var timeInput in parseResult.PastTimeInputs)
         {
-            await botClient.SendMessage(
-                message.Chat.Id,
+            await messenger.SendGroupMessageAsync(
+                TelegramPlatformIds.Group(message.Chat.Id, null),
                 $"⚠️ Предупреждение: дата {timeInput} находится в прошлом и будет пропущена.",
-                cancellationToken: cancellationToken);
+                ct);
         }
 
         foreach (var timeInput in parseResult.InvalidTimeInputs)
         {
-            await botClient.SendMessage(
-                message.Chat.Id,
+            await messenger.SendGroupMessageAsync(
+                TelegramPlatformIds.Group(message.Chat.Id, null),
                 $"⚠️ Предупреждение: некорректный формат времени '{timeInput}'. Пропущено.",
-                cancellationToken: cancellationToken);
+                ct);
         }
 
         foreach (var seatLimitInput in parseResult.InvalidSeatLimitInputs)
         {
-            await botClient.SendMessage(
-                message.Chat.Id,
+            await messenger.SendGroupMessageAsync(
+                TelegramPlatformIds.Group(message.Chat.Id, null),
                 $"⚠️ Предупреждение: некорректный лимит мест '{seatLimitInput}'. Укажите целое число больше 0.",
-                cancellationToken: cancellationToken);
+                ct);
         }
 
         foreach (var recurringInput in parseResult.InvalidRecurringInputs)
         {
-            await botClient.SendMessage(
-                message.Chat.Id,
+            await messenger.SendGroupMessageAsync(
+                TelegramPlatformIds.Group(message.Chat.Id, null),
                 $"⚠️ Предупреждение: некорректный повтор расписания '{recurringInput}'. Укажите число игр 1-52 и шаг 1-365 дней.",
-                cancellationToken: cancellationToken);
+                ct);
         }
 
         if (!parseResult.IsValid)
         {
-            await botClient.SendMessage(
-                chatId: message.Chat.Id,
-                text: "❌ Не удалось распознать формат. Пожалуйста, используйте шаблон:\n\n/newsession\nНазвание: My Game\nВремя: 15.05.2026 19:30\nВремя: 22.05.2026 19:30\nМест: 4\nСсылка: https://link\nКартинка: https://cover\n\nДля повтора можно указать одну дату и строки:\nИгр: 4\nИнтервал: 7",
-                cancellationToken: cancellationToken);
+            await messenger.SendGroupMessageAsync(
+                TelegramPlatformIds.Group(message.Chat.Id, null),
+                """
+                ❌ Не удалось распознать формат. Пожалуйста, используйте шаблон:
+
+                /newsession
+                Название: My Game
+                Время: 15.05.2026 19:30
+                Время: 22.05.2026 19:30
+                Мест: 4
+                Ссылка: https://link
+                Картинка: https://cover
+
+                Для повтора можно указать одну дату и строки:
+                Игр: 4
+                Интервал: 7
+                """,
+                ct);
             return;
         }
 
-        var title = parseResult.Title!;
-        var link = parseResult.Link!;
         var imageReference = GetBatchImageReference(message, parseResult.ImageUrl);
         var gmId = message.From!.Id;
         var gmName = message.From.FirstName + (string.IsNullOrEmpty(message.From.LastName) ? string.Empty : $" {message.From.LastName}");
         var gmUsername = message.From.Username;
 
-        var chatId = message.Chat.Id;
-        var chatTitle = message.Chat.Title ?? "Private Chat";
+        var topicDestination = TelegramTopicRouting.ResolveNewScheduleDestination(
+            message.Chat.IsForum,
+            message.MessageThreadId);
+        var topicCreatedByBot = topicDestination.TopicCreatedByBot;
+        var messageThreadId = topicDestination.MessageThreadId;
 
-        await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
-        await using var transaction = await connection.BeginTransactionAsync(cancellationToken);
-
-        try
+        if (topicDestination.ShouldCreateForumTopic)
         {
-            await connection.ExecuteAsync(
-                """
-                INSERT INTO players (display_name, platform, external_user_id, external_username)
-                VALUES (@Name, 'Telegram', @ExternalId, @Username)
-                ON CONFLICT (platform, external_user_id)
-                WHERE platform IS NOT NULL AND external_user_id IS NOT NULL
-                DO UPDATE
-                SET display_name = EXCLUDED.display_name,
-                    external_username = EXCLUDED.external_username;
-                """,
-                new { ExternalId = gmId.ToString(), Name = gmName, Username = gmUsername },
-                transaction);
-
-            var existingGroup = await connection.QuerySingleOrDefaultAsync<SessionCreationGroupAccessDto>(
-                """
-                SELECT g.id AS GroupId,
-                       EXISTS (
-                           SELECT 1
-                           FROM group_managers gm
-                           JOIN players p ON p.id = gm.player_id
-                           WHERE gm.group_id = g.id
-                             AND p.platform = 'Telegram'
-                             AND p.external_user_id = @ExternalGmId
-                       ) AS CanManage
-                FROM game_groups g
-                WHERE g.platform = 'Telegram'
-                  AND g.external_group_id = @ExternalChatId
-                """,
-                new { ExternalChatId = chatId.ToString(), ExternalGmId = gmId.ToString() },
-                transaction);
-
-            Guid groupId;
-            if (existingGroup is null)
-            {
-                groupId = await connection.ExecuteScalarAsync<Guid>(
-                    """
-                    INSERT INTO game_groups (name, platform, external_group_id)
-                    VALUES (@ChatName, 'Telegram', @ExternalChatId)
-                    RETURNING id;
-                    """,
-                    new { ExternalChatId = chatId.ToString(), ChatName = chatTitle },
-                    transaction);
-
-                await connection.ExecuteAsync(
-                    """
-                    INSERT INTO group_managers (group_id, player_id, role)
-                    SELECT @GroupId, p.id, @OwnerRole
-                    FROM players p
-                    WHERE p.platform = 'Telegram'
-                      AND p.external_user_id = @ExternalGmId
-                    ON CONFLICT (group_id, player_id) DO NOTHING
-                    """,
-                    new { GroupId = groupId, ExternalGmId = gmId.ToString(), OwnerRole = GroupManagerRoleExtensions.OwnerValue },
-                    transaction);
-            }
-            else
-            {
-                if (!existingGroup.CanManage)
-                {
-                    await transaction.RollbackAsync(cancellationToken);
-                    await botClient.SendMessage(
-                        chatId,
-                        "⛔ Только owner или co-GM этой группы может создавать игровые сессии.",
-                        cancellationToken: cancellationToken);
-                    return;
-                }
-
-                groupId = existingGroup.GroupId;
-                await connection.ExecuteAsync(
-                    "UPDATE game_groups SET name = @ChatName WHERE id = @GroupId",
-                    new { ChatName = chatTitle, GroupId = groupId },
-                    transaction);
-            }
-
-            var topicDestination = TelegramTopicRouting.ResolveNewScheduleDestination(
-                message.Chat.IsForum,
-                message.MessageThreadId);
-            var messageThreadId = topicDestination.MessageThreadId;
-            var topicCreatedByBot = topicDestination.TopicCreatedByBot;
-            if (topicDestination.ShouldCreateForumTopic)
-            {
-                try
-                {
-                    var topic = await botClient.CreateForumTopic(
-                        chatId: chatId,
-                        name: $"🎲 Игры: {title}",
-                        cancellationToken: cancellationToken);
-                    messageThreadId = topic.MessageThreadId;
-                }
-                catch (Telegram.Bot.Exceptions.ApiRequestException ex)
-                    when (TelegramTopicRouting.IsMissingForumTopicRightsError(ex.Message))
-                {
-                    await transaction.RollbackAsync(cancellationToken);
-                    await botClient.SendMessage(
-                        chatId,
-                        TelegramTopicRouting.MissingForumTopicRightsMessage,
-                        cancellationToken: cancellationToken);
-                    return;
-                }
-            }
-
-            var batchId = Guid.NewGuid();
-            var sessions = new List<SessionBatchDto>();
-
-            foreach (var scheduledAt in parseResult.ScheduledTimes.OrderBy(value => value))
-            {
-                var sessionId = await connection.ExecuteScalarAsync<Guid>(
-                    """
-                    INSERT INTO sessions (batch_id, group_id, title, join_link, scheduled_at, status, thread_id, topic_created_by_bot, max_players)
-                    VALUES (@BatchId, @GroupId, @Title, @Link, @ScheduledAt, @Status, @ThreadId, @TopicCreatedByBot, @MaxPlayers)
-                    RETURNING id;
-                    """,
-                    new
-                    {
-                        BatchId = batchId,
-                        GroupId = groupId,
-                        Title = title,
-                        Link = link,
-                        ScheduledAt = scheduledAt,
-                        ThreadId = messageThreadId,
-                        TopicCreatedByBot = topicCreatedByBot,
-                        MaxPlayers = parseResult.MaxPlayers,
-                        Status = SessionStatus.Planned
-                    },
-                    transaction);
-
-                sessions.Add(new SessionBatchDto(sessionId, scheduledAt.UtcDateTime, SessionStatus.Planned, parseResult.MaxPlayers, link));
-            }
-
-            await transaction.CommitAsync(cancellationToken);
-            logger.LogInformation("Создан батч {BatchId} с {Count} сессиями в группе {GroupId}", batchId, sessions.Count, groupId);
-
-            var view = SessionBatchViewBuilder.Build(title, sessions, Array.Empty<ParticipantBatchDto>());
-            var renderResult = TelegramSessionBatchRenderer.Render(view);
-
-            Message batchMessage;
-
-            if (imageReference is not null && renderResult.Text.Length <= 1024)
-            {
-                // Картинка + расписание умещаются в одном Telegram-фото с подписью
-                try
-                {
-                    batchMessage = await botClient.SendPhoto(
-                        chatId: chatId,
-                        messageThreadId: messageThreadId,
-                        photo: InputFile.FromString(imageReference),
-                        caption: renderResult.Text,
-                        parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                        replyMarkup: renderResult.Markup,
-                        cancellationToken: cancellationToken);
-                }
-                catch (Exception ex)
-                {
-                    logger.LogWarning(ex, "Не удалось отправить картинку для батча {BatchId}, отправляем текстом", batchId);
-                    batchMessage = await botClient.SendMessage(
-                        chatId: chatId,
-                        messageThreadId: messageThreadId,
-                        text: renderResult.Text,
-                        parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                        replyMarkup: renderResult.Markup,
-                        cancellationToken: cancellationToken);
-                }
-            }
-            else
-            {
-                // Текст слишком длинный для caption — fallback на два сообщения
-                if (imageReference is not null)
-                {
-                    try
-                    {
-                        await botClient.SendPhoto(
-                            chatId: chatId,
-                            messageThreadId: messageThreadId,
-                            photo: InputFile.FromString(imageReference),
-                            caption: $"🎲 {System.Net.WebUtility.HtmlEncode(title)}",
-                            parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                            cancellationToken: cancellationToken);
-                    }
-                    catch (Exception ex)
-                    {
-                        logger.LogWarning(ex, "Не удалось отправить картинку для батча {BatchId}", batchId);
-                    }
-                }
-
-                batchMessage = await botClient.SendMessage(
-                    chatId: chatId,
-                    messageThreadId: messageThreadId,
-                    text: renderResult.Text,
-                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                    replyMarkup: renderResult.Markup,
-                    cancellationToken: cancellationToken);
-            }
-
-            await connection.ExecuteAsync(
-                "UPDATE sessions SET batch_message_id = @MsgId WHERE batch_id = @BatchId",
-                new { MsgId = batchMessage.MessageId, BatchId = batchId });
-
             try
             {
-                await botClient.DeleteMessage(
-                    chatId: chatId,
-                    messageId: message.MessageId,
-                    cancellationToken: cancellationToken);
+                var topicRef = await messenger.CreateThreadAsync(
+                    TelegramPlatformIds.Group(message.Chat.Id, null),
+                    $"🎲 Игры: {parseResult.Title}",
+                    ct);
+                messageThreadId = int.Parse(topicRef.ExternalThreadId!, System.Globalization.CultureInfo.InvariantCulture);
             }
             catch (Exception ex)
+                when (ex.Message.Contains("not enough rights") ||
+                      ex.Message.Contains("CHAT_ADMIN_REQUIRED") ||
+                      ex.Message.Contains("not an administrator"))
             {
-                logger.LogWarning(ex, "Не удалось удалить исходное сообщение {MessageId} в чате {ChatId}", message.MessageId, chatId);
+                await messenger.SendGroupMessageAsync(
+                    TelegramPlatformIds.Group(message.Chat.Id, null),
+                    TelegramTopicRouting.MissingForumTopicRightsMessage,
+                    ct);
+                return;
             }
         }
+
+        var platformGroup = TelegramPlatformIds.Group(message.Chat.Id, messageThreadId, message.Chat.Title ?? "Private Chat");
+        var platformUser = new PlatformUser(
+            PlatformKind.Telegram,
+            gmId.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            gmName,
+            gmUsername);
+
+        var command = new GmRelay.Shared.Features.Sessions.CreateSession.CreateSessionCommand(
+            platformUser,
+            platformGroup,
+            parseResult.Title!,
+            parseResult.Link!,
+            parseResult.ScheduledTimes,
+            parseResult.MaxPlayers,
+            imageReference);
+
+        GmRelay.Shared.Features.Sessions.CreateSession.CreateSessionResult result;
+        try
+        {
+            result = await sharedHandler.HandleAsync(command, ct);
+        }
+        catch
+        {
+            await messenger.SendGroupMessageAsync(
+                TelegramPlatformIds.Group(message.Chat.Id, null),
+                "💥 Произошла ошибка базы данных при создании сессии.",
+                ct);
+            throw;
+        }
+
+        if (!result.Success)
+        {
+            await messenger.SendGroupMessageAsync(
+                TelegramPlatformIds.Group(message.Chat.Id, null),
+                result.ErrorMessage!,
+                ct);
+            return;
+        }
+
+        var scheduleMessage = new PlatformScheduleMessage(
+            platformGroup,
+            result.View!,
+            null,
+            imageReference);
+
+        var sentMessageRef = await messenger.SendScheduleAsync(scheduleMessage, ct);
+
+        // Store batch_message_id
+        if (int.TryParse(sentMessageRef.ExternalMessageId, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out var batchMessageId))
+        {
+            await using var connection = await dataSource.OpenConnectionAsync(ct);
+            await connection.ExecuteAsync(
+                "UPDATE sessions SET batch_message_id = @MsgId WHERE batch_id = @BatchId",
+                new { MsgId = batchMessageId, BatchId = result.BatchId });
+        }
+
+        // Delete original message
+        try
+        {
+            await messenger.DeleteMessageAsync(
+                TelegramPlatformIds.Message(message.Chat.Id, null, message.MessageId),
+                ct);
+        }
         catch (Exception ex)
         {
-            logger.LogError(ex, "Ошибка при создании сессии");
-            await transaction.RollbackAsync(cancellationToken);
-            await botClient.SendMessage(chatId, "💥 Произошла ошибка базы данных при создании сессии.", cancellationToken: cancellationToken);
+            logger.LogWarning(ex, "Не удалось удалить исходное сообщение {MessageId} в чате {ChatId}", message.MessageId, message.Chat.Id);
         }
     }
 

src/GmRelay.Bot/Features/Sessions/ExportCalendar/ExportCalendarHandler.cs

@@ -1,114 +1,25 @@
-using System.Text;
-using Dapper;
-using GmRelay.Bot.Infrastructure.Telegram;
-using GmRelay.Shared.Domain;
 using GmRelay.Shared.Platform;
-using Microsoft.Extensions.Configuration;
-using Npgsql;
 using Telegram.Bot.Types;
 
 namespace GmRelay.Bot.Features.Sessions.ExportCalendar;
 
-internal sealed record CalendarSessionDto(Guid Id, string Title, DateTime ScheduledAt);
-
 public sealed class ExportCalendarHandler(
-    NpgsqlDataSource dataSource,
-    IPlatformMessenger messenger,
-    IConfiguration configuration)
+    GmRelay.Shared.Features.Sessions.ExportCalendar.ExportCalendarHandler sharedHandler)
 {
-    public async Task HandleAsync(Message message, CancellationToken cancellationToken)
+    public Task HandleAsync(Message message, CancellationToken cancellationToken)
     {
-        await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
+        var command = new GmRelay.Shared.Features.Sessions.ExportCalendar.ExportCalendarCommand(
+            new PlatformGroup(
+                PlatformKind.Telegram,
+                message.Chat.Id.ToString(),
+                message.Chat.Title ?? "Private Chat",
+                message.MessageThreadId?.ToString()),
+            new PlatformUser(
+                PlatformKind.Telegram,
+                message.From?.Id.ToString() ?? string.Empty,
+                message.From?.FirstName ?? string.Empty,
+                message.From?.Username));
 
-        var sessions = await connection.QueryAsync<CalendarSessionDto>(
-            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt"
-            + " FROM sessions s"
-            + " JOIN game_groups g ON s.group_id = g.id"
-            + " WHERE g.platform = 'Telegram'"
-            + " AND g.external_group_id = @ExternalChatId"
-            + " AND s.status = @Planned"
-            + " AND s.scheduled_at > NOW()"
-            + " ORDER BY s.scheduled_at ASC",
-            new { ExternalChatId = message.Chat.Id.ToString(), Planned = SessionStatus.Planned });
-
-        var sessionsList = sessions.ToList();
-
-        if (sessionsList.Count == 0)
-        {
-            await messenger.SendGroupMessageAsync(
-                TelegramPlatformIds.Group(message.Chat.Id, message.MessageThreadId),
-                "📭 У этой группы нет запланированных сессий для экспорта.",
-                cancellationToken);
-            return;
-        }
-
-        var sb = new StringBuilder();
-        sb.AppendLine("BEGIN:VCALENDAR");
-        sb.AppendLine("VERSION:2.0");
-        sb.AppendLine("PRODID:-//GM-Relay//TTRPG Schedule//EN");
-
-        foreach (var s in sessionsList)
-        {
-            var dtStart = s.ScheduledAt.ToString("yyyyMMddTHHmmssZ");
-            var dtEnd = s.ScheduledAt.AddHours(4).ToString("yyyyMMddTHHmmssZ");
-
-            sb.AppendLine("BEGIN:VEVENT");
-            sb.AppendLine($"UID:{s.Id}@gmrelay");
-            sb.AppendLine($"DTSTAMP:{DateTime.UtcNow:yyyyMMddTHHmmssZ}");
-            sb.AppendLine($"DTSTART:{dtStart}");
-            sb.AppendLine($"DTEND:{dtEnd}");
-            sb.AppendLine($"SUMMARY:{s.Title}");
-            sb.AppendLine("END:VEVENT");
-        }
-
-        sb.AppendLine("END:VCALENDAR");
-
-        var bytes = Encoding.UTF8.GetBytes(sb.ToString());
-
-
-        // Create calendar subscription
-        string? subscriptionUrl = null;
-        var baseUrl = configuration["Web:BaseUrl"];
-        var senderId = message.From?.Id;
-        if (!string.IsNullOrWhiteSpace(baseUrl) && senderId.HasValue)
-        {
-            try
-            {
-                var token = Guid.NewGuid().ToString("N");
-                var groupId = await connection.QueryFirstOrDefaultAsync<Guid?>(
-                    @"SELECT id FROM game_groups WHERE platform = 'Telegram' AND external_group_id = @ExternalChatId",
-                    new { ExternalChatId = message.Chat.Id.ToString() });
-
-                await connection.ExecuteAsync(
-                    @"INSERT INTO calendar_subscriptions (id, token, user_platform, user_external_id, group_id, filter_type, created_at, expires_at)
-                      VALUES (gen_random_uuid(), @token, 'Telegram', @userExternalId, @groupId, @filterType, now(), NULL)",
-                    new { token, userExternalId = senderId.Value.ToString(), groupId, filterType = (int)CalendarSubscriptionFilter.SpecificGroup });
-
-                subscriptionUrl = $"{baseUrl.TrimEnd('/')}/calendar/{token}.ics";
-            }
-            catch
-            {
-                // Non-critical: if subscription creation fails, still send the file
-            }
-        }
-
-        var actions = subscriptionUrl is not null
-            ? new[]
-            {
-                new PlatformMessageAction(
-                    "calendar-subscription",
-                    "🔗 Подписаться на календарь",
-                    subscriptionUrl)
-            }
-            : Array.Empty<PlatformMessageAction>();
-
-        await messenger.SendCalendarFileAsync(
-            new PlatformCalendarFile(
-                TelegramPlatformIds.Group(message.Chat.Id, message.MessageThreadId),
-                "schedule.ics",
-                bytes,
-                "📅 <b>Ваш календарь игр!</b>\nОткройте файл на устройстве, чтобы добавить события в свой календарь.",
-                actions),
-            cancellationToken);
+        return sharedHandler.HandleAsync(command, cancellationToken);
     }
 }

src/GmRelay.Bot/Features/Sessions/ListSessions/DeleteSessionHandler.cs

@@ -1,8 +1,5 @@
-using Dapper;
-using Npgsql;
-using Telegram.Bot;
 using GmRelay.Bot.Infrastructure.Telegram;
-using GmRelay.Shared.Domain;
+using GmRelay.Shared.Platform;
 
 namespace GmRelay.Bot.Features.Sessions.ListSessions;
 
@@ -13,143 +10,88 @@ public sealed record DeleteSessionCommand(
     long ChatId,
     int MessageId);
 
-internal sealed record DeleteSessionInfoDto(
-    string Title,
-    Guid BatchId,
-    Guid GroupId,
-    bool CanManage,
-    int? ThreadId,
-    bool TopicCreatedByBot);
-
 public sealed class DeleteSessionHandler(
-    NpgsqlDataSource dataSource,
-    ITelegramBotClient bot,
+    GmRelay.Shared.Features.Sessions.ListSessions.DeleteSessionHandler sharedHandler,
+    GmRelay.Shared.Features.Sessions.ListSessions.ListSessionsHandler listSessionsHandler,
+    IPlatformMessenger messenger,
     ILogger<DeleteSessionHandler> logger)
 {
     public async Task HandleAsync(DeleteSessionCommand command, CancellationToken ct)
     {
-        await using var connection = await dataSource.OpenConnectionAsync(ct);
-        await using var transaction = await connection.BeginTransactionAsync(ct);
+        var platformUser = new PlatformUser(
+            PlatformKind.Telegram,
+            command.TelegramUserId.ToString(),
+            string.Empty,
+            null);
 
-        // 1. Fetch session and verify group manager.
-        var session = await connection.QuerySingleOrDefaultAsync<DeleteSessionInfoDto>(
-            """
-            SELECT s.title AS Title,
-                   s.batch_id AS BatchId,
-                   s.group_id AS GroupId,
-                   s.thread_id AS ThreadId,
-                   s.topic_created_by_bot AS TopicCreatedByBot,
-                   EXISTS (
-                       SELECT 1
-                       FROM group_managers gm
-                       JOIN players p ON p.id = gm.player_id
-                       WHERE gm.group_id = s.group_id
-                         AND p.platform = 'Telegram'
-                       AND p.external_user_id = @ExternalUserId
-                   ) AS CanManage
-            FROM sessions s
-            WHERE s.id = @SessionId
-            """,
-            new { command.SessionId, ExternalUserId = command.TelegramUserId.ToString() }, transaction);
+        var platformGroup = new PlatformGroup(
+            PlatformKind.Telegram,
+            command.ChatId.ToString(),
+            string.Empty);
 
-        if (session == null)
+        var scheduleMessage = TelegramPlatformIds.Message(command.ChatId, null, command.MessageId);
+
+        var sharedCommand = new GmRelay.Shared.Features.Sessions.ListSessions.DeleteSessionCommand(
+            command.SessionId,
+            platformUser,
+            platformGroup,
+            scheduleMessage);
+
+        var result = await sharedHandler.HandleAsync(sharedCommand, ct);
+
+        if (!result.Success)
         {
-            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия не найдена.", cancellationToken: ct);
+            await messenger.AnswerInteractionAsync(
+                new PlatformInteractionReply(command.CallbackQueryId, result.ReplyText!, result.ReplyText!.Contains("owner")),
+                ct);
             return;
         }
 
-        if (!session.CanManage)
-        {
-            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Только owner или co-GM может удалять сессию.", showAlert: true, cancellationToken: ct);
-            return;
-        }
-
-        // 2. Delete session
-        await connection.ExecuteAsync("DELETE FROM sessions WHERE id = @Id", new { Id = command.SessionId }, transaction);
-
-        var remainingInTopic = session.ThreadId.HasValue
-            ? await connection.ExecuteScalarAsync<int>(
-                """
-                SELECT COUNT(*)
-                FROM sessions
-                WHERE group_id = @GroupId
-                  AND thread_id = @ThreadId
-                """,
-                new { session.GroupId, ThreadId = session.ThreadId.Value },
-                transaction)
-            : 0;
-
-        await transaction.CommitAsync(ct);
-
         // 4. If no sessions are left in a bot-owned forum topic, delete the topic.
-        if (session.ThreadId.HasValue &&
-            TelegramTopicRouting.ShouldDeleteForumTopic(session.TopicCreatedByBot, remainingInTopic))
+        if (result.ThreadId.HasValue &&
+            TelegramTopicRouting.ShouldDeleteForumTopic(result.TopicCreatedByBot, result.RemainingInTopic))
         {
             try
             {
-                await bot.DeleteForumTopic(command.ChatId, session.ThreadId.Value, cancellationToken: ct);
-                logger.LogInformation("Deleted forum topic {ThreadId} for batch {BatchId} as no sessions remained.", session.ThreadId.Value, session.BatchId);
+                await messenger.DeleteThreadAsync(
+                    new PlatformGroup(PlatformKind.Telegram, command.ChatId.ToString(), string.Empty, null, result.ThreadId.Value.ToString(System.Globalization.CultureInfo.InvariantCulture)),
+                    ct);
+                logger.LogInformation("Deleted forum topic {ThreadId} for batch {BatchId} as no sessions remained.", result.ThreadId.Value, result.GroupId);
             }
             catch (Exception ex)
             {
-                logger.LogWarning(ex, "Failed to delete forum topic {ThreadId}", session.ThreadId.Value);
+                logger.LogWarning(ex, "Failed to delete forum topic {ThreadId}", result.ThreadId.Value);
             }
         }
 
-        await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия удалена!", cancellationToken: ct);
+        await messenger.AnswerInteractionAsync(
+            new PlatformInteractionReply(command.CallbackQueryId, result.ReplyText!),
+            ct);
 
-        // 5. Update the /listsessions message (we delete the message or edit it to remove the button)
-        // A simple way is to re-render the list:
-        await using var readConnection = await dataSource.OpenConnectionAsync(ct);
-        var sessions = await readConnection.QueryAsync<SessionListItemDto>(
-            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt, s.status as Status, s.max_players as MaxPlayers,
-                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false AND sp.registration_status = @Active) as PlayerCount,
-                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false AND sp.registration_status = @Waitlisted) as WaitlistCount,
-                     EXISTS (
-                         SELECT 1
-                         FROM group_managers gm
-                         JOIN players manager_player ON manager_player.id = gm.player_id
-                         WHERE gm.group_id = s.group_id
-                           AND manager_player.platform = 'Telegram'
-                           AND manager_player.external_user_id = @ExternalUserId
-                     ) AS CanManage
-              FROM sessions s
-              JOIN game_groups g ON s.group_id = g.id
-              LEFT JOIN session_participants sp ON s.id = sp.session_id
-              WHERE g.platform = 'Telegram'
-                AND g.external_group_id = @ExternalChatId
-                AND s.status != @Cancelled
-                AND s.scheduled_at > NOW()
-              GROUP BY s.id, s.title, s.scheduled_at, s.status, s.max_players, s.group_id
-              ORDER BY s.scheduled_at ASC",
-            new
-            {
-                ExternalChatId = command.ChatId.ToString(),
-                ExternalUserId = command.TelegramUserId.ToString(),
-                Cancelled = SessionStatus.Cancelled,
-                Active = ParticipantRegistrationStatus.Active,
-                Waitlisted = ParticipantRegistrationStatus.Waitlisted
-            });
+        // 5. Update the /listsessions message
+        var listCommand = new GmRelay.Shared.Features.Sessions.ListSessions.ListSessionsCommand(platformGroup, platformUser);
+        var listResult = await listSessionsHandler.HandleAsync(listCommand, ct);
 
-        var sessionsList = sessions.ToList();
-
-        if (sessionsList.Count == 0)
+        if (listResult.Sessions.Count == 0)
         {
-            try { await bot.EditMessageText(command.ChatId, command.MessageId, "📭 В этой группе нет предстоящих игр.", cancellationToken: ct); } catch { }
+            try
+            {
+                await messenger.UpdateGroupMessageAsync(
+                    scheduleMessage,
+                    "📭 В этой группе нет предстоящих игр.",
+                    [],
+                    ct);
+            }
+            catch { }
             return;
         }
 
-        var renderResult = SessionListMessageRenderer.Render(sessionsList);
+        var text = SessionListMessageRenderer.RenderText(listResult.Sessions);
+        var actions = listResult.CanManage ? SessionListMessageRenderer.RenderActions(listResult.Sessions) : [];
 
         try
         {
-            await bot.EditMessageText(
-                command.ChatId,
-                command.MessageId,
-                renderResult.Text,
-                parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                replyMarkup: renderResult.Markup,
-                cancellationToken: ct);
+            await messenger.UpdateGroupMessageAsync(scheduleMessage, text, actions, ct);
         }
         catch (Exception ex)
         {

src/GmRelay.Bot/Features/Sessions/ListSessions/ListSessionsHandler.cs

@@ -1,118 +1,37 @@
-using Dapper;
-using GmRelay.Shared.Domain;
-using Npgsql;
-using Telegram.Bot;
+using GmRelay.Shared.Platform;
 using Telegram.Bot.Types;
-using Telegram.Bot.Types.ReplyMarkups;
 
 namespace GmRelay.Bot.Features.Sessions.ListSessions;
 
-internal sealed record SessionListItemDto(Guid Id, string Title, DateTime ScheduledAt, string Status, int? MaxPlayers, int PlayerCount, int WaitlistCount, bool CanManage);
-
-internal static class SessionListMessageRenderer
-{
-    public static (string Text, InlineKeyboardMarkup? Markup) Render(IReadOnlyList<SessionListItemDto> sessions)
-    {
-        var text = "📅 <b>Ближайшие игры:</b>\n\n";
-        foreach (var session in sessions)
-        {
-            var seats = session.MaxPlayers.HasValue
-                ? $"{session.PlayerCount}/{session.MaxPlayers.Value}"
-                : session.PlayerCount.ToString(System.Globalization.CultureInfo.InvariantCulture);
-            var waitlist = session.WaitlistCount > 0 ? $", ожидание: {session.WaitlistCount}" : string.Empty;
-            text += $"🔹 <b>{session.ScheduledAt.FormatMoscow()}</b> — {System.Net.WebUtility.HtmlEncode(session.Title)} (Места: {seats}{waitlist})\n";
-        }
-
-        var canManage = sessions.Count > 0 && sessions.First().CanManage;
-        if (!canManage)
-        {
-            return (text, null);
-        }
-
-        var buttons = new List<InlineKeyboardButton[]>();
-        foreach (var session in sessions)
-        {
-            var dateTitle = session.ScheduledAt.FormatMoscowShort();
-            buttons.Add(
-            [
-                InlineKeyboardButton.WithCallbackData($"❌ {dateTitle}", $"cancel_session:{session.Id}"),
-                InlineKeyboardButton.WithCallbackData($"⏰ {dateTitle}", $"reschedule_session:{session.Id}")
-            ]);
-
-            if (SessionCapacityRules.CanPromoteWaitlistedPlayer(session.MaxPlayers, session.PlayerCount, session.WaitlistCount))
-            {
-                buttons.Add(
-                [
-                    InlineKeyboardButton.WithCallbackData($"⬆️ Из ожидания {dateTitle}", $"promote_waitlist:{session.Id}")
-                ]);
-            }
-
-            buttons.Add(
-            [
-                InlineKeyboardButton.WithCallbackData($"🗑 Удалить {dateTitle}", $"delete_session:{session.Id}")
-            ]);
-        }
-
-        return (text, new InlineKeyboardMarkup(buttons));
-    }
-}
-
 public sealed class ListSessionsHandler(
-    NpgsqlDataSource dataSource,
-    ITelegramBotClient botClient)
+    GmRelay.Shared.Features.Sessions.ListSessions.ListSessionsHandler sharedHandler,
+    IPlatformMessenger messenger)
 {
     public async Task HandleAsync(Message message, CancellationToken cancellationToken)
     {
-        await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
+        var command = new GmRelay.Shared.Features.Sessions.ListSessions.ListSessionsCommand(
+            new PlatformGroup(
+                PlatformKind.Telegram,
+                message.Chat.Id.ToString(),
+                message.Chat.Title ?? "Private Chat",
+                message.MessageThreadId?.ToString()),
+            new PlatformUser(
+                PlatformKind.Telegram,
+                message.From?.Id.ToString() ?? string.Empty,
+                message.From?.FirstName ?? string.Empty,
+                message.From?.Username));
 
-        var sessions = await connection.QueryAsync<SessionListItemDto>(
-            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt, s.status as Status, s.max_players as MaxPlayers,
-                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false AND sp.registration_status = @Active) as PlayerCount,
-                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false AND sp.registration_status = @Waitlisted) as WaitlistCount,
-                     EXISTS (
-                         SELECT 1
-                         FROM group_managers gm
-                         JOIN players manager_player ON manager_player.id = gm.player_id
-                         WHERE gm.group_id = s.group_id
-                           AND manager_player.platform = 'Telegram'
-                           AND manager_player.external_user_id = @ExternalUserId
-                     ) AS CanManage
-              FROM sessions s
-              JOIN game_groups g ON s.group_id = g.id
-              LEFT JOIN session_participants sp ON s.id = sp.session_id
-              WHERE g.platform = 'Telegram'
-                AND g.external_group_id = @ExternalChatId
-                AND s.status != @Cancelled
-                AND s.scheduled_at > NOW()
-              GROUP BY s.id, s.title, s.scheduled_at, s.status, s.max_players, s.group_id
-              ORDER BY s.scheduled_at ASC",
-            new
-            {
-                ExternalChatId = message.Chat.Id.ToString(),
-                ExternalUserId = message.From?.Id.ToString(),
-                Cancelled = SessionStatus.Cancelled,
-                Active = ParticipantRegistrationStatus.Active,
-                Waitlisted = ParticipantRegistrationStatus.Waitlisted
-            });
+        var result = await sharedHandler.HandleAsync(command, cancellationToken);
 
-        var sessionsList = sessions.ToList();
-
-        if (sessionsList.Count == 0)
+        if (result.Sessions.Count == 0)
         {
-            await botClient.SendMessage(
-                chatId: message.Chat.Id,
-                text: "📭 В этой группе нет предстоящих игр.",
-                cancellationToken: cancellationToken);
+            await messenger.SendGroupMessageAsync(command.Group, "📭 В этой группе нет предстоящих игр.", cancellationToken);
             return;
         }
 
-        var renderResult = SessionListMessageRenderer.Render(sessionsList);
+        var text = SessionListMessageRenderer.RenderText(result.Sessions);
+        var actions = result.CanManage ? SessionListMessageRenderer.RenderActions(result.Sessions) : [];
 
-        await botClient.SendMessage(
-            chatId: message.Chat.Id,
-            text: renderResult.Text,
-            parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-            replyMarkup: renderResult.Markup,
-            cancellationToken: cancellationToken);
+        await messenger.SendGroupMessageAsync(command.Group, text, actions, cancellationToken);
     }
 }

src/GmRelay.Bot/Features/Sessions/ListSessions/SessionListMessageRenderer.cs

@@ -0,0 +1,63 @@
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Platform;
+using GmRelay.Shared.Features.Sessions.ListSessions;
+
+namespace GmRelay.Bot.Features.Sessions.ListSessions;
+
+internal static class SessionListMessageRenderer
+{
+    public static string RenderText(IReadOnlyList<SessionListItemDto> sessions)
+    {
+        var text = "📅 <b>Ближайшие игры:</b>\n\n";
+        foreach (var session in sessions)
+        {
+            var seats = session.MaxPlayers.HasValue
+                ? $"{session.PlayerCount}/{session.MaxPlayers.Value}"
+                : session.PlayerCount.ToString(System.Globalization.CultureInfo.InvariantCulture);
+            var waitlist = session.WaitlistCount > 0 ? $", ожидание: {session.WaitlistCount}" : string.Empty;
+            text += $"🔹 <b>{session.ScheduledAt.FormatMoscow()}</b> — {System.Net.WebUtility.HtmlEncode(session.Title)} (Места: {seats}{waitlist})\n";
+        }
+
+        return text;
+    }
+
+    public static IReadOnlyList<PlatformMessageAction> RenderActions(IReadOnlyList<SessionListItemDto> sessions)
+    {
+        if (sessions.Count == 0 || !sessions.First().CanManage)
+        {
+            return [];
+        }
+
+        var actions = new List<PlatformMessageAction>();
+
+        foreach (var session in sessions)
+        {
+            var dateTitle = session.ScheduledAt.FormatMoscowShort();
+
+            actions.Add(new PlatformMessageAction(
+                $"cancel_session:{session.Id}",
+                $"❌ {dateTitle}",
+                $"cancel_session:{session.Id}"));
+
+            actions.Add(new PlatformMessageAction(
+                $"reschedule_session:{session.Id}",
+                $"⏰ {dateTitle}",
+                $"reschedule_session:{session.Id}"));
+
+            if (SessionCapacityRules.CanPromoteWaitlistedPlayer(session.MaxPlayers, session.PlayerCount, session.WaitlistCount))
+            {
+                actions.Add(new PlatformMessageAction(
+                    $"promote_waitlist:{session.Id}",
+                    $"⬆️ Из ожидания {dateTitle}",
+                    $"promote_waitlist:{session.Id}"));
+            }
+
+            actions.Add(new PlatformMessageAction(
+                $"delete_session:{session.Id}",
+                $"🗑 Удалить {dateTitle}",
+                $"delete_session:{session.Id}"));
+        }
+
+        return actions;
+    }
+}

src/GmRelay.Bot/Features/Sessions/RescheduleSession/HandleRescheduleTimeInputHandler.cs

@@ -12,243 +12,156 @@ using GmRelay.Bot.Infrastructure.Telegram;
 
 namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
 
-// ── DTOs ─────────────────────────────────────────────────────────────
-
-internal sealed record AwaitingProposalDto(
-    Guid Id, Guid SessionId, string Title, DateTime CurrentScheduledAt,
-    Guid BatchId, int? BatchMessageId, long TelegramChatId, int? ThreadId, string NotificationMode);
-
-// ── Handler ──────────────────────────────────────────────────────────
-
 /// <summary>
-/// Handles text input from the GM who has an AwaitingTime proposal.
-/// Parses reschedule options with a voting deadline, creates a voting message,
-/// and tags all participants.
-/// If no participants are registered, reschedules immediately.
+/// Telegram adapter for reschedule time input.
+/// Delegates core logic to the shared handler, then performs Telegram-specific
+/// message sending, DM notifications, vote_message_id storage, and cleanup.
 /// </summary>
 public sealed class HandleRescheduleTimeInputHandler(
+    GmRelay.Shared.Features.Sessions.RescheduleSession.HandleRescheduleTimeInputHandler sharedHandler,
     NpgsqlDataSource dataSource,
     ITelegramBotClient bot,
     IPlatformMessenger messenger,
     DirectSessionNotificationSender directSender,
     ILogger<HandleRescheduleTimeInputHandler> logger)
 {
-    /// <summary>
-    /// Attempts to handle a text message as reschedule time input.
-    /// Returns true if it was handled (i.e. user had an AwaitingTime proposal).
-    /// </summary>
     public async Task<bool> TryHandleAsync(Message message, CancellationToken ct)
     {
         if (message.From is null || string.IsNullOrWhiteSpace(message.Text))
             return false;
 
-        var gmTelegramId = message.From.Id;
-        var chatId = message.Chat.Id;
-        var text = message.Text.Trim();
+        var command = new GmRelay.Shared.Features.Sessions.RescheduleSession.HandleRescheduleTimeInputCommand(
+            new PlatformUser(
+                PlatformKind.Telegram,
+                message.From.Id.ToString(),
+                message.From.FirstName + (string.IsNullOrEmpty(message.From.LastName) ? "" : $" {message.From.LastName}"),
+                message.From.Username),
+            TelegramPlatformIds.Group(message.Chat.Id, message.MessageThreadId, message.Chat.Title),
+            message.Text.Trim());
 
-        await using var connection = await dataSource.OpenConnectionAsync(ct);
-
-        // 1. Check if this GM has an AwaitingTime proposal in this chat
-        var proposal = await connection.QuerySingleOrDefaultAsync<AwaitingProposalDto>(
-            """
-            SELECT rp.id AS Id, rp.session_id AS SessionId, s.title AS Title, s.scheduled_at AS CurrentScheduledAt,
-                   s.batch_id AS BatchId, s.batch_message_id AS BatchMessageId,
-                   g.external_group_id::BIGINT AS TelegramChatId,
-                   s.thread_id AS ThreadId,
-                   s.notification_mode AS NotificationMode
-            FROM reschedule_proposals rp
-            JOIN sessions s ON s.id = rp.session_id
-            JOIN game_groups g ON g.id = s.group_id
-            WHERE rp.proposed_by_external_user_id = @ExternalGmId
-              AND rp.status = 'AwaitingTime'
-              AND g.platform = 'Telegram'
-              AND g.external_group_id = @ExternalChatId
-              AND EXISTS (
-                  SELECT 1
-                  FROM group_managers gm
-                  JOIN players manager_player ON manager_player.id = gm.player_id
-                  WHERE gm.group_id = s.group_id
-                    AND manager_player.platform = 'Telegram'
-                    AND manager_player.external_user_id = @ExternalGmId
-              )
-            ORDER BY rp.created_at DESC
-            LIMIT 1
-            """,
-            new { ExternalGmId = gmTelegramId.ToString(), ExternalChatId = chatId.ToString() });
-
-        if (proposal is null)
+        var result = await sharedHandler.HandleAsync(command, ct);
+        if (!result.Handled)
             return false;
 
-        // 2. Parse voting input
-        if (!RescheduleVotingInput.TryParse(text, DateTimeOffset.UtcNow, out var votingInput, out var parseError))
+        if (!string.IsNullOrEmpty(result.ReplyText) && !result.IsRescheduledImmediately)
         {
             await messenger.SendGroupMessageAsync(
-                TelegramPlatformIds.Group(chatId, proposal.ThreadId),
-                $"⚠️ {parseError}\n\nИспользуйте формат:\n<code>25.04.2026 19:30\n26.04.2026 18:00\nДедлайн: 25.04.2026 12:00</code>",
+                command.Group,
+                $"""⚠️ {result.ReplyText}\n\nИспользуйте формат:\n<code>25.04.2026 19:30\n26.04.2026 18:00\nДедлайн: 25.04.2026 12:00</code>""",
                 ct);
             return true;
         }
 
-        // 3. Load participants (non-GM) signed up for this session
-        var participants = (await connection.QueryAsync<VoteParticipantDto>(
-            """
-            SELECT p.id AS PlayerId,
-                   p.display_name AS DisplayName,
-                   p.external_username AS TelegramUsername,
-                   p.external_user_id::BIGINT AS TelegramId
-            FROM session_participants sp
-            JOIN players p ON p.id = sp.player_id
-            WHERE sp.session_id = @SessionId
-              AND sp.is_gm = false
-              AND sp.registration_status = @Active
-            """,
-            new { proposal.SessionId, Active = ParticipantRegistrationStatus.Active })).ToList();
-
-        // 4. If no participants — reschedule immediately
-        if (participants.Count == 0)
+        if (result.IsRescheduledImmediately)
         {
-            await RescheduleImmediately(connection, proposal, votingInput.Options[0], chatId, ct);
-            await TryDeleteMessage(chatId, message.MessageId, ct);
+            if (result.UpdatedView is not null && result.BatchMessageId.HasValue)
+            {
+                await TryUpdateBatchMessage(
+                    command.Group,
+                    result.UpdatedView,
+                    TelegramPlatformIds.Message(message.Chat.Id, message.MessageThreadId, result.BatchMessageId.Value),
+                    ct);
+            }
+
+            await messenger.SendGroupMessageAsync(command.Group, result.ReplyText!, ct);
+            await TryDeleteMessage(message.Chat.Id, message.MessageId, ct);
             return true;
         }
 
-        // 5. Create voting message
-        await using var transaction = await connection.BeginTransactionAsync(ct);
-        var options = votingInput.Options
-            .Select((proposedAt, index) => new RescheduleOptionDto(
-                Guid.NewGuid(),
-                index + 1,
-                proposedAt))
-            .ToList();
-
-        await connection.ExecuteAsync(
-            """
-            UPDATE reschedule_proposals
-            SET voting_deadline_at = @Deadline, status = 'Voting', vote_chat_id = @ChatId
-            WHERE id = @Id
-            """,
-            new { votingInput.Deadline, ChatId = chatId, Id = proposal.Id },
-            transaction);
-
-        foreach (var option in options)
-        {
-            await connection.ExecuteAsync(
-                """
-                INSERT INTO reschedule_options (id, proposal_id, proposed_at, display_order)
-                VALUES (@OptionId, @ProposalId, @ProposedAt, @DisplayOrder)
-                """,
-                new
-                {
-                    option.OptionId,
-                    ProposalId = proposal.Id,
-                    option.ProposedAt,
-                    option.DisplayOrder
-                },
-                transaction);
-        }
-
-        await transaction.CommitAsync(ct);
-
+        // Voting mode
         var voteText = BuildVotingMessage(
-            proposal.Title,
-            proposal.CurrentScheduledAt,
-            votingInput.Deadline,
-            options,
-            participants,
+            result.Title!,
+            result.CurrentScheduledAt,
+            result.VotingDeadlineAt!.Value,
+            result.Options,
+            result.Participants,
             []);
-        var keyboard = BuildVotingKeyboard(options);
+
+        var keyboard = BuildVotingKeyboard(result.Options);
 
         var voteMsg = await bot.SendMessage(
-            chatId: chatId,
-            messageThreadId: proposal.ThreadId,
+            chatId: message.Chat.Id,
+            messageThreadId: message.MessageThreadId,
             text: voteText,
             parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
             replyMarkup: keyboard,
             cancellationToken: ct);
 
-        var mode = SessionNotificationModeExtensions.FromDatabaseValue(proposal.NotificationMode);
+        var mode = await GetNotificationModeAsync(result.ProposalId!.Value, ct);
         if (mode.ShouldSendDirectMessages())
         {
             var optionsText = string.Join(
                 "\n",
-                options.Select(option => $"{option.DisplayOrder}. <b>{option.ProposedAt.FormatMoscow()}</b> (МСК)"));
+                result.Options.Select(option => $"{option.DisplayOrder}. <b>{option.ProposedAt.FormatMoscow()}</b> (МСК)"));
             var directText = $"""
                 🔄 <b>Голосование за перенос сессии</b>
 
-                📌 <b>{System.Net.WebUtility.HtmlEncode(proposal.Title)}</b>
-                📅 Текущее время: <b>{proposal.CurrentScheduledAt.FormatMoscow()}</b> (МСК)
+                📌 <b>{System.Net.WebUtility.HtmlEncode(result.Title)}</b>
+                📅 Текущее время: <b>{result.CurrentScheduledAt.FormatMoscow()}</b> (МСК)
                 🗳 Варианты:
                 {optionsText}
 
-                ⏳ Дедлайн: <b>{votingInput.Deadline.FormatMoscow()}</b> (МСК)
+                ⏳ Дедлайн: <b>{result.VotingDeadlineAt.Value.FormatMoscow()}</b> (МСК)
 
                 Проголосуйте кнопкой в групповом сообщении.
                 """;
 
             await directSender.SendAsync(
-                participants.Select(p => new DirectNotificationRecipient(
+                result.Participants.Select(p => new DirectNotificationRecipient(
                     p.TelegramId,
                     p.DisplayName)),
                 directText,
                 "reschedule-vote",
-                proposal.SessionId,
+                result.ProposalId.Value,
                 ct);
         }
 
-        // Store vote message ID
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
         await connection.ExecuteAsync(
             "UPDATE reschedule_proposals SET vote_message_id = @MsgId WHERE id = @Id",
-            new { MsgId = voteMsg.MessageId, Id = proposal.Id });
+            new { MsgId = voteMsg.MessageId, Id = result.ProposalId.Value });
 
         logger.LogInformation(
             "Reschedule voting started for session {SessionId}, proposal {ProposalId}, options {OptionCount}, deadline {Deadline}",
-            proposal.SessionId,
-            proposal.Id,
-            options.Count,
-            votingInput.Deadline);
-
-        // Delete GM's time input message
-        await TryDeleteMessage(chatId, message.MessageId, ct);
+            result.ProposalId.Value,
+            result.ProposalId.Value,
+            result.Options.Count,
+            result.VotingDeadlineAt.Value);
 
+        await TryDeleteMessage(message.Chat.Id, message.MessageId, ct);
         return true;
     }
 
-    private async Task RescheduleImmediately(
-        NpgsqlConnection connection, AwaitingProposalDto proposal,
-        DateTimeOffset newTime, long chatId, CancellationToken ct)
+    private async Task<SessionNotificationMode> GetNotificationModeAsync(Guid proposalId, CancellationToken ct)
     {
-        await using var transaction = await connection.BeginTransactionAsync(ct);
-
-        await connection.ExecuteAsync(
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        var raw = await connection.QuerySingleOrDefaultAsync<string?>(
             """
-            UPDATE sessions
-            SET scheduled_at = @NewTime,
-                status = @Status,
-                confirmation_message_id = NULL,
-                confirmation_sent_at = NULL,
-                one_hour_reminder_processed_at = NULL,
-                updated_at = now()
-            WHERE id = @SessionId
+            SELECT s.notification_mode
+            FROM sessions s
+            JOIN reschedule_proposals rp ON rp.session_id = s.id
+            WHERE rp.id = @Id
             """,
-            new { NewTime = newTime, proposal.SessionId, Status = SessionStatus.Planned },
-            transaction);
+            new { Id = proposalId });
+        return SessionNotificationModeExtensions.FromDatabaseValue(raw ?? string.Empty);
+    }
 
-        await connection.ExecuteAsync(
-            "UPDATE reschedule_proposals SET proposed_at = @NewTime, status = 'Approved' WHERE id = @Id",
-            new { NewTime = newTime, Id = proposal.Id },
-            transaction);
-
-        await transaction.CommitAsync(ct);
-
-        await messenger.SendGroupMessageAsync(
-            TelegramPlatformIds.Group(chatId, proposal.ThreadId),
-            $"✅ Сессия «{proposal.Title}» перенесена!\n\n📅 Новое время: <b>{newTime.ToOffset(TimeSpan.FromHours(3)).ToString("d MMMM yyyy, HH:mm", System.Globalization.CultureInfo.GetCultureInfo("ru-RU"))}</b> (МСК)\n\n<i>Участников нет — голосование не требуется.</i>",
-            ct);
-
-        // Re-render batch message with updated time
-        await TryUpdateBatchMessage(proposal, ct);
-
-        logger.LogInformation("Session {SessionId} rescheduled immediately (no participants)", proposal.SessionId);
+    private async Task TryUpdateBatchMessage(
+        PlatformGroup group,
+        SessionBatchViewModel view,
+        PlatformMessageRef scheduleMessage,
+        CancellationToken ct)
+    {
+        try
+        {
+            await messenger.UpdateScheduleAsync(
+                new PlatformScheduleMessage(group, view, scheduleMessage),
+                ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to update batch message after immediate reschedule");
+        }
     }
 
     internal static string BuildVotingMessage(
@@ -270,7 +183,7 @@ public sealed class HandleRescheduleTimeInputHandler(
 
         var lines = new List<string>
         {
-            $"🔄 <b>Перенос сессии «{System.Net.WebUtility.HtmlEncode(title)}»</b>",
+            $"""🔄 <b>Перенос сессии «{System.Net.WebUtility.HtmlEncode(title)}»</b>""",
             "",
             $"📅 Текущее время: <b>{currentTime.FormatMoscow()}</b> (МСК)",
             $"⏳ Дедлайн: <b>{deadline.FormatMoscow()}</b> (МСК)",
@@ -351,52 +264,6 @@ public sealed class HandleRescheduleTimeInputHandler(
             "dd.MM HH:mm",
             System.Globalization.CultureInfo.InvariantCulture);
 
-    private async Task TryUpdateBatchMessage(AwaitingProposalDto proposal, CancellationToken ct)
-    {
-        try
-        {
-            await using var conn = await dataSource.OpenConnectionAsync(ct);
-
-            var batchSessions = (await conn.QueryAsync<SessionBatchDto>(
-                "SELECT id AS SessionId, scheduled_at AS ScheduledAt, status AS Status, max_players AS MaxPlayers, join_link AS JoinLink FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
-                new { proposal.BatchId })).ToList();
-
-            var batchParticipants = (await conn.QueryAsync<ParticipantBatchDto>(
-                """
-                SELECT sp.session_id AS SessionId,
-                       p.display_name AS DisplayName,
-                       p.external_username AS TelegramUsername,
-                       sp.registration_status AS RegistrationStatus
-                FROM session_participants sp
-                JOIN players p ON sp.player_id = p.id
-                JOIN sessions s ON sp.session_id = s.id
-                WHERE s.batch_id = @BatchId AND sp.is_gm = false
-                ORDER BY sp.registration_status ASC, sp.created_at ASC, sp.responded_at ASC, p.created_at ASC
-                """,
-                new { proposal.BatchId })).ToList();
-
-            if (proposal.BatchMessageId.HasValue)
-            {
-                var view = SessionBatchViewBuilder.Build(proposal.Title, batchSessions, batchParticipants);
-
-                await messenger.UpdateScheduleAsync(
-                    new PlatformScheduleMessage(
-                        TelegramPlatformIds.Group(proposal.TelegramChatId, proposal.ThreadId),
-                        view,
-                        TelegramPlatformIds.Message(proposal.TelegramChatId, proposal.ThreadId, proposal.BatchMessageId.Value)),
-                    ct);
-            }
-            else
-            {
-                logger.LogWarning("No batch_message_id stored for session {SessionId}, cannot edit batch message in-place", proposal.SessionId);
-            }
-        }
-        catch (Exception ex)
-        {
-            logger.LogWarning(ex, "Failed to update batch message after immediate reschedule for session {SessionId}", proposal.SessionId);
-        }
-    }
-
     private async Task TryDeleteMessage(long chatId, int messageId, CancellationToken ct)
     {
         try

src/GmRelay.Bot/Features/Sessions/RescheduleSession/HandleRescheduleVoteHandler.cs

@@ -1,8 +1,7 @@
-using Dapper;
+using GmRelay.Bot.Infrastructure.Telegram;
 using GmRelay.Shared.Domain;
 using GmRelay.Shared.Features.Sessions.RescheduleSession;
 using GmRelay.Shared.Platform;
-using Npgsql;
 using Telegram.Bot;
 
 namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
@@ -15,131 +14,49 @@ public sealed record HandleRescheduleVoteCommand(
     int MessageId);
 
 public sealed class HandleRescheduleVoteHandler(
-    NpgsqlDataSource dataSource,
+    GmRelay.Shared.Features.Sessions.RescheduleSession.HandleRescheduleVoteHandler sharedHandler,
     ITelegramBotClient bot,
     IPlatformMessenger messenger,
     ILogger<HandleRescheduleVoteHandler> logger)
 {
     public async Task HandleAsync(HandleRescheduleVoteCommand command, CancellationToken ct)
     {
-        await using var connection = await dataSource.OpenConnectionAsync(ct);
-        await using var transaction = await connection.BeginTransactionAsync(ct);
+        var platformUser = new PlatformUser(
+            PlatformKind.Telegram,
+            command.TelegramUserId.ToString(),
+            string.Empty,
+            null);
 
-        var proposal = await connection.QuerySingleOrDefaultAsync<VoteProposalDto>(
-            """
-            SELECT rp.id AS Id,
-                   rp.session_id AS SessionId,
-                   rp.voting_deadline_at AS VotingDeadlineAt,
-                   s.title AS Title,
-                   s.scheduled_at AS CurrentScheduledAt
-            FROM reschedule_options ro
-            JOIN reschedule_proposals rp ON rp.id = ro.proposal_id
-            JOIN sessions s ON s.id = rp.session_id
-            WHERE ro.id = @OptionId AND rp.status = 'Voting'
-            """,
-            new { command.OptionId },
-            transaction);
+        var platformGroup = new PlatformGroup(
+            PlatformKind.Telegram,
+            command.ChatId.ToString(),
+            string.Empty);
 
-        if (proposal is null)
+        var sharedCommand = new GmRelay.Shared.Features.Sessions.RescheduleSession.HandleRescheduleVoteCommand(
+            command.OptionId,
+            platformUser,
+            platformGroup,
+            command.CallbackQueryId,
+            TelegramPlatformIds.Message(command.ChatId, null, command.MessageId));
+
+        var result = await sharedHandler.HandleAsync(sharedCommand, ct);
+
+        if (!result.Success)
         {
-            await AnswerAsync(command.CallbackQueryId, "Голосование уже завершено или не найдено.", ct);
+            await messenger.AnswerInteractionAsync(
+                new PlatformInteractionReply(command.CallbackQueryId, result.ReplyText!, result.ReplyText!.Contains("дедлайн")),
+                ct);
             return;
         }
 
-        if (proposal.VotingDeadlineAt <= DateTimeOffset.UtcNow)
-        {
-            await AnswerAsync(command.CallbackQueryId, "Дедлайн уже прошёл. Результаты скоро будут применены.", ct, showAlert: true);
-            return;
-        }
-
-        var playerId = await connection.ExecuteScalarAsync<Guid?>(
-            """
-            SELECT p.id
-            FROM session_participants sp
-            JOIN players p ON p.id = sp.player_id
-            WHERE sp.session_id = @SessionId
-              AND p.platform = 'Telegram'
-              AND p.external_user_id = @ExternalUserId
-              AND sp.is_gm = false
-              AND sp.registration_status = @Active
-            """,
-            new { proposal.SessionId, ExternalUserId = command.TelegramUserId.ToString(), Active = ParticipantRegistrationStatus.Active },
-            transaction);
-
-        if (playerId is null)
-        {
-            await AnswerAsync(command.CallbackQueryId, "Вы не являетесь участником этой сессии.", ct);
-            return;
-        }
-
-        await connection.ExecuteAsync(
-            """
-            INSERT INTO reschedule_option_votes (proposal_id, player_id, option_id)
-            VALUES (@ProposalId, @PlayerId, @OptionId)
-            ON CONFLICT (proposal_id, player_id) DO UPDATE
-            SET option_id = EXCLUDED.option_id,
-                voted_at = now()
-            """,
-            new
-            {
-                ProposalId = proposal.Id,
-                PlayerId = playerId.Value,
-                command.OptionId
-            },
-            transaction);
-
-        var participants = (await connection.QueryAsync<VoteParticipantDto>(
-            """
-            SELECT p.id AS PlayerId,
-                   p.display_name AS DisplayName,
-                   p.external_username AS TelegramUsername,
-                   p.external_user_id::BIGINT AS TelegramId
-            FROM session_participants sp
-            JOIN players p ON p.id = sp.player_id
-            WHERE sp.session_id = @SessionId
-              AND sp.is_gm = false
-              AND sp.registration_status = @Active
-            ORDER BY p.display_name
-            """,
-            new { proposal.SessionId, Active = ParticipantRegistrationStatus.Active },
-            transaction)).ToList();
-
-        var options = (await connection.QueryAsync<RescheduleOptionDto>(
-            """
-            SELECT id AS OptionId,
-                   display_order AS DisplayOrder,
-                   proposed_at AS ProposedAt
-            FROM reschedule_options
-            WHERE proposal_id = @ProposalId
-            ORDER BY display_order
-            """,
-            new { ProposalId = proposal.Id },
-            transaction)).ToList();
-
-        var votes = (await connection.QueryAsync<RescheduleOptionVoteDto>(
-            """
-            SELECT rov.option_id AS OptionId,
-                   p.id AS PlayerId,
-                   p.display_name AS DisplayName,
-                   p.external_username AS TelegramUsername
-            FROM reschedule_option_votes rov
-            JOIN players p ON p.id = rov.player_id
-            WHERE rov.proposal_id = @ProposalId
-            ORDER BY rov.voted_at, p.display_name
-            """,
-            new { ProposalId = proposal.Id },
-            transaction)).ToList();
-
-        await transaction.CommitAsync(ct);
-
         var voteText = HandleRescheduleTimeInputHandler.BuildVotingMessage(
-            proposal.Title,
-            proposal.CurrentScheduledAt,
-            proposal.VotingDeadlineAt,
-            options,
-            participants,
-            votes);
-        var keyboard = HandleRescheduleTimeInputHandler.BuildVotingKeyboard(options);
+            result.Title!,
+            result.CurrentScheduledAt,
+            result.VotingDeadlineAt,
+            result.Options,
+            result.Participants,
+            result.Votes);
+        var keyboard = HandleRescheduleTimeInputHandler.BuildVotingKeyboard(result.Options);
 
         try
         {
@@ -153,12 +70,11 @@ public sealed class HandleRescheduleVoteHandler(
         }
         catch (Exception ex)
         {
-            logger.LogWarning(ex, "Failed to update reschedule vote message for proposal {ProposalId}", proposal.Id);
+            logger.LogWarning(ex, "Failed to update reschedule vote message for proposal {ProposalId}", result.ProposalId);
         }
 
-        await AnswerAsync(command.CallbackQueryId, "Ваш голос учтён. До дедлайна его можно изменить.", ct);
+        await messenger.AnswerInteractionAsync(
+            new PlatformInteractionReply(command.CallbackQueryId, result.ReplyText!),
+            ct);
     }
-
-    private Task AnswerAsync(string callbackQueryId, string text, CancellationToken ct, bool showAlert = false) =>
-        messenger.AnswerInteractionAsync(new PlatformInteractionReply(callbackQueryId, text, showAlert), ct);
 }

src/GmRelay.Bot/Infrastructure/Telegram/TelegramPlatformMessenger.cs

@@ -95,6 +95,68 @@ public sealed class TelegramPlatformMessenger(
             cancellationToken: ct);
     }
 
+    public async Task SendGroupMessageAsync(PlatformGroup group, string htmlText, IReadOnlyList<PlatformMessageAction> actions, CancellationToken ct)
+    {
+        EnsureTelegram(group.Platform);
+        await bot.SendMessage(
+            chatId: ParseLong(group.ExternalGroupId),
+            messageThreadId: ParseNullableInt(group.ExternalThreadId),
+            text: htmlText,
+            parseMode: ParseMode.Html,
+            replyMarkup: BuildActionsMarkup(actions),
+            cancellationToken: ct);
+    }
+
+    public async Task UpdateGroupMessageAsync(PlatformMessageRef messageRef, string htmlText, IReadOnlyList<PlatformMessageAction> actions, CancellationToken ct)
+    {
+        EnsureTelegram(messageRef.Platform);
+        await bot.EditMessageText(
+            chatId: ParseLong(messageRef.ExternalGroupId),
+            messageId: ParseInt(messageRef.ExternalMessageId),
+            text: htmlText,
+            parseMode: ParseMode.Html,
+            replyMarkup: BuildActionsMarkup(actions),
+            cancellationToken: ct);
+    }
+
+    public async Task<PlatformMessageRef> CreateThreadAsync(PlatformGroup group, string title, CancellationToken ct)
+    {
+        EnsureTelegram(group.Platform);
+        var topic = await bot.CreateForumTopic(
+            chatId: ParseLong(group.ExternalGroupId),
+            name: title,
+            cancellationToken: ct);
+
+        return new PlatformMessageRef(
+            PlatformKind.Telegram,
+            group.ExternalGroupId,
+            topic.MessageThreadId.ToString(CultureInfo.InvariantCulture),
+            string.Empty);
+    }
+
+    public Task DeleteThreadAsync(PlatformGroup group, CancellationToken ct)
+    {
+        EnsureTelegram(group.Platform);
+        if (string.IsNullOrWhiteSpace(group.ExternalThreadId))
+        {
+            return Task.CompletedTask;
+        }
+
+        return bot.DeleteForumTopic(
+            ParseLong(group.ExternalGroupId),
+            ParseInt(group.ExternalThreadId),
+            cancellationToken: ct);
+    }
+
+    public Task DeleteMessageAsync(PlatformMessageRef messageRef, CancellationToken ct)
+    {
+        EnsureTelegram(messageRef.Platform);
+        return bot.DeleteMessage(
+            ParseLong(messageRef.ExternalGroupId),
+            ParseInt(messageRef.ExternalMessageId),
+            cancellationToken: ct);
+    }
+
     public Task SendPrivateMessageAsync(PlatformPrivateMessage message, CancellationToken ct)
     {
         EnsureTelegram(message.Recipient.Platform);

src/GmRelay.Bot/Infrastructure/Telegram/UpdateRouter.cs

@@ -5,6 +5,9 @@ using GmRelay.Shared.Features.Sessions.CreateSession;
 using GmRelay.Shared.Rendering;
 using GmRelay.Bot.Features.Sessions.CreateSession;
 using GmRelay.Bot.Features.Sessions.ListSessions;
+using BotCreateSessionHandler = GmRelay.Bot.Features.Sessions.CreateSession.CreateSessionHandler;
+using BotRescheduleTimeInputHandler = GmRelay.Bot.Features.Sessions.RescheduleSession.HandleRescheduleTimeInputHandler;
+using BotRescheduleVoteHandler = GmRelay.Bot.Features.Sessions.RescheduleSession.HandleRescheduleVoteHandler;
 using GmRelay.Bot.Features.Sessions.ExportCalendar;
 using GmRelay.Bot.Features.Sessions.RescheduleSession;
 using Telegram.Bot;
@@ -20,7 +23,7 @@ namespace GmRelay.Bot.Infrastructure.Telegram;
 /// </summary>
 public sealed class UpdateRouter(
     HandleRsvpHandler rsvpHandler,
-    CreateSessionHandler createSessionHandler,
+    BotCreateSessionHandler createSessionHandler,
     JoinSessionHandler joinSessionHandler,
     LeaveSessionHandler leaveSessionHandler,
     PromoteWaitlistedPlayerHandler promoteWaitlistedPlayerHandler,
@@ -29,8 +32,8 @@ public sealed class UpdateRouter(
     ListSessionsHandler listSessionsHandler,
     ExportCalendarHandler exportCalendarHandler,
     InitiateRescheduleHandler initiateRescheduleHandler,
-    HandleRescheduleTimeInputHandler rescheduleTimeInputHandler,
-    HandleRescheduleVoteHandler rescheduleVoteHandler,
+    BotRescheduleTimeInputHandler rescheduleTimeInputHandler,
+    BotRescheduleVoteHandler rescheduleVoteHandler,
     ITelegramBotClient bot,
     IConfiguration configuration,
     ILogger<UpdateRouter> logger) : ITelegramUpdateHandler

src/GmRelay.Bot/Program.cs

@@ -66,7 +66,8 @@ builder.Services.AddSingleton<SendJoinLinkHandler>();
 builder.Services.AddSingleton<ISendJoinLinkHandler>(sp => sp.GetRequiredService<SendJoinLinkHandler>());
 builder.Services.AddSingleton<SendOneHourReminderHandler>();
 builder.Services.AddSingleton<ISendOneHourReminderHandler>(sp => sp.GetRequiredService<SendOneHourReminderHandler>());
-builder.Services.AddSingleton<CreateSessionHandler>();
+builder.Services.AddSingleton<GmRelay.Shared.Features.Sessions.CreateSession.CreateSessionHandler>();
+builder.Services.AddSingleton<GmRelay.Bot.Features.Sessions.CreateSession.CreateSessionHandler>();
 builder.Services.AddSingleton<IScheduleMessageUpdateLock, ScheduleMessageUpdateLock>();
 builder.Services.AddSingleton<JoinSessionHandler>();
 builder.Services.AddSingleton<LeaveSessionHandler>();
@@ -74,10 +75,13 @@ builder.Services.AddSingleton<PromoteWaitlistedPlayerHandler>();
 builder.Services.AddSingleton<CancelSessionHandler>();
 builder.Services.AddSingleton<GmRelay.Bot.Features.Sessions.ListSessions.DeleteSessionHandler>();
 builder.Services.AddSingleton<GmRelay.Bot.Features.Sessions.ListSessions.ListSessionsHandler>();
+builder.Services.AddSingleton<GmRelay.Shared.Features.Sessions.ExportCalendar.ExportCalendarHandler>();
 builder.Services.AddSingleton<GmRelay.Bot.Features.Sessions.ExportCalendar.ExportCalendarHandler>();
 builder.Services.AddSingleton<InitiateRescheduleHandler>();
-builder.Services.AddSingleton<HandleRescheduleTimeInputHandler>();
-builder.Services.AddSingleton<HandleRescheduleVoteHandler>();
+builder.Services.AddSingleton<GmRelay.Shared.Features.Sessions.RescheduleSession.HandleRescheduleTimeInputHandler>();
+builder.Services.AddSingleton<GmRelay.Bot.Features.Sessions.RescheduleSession.HandleRescheduleTimeInputHandler>();
+builder.Services.AddSingleton<GmRelay.Shared.Features.Sessions.RescheduleSession.HandleRescheduleVoteHandler>();
+builder.Services.AddSingleton<GmRelay.Bot.Features.Sessions.RescheduleSession.HandleRescheduleVoteHandler>();
 builder.Services.AddSingleton<RescheduleVotingFinalizer>();
 
 builder.Services.AddSingleton<DirectSessionNotificationSender>();