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);
         }
     }