Files

T

Toutsu fcd7de035f refactor(shared): extract reschedule voting types to Shared

2026-05-20 11:44:57 +03:00

56 KiB

Raw Blame History

Discord Reschedule Voting Implementation Plan

For agentic workers: REQUIRED SUB-SKILL: Use superpowers:test-driven-development to implement this plan task-by-task. Steps use checkbox (- [ ]) syntax for tracking.

Goal: Enable Discord users to initiate reschedule voting, cast votes via button interactions, and apply results automatically at deadline — without breaking the existing Telegram reschedule flow.

Architecture: Extract platform-neutral reschedule logic (vote persistence, winner selection, finalization) into GmRelay.Shared. Keep Telegram-specific handlers unchanged (with source_platform annotations). Build Discord-specific slash command (/reschedule), button interaction handlers, and a dedicated deadline background service in GmRelay.DiscordBot. Store Discord vote message references in platform_messages.

Tech Stack: .NET 10, Npgsql + Dapper.AOT, NetCord (Discord gateway), Native AOT.

File Structure

File	Action	Responsibility
`src/GmRelay.Bot/Migrations/V017__discord_reschedule_proposals.sql`	Create	Add `source_platform` and `proposed_by_external_user_id` to `reschedule_proposals`
`src/GmRelay.Shared/Features/Sessions/RescheduleSession/RescheduleVoteRules.cs`	Create (move from Bot)	Winner selection logic
`src/GmRelay.Shared/Features/Sessions/RescheduleSession/RescheduleVotingInput.cs`	Create (move from Bot)	Parse 2-3 options + deadline
`src/GmRelay.Shared/Features/Sessions/RescheduleSession/RescheduleDtos.cs`	Create (move from Bot)	DTOs: `RescheduleOptionDto`, `RescheduleOptionVoteDto`, `RescheduleOptionVoteCount`, `RescheduleVoteDecision`, `RescheduleVoteOutcome`, `VoteParticipantDto`
`src/GmRelay.Shared/Features/Sessions/RescheduleSession/RescheduleVotingFinalizer.cs`	Create	Platform-neutral DB finalization logic
`src/GmRelay.Shared/Platform/ISystemClock.cs`	Create (move from Bot)	Clock abstraction
`src/GmRelay.Bot/Infrastructure/Scheduling/SystemClock.cs`	Modify (namespace only)	Implementation stays in Bot
`src/GmRelay.Bot/Features/Sessions/RescheduleSession/*.cs`	Modify	Update usings, add `source_platform = 'Telegram'`
`src/GmRelay.DiscordBot/Program.cs`	Modify	Register new handlers, services, `ISystemClock`
`src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleCommand.cs`	Create	`/reschedule` slash command
`src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleHandler.cs`	Create	Validates GM, creates proposal + options, sends vote message
`src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleVoteHandler.cs`	Create	Upserts vote, re-renders vote message
`src/GmRelay.DiscordBot/Features/Sessions/DiscordSessionInteractionModule.cs`	Modify	Add `reschedule_vote` route
`src/GmRelay.DiscordBot/Rendering/DiscordRescheduleVotingRenderer.cs`	Create	Builds Discord embed + buttons for voting
`src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPlatformMessenger.cs`	Modify	Implement `SendGroupMessageAsync`, add `UpdateMessageAsync` helper
`src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleVotingDeadlineService.cs`	Create	BackgroundService: polls proposals, calls finalizer, edits Discord messages
`tests/GmRelay.Bot.Tests/Features/Sessions/RescheduleSession/*Tests.cs`	Modify	Update namespaces/usings after move
`tests/GmRelay.Bot.Tests/Discord/DiscordRescheduleCommandTests.cs`	Create	TDD tests for `/reschedule` command
`tests/GmRelay.Bot.Tests/Discord/DiscordRescheduleVoteHandlerTests.cs`	Create	TDD tests for vote button handler
`tests/GmRelay.Bot.Tests/Discord/DiscordRescheduleVotingRendererTests.cs`	Create	TDD tests for renderer
`tests/GmRelay.Bot.Tests/Discord/DiscordRescheduleVotingDeadlineServiceTests.cs`	Create	TDD tests for deadline service
`tests/GmRelay.Bot.Tests/Shared/RescheduleVoteRulesTests.cs`	Create (move)	Winner selection tests
`tests/GmRelay.Bot.Tests/Shared/RescheduleVotingInputTests.cs`	Create (move)	Parser tests
`Directory.Build.props`	Modify	Version bump 2.5.0 → 2.6.0
`compose.yaml`	Modify	Image tags 2.6.0
`.gitea/workflows/deploy.yml`	Modify	VERSION 2.6.0
`src/GmRelay.Web/Components/Layout/NavMenu.razor`	Modify	Version label 2.6.0

Task 1: Database Migration V017

Files:

Create: src/GmRelay.Bot/Migrations/V017__discord_reschedule_proposals.sql
Step 1: Write migration SQL

-- =============================================================
-- V017: Add platform columns to reschedule_proposals for Discord support
-- =============================================================

ALTER TABLE reschedule_proposals
    ADD COLUMN source_platform VARCHAR(50),
    ADD COLUMN proposed_by_external_user_id VARCHAR(255);

-- Backfill existing Telegram proposals
UPDATE reschedule_proposals
   SET source_platform = 'Telegram',
       proposed_by_external_user_id = proposed_by::TEXT
 WHERE source_platform IS NULL;

Step 2: Verify migration applies cleanly

Run: dotnet build src/GmRelay.Bot/GmRelay.Bot.csproj --no-restore Expected: Build succeeds (DbUp will run migration on next startup).

Step 3: Commit

git add src/GmRelay.Bot/Migrations/V017__discord_reschedule_proposals.sql
git commit -m "feat(db): add platform columns to reschedule_proposals"

Task 2: Extract Shared Reschedule Types

Files:

