316 lines
13 KiB
C#
316 lines
13 KiB
C#
using Dapper;
|
|
using GmRelay.Bot.Features.Notifications;
|
|
using GmRelay.Shared.Domain;
|
|
using GmRelay.Shared.Rendering;
|
|
using Npgsql;
|
|
using Telegram.Bot;
|
|
using Telegram.Bot.Types;
|
|
using Telegram.Bot.Types.ReplyMarkups;
|
|
|
|
namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
|
|
|
|
// ── DTOs ─────────────────────────────────────────────────────────────
|
|
|
|
internal sealed record AwaitingProposalDto(
|
|
Guid Id, Guid SessionId, string Title, DateTime CurrentScheduledAt,
|
|
Guid BatchId, int? BatchMessageId, long TelegramChatId, string NotificationMode);
|
|
|
|
internal sealed record VoteParticipantDto(
|
|
Guid PlayerId,
|
|
string DisplayName,
|
|
string? TelegramUsername,
|
|
long TelegramId = 0);
|
|
|
|
// ── Handler ──────────────────────────────────────────────────────────
|
|
|
|
/// <summary>
|
|
/// Handles text input from the GM who has an AwaitingTime proposal.
|
|
/// Parses the new time, creates a voting message, and tags all participants.
|
|
/// If no participants are registered, reschedules immediately.
|
|
/// </summary>
|
|
public sealed class HandleRescheduleTimeInputHandler(
|
|
NpgsqlDataSource dataSource,
|
|
ITelegramBotClient bot,
|
|
DirectSessionNotificationSender directSender,
|
|
ILogger<HandleRescheduleTimeInputHandler> logger)
|
|
{
|
|
/// <summary>
|
|
/// Attempts to handle a text message as reschedule time input.
|
|
/// Returns true if it was handled (i.e. user had an AwaitingTime proposal).
|
|
/// </summary>
|
|
public async Task<bool> TryHandleAsync(Message message, CancellationToken ct)
|
|
{
|
|
if (message.From is null || string.IsNullOrWhiteSpace(message.Text))
|
|
return false;
|
|
|
|
var gmTelegramId = message.From.Id;
|
|
var chatId = message.Chat.Id;
|
|
var text = message.Text.Trim();
|
|
|
|
await using var connection = await dataSource.OpenConnectionAsync(ct);
|
|
|
|
// 1. Check if this GM has an AwaitingTime proposal in this chat
|
|
var proposal = await connection.QuerySingleOrDefaultAsync<AwaitingProposalDto>(
|
|
"""
|
|
SELECT rp.id AS Id, rp.session_id AS SessionId, s.title AS Title, s.scheduled_at AS CurrentScheduledAt,
|
|
s.batch_id AS BatchId, s.batch_message_id AS BatchMessageId,
|
|
g.telegram_chat_id AS TelegramChatId,
|
|
s.notification_mode AS NotificationMode
|
|
FROM reschedule_proposals rp
|
|
JOIN sessions s ON s.id = rp.session_id
|
|
JOIN game_groups g ON g.id = s.group_id
|
|
WHERE rp.proposed_by = @GmId
|
|
AND rp.status = 'AwaitingTime'
|
|
AND g.telegram_chat_id = @ChatId
|
|
AND EXISTS (
|
|
SELECT 1
|
|
FROM group_managers gm
|
|
JOIN players manager_player ON manager_player.id = gm.player_id
|
|
WHERE gm.group_id = s.group_id
|
|
AND manager_player.telegram_id = @GmId
|
|
)
|
|
ORDER BY rp.created_at DESC
|
|
LIMIT 1
|
|
""",
|
|
new { GmId = gmTelegramId, ChatId = chatId });
|
|
|
|
if (proposal is null)
|
|
return false;
|
|
|
|
// 2. Parse the new time
|
|
if (!MoscowTime.TryParseMoscow(text, out var newTime))
|
|
{
|
|
await bot.SendMessage(
|
|
chatId: chatId,
|
|
text: "⚠️ Не удалось распознать время. Используйте формат: <code>ДД.ММ.ГГГГ ЧЧ:ММ</code>\nНапример: <code>25.04.2026 19:30</code>",
|
|
parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
|
|
cancellationToken: ct);
|
|
return true;
|
|
}
|
|
|
|
if (newTime <= DateTimeOffset.UtcNow)
|
|
{
|
|
await bot.SendMessage(
|
|
chatId: chatId,
|
|
text: "⚠️ Новое время должно быть в будущем. Попробуйте снова.",
|
|
cancellationToken: ct);
|
|
return true;
|
|
}
|
|
|
|
// 3. Load participants (non-GM) signed up for this session
|
|
var participants = (await connection.QueryAsync<VoteParticipantDto>(
|
|
"""
|
|
SELECT p.id AS PlayerId,
|
|
p.display_name AS DisplayName,
|
|
p.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
|
|
""",
|
|
new { proposal.SessionId, Active = ParticipantRegistrationStatus.Active })).ToList();
|
|
|
|
// 4. If no participants — reschedule immediately
|
|
if (participants.Count == 0)
|
|
{
|
|
await RescheduleImmediately(connection, proposal, newTime, chatId, ct);
|
|
await TryDeleteMessage(chatId, message.MessageId, ct);
|
|
return true;
|
|
}
|
|
|
|
// 5. Create voting message
|
|
await using var transaction = await connection.BeginTransactionAsync(ct);
|
|
|
|
// Update proposal with proposed time and Voting status
|
|
await connection.ExecuteAsync(
|
|
"""
|
|
UPDATE reschedule_proposals
|
|
SET proposed_at = @ProposedAt, status = 'Voting', vote_chat_id = @ChatId
|
|
WHERE id = @Id
|
|
""",
|
|
new { ProposedAt = newTime, ChatId = chatId, Id = proposal.Id },
|
|
transaction);
|
|
|
|
await transaction.CommitAsync(ct);
|
|
|
|
// Build voting message text
|
|
var voteText = BuildVotingMessage(proposal.Title, proposal.CurrentScheduledAt, newTime, participants, []);
|
|
|
|
var keyboard = new InlineKeyboardMarkup([
|
|
[
|
|
InlineKeyboardButton.WithCallbackData("✅ Согласен", $"reschedule_vote:yes:{proposal.Id}"),
|
|
InlineKeyboardButton.WithCallbackData("❌ Против", $"reschedule_vote:no:{proposal.Id}")
|
|
]
|
|
]);
|
|
|
|
var voteMsg = await bot.SendMessage(
|
|
chatId: chatId,
|
|
text: voteText,
|
|
parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
|
|
replyMarkup: keyboard,
|
|
cancellationToken: ct);
|
|
|
|
var mode = SessionNotificationModeExtensions.FromDatabaseValue(proposal.NotificationMode);
|
|
if (mode.ShouldSendDirectMessages())
|
|
{
|
|
var directText = $"""
|
|
🔄 <b>Голосование за перенос сессии</b>
|
|
|
|
📌 <b>{System.Net.WebUtility.HtmlEncode(proposal.Title)}</b>
|
|
📅 Текущее время: <b>{proposal.CurrentScheduledAt.FormatMoscow()}</b> (МСК)
|
|
📅 Новое время: <b>{newTime.FormatMoscow()}</b> (МСК)
|
|
|
|
Проголосуйте кнопкой в групповом сообщении.
|
|
""";
|
|
|
|
await directSender.SendAsync(
|
|
participants.Select(p => new DirectNotificationRecipient(
|
|
p.TelegramId,
|
|
p.DisplayName)),
|
|
directText,
|
|
"reschedule-vote",
|
|
proposal.SessionId,
|
|
ct);
|
|
}
|
|
|
|
// Store vote message ID
|
|
await connection.ExecuteAsync(
|
|
"UPDATE reschedule_proposals SET vote_message_id = @MsgId WHERE id = @Id",
|
|
new { MsgId = voteMsg.MessageId, Id = proposal.Id });
|
|
|
|
logger.LogInformation("Reschedule voting started for session {SessionId}, proposal {ProposalId}", proposal.SessionId, proposal.Id);
|
|
|
|
// Delete GM's time input message
|
|
await TryDeleteMessage(chatId, message.MessageId, ct);
|
|
|
|
return true;
|
|
}
|
|
|
|
private async Task RescheduleImmediately(
|
|
NpgsqlConnection connection, AwaitingProposalDto proposal,
|
|
DateTimeOffset newTime, long chatId, CancellationToken ct)
|
|
{
|
|
await using var transaction = await connection.BeginTransactionAsync(ct);
|
|
|
|
await connection.ExecuteAsync(
|
|
"""
|
|
UPDATE sessions
|
|
SET scheduled_at = @NewTime,
|
|
status = @Status,
|
|
one_hour_reminder_processed_at = NULL,
|
|
updated_at = now()
|
|
WHERE id = @SessionId
|
|
""",
|
|
new { NewTime = newTime, proposal.SessionId, Status = SessionStatus.Planned },
|
|
transaction);
|
|
|
|
await connection.ExecuteAsync(
|
|
"UPDATE reschedule_proposals SET proposed_at = @NewTime, status = 'Approved' WHERE id = @Id",
|
|
new { NewTime = newTime, Id = proposal.Id },
|
|
transaction);
|
|
|
|
await transaction.CommitAsync(ct);
|
|
|
|
await bot.SendMessage(
|
|
chatId: chatId,
|
|
text: $"✅ Сессия «{proposal.Title}» перенесена!\n\n📅 Новое время: <b>{newTime.ToOffset(TimeSpan.FromHours(3)).ToString("d MMMM yyyy, HH:mm", System.Globalization.CultureInfo.GetCultureInfo("ru-RU"))}</b> (МСК)\n\n<i>Участников нет — голосование не требуется.</i>",
|
|
parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
|
|
cancellationToken: ct);
|
|
|
|
// Re-render batch message with updated time
|
|
await TryUpdateBatchMessage(proposal, ct);
|
|
|
|
logger.LogInformation("Session {SessionId} rescheduled immediately (no participants)", proposal.SessionId);
|
|
}
|
|
|
|
internal static string BuildVotingMessage(
|
|
string title, DateTime currentTime, DateTimeOffset newTime,
|
|
IReadOnlyList<VoteParticipantDto> participants,
|
|
IReadOnlyCollection<Guid> approvedPlayerIds)
|
|
{
|
|
var lines = new List<string>
|
|
{
|
|
$"🔄 <b>Перенос сессии «{System.Net.WebUtility.HtmlEncode(title)}»</b>",
|
|
"",
|
|
$"📅 Текущее время: <b>{currentTime.FormatMoscow()}</b> (МСК)",
|
|
$"📅 Новое время: <b>{newTime.ToOffset(TimeSpan.FromHours(3)).ToString("d MMMM yyyy, HH:mm", System.Globalization.CultureInfo.GetCultureInfo("ru-RU"))}</b> (МСК)",
|
|
"",
|
|
"Для переноса нужно согласие всех участников:"
|
|
};
|
|
|
|
foreach (var p in participants)
|
|
{
|
|
var name = p.TelegramUsername is not null ? $"@{p.TelegramUsername}" : p.DisplayName;
|
|
var icon = approvedPlayerIds.Contains(p.PlayerId) ? "✅" : "⏳";
|
|
lines.Add($" {icon} {name}");
|
|
}
|
|
|
|
lines.Add("");
|
|
lines.Add($"Голоса: {approvedPlayerIds.Count}/{participants.Count} ✅");
|
|
|
|
return string.Join("\n", lines);
|
|
}
|
|
|
|
private async Task TryUpdateBatchMessage(AwaitingProposalDto proposal, CancellationToken ct)
|
|
{
|
|
try
|
|
{
|
|
await using var conn = await dataSource.OpenConnectionAsync(ct);
|
|
|
|
var batchSessions = (await conn.QueryAsync<SessionBatchDto>(
|
|
"SELECT id AS SessionId, scheduled_at AS ScheduledAt, status AS Status, max_players AS MaxPlayers FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
|
|
new { proposal.BatchId })).ToList();
|
|
|
|
var batchParticipants = (await conn.QueryAsync<ParticipantBatchDto>(
|
|
"""
|
|
SELECT sp.session_id AS SessionId,
|
|
p.display_name AS DisplayName,
|
|
p.telegram_username AS TelegramUsername,
|
|
sp.registration_status AS RegistrationStatus
|
|
FROM session_participants sp
|
|
JOIN players p ON sp.player_id = p.id
|
|
JOIN sessions s ON sp.session_id = s.id
|
|
WHERE s.batch_id = @BatchId AND sp.is_gm = false
|
|
ORDER BY sp.registration_status ASC, sp.created_at ASC, sp.responded_at ASC, p.created_at ASC
|
|
""",
|
|
new { proposal.BatchId })).ToList();
|
|
|
|
if (proposal.BatchMessageId.HasValue)
|
|
{
|
|
var renderResult = SessionBatchRenderer.Render(
|
|
proposal.Title, batchSessions, batchParticipants);
|
|
|
|
await bot.EditMessageText(
|
|
chatId: proposal.TelegramChatId,
|
|
messageId: proposal.BatchMessageId.Value,
|
|
text: renderResult.Text,
|
|
parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
|
|
replyMarkup: renderResult.Markup,
|
|
cancellationToken: ct);
|
|
}
|
|
else
|
|
{
|
|
logger.LogWarning("No batch_message_id stored for session {SessionId}, cannot edit batch message in-place", proposal.SessionId);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.LogWarning(ex, "Failed to update batch message after immediate reschedule for session {SessionId}", proposal.SessionId);
|
|
}
|
|
}
|
|
|
|
private async Task TryDeleteMessage(long chatId, int messageId, CancellationToken ct)
|
|
{
|
|
try
|
|
{
|
|
await bot.DeleteMessage(chatId, messageId, cancellationToken: ct);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.LogWarning(ex, "Failed to delete message {MessageId} in chat {ChatId}", messageId, chatId);
|
|
}
|
|
}
|
|
}
|