Remora.Discord part 4 out of ∞ (well that was painful)

Signed-off-by: Octol1ttle <l1ttleofficial@outlook.com>

Boyfriend.cs

@@ -7,9 +7,11 @@ using Remora.Discord.API.Abstractions.Objects;
 using Remora.Discord.API.Objects;
 using Remora.Discord.Caching.Extensions;
 using Remora.Discord.Caching.Services;
+using Remora.Discord.Commands.Extensions;
 using Remora.Discord.Gateway;
 using Remora.Discord.Gateway.Extensions;
 using Remora.Discord.Hosting.Extensions;
+using Remora.Discord.Interactivity.Extensions;
 using Remora.Rest.Core;
 
 namespace Boyfriend;
@@ -62,7 +64,13 @@ public class Boyfriend {
                     services.AddTransient<IConfigurationBuilder, ConfigurationBuilder>();
 
                     services.Configure<DiscordGatewayClientOptions>(
-                        options => options.Intents |= GatewayIntents.MessageContents | GatewayIntents.GuildMembers);
+                        options => options.Intents |= GatewayIntents.MessageContents
+                                                      | GatewayIntents.GuildMembers
+                                                      | GatewayIntents.GuildScheduledEvents);
+
+                    services.AddDiscordCommands();
+                    services.AddInteractivity();
+                    services.AddInteractionGroup<InteractionResponders>();
                 }
             ).ConfigureLogging(
                 c => c.AddConsole()

EventResponders.cs

@@ -5,11 +5,14 @@ using Microsoft.Extensions.Logging;
 using Remora.Discord.API.Abstractions.Gateway.Events;
 using Remora.Discord.API.Abstractions.Objects;
 using Remora.Discord.API.Abstractions.Rest;
+using Remora.Discord.API.Objects;
 using Remora.Discord.Caching;
 using Remora.Discord.Caching.Services;
 using Remora.Discord.Extensions.Embeds;
 using Remora.Discord.Extensions.Formatting;
 using Remora.Discord.Gateway.Responders;
+using Remora.Discord.Interactivity;
+using Remora.Rest.Core;
 using Remora.Results;
 
 // ReSharper disable UnusedType.Global
@@ -50,11 +53,10 @@ public class GuildCreateResponder : IResponder<IGuildCreate> {
             .WithCurrentTimestamp()
             .WithColour(Color.Aqua)
             .Build();
-
         if (!embed.IsDefined(out var built)) return Result.FromError(embed);
 
         return (Result)await _channelApi.CreateMessageAsync(
-            channel, embeds: new[] { built }!, ct: ct);
+            channel, embeds: new[] { built }, ct: ct);
     }
 }
 