Create: src/GmRelay.Shared/Features/Sessions/RescheduleSession/RescheduleVoteRules.cs
Create: src/GmRelay.Shared/Features/Sessions/RescheduleSession/RescheduleVotingInput.cs
Create: src/GmRelay.Shared/Features/Sessions/RescheduleSession/RescheduleDtos.cs
Delete (after move): src/GmRelay.Bot/Features/Sessions/RescheduleSession/RescheduleVoteRules.cs
Delete (after move): src/GmRelay.Bot/Features/Sessions/RescheduleSession/RescheduleVotingInput.cs
Modify: src/GmRelay.Bot/Features/Sessions/RescheduleSession/HandleRescheduleTimeInputHandler.cs
Modify: src/GmRelay.Bot/Features/Sessions/RescheduleSession/HandleRescheduleVoteHandler.cs
Modify: src/GmRelay.Bot/Features/Sessions/RescheduleSession/RescheduleVotingDeadlineService.cs
Modify: tests/GmRelay.Bot.Tests/Features/Sessions/RescheduleSession/HandleRescheduleTimeInputHandlerTests.cs
Modify: tests/GmRelay.Bot.Tests/Features/Sessions/RescheduleSession/RescheduleVoteRulesTests.cs
Step 1: Write shared DTOs file

namespace GmRelay.Shared.Features.Sessions.RescheduleSession;

internal enum RescheduleVoteOutcome { Pending, Rejected, Approved }

internal sealed record RescheduleVoteDecision(
    RescheduleVoteOutcome Outcome,
    string Reason,
    Guid? SelectedOptionId = null,
    string CallbackText = "",
    bool ShouldRescheduleSession = false,
    bool ShouldResetParticipantRsvps = false);

internal sealed record RescheduleOptionVoteCount(Guid OptionId, int VoteCount);

internal sealed record RescheduleOptionDto(Guid OptionId, int DisplayOrder, DateTimeOffset ProposedAt);

internal sealed record RescheduleOptionVoteDto(Guid OptionId, Guid PlayerId, string DisplayName, string? TelegramUsername);

internal sealed record VoteParticipantDto(Guid PlayerId, string DisplayName, string? TelegramUsername, long TelegramId = 0);

Step 2: Write shared RescheduleVoteRules

Copy content from src/GmRelay.Bot/Features/Sessions/RescheduleSession/RescheduleVoteRules.cs into new namespace GmRelay.Shared.Features.Sessions.RescheduleSession.

Step 3: Write shared RescheduleVotingInput

Copy content from src/GmRelay.Bot/Features/Sessions/RescheduleSession/RescheduleVotingInput.cs into new namespace GmRelay.Shared.Features.Sessions.RescheduleSession.

Step 4: Update Telegram handler usings

In HandleRescheduleTimeInputHandler.cs, HandleRescheduleVoteHandler.cs, and RescheduleVotingDeadlineService.cs, replace:

using GmRelay.Bot.Features.Sessions.RescheduleSession;

with:

using GmRelay.Shared.Features.Sessions.RescheduleSession;

Step 5: Update test usings

Same replacement in test files.

Step 6: Run tests to verify no regressions

Run: dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~Reschedule" --verbosity normal Expected: All existing reschedule tests pass.

Step 7: Commit

git add src/GmRelay.Shared/Features/Sessions/RescheduleSession/
git add src/GmRelay.Bot/Features/Sessions/RescheduleSession/
git add tests/GmRelay.Bot.Tests/
git commit -m "refactor(shared): extract reschedule voting types to Shared"

Task 3: Create Shared RescheduleVotingFinalizer

Files:

Create: src/GmRelay.Shared/Features/Sessions/RescheduleSession/RescheduleVotingFinalizer.cs
Create: src/GmRelay.Shared/Platform/ISystemClock.cs
Modify: src/GmRelay.Bot/Infrastructure/Scheduling/SystemClock.cs
Modify: src/GmRelay.Bot/Program.cs
Step 1: Write ISystemClock abstraction

namespace GmRelay.Shared.Platform;

public interface ISystemClock
{
    DateTimeOffset UtcNow { get; }
}

Step 2: Move SystemClock implementation

Move SystemClock from src/GmRelay.Bot/Infrastructure/Scheduling/ISystemClock.cs to src/GmRelay.Bot/Infrastructure/Scheduling/SystemClock.cs and update namespace to GmRelay.Bot.Infrastructure.Scheduling. It implements GmRelay.Shared.Platform.ISystemClock.

namespace GmRelay.Bot.Infrastructure.Scheduling;

public sealed class SystemClock : GmRelay.Shared.Platform.ISystemClock
{
    public DateTimeOffset UtcNow => DateTimeOffset.UtcNow;
}

Step 3: Write RescheduleVotingFinalizer

Extract DB-only logic from RescheduleVotingDeadlineService. The finalizer performs the transaction, updates session/participants/proposal, and returns the result. It does NOT touch any messenger or bot client.

namespace GmRelay.Shared.Features.Sessions.RescheduleSession;

using Dapper;
using GmRelay.Shared.Domain;
using GmRelay.Shared.Platform;
using Npgsql;

internal sealed record FinalizeProposalInput(
    Guid ProposalId,
    IReadOnlyList<RescheduleOptionDto> Options,
    IReadOnlyList<VoteParticipantDto> Participants,
    IReadOnlyList<RescheduleOptionVoteDto> Votes,
    RescheduleVoteDecision Decision,
    RescheduleOptionDto? SelectedOption);

internal sealed record FinalizeProposalResult(
    Guid ProposalId,
    Guid SessionId,
    string Title,
    DateTime CurrentScheduledAt,
    Guid BatchId,
    string NotificationMode,
    RescheduleVoteDecision Decision,
    RescheduleOptionDto? SelectedOption,
    IReadOnlyList<VoteParticipantDto> Participants);

