Refactors. Cleanup. Refactored responses source gen a little. Parametrized localized strings are now generic. Refactored .cash bank interaction. Updated changelog. Reverted clubapps/ban/unban to use .ToString method and configured it to not have right to left unicode. Added extension methods to SocketMessageComponent akin to ones on the IMessageChannel (RespondConfirm, etc...)

src/NadekoBot/_Extensions/Extensions.cs

@@ -214,10 +214,4 @@ public static class Extensions
         => msg.Content.Headers.ContentLength is long length
             ? length
             : long.MaxValue;
-
-    public static string GetText(this IBotStrings strings, in LocStr str, ulong? guildId = null)
-        => strings.GetText(str.Key, guildId, str.Params);
-
-    public static string GetText(this IBotStrings strings, in LocStr str, CultureInfo culture)
-        => strings.GetText(str.Key, culture, str.Params);
 }

src/NadekoBot/_Extensions/PipeExtensions.cs

@@ -0,0 +1,23 @@
+namespace NadekoBot.Extensions;
+
+
+public delegate TOut PipeFunc<TIn, out TOut>(in TIn a);
+public delegate TOut PipeFunc<TIn1, TIn2, out TOut>(in TIn1 a, in TIn2 b);
+
+public static class PipeExtensions
+{
+    public static TOut Pipe<TIn, TOut>(this TIn a, Func<TIn, TOut> fn)
+        => fn(a);
+    
+    public static TOut Pipe<TIn, TOut>(this TIn a, PipeFunc<TIn, TOut> fn)
+        => fn(a);
+    
+    public static TOut Pipe<TIn1, TIn2, TOut>(this (TIn1, TIn2) a, PipeFunc<TIn1, TIn2, TOut> fn)
+        => fn(a.Item1, a.Item2);
+
+    public static (TIn, TExtra) With<TIn, TExtra>(this TIn a, TExtra b)
+        => (a, b);
+    
+    public static async Task<TOut> Pipe<TIn, TOut>(this Task<TIn> a, Func<TIn, TOut> fn)
+        => fn(await a);
+}

src/NadekoBot/_Extensions/SocketMessageComponentExtensions.cs

@@ -0,0 +1,99 @@
+namespace NadekoBot.Extensions;
+
+public static class SocketMessageComponentExtensions
+{
+    public static Task RespondAsync(
+        this SocketMessageComponent smc,
+        string? plainText,
+        Embed? embed = null,
+        IReadOnlyCollection<Embed>? embeds = null,
+        bool sanitizeAll = false,
+        MessageComponent? components = null,
+        bool ephemeral = true)
+    {
+        plainText = sanitizeAll
+            ? plainText?.SanitizeAllMentions() ?? ""
+            : plainText?.SanitizeMentions() ?? "";
+
+        return smc.RespondAsync(plainText,
+            embed: embed,
+            embeds: embeds is null
+                ? null
+                : embeds as Embed[] ?? embeds.ToArray(),
+            components: components,
+            ephemeral: ephemeral,
+            options: new()
+            {
+                RetryMode = RetryMode.AlwaysRetry
+            });
+    }
+
+    public static Task RespondAsync(
+        this SocketMessageComponent smc,
+        SmartText text,
+        bool sanitizeAll = false,
+        bool ephemeral = true)
+        => text switch
+        {
+            SmartEmbedText set => smc.RespondAsync(set.PlainText,
+                set.GetEmbed().Build(),
+                sanitizeAll: sanitizeAll,
+                ephemeral: ephemeral),
+            SmartPlainText st => smc.RespondAsync(st.Text,
+                default(Embed),
+                sanitizeAll: sanitizeAll,
+                ephemeral: ephemeral),
+            SmartEmbedTextArray arr => smc.RespondAsync(arr.Content,
+                embeds: arr.GetEmbedBuilders().Map(e => e.Build()),
+                ephemeral: ephemeral),
+            _ => throw new ArgumentOutOfRangeException(nameof(text))
+        };
+
+    public static Task EmbedAsync(
+        this SocketMessageComponent smc,
+        IEmbedBuilder? embed,
+        string plainText = "",
+        IReadOnlyCollection<IEmbedBuilder>? embeds = null,
+        NadekoInteraction? inter = null,
+        bool ephemeral = false)
+        => smc.RespondAsync(plainText,
+            embed: embed?.Build(),
+            embeds: embeds?.Map(x => x.Build()));
+    
+    public static Task RespondAsync(
+        this SocketMessageComponent ch,
+        IEmbedBuilderService eb,
+        string text,
+        MessageType type,
+        bool ephemeral = false,
+        NadekoInteraction? inter = null)
+    {
+        var builder = eb.Create().WithDescription(text);
+
+        builder = (type switch
+        {
+            MessageType.Error => builder.WithErrorColor(),
+            MessageType.Ok => builder.WithOkColor(),
+            MessageType.Pending => builder.WithPendingColor(),
+            _ => throw new ArgumentOutOfRangeException(nameof(type))
+        });
+
+        return ch.EmbedAsync(builder, inter: inter, ephemeral: ephemeral);
+    }
+    
+    // embed title and optional footer overloads
+
+    public static Task RespondErrorAsync(
+        this SocketMessageComponent smc,
+        IEmbedBuilderService eb,
+        string text,
+        bool ephemeral = false)
+        => smc.RespondAsync(eb, text, MessageType.Error, ephemeral);
+
+    public static Task RespondConfirmAsync(
+        this SocketMessageComponent smc,
+        IEmbedBuilderService eb,
+        string text,
+        bool ephemeral = false)
+        => smc.RespondAsync(eb, text, MessageType.Ok, ephemeral);
+}