@@ -62,12 +64,15 @@ public class MessageDeletedResponder : IResponder<IMessageDelete> {
     private readonly IDiscordRestAuditLogAPI _auditLogApi;
     private readonly CacheService _cacheService;
     private readonly IDiscordRestChannelAPI _channelApi;
+    private readonly IDiscordRestUserAPI _userApi;
 
     public MessageDeletedResponder(
-        IDiscordRestAuditLogAPI auditLogApi, CacheService cacheService, IDiscordRestChannelAPI channelApi) {
+        IDiscordRestAuditLogAPI auditLogApi, CacheService cacheService, IDiscordRestChannelAPI channelApi,
+        IDiscordRestUserAPI     userApi) {
         _auditLogApi = auditLogApi;
         _cacheService = cacheService;
         _channelApi = channelApi;
+        _userApi = userApi;
     }
 
     public async Task<Result> RespondAsync(IMessageDelete gatewayEvent, CancellationToken ct = default) {
@@ -92,12 +97,12 @@ public class MessageDeletedResponder : IResponder<IMessageDelete> {
         var user = message.Author;
         if (options.ChannelID == gatewayEvent.ChannelID
             && DateTimeOffset.UtcNow.Subtract(auditLog.ID.Timestamp).TotalSeconds <= 2) {
-            var userResult = await _cacheService.TryGetValueAsync<IUser>(
-                new KeyHelpers.UserCacheKey(auditLog.UserID!.Value), ct);
+            var userResult = await auditLog.UserID!.Value.TryGetUserAsync(_cacheService, _userApi, ct);
             if (!userResult.IsDefined(out user)) return Result.FromError(userResult);
         }
 
         Messages.Culture = guildId.GetGuildCulture();
+
         var embed = new EmbedBuilder()
             .WithSmallTitle(
                 message.Author,
@@ -127,23 +132,32 @@ public class MessageEditedResponder : IResponder<IMessageUpdate> {
     }
 
     public async Task<Result> RespondAsync(IMessageUpdate gatewayEvent, CancellationToken ct = default) {
-        if (!gatewayEvent.GuildID.IsDefined(out var guildId)) return Result.FromSuccess();
+        if (!gatewayEvent.GuildID.IsDefined(out var guildId))
+            return Result.FromSuccess();
+        if (!gatewayEvent.Content.IsDefined(out var newContent))
+            return Result.FromSuccess();
+
         if (!gatewayEvent.ChannelID.IsDefined(out var channelId))
             return Result.FromError(new ArgumentNullError(nameof(gatewayEvent.ChannelID)));
         if (!gatewayEvent.ID.IsDefined(out var messageId))
             return Result.FromError(new ArgumentNullError(nameof(gatewayEvent.ID)));
-        if (!gatewayEvent.Content.IsDefined(out var newContent))
-            return Result.FromError(new ArgumentNullError(nameof(gatewayEvent.Content)));
         if (!gatewayEvent.EditedTimestamp.IsDefined(out var timestamp))
             return Result.FromError(new ArgumentNullError(nameof(gatewayEvent.EditedTimestamp)));
 
+        var cacheKey = new KeyHelpers.MessageCacheKey(channelId, messageId);
         var messageResult = await _cacheService.TryGetValueAsync<IMessage>(
-            new KeyHelpers.MessageCacheKey(channelId, messageId), ct);
+            cacheKey, ct);
         if (!messageResult.IsDefined(out var message)) return Result.FromError(messageResult);
         if (string.IsNullOrWhiteSpace(message.Content)
             || string.IsNullOrWhiteSpace(newContent)
             || message.Content == newContent) return Result.FromSuccess();
 
+        await _cacheService.EvictAsync<IMessage>(cacheKey, ct);
+        var newMessageResult = await _channelApi.GetChannelMessageAsync(channelId, messageId, ct);
+        if (!newMessageResult.IsDefined(out var newMessage)) return Result.FromError(newMessageResult);
+        // No need to await the recache since we don't depend on it
+        _ = _cacheService.CacheAsync(cacheKey, newMessage, ct);
+
         var logChannelResult = guildId.GetConfigChannel("PrivateFeedbackChannel");
         if (!logChannelResult.IsDefined(out var logChannel)) return Result.FromSuccess();
 
@@ -154,12 +168,12 @@ public class MessageEditedResponder : IResponder<IMessageUpdate> {
         var diff = new SideBySideDiffBuilder(Differ.Instance).BuildDiffModel(message.Content, newContent, true, true);
 
         Messages.Culture = guildId.GetGuildCulture();
+
         var embed = new EmbedBuilder()
             .WithSmallTitle(
                 message.Author,
-                string.Format(Messages.CachedMessageEdited, message.Author.GetTag()),
-                $"https://discord.com/channels/{guildId}/{channelId}/{messageId}")
-            .WithDescription($"{Mention.Channel(message.ChannelID)}\n{diff.AsMarkdown()}")
+                string.Format(Messages.CachedMessageEdited, message.Author.GetTag()))
+            .WithDescription($"https://discord.com/channels/{guildId}/{channelId}/{messageId}\n{diff.AsMarkdown()}")
             .WithUserFooter(currentUser)
             .WithTimestamp(timestamp.Value)
             .WithColour(Color.Gold)
@@ -210,3 +224,90 @@ public class GuildMemberAddResponder : IResponder<IGuildMemberAdd> {
             channel, embeds: new[] { built }, allowedMentions: Boyfriend.NoMentions, ct: ct);
     }
 }
+
+public class GuildScheduledEventCreateResponder : IResponder<IGuildScheduledEventCreate> {
+    private readonly CacheService _cacheService;
+    private readonly IDiscordRestChannelAPI _channelApi;
+    private readonly IDiscordRestUserAPI _userApi;
+
+    public GuildScheduledEventCreateResponder(
+        CacheService cacheService, IDiscordRestChannelAPI channelApi, IDiscordRestUserAPI userApi) {
+        _cacheService = cacheService;
+        _channelApi = channelApi;
+        _userApi = userApi;
+    }
+
+    public async Task<Result> RespondAsync(IGuildScheduledEventCreate gatewayEvent, CancellationToken ct = default) {
+        var channelResult = gatewayEvent.GuildID.GetConfigChannel("EventNotificationChannel");
+        if (!channelResult.IsDefined(out var channel)) return Result.FromSuccess();
+
+        var currentUserResult = await _cacheService.TryGetValueAsync<IUser>(
+            new KeyHelpers.CurrentUserCacheKey(), ct);
+        if (!currentUserResult.IsDefined(out var currentUser)) return Result.FromError(currentUserResult);
+
+        if (!gatewayEvent.CreatorID.IsDefined(out var creatorId))
+            return Result.FromError(new ArgumentNullError(nameof(gatewayEvent.CreatorID)));
+        var creatorResult = await creatorId.Value.TryGetUserAsync(_cacheService, _userApi, ct);
+        if (!creatorResult.IsDefined(out var creator)) return Result.FromError(creatorResult);
+
+        Messages.Culture = gatewayEvent.GuildID.GetGuildCulture();
+
+        string embedDescription;
+        var eventDescription = gatewayEvent.Description is { HasValue: true, Value: not null }
+            ? gatewayEvent.Description.Value
+            : string.Empty;
+        switch (gatewayEvent.EntityType) {
+            case GuildScheduledEventEntityType.StageInstance or GuildScheduledEventEntityType.Voice:
+                if (!gatewayEvent.ChannelID.AsOptional().IsDefined(out var channelId))
+                    return Result.FromError(new ArgumentNullError(nameof(gatewayEvent.ChannelID)));
+
+                embedDescription = $"{eventDescription}\n\n{Markdown.BlockQuote(
+                    string.Format(
+                        Messages.LocalEventCreatedDescription,
+                        Markdown.Timestamp(gatewayEvent.ScheduledStartTime),
+                        Mention.Channel(channelId)
+                    ))}";
+                break;
+            case GuildScheduledEventEntityType.External:
+                if (!gatewayEvent.EntityMetadata.AsOptional().IsDefined(out var metadata))
+                    return Result.FromError(new ArgumentNullError(nameof(gatewayEvent.EntityMetadata)));
+                if (!gatewayEvent.ScheduledEndTime.AsOptional().IsDefined(out var endTime))
+                    return Result.FromError(new ArgumentNullError(nameof(gatewayEvent.ScheduledEndTime)));
+                if (!metadata.Location.IsDefined(out var location))
+                    return Result.FromError(new ArgumentNullError(nameof(metadata.Location)));
+
+                embedDescription = $"{eventDescription}\n\n{Markdown.BlockQuote(
+                    string.Format(
+                        Messages.ExternalEventCreatedDescription,
+                        Markdown.Timestamp(gatewayEvent.ScheduledStartTime),
+                        Markdown.Timestamp(endTime),
+                        Markdown.InlineCode(location)
+                    ))}";
+                break;
+            default:
+                return Result.FromError(new ArgumentOutOfRangeError(nameof(gatewayEvent.EntityType)));
+        }
+
+        var embed = new EmbedBuilder()
+            .WithSmallTitle(creator, string.Format(Messages.EventCreatedTitle, creator.GetTag()))
+            .WithTitle(gatewayEvent.Name)
+            .WithDescription(embedDescription)
+            .WithEventCover(gatewayEvent.ID, gatewayEvent.Image)
+            .WithUserFooter(currentUser)
+            .WithCurrentTimestamp()
+            .WithColour(Color.Gray)
+            .Build();
+        if (!embed.IsDefined(out var built)) return Result.FromError(embed);
+
+        var button = new ButtonComponent(
+            ButtonComponentStyle.Primary,
+            Messages.EventDetailsButton,
+            new PartialEmoji(Name: "📋"),
+            CustomIDHelpers.CreateButtonIDWithState(
+                "scheduled-event-details", $"{gatewayEvent.GuildID}:{gatewayEvent.ID}")
+        );
+
+        return (Result)await _channelApi.CreateMessageAsync(
+            channel, embeds: new[] { built }, components: new[] { new ActionRowComponent(new[] { button }) }, ct: ct);
+    }
+}