public sealed class RescheduleVotingFinalizer(
    NpgsqlDataSource dataSource,
    ISystemClock clock,
    ILogger<RescheduleVotingFinalizer> logger)
{
    public async Task<IReadOnlyList<Guid>> GetDueProposalIdsAsync(CancellationToken ct)
    {
        await using var connection = await dataSource.OpenConnectionAsync(ct);
        return (await connection.QueryAsync<Guid>(
            """
            SELECT id
            FROM reschedule_proposals
            WHERE status = 'Voting'
              AND voting_deadline_at IS NOT NULL
              AND voting_deadline_at <= @Now
            ORDER BY voting_deadline_at
            LIMIT 25
            """,
            new { Now = clock.UtcNow.UtcDateTime })).ToList();
    }

    public async Task<FinalizeProposalResult?> FinalizeAsync(Guid proposalId, CancellationToken ct)
    {
        await using var connection = await dataSource.OpenConnectionAsync(ct);
        await using var transaction = await connection.BeginTransactionAsync(ct);

        var proposal = await connection.QuerySingleOrDefaultAsync<DueProposalDto>(
            """
            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,
                   s.batch_id AS BatchId,
                   s.notification_mode AS NotificationMode
            FROM reschedule_proposals rp
            JOIN sessions s ON s.id = rp.session_id
            WHERE rp.id = @ProposalId
              AND rp.status = 'Voting'
              AND rp.voting_deadline_at IS NOT NULL
              AND rp.voting_deadline_at <= @Now
            FOR UPDATE
            """,
            new { ProposalId = proposalId, Now = clock.UtcNow.UtcDateTime },
            transaction);

        if (proposal is null) return null;

        var participants = (await connection.QueryAsync<VoteParticipantDto>(
            """
            SELECT p.id AS PlayerId,
                   p.display_name AS DisplayName,
                   p.telegram_username AS TelegramUsername,
                   p.telegram_id 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.telegram_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();

        var voteCounts = options
            .Select(o => new RescheduleOptionVoteCount(o.OptionId, votes.Count(v => v.OptionId == o.OptionId)))
            .ToList();
        var decision = RescheduleVoteRules.SelectWinner(voteCounts);
        var selectedOption = decision.SelectedOptionId is { } sid
            ? options.Single(o => o.OptionId == sid)
            : null;

        if (selectedOption is not null)
        {
            await connection.ExecuteAsync(
                """
                UPDATE sessions
                SET scheduled_at = @NewTime, status = @Status,
                    confirmation_message_id = NULL, confirmation_sent_at = NULL,
                    link_message_id = NULL, one_hour_reminder_processed_at = NULL,
                    updated_at = now()
                WHERE id = @SessionId
                """,
                new { NewTime = selectedOption.ProposedAt, proposal.SessionId, Status = SessionStatus.Planned },
                transaction);

            await connection.ExecuteAsync(
                """
                UPDATE session_participants
                SET rsvp_status = 'Pending', responded_at = NULL
                WHERE session_id = @SessionId AND is_gm = false AND registration_status = @Active
                """,
                new { proposal.SessionId, Active = ParticipantRegistrationStatus.Active },
                transaction);

            await connection.ExecuteAsync(
                """
                UPDATE reschedule_proposals
                SET status = 'Approved', selected_option_id = @SelectedOptionId, proposed_at = @ProposedAt
                WHERE id = @ProposalId
                """,
                new { ProposalId = proposal.Id, SelectedOptionId = selectedOption.OptionId, ProposedAt = selectedOption.ProposedAt },
                transaction);
        }
        else
        {
            await connection.ExecuteAsync(
                "UPDATE reschedule_proposals SET status = 'Rejected' WHERE id = @ProposalId",
                new { ProposalId = proposal.Id },
                transaction);
        }

        await transaction.CommitAsync(ct);

        return new FinalizeProposalResult(
            proposal.Id, proposal.SessionId, proposal.Title, proposal.CurrentScheduledAt,
            proposal.BatchId, proposal.NotificationMode, decision, selectedOption, participants);
    }

    internal sealed record DueProposalDto(
        Guid Id, Guid SessionId, DateTimeOffset VotingDeadlineAt,
        string Title, DateTime CurrentScheduledAt, Guid BatchId, string NotificationMode);
}

Step 4: Update Telegram RescheduleVotingDeadlineService to use finalizer

Replace DB transaction logic with calls to RescheduleVotingFinalizer. Keep Telegram-specific message editing and DM sending.

Step 5: Register finalizer in Bot Program.cs

builder.Services.AddSingleton<RescheduleVotingFinalizer>();

Step 6: Run Telegram reschedule tests

Run: dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~Reschedule" --verbosity normal Expected: All pass.

Step 7: Commit

git add src/GmRelay.Shared/Features/Sessions/RescheduleSession/RescheduleVotingFinalizer.cs
git add src/GmRelay.Shared/Platform/ISystemClock.cs
git add src/GmRelay.Bot/Infrastructure/Scheduling/SystemClock.cs
git add src/GmRelay.Bot/Program.cs
git add src/GmRelay.Bot/Features/Sessions/RescheduleSession/RescheduleVotingDeadlineService.cs
git commit -m "feat(shared): add RescheduleVotingFinalizer and ISystemClock"

Task 4: Discord /reschedule Slash Command

Files:

Create: src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleCommand.cs
Create: src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleHandler.cs
Modify: src/GmRelay.DiscordBot/Program.cs
Step 1: Write failing test for DiscordRescheduleHandler validation

namespace GmRelay.Bot.Tests.Discord;

public sealed class DiscordRescheduleHandlerTests
{
    [Fact]
    public async Task HandleAsync_ShouldThrow_WhenUserIsNotManager()
    {
        // Arrange: mock NpgsqlDataSource with no managers
        // Act + Assert: UnauthorizedAccessException
    }
}

Run: dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordRescheduleHandlerTests" --verbosity normal Expected: FAIL (class not found).

Step 2: Implement DiscordRescheduleHandler

namespace GmRelay.DiscordBot.Features.Sessions;

using Dapper;
using GmRelay.DiscordBot.Infrastructure.Discord;
using GmRelay.Shared.Domain;
using GmRelay.Shared.Features.Sessions.RescheduleSession;
using GmRelay.Shared.Platform;
using GmRelay.Shared.Rendering;
using Npgsql;
using NetCord.Rest;

public sealed class DiscordRescheduleHandler(
    NpgsqlDataSource dataSource,
    DiscordPermissionChecker permissionChecker,
    IPlatformMessenger messenger,
    ILogger<DiscordRescheduleHandler> logger)
{
    public async Task<DiscordRescheduleResult> HandleAsync(
        string guildId,
        string channelId,
        ulong userId,
        string userDisplayName,
        ulong resolvedPermissions,
        ulong guildOwnerId,
        Guid sessionId,
        IReadOnlyList<DateTimeOffset> options,
        DateTimeOffset deadline,
        CancellationToken ct)
    {
        await using var connection = await dataSource.OpenConnectionAsync(ct);

        var dbManagerUserIds = await connection.QueryAsync<ulong>(
            @"SELECT CAST(p.external_user_id AS BIGINT)
              FROM group_managers gm
              JOIN players p ON p.id = gm.player_id
              JOIN game_groups g ON g.id = gm.group_id
              WHERE g.platform = 'Discord' AND g.external_group_id = @GuildId",
            new { GuildId = guildId });

        if (!permissionChecker.CanManageSchedule(guildOwnerId, userId, dbManagerUserIds, resolvedPermissions))
        {
            throw new UnauthorizedAccessException("⛔ Только owner, администратор или manager могут переносить сессии.");
        }

        // Ensure player exists
        await connection.ExecuteAsync(
            @"INSERT INTO players (display_name, platform, external_user_id, external_username)
              VALUES (@Name, 'Discord', @UserId, @Name)
              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",
            new { Name = userDisplayName, UserId = userId.ToString() });

        // Verify session exists and is not cancelled
        var session = await connection.QuerySingleOrDefaultAsync<RescheduleSessionInfoDto>(
            """
            SELECT s.title AS Title, s.scheduled_at AS CurrentScheduledAt,
                   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 = 'Discord' AND p.external_user_id = @UserId
                   ) AS CanManage
            FROM sessions s
            WHERE s.id = @SessionId AND s.status != @Cancelled
            """,
            new { SessionId = sessionId, UserId = userId.ToString(), Cancelled = SessionStatus.Cancelled });

        if (session is null)
            throw new InvalidOperationException("Сессия не найдена или отменена.");

        if (!session.CanManage)
            throw new UnauthorizedAccessException("Только owner или co-GM может переносить сессию.");

        var hasActive = await connection.ExecuteScalarAsync<bool>(
            "SELECT EXISTS (SELECT 1 FROM reschedule_proposals WHERE session_id = @SessionId AND status IN ('AwaitingTime', 'Voting'))",
            new { SessionId = sessionId });

        if (hasActive)
            throw new InvalidOperationException("Уже есть активный запрос на перенос этой сессии.");

        var proposalId = Guid.NewGuid();
        var optionDtos = options.Select((o, i) => new RescheduleOptionDto(Guid.NewGuid(), i + 1, o)).ToList();

        await using var transaction = await connection.BeginTransactionAsync(ct);

        await connection.ExecuteAsync(
            """
            INSERT INTO reschedule_proposals (id, session_id, proposed_by, source_platform, proposed_by_external_user_id, status, voting_deadline_at)
            VALUES (@Id, @SessionId, 0, 'Discord', @ProposedBy, 'Voting', @Deadline)
            """,
            new { Id = proposalId, SessionId = sessionId, ProposedBy = userId.ToString(), Deadline = deadline.UtcDateTime },
            transaction);

        foreach (var option in optionDtos)
        {
            await connection.ExecuteAsync(
                """
                INSERT INTO reschedule_options (id, proposal_id, proposed_at, display_order)
                VALUES (@OptionId, @ProposalId, @ProposedAt, @DisplayOrder)
                """,
                new { option.OptionId, ProposalId = proposalId, option.ProposedAt, option.DisplayOrder },
            transaction);
        }

        await transaction.CommitAsync(ct);

        // Load participants for rendering
        var participants = (await connection.QueryAsync<VoteParticipantDto>(
            """
            SELECT p.id AS PlayerId, p.display_name AS DisplayName, p.external_username AS TelegramUsername, 0 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 { SessionId = sessionId, Active = ParticipantRegistrationStatus.Active })).ToList();

        var (embed, actionRow) = DiscordRescheduleVotingRenderer.Render(
            session.Title, session.CurrentScheduledAt, deadline, optionDtos, participants, []);

        var group = new PlatformGroup(PlatformKind.Discord, guildId, guildId, channelId);
        var msgRef = await messenger.SendGroupMessageAsync(
            group,
            session.Title,
            new[] { embed },
            new[] { actionRow },
            ct);

        // Store message ref in platform_messages
        await connection.ExecuteAsync(
            """
            INSERT INTO platform_messages (platform, group_id, session_id, external_channel_id, external_message_id, purpose)
            VALUES ('Discord', (SELECT id FROM game_groups WHERE platform = 'Discord' AND external_group_id = @GuildId), @SessionId, @ChannelId, @MessageId, 'reschedule_vote')
            """,
            new { GuildId = guildId, SessionId = sessionId, ChannelId = channelId, MessageId = msgRef.ExternalMessageId });

        logger.LogInformation("Discord reschedule voting started for session {SessionId}, proposal {ProposalId}", sessionId, proposalId);

        return new DiscordRescheduleResult(proposalId, optionDtos, deadline);
    }
}

