357 lines
13 KiB
C#
357 lines
13 KiB
C#
using System.Globalization;
|
|
using Dapper;
|
|
using GmRelay.Shared.Domain;
|
|
using GmRelay.Shared.Features.Notifications;
|
|
using GmRelay.Shared.Platform;
|
|
using Microsoft.Extensions.Logging;
|
|
using Npgsql;
|
|
|
|
namespace GmRelay.Shared.Features.Confirmation.HandleRsvp;
|
|
|
|
public sealed record HandleRsvpCommand(
|
|
Guid SessionId,
|
|
PlatformUser User,
|
|
string Status,
|
|
string InteractionId,
|
|
PlatformGroup Group,
|
|
PlatformMessageRef ConfirmationMessage);
|
|
|
|
internal sealed record RsvpCounts(int Total, int Confirmed, int Declined);
|
|
|
|
internal sealed record RsvpSessionContext(
|
|
Guid GroupId,
|
|
string Title,
|
|
DateTime ScheduledAt,
|
|
string Status);
|
|
|
|
internal sealed record ParticipantRsvpRow(
|
|
string Platform,
|
|
string ExternalUserId,
|
|
string DisplayName,
|
|
string? ExternalUsername,
|
|
string RsvpStatus,
|
|
string RegistrationStatus,
|
|
bool IsGm);
|
|
|
|
internal sealed record RsvpRecipientRow(
|
|
string Platform,
|
|
string ExternalUserId,
|
|
string DisplayName,
|
|
string? ExternalUsername);
|
|
|
|
public sealed class HandleRsvpHandler(
|
|
NpgsqlDataSource dataSource,
|
|
IPlatformMessenger messenger,
|
|
ILogger<HandleRsvpHandler> logger)
|
|
{
|
|
public async Task HandleAsync(HandleRsvpCommand command, CancellationToken ct)
|
|
{
|
|
await using var connection = await dataSource.OpenConnectionAsync(ct);
|
|
await using var transaction = await connection.BeginTransactionAsync(ct);
|
|
|
|
var participantExists = await connection.ExecuteScalarAsync<bool>(
|
|
"""
|
|
SELECT EXISTS (
|
|
SELECT 1
|
|
FROM session_participants sp
|
|
JOIN players p ON p.id = sp.player_id
|
|
WHERE sp.session_id = @SessionId
|
|
AND COALESCE(p.platform, 'Telegram') = @Platform
|
|
AND COALESCE(p.external_user_id, p.telegram_id::TEXT) = @ExternalUserId
|
|
AND sp.is_gm = false
|
|
AND sp.registration_status = @Active
|
|
)
|
|
""",
|
|
new
|
|
{
|
|
command.SessionId,
|
|
Platform = command.User.Platform.ToString(),
|
|
command.User.ExternalUserId,
|
|
Active = ParticipantRegistrationStatus.Active
|
|
},
|
|
transaction);
|
|
|
|
if (!participantExists)
|
|
{
|
|
await messenger.AnswerInteractionAsync(
|
|
new PlatformInteractionReply(
|
|
command.InteractionId,
|
|
"Вы не являетесь участником этой сессии."),
|
|
ct);
|
|
return;
|
|
}
|
|
|
|
var updated = await connection.ExecuteAsync(
|
|
"""
|
|
UPDATE session_participants
|
|
SET rsvp_status = @Status,
|
|
responded_at = now()
|
|
WHERE session_id = @SessionId
|
|
AND player_id = (
|
|
SELECT id
|
|
FROM players
|
|
WHERE COALESCE(platform, 'Telegram') = @Platform
|
|
AND COALESCE(external_user_id, telegram_id::TEXT) = @ExternalUserId
|
|
LIMIT 1
|
|
)
|
|
AND registration_status = @Active
|
|
AND rsvp_status != @Status
|
|
""",
|
|
new
|
|
{
|
|
command.SessionId,
|
|
command.Status,
|
|
Platform = command.User.Platform.ToString(),
|
|
command.User.ExternalUserId,
|
|
Active = ParticipantRegistrationStatus.Active
|
|
},
|
|
transaction);
|
|
|
|
if (updated == 0)
|
|
{
|
|
var alreadyText = command.Status == RsvpStatus.Confirmed
|
|
? "Вы уже подтвердили участие."
|
|
: "Вы уже отказались от участия.";
|
|
|
|
await messenger.AnswerInteractionAsync(
|
|
new PlatformInteractionReply(command.InteractionId, alreadyText),
|
|
ct);
|
|
return;
|
|
}
|
|
|
|
var session = await connection.QuerySingleAsync<RsvpSessionContext>(
|
|
"""
|
|
SELECT s.group_id AS GroupId,
|
|
s.title,
|
|
s.scheduled_at AS ScheduledAt,
|
|
s.status AS Status
|
|
FROM sessions s
|
|
WHERE s.id = @SessionId
|
|
""",
|
|
new { command.SessionId },
|
|
transaction);
|
|
|
|
if (command.Status == RsvpStatus.Declined)
|
|
{
|
|
var decision = RsvpFlowRules.Evaluate(
|
|
command.Status,
|
|
session.Status,
|
|
totalParticipants: 0,
|
|
confirmedParticipants: 0);
|
|
|
|
if (decision.ShouldRevertSessionToConfirmationSent)
|
|
{
|
|
await connection.ExecuteAsync(
|
|
"""
|
|
UPDATE sessions
|
|
SET status = @ConfirmationSent, updated_at = now()
|
|
WHERE id = @SessionId AND status = @Confirmed
|
|
""",
|
|
new
|
|
{
|
|
command.SessionId,
|
|
ConfirmationSent = SessionStatus.ConfirmationSent,
|
|
Confirmed = SessionStatus.Confirmed
|
|
},
|
|
transaction);
|
|
}
|
|
|
|
var gmRecipients = (await GetGmRecipientsAsync(connection, session.GroupId, transaction))
|
|
.ToList();
|
|
|
|
await transaction.CommitAsync(ct);
|
|
|
|
if (gmRecipients.Count > 0)
|
|
{
|
|
await messenger.SendRsvpOutcomeAsync(
|
|
new PlatformRsvpOutcomeNotification(
|
|
PlatformRsvpOutcomeKind.GmPlayerDeclined,
|
|
Group: null,
|
|
gmRecipients,
|
|
command.SessionId,
|
|
session.Title,
|
|
session.ScheduledAt,
|
|
ActorDisplayName: command.User.DisplayName),
|
|
ct);
|
|
}
|
|
|
|
await messenger.AnswerInteractionAsync(
|
|
new PlatformInteractionReply(command.InteractionId, decision.CallbackText),
|
|
ct);
|
|
}
|
|
else
|
|
{
|
|
var counts = await connection.QuerySingleAsync<RsvpCounts>(
|
|
"""
|
|
SELECT
|
|
count(*) AS Total,
|
|
count(*) FILTER (WHERE rsvp_status = @Confirmed) AS Confirmed,
|
|
count(*) FILTER (WHERE rsvp_status = @Declined) AS Declined
|
|
FROM session_participants
|
|
WHERE session_id = @SessionId AND is_gm = false
|
|
AND registration_status = @Active
|
|
""",
|
|
new
|
|
{
|
|
command.SessionId,
|
|
Confirmed = RsvpStatus.Confirmed,
|
|
Declined = RsvpStatus.Declined,
|
|
Active = ParticipantRegistrationStatus.Active
|
|
},
|
|
transaction);
|
|
|
|
var decision = RsvpFlowRules.Evaluate(command.Status, session.Status, counts.Total, counts.Confirmed);
|
|
|
|
if (decision.ShouldMarkSessionConfirmed)
|
|
{
|
|
await connection.ExecuteAsync(
|
|
"""
|
|
UPDATE sessions
|
|
SET status = @Confirmed, updated_at = now()
|
|
WHERE id = @SessionId
|
|
""",
|
|
new { command.SessionId, Confirmed = SessionStatus.Confirmed },
|
|
transaction);
|
|
}
|
|
|
|
var gmRecipients = decision.ShouldNotifyGm
|
|
? (await GetGmRecipientsAsync(connection, session.GroupId, transaction)).ToList()
|
|
: [];
|
|
|
|
await transaction.CommitAsync(ct);
|
|
|
|
if (decision.ShouldNotifyGroup)
|
|
{
|
|
await messenger.SendRsvpOutcomeAsync(
|
|
new PlatformRsvpOutcomeNotification(
|
|
PlatformRsvpOutcomeKind.GroupAllConfirmed,
|
|
command.Group,
|
|
[],
|
|
command.SessionId,
|
|
session.Title,
|
|
session.ScheduledAt),
|
|
ct);
|
|
}
|
|
|
|
if (decision.ShouldNotifyGm && gmRecipients.Count > 0)
|
|
{
|
|
await messenger.SendRsvpOutcomeAsync(
|
|
new PlatformRsvpOutcomeNotification(
|
|
PlatformRsvpOutcomeKind.GmAllConfirmed,
|
|
Group: null,
|
|
gmRecipients,
|
|
command.SessionId,
|
|
session.Title,
|
|
session.ScheduledAt),
|
|
ct);
|
|
}
|
|
|
|
await messenger.AnswerInteractionAsync(
|
|
new PlatformInteractionReply(command.InteractionId, decision.CallbackText),
|
|
ct);
|
|
}
|
|
|
|
await UpdateConfirmationMessage(command, session, ct);
|
|
}
|
|
|
|
private async Task UpdateConfirmationMessage(
|
|
HandleRsvpCommand command,
|
|
RsvpSessionContext session,
|
|
CancellationToken ct)
|
|
{
|
|
try
|
|
{
|
|
await using var connection = await dataSource.OpenConnectionAsync(ct);
|
|
|
|
var participants = (await connection.QueryAsync<ParticipantRsvpRow>(
|
|
"""
|
|
SELECT COALESCE(p.platform, 'Telegram') AS Platform,
|
|
COALESCE(p.external_user_id, p.telegram_id::TEXT) AS ExternalUserId,
|
|
p.display_name AS DisplayName,
|
|
COALESCE(p.external_username, p.telegram_username) AS ExternalUsername,
|
|
sp.rsvp_status AS RsvpStatus,
|
|
sp.registration_status AS RegistrationStatus,
|
|
sp.is_gm AS IsGm
|
|
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 sp.responded_at NULLS LAST
|
|
""",
|
|
new { command.SessionId, Active = ParticipantRegistrationStatus.Active }))
|
|
.Select(ToParticipant)
|
|
.ToList();
|
|
|
|
var disableActions = participants.Count > 0 &&
|
|
participants.All(participant => participant.RsvpStatus == RsvpStatus.Confirmed);
|
|
|
|
await messenger.UpdateConfirmationRequestAsync(
|
|
new PlatformRsvpMessageUpdate(
|
|
new PlatformConfirmationRequest(
|
|
command.Group,
|
|
command.SessionId,
|
|
session.Title,
|
|
session.ScheduledAt,
|
|
participants,
|
|
command.ConfirmationMessage),
|
|
disableActions),
|
|
ct);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.LogWarning(ex, "Failed to update confirmation message for session {SessionId}", command.SessionId);
|
|
}
|
|
}
|
|
|
|
private static async Task<IEnumerable<PlatformUser>> GetGmRecipientsAsync(
|
|
NpgsqlConnection connection,
|
|
Guid groupId,
|
|
NpgsqlTransaction transaction)
|
|
{
|
|
var rows = await connection.QueryAsync<RsvpRecipientRow>(
|
|
"""
|
|
SELECT DISTINCT
|
|
COALESCE(p.platform, 'Telegram') AS Platform,
|
|
COALESCE(p.external_user_id, p.telegram_id::TEXT) AS ExternalUserId,
|
|
p.display_name AS DisplayName,
|
|
COALESCE(p.external_username, p.telegram_username) AS ExternalUsername
|
|
FROM group_managers gm
|
|
JOIN players p ON p.id = gm.player_id
|
|
WHERE gm.group_id = @GroupId
|
|
UNION
|
|
SELECT DISTINCT
|
|
COALESCE(p.platform, 'Telegram') AS Platform,
|
|
COALESCE(p.external_user_id, p.telegram_id::TEXT) AS ExternalUserId,
|
|
p.display_name AS DisplayName,
|
|
COALESCE(p.external_username, p.telegram_username) AS ExternalUsername
|
|
FROM game_groups g
|
|
JOIN players p ON p.telegram_id = g.gm_telegram_id
|
|
WHERE g.id = @GroupId
|
|
AND g.gm_telegram_id IS NOT NULL
|
|
""",
|
|
new { GroupId = groupId },
|
|
transaction);
|
|
|
|
return rows.Select(row => new PlatformUser(
|
|
ParsePlatform(row.Platform),
|
|
row.ExternalUserId,
|
|
row.DisplayName,
|
|
row.ExternalUsername));
|
|
}
|
|
|
|
private static PlatformSessionParticipant ToParticipant(ParticipantRsvpRow row) =>
|
|
new(
|
|
new PlatformUser(
|
|
ParsePlatform(row.Platform),
|
|
row.ExternalUserId,
|
|
row.DisplayName,
|
|
row.ExternalUsername),
|
|
row.RsvpStatus,
|
|
row.RegistrationStatus,
|
|
row.IsGm);
|
|
|
|
private static PlatformKind ParsePlatform(string platform) =>
|
|
Enum.Parse<PlatformKind>(platform, ignoreCase: true);
|
|
}
|