Extensions.cs

@@ -4,7 +4,10 @@ using DiffPlex.DiffBuilder.Model;
 using Microsoft.Extensions.Configuration;
 using Remora.Discord.API;
 using Remora.Discord.API.Abstractions.Objects;
+using Remora.Discord.API.Abstractions.Rest;
 using Remora.Discord.API.Objects;
+using Remora.Discord.Caching;
+using Remora.Discord.Caching.Services;
 using Remora.Discord.Extensions.Embeds;
 using Remora.Discord.Extensions.Formatting;
 using Remora.Rest.Core;
@@ -41,6 +44,16 @@ public static class Extensions {
         return value is not null ? CultureInfoCache[value] : CultureInfoCache["en"];
     }
 
+    public static async Task<Result<IUser>> TryGetUserAsync(
+        this Snowflake userId, CacheService cacheService, IDiscordRestUserAPI userApi, CancellationToken ct) {
+        var cachedUserResult = await cacheService.TryGetValueAsync<IUser>(
+            new KeyHelpers.UserCacheKey(userId), ct);
+
+        if (cachedUserResult.IsDefined(out var cachedUser)) return Result<IUser>.FromSuccess(cachedUser);
+
+        return await userApi.GetUserAsync(userId, ct);
+    }
+
     public static EmbedBuilder WithUserFooter(this EmbedBuilder builder, IUser user) {
         var avatarUrlResult = CDN.GetUserAvatarUrl(user, imageSize: 256);
         var avatarUrl = avatarUrlResult.IsSuccess
@@ -81,6 +94,14 @@ public static class Extensions {
         return builder.WithFooter(new EmbedFooter(guild.Name, iconUrl));
     }
 
+    public static EmbedBuilder WithEventCover(
+        this EmbedBuilder builder, Snowflake eventId, Optional<IImageHash?> imageHashOptional) {
+        if (!imageHashOptional.IsDefined(out var imageHash)) return builder;
+
+        var iconUrlResult = CDN.GetGuildScheduledEventCoverUrl(eventId, imageHash, imageSize: 1024);
+        return iconUrlResult.IsDefined(out var iconUrl) ? builder.WithImageUrl(iconUrl.AbsoluteUri) : builder;
+    }
+
     public static string SanitizeForBlockCode(this string s) {
         return s.Replace("```", "​`​`​`​");
     }

InteractionResponders.cs

@@ -0,0 +1,28 @@
+using Remora.Discord.API.Abstractions.Objects;
+using Remora.Discord.Commands.Feedback.Messages;
+using Remora.Discord.Commands.Feedback.Services;
+using Remora.Discord.Interactivity;
+using Remora.Results;
+
+// ReSharper disable ClassNeverInstantiated.Global
+// ReSharper disable UnusedMember.Global
+
+namespace Boyfriend;
+
+public class InteractionResponders : InteractionGroup {
+    private readonly FeedbackService _feedbackService;
+
+    public InteractionResponders(FeedbackService feedbackService) {
+        _feedbackService = feedbackService;
+    }
+
+    [Button("scheduled-event-details")]
+    public async Task<Result> OnStatefulButtonClicked(string? state = null) {
+        if (state is null) return Result.FromError(new ArgumentNullError(nameof(state)));
+
+        var idArray = state.Split(':');
+        return (Result)await _feedbackService.SendContextualAsync(
+            $"https://discord.com/events/{idArray[0]}/{idArray[1]}",
+            options: new FeedbackMessageOptions(MessageFlags: MessageFlags.Ephemeral));
+    }
+}

Messages.Designer.cs

@@ -764,5 +764,29 @@ namespace Boyfriend {
                 return ResourceManager.GetString("IssuedBy", resourceCulture);
             }
         }