public sealed record RescheduleSessionInfoDto(string Title, DateTime CurrentScheduledAt, bool CanManage);
public sealed record DiscordRescheduleResult(Guid ProposalId, IReadOnlyList<RescheduleOptionDto> Options, DateTimeOffset Deadline);

Step 3: Note on IPlatformMessenger extension

IPlatformMessenger needs a new overload for SendGroupMessageAsync that accepts embeds/components. Add this to IPlatformMessenger:

Task<PlatformMessageRef> SendGroupMessageAsync(PlatformGroup group, string text, IReadOnlyList<EmbedProperties> embeds, IReadOnlyList<ActionRowProperties> actionRows, CancellationToken ct);

Wait — EmbedProperties is NetCord-specific and cannot be referenced in GmRelay.Shared. Therefore we need a platform-neutral abstraction.

Revised approach: Create a PlatformRescheduleVoteMessage record in Shared, and add a method to IPlatformMessenger:

Task<PlatformMessageRef> SendRescheduleVoteAsync(PlatformRescheduleVoteMessage message, CancellationToken ct);
Task UpdateRescheduleVoteAsync(PlatformRescheduleVoteMessage message, CancellationToken ct);

Where PlatformRescheduleVoteMessage contains a RescheduleVoteViewModel (platform-neutral view model for the vote UI).

Then DiscordRescheduleVotingRenderer and TelegramRescheduleVotingRenderer (new, extracting from existing HandleRescheduleTimeInputHandler.BuildVotingMessage/Keyboard) render this view model into platform-specific formats inside the respective IPlatformMessenger implementations.

This is cleaner but more complex. For the plan, let's document this abstraction.

Step 4: Write DiscordRescheduleCommand

namespace GmRelay.DiscordBot.Features.Sessions;

using NetCord.Rest;
using NetCord.Services.ApplicationCommands;

[SlashCommand("reschedule", "Initiate reschedule voting for a session")]
public class DiscordRescheduleCommand : ApplicationCommandModule<SlashCommandContext>
{
    private readonly DiscordRescheduleHandler _handler;
    private readonly ILogger<DiscordRescheduleCommand> _logger;

