feat(platform): route scheduler notifications through platform messenger

src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleVotingDeadlineService.cs

@@ -1,19 +1,15 @@
 namespace GmRelay.DiscordBot.Features.Sessions;
 
 using Dapper;
-using GmRelay.Shared.Domain;
 using GmRelay.Shared.Features.Sessions.RescheduleSession;
 using GmRelay.Shared.Platform;
-using GmRelay.DiscordBot.Rendering;
 using GmRelay.Shared.Rendering;
-using NetCord;
-using NetCord.Rest;
 using Npgsql;
 
 public sealed class DiscordRescheduleVotingDeadlineService(
     NpgsqlDataSource dataSource,
     RescheduleVotingFinalizer finalizer,
-    RestClient restClient,
+    IPlatformMessenger messenger,
     ILogger<DiscordRescheduleVotingDeadlineService> logger) : BackgroundService
 {
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
@@ -27,7 +23,9 @@ public sealed class DiscordRescheduleVotingDeadlineService(
                 await ProcessDueProposals(stoppingToken);
             }
         }
-        catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested) { }
+        catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+        {
+        }
     }
 
     private async Task ProcessDueProposals(CancellationToken ct)
@@ -57,10 +55,8 @@ public sealed class DiscordRescheduleVotingDeadlineService(
             if (result.SourcePlatform != "Discord")
                 return;
 
-            // Update Discord vote message
             await TryUpdateDiscordVoteMessage(result, ct);
 
-            // If approved, update batch schedule
             if (result.SelectedOption is not null)
             {
                 await TryUpdateBatchScheduleAsync(result, ct);
@@ -68,7 +64,9 @@ public sealed class DiscordRescheduleVotingDeadlineService(
 
             logger.LogInformation(
                 "Finalized Discord reschedule proposal {ProposalId} for session {SessionId} with outcome {Outcome}",
-                proposalId, result.SessionId, result.Decision.Outcome);
+                proposalId,
+                result.SessionId,
+                result.Decision.Outcome);
         }
         catch (Exception ex)
         {
@@ -83,10 +81,13 @@ public sealed class DiscordRescheduleVotingDeadlineService(
             await using var connection = await dataSource.OpenConnectionAsync(ct);
             var msgRef = await connection.QuerySingleOrDefaultAsync<PlatformMessageRefDto>(
                 """
-                SELECT external_channel_id AS ExternalChannelId, external_message_id AS ExternalMessageId
-                FROM platform_messages
-                WHERE session_id = @SessionId AND purpose = 'reschedule_vote' AND platform = 'Discord'
-                ORDER BY created_at DESC
+                SELECT g.external_group_id AS ExternalGroupId,
+                       COALESCE(pm.external_channel_id, g.external_channel_id, g.external_group_id) AS ExternalChannelId,
+                       pm.external_message_id AS ExternalMessageId
+                FROM platform_messages pm
+                JOIN game_groups g ON g.id = pm.group_id
+                WHERE pm.session_id = @SessionId AND pm.purpose = 'reschedule_vote' AND pm.platform = 'Discord'
+                ORDER BY pm.created_at DESC
                 LIMIT 1
                 """,
                 new { result.SessionId });
@@ -94,31 +95,27 @@ public sealed class DiscordRescheduleVotingDeadlineService(
             if (msgRef is null)
                 return;
 
-            var (embed, actionRow) = DiscordRescheduleVotingRenderer.Render(
-                result.Title, result.CurrentScheduledAt, result.VotingDeadlineAt,
-                result.Options, result.Participants, result.Votes);
+            var group = CreateDiscordGroup(msgRef);
 
-            var channelId = ulong.Parse(msgRef.ExternalChannelId);
-            var messageId = ulong.Parse(msgRef.ExternalMessageId);
-
-            // Disable buttons after finalization
-            var disabledRow = new ActionRowProperties();
-            foreach (var btn in actionRow.OfType<ButtonProperties>())
-            {
-                disabledRow.Add(new ButtonProperties(btn.CustomId, btn.Label ?? string.Empty, ButtonStyle.Secondary) { Disabled = true });
-            }
-
-            var resultText = result.SelectedOption is not null
-                ? $"Голосование завершено. Победил вариант {result.SelectedOption.DisplayOrder}: **{result.SelectedOption.ProposedAt.FormatMoscow()}** (МСК)."
-                : $"Голосование завершено. {result.Decision.Reason}";
-
-            var updatedEmbed = embed.WithDescription($"{embed.Description}\n\n{resultText}");
-
-            await restClient.ModifyMessageAsync(channelId, messageId, options =>
-            {
-                options.Embeds = new[] { updatedEmbed };
-                options.Components = new[] { disabledRow };
-            });
+            await messenger.UpdateRescheduleVoteAsync(
+                new PlatformRescheduleVoteUpdate(
+                    group,
+                    new PlatformMessageRef(
+                        PlatformKind.Discord,
+                        msgRef.ExternalGroupId,
+                        null,
+                        msgRef.ExternalMessageId),
+                    result.ProposalId,
+                    result.SessionId,
+                    result.Title,
+                    result.CurrentScheduledAt,
+                    result.VotingDeadlineAt,
+                    result.Decision,
+                    result.SelectedOption,
+                    result.Options,
+                    result.Votes,
+                    result.Participants),
+                ct);
         }
         catch (Exception ex)
         {
@@ -130,14 +127,16 @@ public sealed class DiscordRescheduleVotingDeadlineService(
     {
         try
         {
-            // Query batch schedule message ref
             await using var connection = await dataSource.OpenConnectionAsync(ct);
             var batchRef = await connection.QuerySingleOrDefaultAsync<PlatformMessageRefDto>(
                 """
-                SELECT external_channel_id AS ExternalChannelId, external_message_id AS ExternalMessageId
-                FROM platform_messages
-                WHERE batch_id = @BatchId AND purpose = 'schedule' AND platform = 'Discord'
-                ORDER BY created_at DESC
+                SELECT g.external_group_id AS ExternalGroupId,
+                       COALESCE(pm.external_channel_id, g.external_channel_id, g.external_group_id) AS ExternalChannelId,
+                       pm.external_message_id AS ExternalMessageId
+                FROM platform_messages pm
+                JOIN game_groups g ON g.id = pm.group_id
+                WHERE pm.batch_id = @BatchId AND pm.purpose = 'schedule' AND pm.platform = 'Discord'
+                ORDER BY pm.created_at DESC
                 LIMIT 1
                 """,
                 new { result.BatchId });
@@ -145,14 +144,16 @@ public sealed class DiscordRescheduleVotingDeadlineService(
             if (batchRef is null)
                 return;
 
-            // Rebuild schedule view and update Discord message
             var sessions = (await connection.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 { result.BatchId })).ToList();
 
             var participants = (await connection.QueryAsync<ParticipantBatchDto>(
                 """
-                SELECT sp.session_id AS SessionId, p.display_name AS DisplayName, COALESCE(p.external_username, p.telegram_username) AS TelegramUsername, sp.registration_status AS RegistrationStatus
+                SELECT sp.session_id AS SessionId,
+                       p.display_name AS DisplayName,
+                       COALESCE(p.external_username, p.telegram_username) AS TelegramUsername,
+                       sp.registration_status AS RegistrationStatus
                 FROM session_participants sp
                 JOIN players p ON p.id = sp.player_id
                 JOIN sessions s ON sp.session_id = s.id
@@ -162,16 +163,18 @@ public sealed class DiscordRescheduleVotingDeadlineService(
                 new { result.BatchId })).ToList();
 
             var view = SessionBatchViewBuilder.Build(result.Title, sessions, participants);
-            var (embeds, actionRows) = DiscordSessionBatchRenderer.Render(view);
+            var group = CreateDiscordGroup(batchRef);
 
-            var channelId = ulong.Parse(batchRef.ExternalChannelId);
-            var messageId = ulong.Parse(batchRef.ExternalMessageId);
-
-            await restClient.ModifyMessageAsync(channelId, messageId, options =>
-            {
-                options.Embeds = embeds;
-                options.Components = actionRows;
-            });
+            await messenger.UpdateScheduleAsync(
+                new PlatformScheduleMessage(
+                    group,
+                    view,
+                    new PlatformMessageRef(
+                        PlatformKind.Discord,
+                        batchRef.ExternalGroupId,
+                        null,
+                        batchRef.ExternalMessageId)),
+                ct);
         }
         catch (Exception ex)
         {
@@ -179,5 +182,15 @@ public sealed class DiscordRescheduleVotingDeadlineService(
         }
     }
 
-    internal sealed record PlatformMessageRefDto(string ExternalChannelId, string ExternalMessageId);
+    private static PlatformGroup CreateDiscordGroup(PlatformMessageRefDto message) =>
+        new(
+            PlatformKind.Discord,
+            message.ExternalGroupId,
+            message.ExternalGroupId,
+            message.ExternalChannelId);
+
+    internal sealed record PlatformMessageRefDto(
+        string ExternalGroupId,
+        string ExternalChannelId,
+        string ExternalMessageId);
 }

src/GmRelay.DiscordBot/Features/Sessions/DiscordSessionInteractionModule.cs

@@ -1,5 +1,9 @@
 using GmRelay.DiscordBot.Infrastructure.Discord;
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Features.Confirmation.HandleRsvp;
 using GmRelay.Shared.Features.Sessions.CreateSession;
+using GmRelay.Shared.Platform;
+using System.Globalization;
 using NetCord;
 using NetCord.Rest;
 using NetCord.Services.ComponentInteractions;
@@ -9,6 +13,7 @@ namespace GmRelay.DiscordBot.Features.Sessions;
 public sealed class DiscordSessionInteractionModule(
     JoinSessionHandler joinSessionHandler,
     LeaveSessionHandler leaveSessionHandler,
+    HandleRsvpHandler rsvpHandler,
     DiscordRescheduleVoteHandler voteHandler,
     DiscordInteractionReplyCache interactionReplies,
     ILogger<DiscordSessionInteractionModule> logger) : ComponentInteractionModule<ButtonInteractionContext>
@@ -67,6 +72,65 @@ public sealed class DiscordSessionInteractionModule(
         await CompleteWithStoredReplyAsync(input.InteractionId);
     }
 
+    [ComponentInteraction("rsvp")]
+    public async Task RsvpAsync(string status, string sessionId)
+    {
+        if (!Guid.TryParse(sessionId, out var parsedSessionId))
+        {
+            await RespondAsync(CreateEphemeralReply("Session button is outdated."));
+            return;
+        }
+
+        var rsvpStatus = status switch
+        {
+            "confirm" => RsvpStatus.Confirmed,
+            "decline" => RsvpStatus.Declined,
+            _ => null
+        };
+
+        if (rsvpStatus is null)
+        {
+            await RespondAsync(CreateEphemeralReply("Session button is outdated."));
+            return;
+        }
+
+        var input = CreateInput(parsedSessionId);
+        await RespondAsync(InteractionCallback.DeferredMessage(MessageFlags.Ephemeral));
+
+        try
+        {
+            await rsvpHandler.HandleAsync(
+                new HandleRsvpCommand(
+                    parsedSessionId,
+                    new PlatformUser(
+                        PlatformKind.Discord,
+                        Context.User.Id.ToString(CultureInfo.InvariantCulture),
+                        string.IsNullOrWhiteSpace(Context.User.GlobalName) ? Context.User.Username : Context.User.GlobalName,
+                        Context.User.Username),
+                    rsvpStatus,
+                    input.InteractionId,
+                    new PlatformGroup(
+                        PlatformKind.Discord,
+                        input.GuildId,
+                        input.GuildId,
+                        input.ChannelId),
+                    new PlatformMessageRef(
+                        PlatformKind.Discord,
+                        input.GuildId,
+                        null,
+                        input.MessageId)),
+                CancellationToken.None);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to handle Discord RSVP interaction for session {SessionId}", parsedSessionId);
+            await CompleteResponseAsync("Не удалось обработать кнопку.");
+            return;
+        }
+
+        await CompleteWithStoredReplyAsync(input.InteractionId);
+    }
+
     [ComponentInteraction("reschedule_vote")]
     public async Task RescheduleVoteAsync(string optionId)
     {
@@ -112,9 +176,9 @@ public sealed class DiscordSessionInteractionModule(
         return new DiscordSessionInteractionInput(
             SessionId: sessionId,
             InteractionId: Context.Interaction.Id.ToString(System.Globalization.CultureInfo.InvariantCulture),
-            GuildId: guild.Id.ToString(System.Globalization.CultureInfo.InvariantCulture),
-            ChannelId: Context.Channel.Id.ToString(System.Globalization.CultureInfo.InvariantCulture),
-            MessageId: message.Id.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            GuildId: guild.Id.ToString(CultureInfo.InvariantCulture),
+            ChannelId: Context.Channel.Id.ToString(CultureInfo.InvariantCulture),
+            MessageId: message.Id.ToString(CultureInfo.InvariantCulture),
             UserId: Context.User.Id,
             Username: Context.User.Username,
             DisplayName: Context.User.GlobalName);

src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPlatformMessenger.cs

@@ -1,21 +1,43 @@
+using System.Globalization;
+using System.Text;
 using GmRelay.DiscordBot.Rendering;
+using GmRelay.Shared.Domain;
 using GmRelay.Shared.Platform;
 using GmRelay.Shared.Rendering;
+using Microsoft.Extensions.Logging;
 using NetCord;
 using NetCord.Rest;
 
 namespace GmRelay.DiscordBot.Infrastructure.Discord;
 
-public sealed class DiscordPlatformMessenger(
-    RestClient restClient,
-    DiscordInteractionReplyCache interactionReplies) : IPlatformMessenger
+public sealed class DiscordPlatformMessenger : IPlatformMessenger
 {
+    private readonly RestClient restClient;
+    private readonly DiscordInteractionReplyCache interactionReplies;
+    private readonly ILogger<DiscordPlatformMessenger>? logger;
+
+    public DiscordPlatformMessenger(
+        RestClient restClient,
+        DiscordInteractionReplyCache interactionReplies)
+        : this(restClient, interactionReplies, logger: null)
+    {
+    }
+
+    public DiscordPlatformMessenger(
+        RestClient restClient,
+        DiscordInteractionReplyCache interactionReplies,
+        ILogger<DiscordPlatformMessenger>? logger)
+    {
+        this.restClient = restClient;
+        this.interactionReplies = interactionReplies;
+        this.logger = logger;
+    }
+
     public async Task<PlatformMessageRef> SendScheduleAsync(PlatformScheduleMessage message, CancellationToken ct)
     {
         var (embeds, actionRows) = DiscordSessionBatchRenderer.Render(message.View);
 
-        var channelId = ulong.Parse(message.Group.ExternalChannelId
-            ?? message.Group.ExternalGroupId);
+        var channelId = GetChannelId(message.Group);
 
         var msg = await restClient.SendMessageAsync(
             channelId,
@@ -27,7 +49,7 @@ public sealed class DiscordPlatformMessenger(
             PlatformKind.Discord,
             message.Group.ExternalGroupId,
             null,
-            msg.Id.ToString());
+            msg.Id.ToString(CultureInfo.InvariantCulture));
     }
 
     public async Task UpdateScheduleAsync(PlatformScheduleMessage message, CancellationToken ct)
@@ -37,9 +59,8 @@ public sealed class DiscordPlatformMessenger(
 
         var (embeds, actionRows) = DiscordSessionBatchRenderer.Render(message.View);
 
-        var channelId = ulong.Parse(message.Group.ExternalChannelId
-            ?? message.Group.ExternalGroupId);
-        var messageId = ulong.Parse(message.ExistingMessage.ExternalMessageId);
+        var channelId = GetChannelId(message.Group);
+        var messageId = ParseSnowflake(message.ExistingMessage.ExternalMessageId);
 
         await restClient.ModifyMessageAsync(
             channelId,
@@ -53,18 +74,12 @@ public sealed class DiscordPlatformMessenger(
 
     public async Task SendGroupMessageAsync(PlatformGroup group, string htmlText, CancellationToken ct)
     {
-        var channelIdStr = group.ExternalChannelId ?? group.ExternalGroupId
-            ?? throw new InvalidOperationException("Group has no ExternalChannelId or ExternalGroupId.");
-
-        if (!ulong.TryParse(channelIdStr, out var channelId))
-            throw new InvalidOperationException($"Invalid Discord channel/group ID: '{channelIdStr}'.");
-
-        await restClient.SendMessageAsync(channelId, htmlText);
+        await restClient.SendMessageAsync(GetChannelId(group), htmlText);
     }
 
-    public Task SendPrivateMessageAsync(PlatformPrivateMessage message, CancellationToken ct)
+    public async Task SendPrivateMessageAsync(PlatformPrivateMessage message, CancellationToken ct)
     {
-        return Task.CompletedTask;
+        await SendDirectContentAsync(message.Recipient, message.HtmlText, ct);
     }
 
     public Task AnswerInteractionAsync(PlatformInteractionReply reply, CancellationToken ct)
@@ -77,4 +92,281 @@ public sealed class DiscordPlatformMessenger(
     {
         return Task.CompletedTask;
     }
+
+    public async Task<PlatformMessageRef> SendConfirmationRequestAsync(
+        PlatformConfirmationRequest request,
+        CancellationToken ct)
+    {
+        var channelId = GetChannelId(request.Group);
+        var message = await restClient.SendMessageAsync(
+            channelId,
+            new MessageProperties()
+                .WithEmbeds([BuildConfirmationEmbed(request)])
+                .WithComponents(BuildRsvpRows(request.SessionId, disabled: false)));
+
+        return new PlatformMessageRef(
+            PlatformKind.Discord,
+            request.Group.ExternalGroupId,
+            null,
+            message.Id.ToString(CultureInfo.InvariantCulture));
+    }
+
+    public async Task UpdateConfirmationRequestAsync(PlatformRsvpMessageUpdate update, CancellationToken ct)
+    {
+        if (update.Request.ExistingMessage is null)
+            return;
+
+        var channelId = GetChannelId(update.Request.Group);
+        var messageId = ParseSnowflake(update.Request.ExistingMessage.ExternalMessageId);
+        var components = BuildRsvpRows(update.Request.SessionId, update.DisableActions);
+
+        await restClient.ModifyMessageAsync(
+            channelId,
+            messageId,
+            options =>
+            {
+                options.Embeds = [BuildConfirmationEmbed(update.Request)];
+                options.Components = components;
+            });
+    }
+
+    public async Task<PlatformMessageRef> SendJoinLinkNotificationAsync(
+        PlatformJoinLinkNotification notification,
+        CancellationToken ct)
+    {
+        var channelId = GetChannelId(notification.Group);
+        var message = await restClient.SendMessageAsync(
+            channelId,
+            new MessageProperties().WithEmbeds([BuildJoinLinkEmbed(notification)]));
+
+        return new PlatformMessageRef(
+            PlatformKind.Discord,
+            notification.Group.ExternalGroupId,
+            null,
+            message.Id.ToString(CultureInfo.InvariantCulture));
+    }
+
+    public async Task SendDirectSessionNotificationAsync(
+        PlatformDirectSessionNotification notification,
+        CancellationToken ct)
+    {
+        try
+        {
+            await SendDirectContentAsync(
+                notification.Recipient,
+                BuildDirectContent(notification),
+                ct);
+        }
+        catch (Exception ex)
+        {
+            logger?.LogWarning(
+                ex,
+                "Failed to send Discord direct notification {NotificationKind} for session {SessionId} to user {ExternalUserId}",
+                notification.Kind,
+                notification.SessionId,
+                notification.Recipient.ExternalUserId);
+        }
+    }
+
+    public async Task SendRsvpOutcomeAsync(PlatformRsvpOutcomeNotification notification, CancellationToken ct)
+    {
+        if (notification.Kind == PlatformRsvpOutcomeKind.GroupAllConfirmed && notification.Group is not null)
+        {
+            await restClient.SendMessageAsync(
+                GetChannelId(notification.Group),
+                BuildRsvpGroupOutcomeContent(notification));
+            return;
+        }
+
+        var directKind = notification.Kind == PlatformRsvpOutcomeKind.GmPlayerDeclined
+            ? PlatformDirectSessionNotificationKind.RsvpDeclined
+            : PlatformDirectSessionNotificationKind.RsvpAllConfirmed;
+
+        foreach (var recipient in notification.Recipients)
+        {
+            await SendDirectSessionNotificationAsync(
+                new PlatformDirectSessionNotification(
+                    directKind,
+                    recipient,
+                    notification.SessionId,
+                    notification.Title,
+                    notification.ScheduledAt,
+                    ActorDisplayName: notification.ActorDisplayName),
+                ct);
+        }
+    }
+
+    public async Task UpdateRescheduleVoteAsync(PlatformRescheduleVoteUpdate update, CancellationToken ct)
+    {
+        var (embed, actionRow) = DiscordRescheduleVotingRenderer.Render(
+            update.Title,
+            update.CurrentScheduledAt,
+            update.VotingDeadlineAt,
+            update.Options,
+            update.Participants,
+            update.Votes);
+
+        var disabledRow = new ActionRowProperties();
+        foreach (var button in actionRow.OfType<ButtonProperties>())
+        {
+            disabledRow.Add(new ButtonProperties(
+                button.CustomId,
+                button.Label ?? string.Empty,
+                ButtonStyle.Secondary)
+            {
+                Disabled = true
+            });
+        }
+
+        var updatedEmbed = embed.WithDescription(
+            $"{embed.Description}\n\n{BuildRescheduleResultText(update)}");
+
+        await restClient.ModifyMessageAsync(
+            GetChannelId(update.Group),
+            ParseSnowflake(update.ExistingMessage.ExternalMessageId),
+            options =>
+            {
+                options.Embeds = [updatedEmbed];
+                options.Components = [disabledRow];
+            });
+    }
+
+    private static EmbedProperties BuildConfirmationEmbed(PlatformConfirmationRequest request)
+    {
+        var embed = new EmbedProperties()
+            .WithTitle($"Подтверждение: {request.Title}")
+            .WithDescription(BuildConfirmationDescription(request))
+            .WithColor(new Color(0x5865F2));
+
+        return embed.AddFields(
+        [
+            BuildParticipantField("Подтвердили", request.Participants, RsvpStatus.Confirmed),
+            BuildParticipantField("Отказались", request.Participants, RsvpStatus.Declined),
+            BuildParticipantField("Ожидаем ответ", request.Participants, RsvpStatus.Pending)
+        ]);
+    }
+
+    private static string BuildConfirmationDescription(PlatformConfirmationRequest request) =>
+        $"Время: **{request.ScheduledAt.FormatMoscow()}** (МСК)\n" +
+        "Подтвердите участие кнопкой ниже.";
+
+    private static EmbedFieldProperties BuildParticipantField(
+        string title,
+        IReadOnlyList<PlatformSessionParticipant> participants,
+        string status)
+    {
+        var values = participants
+            .Where(participant => participant.RsvpStatus == status)
+            .Select(FormatDiscordParticipant)
+            .ToList();
+
+        return new EmbedFieldProperties()
+            .WithName(title)
+            .WithValue(values.Count == 0 ? "—" : string.Join("\n", values))
+            .WithInline();
+    }
+
+    private static EmbedProperties BuildJoinLinkEmbed(PlatformJoinLinkNotification notification)
+    {
+        var mentions = notification.ConfirmedPlayers.Count == 0
+            ? "—"
+            : string.Join(", ", notification.ConfirmedPlayers.Select(p => Mention(p.User)));
+
+        return new EmbedProperties()
+            .WithTitle($"Ссылка на игру: {notification.Title}")
+            .WithDescription(
+                $"Время: **{notification.ScheduledAt.FormatMoscow()}** (МСК)\n" +
+                $"Ссылка: {notification.JoinLink}\n\n" +
+                $"Участники: {mentions}")
+            .WithUrl(notification.JoinLink)
+            .WithColor(new Color(0x57F287));
+    }
+
+    private static IReadOnlyList<ActionRowProperties> BuildRsvpRows(Guid sessionId, bool disabled)
+    {
+        var row = new ActionRowProperties();
+        row.Add(new ButtonProperties($"rsvp:confirm:{sessionId}", "Буду", ButtonStyle.Success)
+        {
+            Disabled = disabled
+        });
+        row.Add(new ButtonProperties($"rsvp:decline:{sessionId}", "Не смогу", ButtonStyle.Danger)
+        {
+            Disabled = disabled
+        });
+
+        return [row];
+    }
+
+    private static string BuildDirectContent(PlatformDirectSessionNotification notification)
+    {
+        var builder = new StringBuilder();
+        builder.AppendLine(notification.Kind switch
+        {
+            PlatformDirectSessionNotificationKind.ConfirmationRequest => "Нужно подтвердить участие",
+            PlatformDirectSessionNotificationKind.OneHourReminder => "Напоминание: сессия через час",
+            PlatformDirectSessionNotificationKind.JoinLink => "Ссылка на игру",
+            PlatformDirectSessionNotificationKind.RsvpAllConfirmed => "Все игроки подтвердили участие",
+            PlatformDirectSessionNotificationKind.RsvpDeclined => "Игрок отказался от участия",
+            PlatformDirectSessionNotificationKind.RescheduleApproved => "Сессия перенесена",
+            PlatformDirectSessionNotificationKind.RescheduleRejected => "Перенос сессии отклонен",
+            _ => "Уведомление по сессии"
+        });
+
+        builder.AppendLine();
+        builder.AppendLine($"**{notification.Title}**");
+        builder.AppendLine($"Время: **{notification.ScheduledAt.FormatMoscow()}** (МСК)");
+
+        if (!string.IsNullOrWhiteSpace(notification.JoinLink))
+            builder.AppendLine($"Ссылка: {notification.JoinLink}");
+
+        if (!string.IsNullOrWhiteSpace(notification.ActorDisplayName))
+            builder.AppendLine($"Игрок: {notification.ActorDisplayName}");
+
+        if (!string.IsNullOrWhiteSpace(notification.Reason))
+            builder.AppendLine($"Причина: {notification.Reason}");
+
+        return builder.ToString();
+    }
+
+    private static string BuildRsvpGroupOutcomeContent(PlatformRsvpOutcomeNotification notification) =>
+        $"Все участники подтвердили сессию **{notification.Title}** на " +
+        $"**{notification.ScheduledAt.FormatMoscow()}** (МСК).";
+
+    private static string BuildRescheduleResultText(PlatformRescheduleVoteUpdate update)
+    {
+        if (update.SelectedOption is not null)
+        {
+            return "Голосование завершено. " +
+                $"Победил вариант {update.SelectedOption.DisplayOrder}: " +
+                $"**{update.SelectedOption.ProposedAt.FormatMoscow()}** (МСК).";
+        }
+
+        return $"Голосование завершено. {update.Decision.Reason}";
+    }
+
+    private async Task SendDirectContentAsync(PlatformUser recipient, string content, CancellationToken ct)
+    {
+        var userId = ParseSnowflake(recipient.ExternalUserId);
+        var dm = await restClient.GetDMChannelAsync(userId, cancellationToken: ct);
+        await restClient.SendMessageAsync(
+            dm.Id,
+            new MessageProperties().WithContent(content),
+            cancellationToken: ct);
+    }
+
+    private static string FormatDiscordParticipant(PlatformSessionParticipant participant) =>
+        $"{Mention(participant.User)} ({participant.User.DisplayName})";
+
+    private static string Mention(PlatformUser user) => $"<@{user.ExternalUserId}>";
+
+    private static ulong GetChannelId(PlatformGroup group)
+    {
+        var channelId = group.ExternalChannelId ?? group.ExternalGroupId
+            ?? throw new InvalidOperationException("Discord group has no channel or group identifier.");
+
+        return ParseSnowflake(channelId);
+    }
+
+    private static ulong ParseSnowflake(string value) =>
+        ulong.Parse(value, CultureInfo.InvariantCulture);
 }

src/GmRelay.DiscordBot/Program.cs

@@ -3,8 +3,14 @@ using GmRelay.DiscordBot.Features.Sessions;
 using GmRelay.DiscordBot.Infrastructure;
 using GmRelay.DiscordBot.Infrastructure.Discord;
 using GmRelay.DiscordBot.Infrastructure.Logging;
+using GmRelay.Shared.Features.Confirmation.HandleRsvp;
+using GmRelay.Shared.Features.Confirmation.SendConfirmation;
+using GmRelay.Shared.Features.Notifications;
+using GmRelay.Shared.Features.Reminders.SendJoinLink;
+using GmRelay.Shared.Features.Reminders.SendOneHourReminder;
 using GmRelay.Shared.Features.Sessions.CreateSession;
 using GmRelay.Shared.Features.Sessions.RescheduleSession;
+using GmRelay.Shared.Infrastructure.Scheduling;
 using GmRelay.Shared.Platform;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -54,7 +60,18 @@ builder.Services.AddSingleton<LeaveSessionHandler>();
 builder.Services.AddSingleton<DiscordInteractionReplyCache>();
 builder.Services.AddSingleton<IPlatformMessenger, DiscordPlatformMessenger>();
 builder.Services.AddSingleton<ISystemClock, SystemClock>();
+builder.Services.AddSingleton(new PlatformSchedulerOptions(PlatformKind.Discord));
+builder.Services.AddSingleton<ISessionTriggerStore, DbSessionTriggerStore>();
+builder.Services.AddSingleton<PlatformDirectNotificationSender>();
+builder.Services.AddSingleton<SendConfirmationHandler>();
+builder.Services.AddSingleton<ISendConfirmationHandler>(sp => sp.GetRequiredService<SendConfirmationHandler>());
+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<HandleRsvpHandler>();
 builder.Services.AddSingleton<RescheduleVotingFinalizer>();
+builder.Services.AddHostedService<SessionSchedulerService>();
 builder.Services.AddHostedService<DiscordRescheduleVotingDeadlineService>();
 
 builder.Services

src/GmRelay.DiscordBot/packages.lock.json

@@ -669,6 +669,7 @@
         "type": "Project",
         "dependencies": {
           "Dapper": "[2.1.72, )",
+          "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )",
           "Microsoft.Extensions.Logging.Abstractions": "[10.0.5, )",
           "Npgsql": "[10.0.2, )"
         }