+        
+        internal static string EventCreatedTitle {
+            get {
+                return ResourceManager.GetString("EventCreatedTitle", resourceCulture);
+            }
+        }
+        
+        internal static string LocalEventCreatedDescription {
+            get {
+                return ResourceManager.GetString("LocalEventCreatedDescription", resourceCulture);
+            }
+        }
+        
+        internal static string ExternalEventCreatedDescription {
+            get {
+                return ResourceManager.GetString("ExternalEventCreatedDescription", resourceCulture);
+            }
+        }
+        
+        internal static string EventDetailsButton {
+            get {
+                return ResourceManager.GetString("EventDetailsButton", resourceCulture);
+            }
+        }
     }
 }

Messages.resx

@@ -481,4 +481,16 @@
     <data name="IssuedBy" xml:space="preserve">
         <value>Issued by</value>
     </data>
+    <data name="EventCreatedTitle" xml:space="preserve">
+        <value>{0} has created a new event:</value>
+    </data>
+    <data name="LocalEventCreatedDescription" xml:space="preserve">
+        <value>The event will start at {0} in {1}</value>
+    </data>
+    <data name="ExternalEventCreatedDescription" xml:space="preserve">
+        <value>The event will start at {0} until {1} in {2}</value>
+    </data>
+    <data name="EventDetailsButton" xml:space="preserve">
+        <value>Event details</value>
+    </data>
 </root>