    public DiscordRescheduleCommand(DiscordRescheduleHandler handler, ILogger<DiscordRescheduleCommand> logger)
    {
        _handler = handler;
        _logger = logger;
    }

    public async Task ExecuteAsync(
        [SlashCommandParameter(Name = "session", Description = "Session ID to reschedule")] string sessionIdText,
        [SlashCommandParameter(Name = "option1", Description = "First time option (YYYY-MM-DD HH:mm)")] string option1,
        [SlashCommandParameter(Name = "option2", Description = "Second time option (YYYY-MM-DD HH:mm)")] string option2,
        [SlashCommandParameter(Name = "option3", Description = "Third time option (optional)")] string? option3 = null,
        [SlashCommandParameter(Name = "deadline", Description = "Voting deadline (YYYY-MM-DD HH:mm)")] string deadline = "")
    {
        var guild = Context.Guild
            ?? throw new InvalidOperationException("This command can only be used in a guild.");

        if (!Guid.TryParse(sessionIdText, out var sessionId))
        {
            await Context.Interaction.SendResponseAsync(
                InteractionCallback.Message("❌ Некорректный ID сессии."));
            return;
        }

        var options = new List<string> { option1, option2 };
        if (!string.IsNullOrWhiteSpace(option3))
            options.Add(option3);

        var parsedOptions = new List<DateTimeOffset>();
        foreach (var opt in options)
        {
            var result = DiscordNewSessionHandler.ParseTimeInput(opt);
            if (!result.IsSuccess)
            {
                await Context.Interaction.SendResponseAsync(
                    InteractionCallback.Message($"❌ {opt}: {result.Error}"));
                return;
            }
            parsedOptions.Add(result.Value);
        }

        var deadlineResult = DiscordNewSessionHandler.ParseTimeInput(deadline);
        if (!deadlineResult.IsSuccess)
        {
            await Context.Interaction.SendResponseAsync(
                InteractionCallback.Message($"❌ Дедлайн: {deadlineResult.Error}"));
            return;
        }

        if (deadlineResult.Value >= parsedOptions.Min())
        {
            await Context.Interaction.SendResponseAsync(
                InteractionCallback.Message("❌ Дедлайн должен быть раньше первого варианта времени."));
            return;
        }

        var resolvedPermissions = GetResolvedPermissions(guild, Context.User.Id);

        try
        {
            var result = await _handler.HandleAsync(
                guildId: guild.Id.ToString(),
                channelId: Context.Channel.Id.ToString(),
                userId: Context.User.Id,
                userDisplayName: Context.User.GlobalName ?? Context.User.Username,
                resolvedPermissions: resolvedPermissions,
                guildOwnerId: guild.OwnerId,
                sessionId: sessionId,
                options: parsedOptions,
                deadline: deadlineResult.Value,
                CancellationToken.None);

            await Context.Interaction.SendResponseAsync(
                InteractionCallback.Message($"🗳 Голосование за перенос запущено! Дедлайн: {deadlineResult.Value:yyyy-MM-dd HH:mm} UTC."));
        }
        catch (UnauthorizedAccessException ex)
        {
            await Context.Interaction.SendResponseAsync(
                InteractionCallback.Message($":no_entry: {ex.Message}"));
        }
        catch (InvalidOperationException ex)
        {
            await Context.Interaction.SendResponseAsync(
                InteractionCallback.Message($":warning: {ex.Message}"));
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to initiate reschedule for session {SessionId}", sessionId);
            await Context.Interaction.SendResponseAsync(
                InteractionCallback.Message(":boom: Ошибка при запуске голосования."));
        }
    }

    private static ulong GetResolvedPermissions(NetCord.Gateway.Guild guild, ulong userId)
    {
        if (!guild.Users.TryGetValue(userId, out var guildUser))
            return 0;
        ulong resolved = 0;
        foreach (var roleId in guildUser.RoleIds)
        {
            if (guild.Roles.TryGetValue(roleId, out var role))
                resolved |= (ulong)role.Permissions;
        }
        return resolved;
    }
}

Step 5: Register handler in Discord Program.cs

builder.Services.AddSingleton<DiscordRescheduleHandler>();

Step 6: Run tests

Run: dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordReschedule" --verbosity normal Expected: Tests pass.

Step 7: Commit

git add src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleCommand.cs
git add src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleHandler.cs
git add src/GmRelay.DiscordBot/Program.cs
git commit -m "feat(discord): add /reschedule slash command and handler"

Task 5: Discord Vote Button Handler

Files:

Create: src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleVoteHandler.cs
Modify: src/GmRelay.DiscordBot/Features/Sessions/DiscordSessionInteractionModule.cs
Step 1: Write failing test

namespace GmRelay.Bot.Tests.Discord;

public sealed class DiscordRescheduleVoteHandlerTests
{
    [Fact]
    public async Task HandleAsync_ShouldUpsertVote_WhenParticipantExists()
    {
        // Arrange: create proposal, option, participant in in-memory DB
        // Act: handler.HandleAsync(...)
        // Assert: vote exists in DB
    }
}

Run: dotnet test ... --filter "FullyQualifiedName~DiscordRescheduleVoteHandlerTests" Expected: FAIL (class not found).

Step 2: Implement handler

namespace GmRelay.DiscordBot.Features.Sessions;

using Dapper;
using GmRelay.Shared.Domain;
using GmRelay.Shared.Features.Sessions.RescheduleSession;
using GmRelay.Shared.Platform;
using Npgsql;
using NetCord.Rest;

public sealed record DiscordRescheduleVoteInput(
    Guid OptionId, ulong UserId, string InteractionId,
    string GuildId, string ChannelId, string MessageId);

public sealed class DiscordRescheduleVoteHandler(
    NpgsqlDataSource dataSource,
    IPlatformMessenger messenger,
    ILogger<DiscordRescheduleVoteHandler> logger)
{
    public async Task<string> HandleAsync(DiscordRescheduleVoteInput input, CancellationToken ct)
    {
        await using var connection = await dataSource.OpenConnectionAsync(ct);
        await using var transaction = await connection.BeginTransactionAsync(ct);

        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 { input.OptionId },
            transaction);

        if (proposal is null)
            return "Голосование уже завершено или не найдено.";

        if (proposal.VotingDeadlineAt <= DateTimeOffset.UtcNow)
            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 = 'Discord'
              AND p.external_user_id = @UserId
              AND sp.is_gm = false
              AND sp.registration_status = @Active
            """,
            new { proposal.SessionId, UserId = input.UserId.ToString(), Active = ParticipantRegistrationStatus.Active },
            transaction);

        if (playerId is null)
            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, input.OptionId },
            transaction);

        var participants = (await connection.QueryAsync<VoteParticipantDto>(
            """
            SELECT p.id AS PlayerId, p.display_name AS DisplayName, p.external_username AS TelegramUsername, 0 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);

        // Update Discord vote message
        var (embed, actionRow) = DiscordRescheduleVotingRenderer.Render(
            proposal.Title, proposal.CurrentScheduledAt, proposal.VotingDeadlineAt, options, participants, votes);

        await messenger.UpdateRescheduleVoteAsync(
            new PlatformRescheduleVoteMessage(
                new PlatformGroup(PlatformKind.Discord, input.GuildId, input.GuildId, input.ChannelId),
                new PlatformMessageRef(PlatformKind.Discord, input.GuildId, null, input.MessageId),
                embed,
                actionRow),
            ct);

        return "Ваш голос учтён. До дедлайна его можно изменить.";
    }
}

Step 3: Extend DiscordSessionInteractionModule

Add RescheduleVoteAsync method:

[ComponentInteraction("reschedule_vote")]
public async Task RescheduleVoteAsync(string optionId)
{
    if (!Guid.TryParse(optionId, out var parsedOptionId))
    {
        await RespondAsync(CreateEphemeralReply("Vote button is outdated."));
        return;
    }

    var input = CreateInput(Guid.Empty); // sessionId not needed for vote
    var voteInput = new DiscordRescheduleVoteInput(
        parsedOptionId, Context.User.Id, Context.Interaction.Id.ToString(),
        input.GuildId, input.ChannelId, input.MessageId);

    await RespondAsync(InteractionCallback.DeferredMessage(MessageFlags.Ephemeral));

    try
    {
        var replyText = await voteHandler.HandleAsync(voteInput, CancellationToken.None);
        await CompleteResponseAsync(replyText);
    }
    catch (Exception ex)
    {
        logger.LogError(ex, "Failed to handle Discord reschedule vote for option {OptionId}", parsedOptionId);
        await CompleteResponseAsync("Не удалось обработать голос.");
    }
}

Update constructor to inject DiscordRescheduleVoteHandler voteHandler.

Step 4: Register in Discord Program.cs

builder.Services.AddSingleton<DiscordRescheduleVoteHandler>();

Step 5: Run tests

Run: dotnet test ... --filter "FullyQualifiedName~DiscordRescheduleVote" Expected: PASS.

Step 6: Commit

git add src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleVoteHandler.cs
git add src/GmRelay.DiscordBot/Features/Sessions/DiscordSessionInteractionModule.cs
git add src/GmRelay.DiscordBot/Program.cs
git commit -m "feat(discord): add reschedule vote button handler"

Task 6: Discord Reschedule Voting Renderer

Files:

Create: src/GmRelay.DiscordBot/Rendering/DiscordRescheduleVotingRenderer.cs
Step 1: Write failing renderer test

namespace GmRelay.Bot.Tests.Discord;

public sealed class DiscordRescheduleVotingRendererTests
{
    [Fact]
    public void Render_ShouldProduceEmbedWithOptionsAndButtons()
    {
        var options = new[] { new RescheduleOptionDto(Guid.NewGuid(), 1, new DateTimeOffset(2026,5,25,16,0,0,TimeSpan.Zero)) };
        var (embed, actionRow) = DiscordRescheduleVotingRenderer.Render(
            "Test", DateTime.UtcNow, DateTimeOffset.UtcNow.AddHours(2), options, [], []);

        Assert.NotNull(embed);
        Assert.NotNull(actionRow);
        Assert.Contains("Перенос", embed.Title);
    }
}

Run: FAIL (class not found).

Step 2: Implement renderer

namespace GmRelay.DiscordBot.Rendering;

using GmRelay.Shared.Domain;
using GmRelay.Shared.Features.Sessions.RescheduleSession;
using NetCord;
using NetCord.Rest;

public static class DiscordRescheduleVotingRenderer
{
    public static (EmbedProperties Embed, ActionRowProperties ActionRow) Render(
        string title,
        DateTime currentTime,
        DateTimeOffset deadline,
        IReadOnlyList<RescheduleOptionDto> options,
        IReadOnlyList<VoteParticipantDto> participants,
        IReadOnlyList<RescheduleOptionVoteDto> votes)
    {
        var votesByOption = votes.GroupBy(v => v.OptionId).ToDictionary(g => g.Key, g => g.ToList());
        var votedPlayerIds = votes.Select(v => v.PlayerId).ToHashSet();
        var pending = participants.Where(p => !votedPlayerIds.Contains(p.PlayerId)).Select(p => p.DisplayName).ToList();

        var description = new System.Text.StringBuilder();
        description.AppendLine($"📅 Текущее время: {currentTime.FormatMoscow()} (МСК)");
        description.AppendLine($"⏳ Дедлайн: {deadline.FormatMoscow()} (МСК)");
        description.AppendLine();
        description.AppendLine("Выберите один из вариантов:");

        foreach (var option in options.OrderBy(o => o.DisplayOrder))
        {
            var optionVotes = votesByOption.GetValueOrDefault(option.OptionId, []);
            description.AppendLine($"{option.DisplayOrder}. **{option.ProposedAt.FormatMoscow()}** (МСК) — {optionVotes.Count} голосов");
            if (optionVotes.Count > 0)
            {
                description.AppendLine($"   {string.Join(", ", optionVotes.Select(v => v.DisplayName))}");
            }
        }

        if (pending.Count > 0)
        {
            description.AppendLine();
            description.AppendLine($"Не проголосовали: {string.Join(", ", pending)}");
        }

        description.AppendLine();
        description.AppendLine($"Голосов: {votedPlayerIds.Count}/{participants.Count}");

        var embed = new EmbedProperties()
            .WithTitle($"🔄 Перенос сессии «{title}»")
            .WithDescription(description.ToString())
            .WithColor(new Color(0xFEE75C));

        var actionRow = new ActionRowProperties();
        foreach (var option in options.OrderBy(o => o.DisplayOrder))
        {
            actionRow.Add(new ButtonProperties(
                $"reschedule_vote:{option.OptionId}",
                $"{option.DisplayOrder}. {FormatButtonTime(option.ProposedAt)}",
                ButtonStyle.Primary));
        }

        return (embed, actionRow);
    }