Messages.ru.resx

@@ -481,4 +481,16 @@
     <data name="IssuedBy" xml:space="preserve">
         <value>Ответственный</value>
     </data>
+    <data name="EventCreatedTitle" xml:space="preserve">
+        <value>{0} создаёт новое событие:</value>
+    </data>
+    <data name="LocalEventCreatedDescription" xml:space="preserve">
+        <value>Событие пройдёт в {0} на {1}</value>
+    </data>
+    <data name="ExternalEventCreatedDescription" xml:space="preserve">
+        <value>Событие пройдёт с {0} до {1} на {2}</value>
+    </data>
+    <data name="EventDetailsButton" xml:space="preserve">
+        <value>Подробнее о событии</value>
+    </data>
 </root>

Messages.tt-ru.resx

@@ -481,4 +481,16 @@
     <data name="IssuedBy" xml:space="preserve">
         <value>ответственный</value>
     </data>
+    <data name="EventCreatedTitle" xml:space="preserve">
+        <value>{0} создает новое событие:</value>
+    </data>
+    <data name="LocalEventCreatedDescription" xml:space="preserve">
+        <value>движуха произойдет в {0} на {1}</value>
+    </data>
+    <data name="ExternalEventCreatedDescription" xml:space="preserve">
+        <value>движуха будет происходить с {0} до {1} на {2}</value>
+    </data>
+    <data name="EventDetailsButton" xml:space="preserve">
+        <value>побольше о движухе</value>
+    </data>
 </root>