    private static string FormatButtonTime(DateTimeOffset utc)
        => utc.ToOffset(TimeSpan.FromHours(3)).ToString("dd.MM HH:mm", System.Globalization.CultureInfo.InvariantCulture);
}

Step 3: Run tests

Run: dotnet test ... --filter "FullyQualifiedName~DiscordRescheduleVotingRenderer" Expected: PASS.

Step 4: Commit

git add src/GmRelay.DiscordBot/Rendering/DiscordRescheduleVotingRenderer.cs
git commit -m "feat(discord): add reschedule voting message renderer"

Task 7: Extend IPlatformMessenger and Implementations

Files:

Modify: src/GmRelay.Shared/Platform/IPlatformMessenger.cs
Modify: src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPlatformMessenger.cs
Modify: src/GmRelay.Bot/Infrastructure/Telegram/TelegramPlatformMessenger.cs
Step 1: Add reschedule vote methods to interface

namespace GmRelay.Shared.Platform;

public interface IPlatformMessenger
{
    // existing methods ...

    Task<PlatformMessageRef> SendRescheduleVoteAsync(PlatformRescheduleVoteMessage message, CancellationToken ct);
    Task UpdateRescheduleVoteAsync(PlatformRescheduleVoteMessage message, CancellationToken ct);
}

public sealed record PlatformRescheduleVoteMessage(
    PlatformGroup Group,
    PlatformMessageRef ExistingMessage,
    string Title,
    DateTime CurrentScheduledAt,
    DateTimeOffset Deadline,
    IReadOnlyList<RescheduleOptionDto> Options,
    IReadOnlyList<VoteParticipantDto> Participants,
    IReadOnlyList<RescheduleOptionVoteDto> Votes);

Wait — RescheduleOptionDto is in GmRelay.Shared.Features.Sessions.RescheduleSession, so the interface can reference it. But the interface currently doesn't reference feature namespaces. To keep it clean, create a dedicated view model:

public sealed record PlatformRescheduleVoteMessage(
    PlatformGroup Group,
    PlatformMessageRef ExistingMessage,
    string HtmlText,        // Telegram uses HTML, Discord uses markdown-ish
    IReadOnlyList<PlatformMessageAction> Actions);

Actually, this is getting over-engineered. Let's keep it pragmatic:

For Discord, the handler directly calls restClient.ModifyMessageAsync or sends via interaction response. We don't need IPlatformMessenger for the vote message — the handler can use RestClient directly, injected alongside IPlatformMessenger.

Revised approach: Keep IPlatformMessenger unchanged. Discord handlers inject RestClient directly for message operations. Telegram handlers keep using ITelegramBotClient.

For the deadline service, Discord version will inject RestClient.

This is simpler and avoids over-engineering the shared interface.

Step 2: Implement DiscordPlatformMessenger.SendGroupMessageAsync

public async Task SendGroupMessageAsync(PlatformGroup group, string htmlText, CancellationToken ct)
{
    var channelId = ulong.Parse(group.ExternalChannelId ?? group.ExternalGroupId);
    await restClient.SendMessageAsync(channelId, htmlText);
}

Step 3: Commit

git add src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPlatformMessenger.cs
git commit -m "feat(discord): implement SendGroupMessageAsync in DiscordPlatformMessenger"

Task 8: Discord Reschedule Voting Deadline Service

Files:

Create: src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleVotingDeadlineService.cs
Modify: src/GmRelay.DiscordBot/Program.cs
Step 1: Write failing test

namespace GmRelay.Bot.Tests.Discord;

public sealed class DiscordRescheduleVotingDeadlineServiceTests
{
    [Fact]
    public async Task ProcessDueProposals_ShouldFinalize_WhenDeadlinePassed()
    {
        // Arrange: insert proposal with past deadline
        // Act: call service method directly
        // Assert: proposal status = Approved/Rejected
    }
}

Run: FAIL.

Step 2: Implement service

namespace GmRelay.DiscordBot.Features.Sessions;

using Dapper;
using GmRelay.Shared.Domain;
using GmRelay.Shared.Features.Sessions.RescheduleSession;
using GmRelay.Shared.Platform;
using GmRelay.Shared.Rendering;
using NetCord.Rest;
using Npgsql;

public sealed class DiscordRescheduleVotingDeadlineService(
    NpgsqlDataSource dataSource,
    RescheduleVotingFinalizer finalizer,
    RestClient restClient,
    ILogger<DiscordRescheduleVotingDeadlineService> logger) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        try
        {
            await ProcessDueProposals(stoppingToken);
            using var timer = new PeriodicTimer(TimeSpan.FromMinutes(1));
            while (await timer.WaitForNextTickAsync(stoppingToken))
            {
                await ProcessDueProposals(stoppingToken);
            }
        }
        catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested) { }
    }

    private async Task ProcessDueProposals(CancellationToken ct)
    {
        try
        {
            var proposalIds = await finalizer.GetDueProposalIdsAsync(ct);
            foreach (var id in proposalIds)
            {
                await FinalizeOneAsync(id, ct);
            }
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Failed to process Discord reschedule proposals");
        }
    }

    private async Task FinalizeOneAsync(Guid proposalId, CancellationToken ct)
    {
        var result = await finalizer.FinalizeAsync(proposalId, ct);
        if (result is null) return;

        // Only process Discord-sourced proposals
        if (!await IsDiscordProposalAsync(proposalId, ct))
            return;

        // Update Discord vote message
        await TryUpdateDiscordVoteMessage(result, ct);

        // Update batch schedule if approved
        if (result.SelectedOption is not null)
        {
            await TryUpdateBatchScheduleAsync(result, ct);
        }

        logger.LogInformation(
            "Finalized Discord reschedule proposal {ProposalId} for session {SessionId} with outcome {Outcome}",
            proposalId, result.SessionId, result.Decision.Outcome);
    }

    private async Task<bool> IsDiscordProposalAsync(Guid proposalId, CancellationToken ct)
    {
        await using var connection = await dataSource.OpenConnectionAsync(ct);
        var platform = await connection.ExecuteScalarAsync<string>(
            "SELECT source_platform FROM reschedule_proposals WHERE id = @Id",
            new { Id = proposalId });
        return platform == "Discord";
    }

    private async Task TryUpdateDiscordVoteMessage(FinalizeProposalResult result, CancellationToken ct)
    {
        try
        {
            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
                LIMIT 1
                """,
                new { result.SessionId });

            if (msgRef is null) return;

            var (embed, actionRow) = DiscordRescheduleVotingRenderer.Render(
                result.Title, result.CurrentScheduledAt, result.Deadline,
                result.Options, result.Participants, result.Votes);

            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, 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 = [updatedEmbed];
                options.Components = [disabledRow];
            });
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "Failed to update Discord vote message for proposal {ProposalId}", result.ProposalId);
        }
    }

    private async Task TryUpdateBatchScheduleAsync(FinalizeProposalResult result, CancellationToken ct)
    {
        // Reuse existing Discord batch update logic or IPlatformMessenger
        // This is simplified — full implementation needs DiscordListSessionsHandler query + renderer
    }

    internal sealed record PlatformMessageRefDto(string ExternalChannelId, string ExternalMessageId);
}

Step 3: Register service in Discord Program.cs

builder.Services.AddSingleton<ISystemClock, SystemClock>(); // need to add SystemClock to DiscordBot or Shared
builder.Services.AddHostedService<DiscordRescheduleVotingDeadlineService>();
builder.Services.AddSingleton<RescheduleVotingFinalizer>();

Wait, SystemClock is in GmRelay.Bot. Need to either move it to Shared or duplicate in DiscordBot.

Simplest: create SystemClock in GmRelay.DiscordBot.Infrastructure:

namespace GmRelay.DiscordBot.Infrastructure;
public sealed class SystemClock : ISystemClock { public DateTimeOffset UtcNow => DateTimeOffset.UtcNow; }

Step 4: Run tests

Run: dotnet test ... --filter "FullyQualifiedName~DiscordRescheduleVotingDeadline" Expected: PASS.

Step 5: Commit

git add src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleVotingDeadlineService.cs
git add src/GmRelay.DiscordBot/Infrastructure/SystemClock.cs
git add src/GmRelay.DiscordBot/Program.cs
git commit -m "feat(discord): add reschedule voting deadline service"

Task 9: Update Telegram Handlers for Source Platform

Files:

Modify: src/GmRelay.Bot/Features/Sessions/RescheduleSession/InitiateRescheduleHandler.cs
Modify: src/GmRelay.Bot/Features/Sessions/RescheduleSession/HandleRescheduleTimeInputHandler.cs
Step 1: Update InitiateRescheduleHandler

Change INSERT to include source_platform:

INSERT INTO reschedule_proposals (session_id, proposed_by, source_platform, status)
VALUES (@SessionId, @GmId, 'Telegram', 'AwaitingTime')

Step 2: Update HandleRescheduleTimeInputHandler

Change UPDATE to include source_platform backfill if null (or ensure it's set). Actually, InitiateRescheduleHandler already sets it. No change needed in time input handler.

Step 3: Update RescheduleVotingDeadlineService to filter Telegram

Add WHERE rp.source_platform = 'Telegram' to the proposal query.

Step 4: Run all Telegram tests

Run: dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~Reschedule" --verbosity normal Expected: PASS.

Step 5: Commit

git add src/GmRelay.Bot/Features/Sessions/RescheduleSession/
git commit -m "fix(telegram): annotate reschedule proposals with source_platform"

Task 10: Version Bump

Files:

Modify: Directory.Build.props
Modify: compose.yaml
Modify: .gitea/workflows/deploy.yml
Modify: src/GmRelay.Web/Components/Layout/NavMenu.razor
Step 1: Bump version 2.5.0 → 2.6.0 in all 4 files
Step 2: Commit

git add Directory.Build.props compose.yaml .gitea/workflows/deploy.yml src/GmRelay.Web/Components/Layout/NavMenu.razor
git commit -m "chore(release): bump version to 2.6.0"

Task 11: Build and Test Verification

Step 1: Full build

Run: dotnet build Expected: Success.

Step 2: Run all tests

Run: dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --verbosity normal Expected: All pass.

Step 3: Format check

Run: dotnet format --verify-no-changes --verbosity diagnostic Expected: Clean.

Step 4: Commit fixes if any

git add -A
git commit -m "style: apply dotnet format"

Self-Review

1. Spec coverage:

Discord UI for 2-3 time options + deadline: covered by /reschedule slash command with option1/option2/option3/deadline params ✓
Persisted votes via existing model: covered by DiscordRescheduleVoteHandler using reschedule_option_votes ✓
Winner selection and session update: covered by RescheduleVotingFinalizer (shared) + DiscordRescheduleVotingDeadlineService ✓
Update Discord schedule message after voting: covered by TryUpdateBatchScheduleAsync in deadline service ✓
Telegram flow does not regress: covered by keeping all Telegram handlers intact, adding source_platform = 'Telegram' ✓

2. Placeholder scan:

No TBD/TODO/fill-in-details found. All code shown explicitly. ✓

3. Type consistency:

RescheduleOptionDto, RescheduleVoteDecision, etc. used consistently across all tasks. ✓

Execution Handoff

Plan complete and saved to docs/superpowers/plans/2026-05-20-discord-reschedule-voting.md.

Two execution options:

1. Subagent-Driven (recommended) — I dispatch a fresh subagent per task, review between tasks, fast iteration.

2. Inline Execution — Execute tasks in this session using superpowers:executing-plans, batch execution with checkpoints for review.

Which approach?

56 KiB Raw Blame History

Discord Reschedule Voting Implementation Plan

File Structure

Task 1: Database Migration V017

Task 2: Extract Shared Reschedule Types

Task 3: Create Shared RescheduleVotingFinalizer

Task 4: Discord /reschedule Slash Command

Task 5: Discord Vote Button Handler

Task 6: Discord Reschedule Voting Renderer

Task 7: Extend IPlatformMessenger and Implementations

Task 8: Discord Reschedule Voting Deadline Service

Task 9: Update Telegram Handlers for Source Platform

Task 10: Version Bump

Task 11: Build and Test Verification

Self-Review

Execution Handoff

56 KiB

Raw Blame History