Fixed some crashes in response strings source generator, reorganized more submodules into their folders

src/NadekoBot/Modules/Utility/CommandMap/CommandMapCommands.cs

@@ -0,0 +1,133 @@
+#nullable disable
+using Microsoft.EntityFrameworkCore;
+using NadekoBot.Db;
+using NadekoBot.Modules.Utility.Services;
+using NadekoBot.Services.Database.Models;
+
+namespace NadekoBot.Modules.Utility;
+
+public partial class Utility
+{
+    [Group]
+    public partial class CommandMapCommands : NadekoSubmodule<CommandMapService>
+    {
+        private readonly DbService _db;
+        private readonly DiscordSocketClient _client;
+
+        public CommandMapCommands(DbService db, DiscordSocketClient client)
+        {
+            _db = db;
+            _client = client;
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [UserPerm(GuildPerm.Administrator)]
+        public async partial Task AliasesClear()
+        {
+            var count = _service.ClearAliases(ctx.Guild.Id);
+            await ReplyConfirmLocalizedAsync(strs.aliases_cleared(count));
+        }
+
+        [Cmd]
+        [UserPerm(GuildPerm.Administrator)]
+        [RequireContext(ContextType.Guild)]
+        public async partial Task Alias(string trigger, [Leftover] string mapping = null)
+        {
+            var channel = (ITextChannel)ctx.Channel;
+
+            if (string.IsNullOrWhiteSpace(trigger))
+                return;
+
+            trigger = trigger.Trim().ToLowerInvariant();
+
+            if (string.IsNullOrWhiteSpace(mapping))
+            {
+                if (!_service.AliasMaps.TryGetValue(ctx.Guild.Id, out var maps) || !maps.TryRemove(trigger, out _))
+                {
+                    await ReplyErrorLocalizedAsync(strs.alias_remove_fail(Format.Code(trigger)));
+                    return;
+                }
+
+                await using (var uow = _db.GetDbContext())
+                {
+                    var config = uow.GuildConfigsForId(ctx.Guild.Id, set => set.Include(x => x.CommandAliases));
+                    var toAdd = new CommandAlias { Mapping = mapping, Trigger = trigger };
+                    var tr = config.CommandAliases.FirstOrDefault(x => x.Trigger == trigger);
+                    if (tr is not null)
+                        uow.Set<CommandAlias>().Remove(tr);
+                    uow.SaveChanges();
+                }
+
+                await ReplyConfirmLocalizedAsync(strs.alias_removed(Format.Code(trigger)));
+                return;
+            }
+
+            _service.AliasMaps.AddOrUpdate(ctx.Guild.Id,
+                _ =>
+                {
+                    using (var uow = _db.GetDbContext())
+                    {
+                        var config = uow.GuildConfigsForId(ctx.Guild.Id, set => set.Include(x => x.CommandAliases));
+                        config.CommandAliases.Add(new() { Mapping = mapping, Trigger = trigger });
+                        uow.SaveChanges();
+                    }
+
+                    return new(new Dictionary<string, string>
+                    {
+                        { trigger.Trim().ToLowerInvariant(), mapping.ToLowerInvariant() }
+                    });
+                },
+                (_, map) =>
+                {
+                    using (var uow = _db.GetDbContext())
+                    {
+                        var config = uow.GuildConfigsForId(ctx.Guild.Id, set => set.Include(x => x.CommandAliases));
+                        var toAdd = new CommandAlias { Mapping = mapping, Trigger = trigger };
+                        var toRemove = config.CommandAliases.Where(x => x.Trigger == trigger);
+                        if (toRemove.Any())
+                            uow.RemoveRange(toRemove.ToArray());
+                        config.CommandAliases.Add(toAdd);
+                        uow.SaveChanges();
+                    }
+
+                    map.AddOrUpdate(trigger, mapping, (_, _) => mapping);
+                    return map;
+                });
+
+            await ReplyConfirmLocalizedAsync(strs.alias_added(Format.Code(trigger), Format.Code(mapping)));
+        }
+
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        public async partial Task AliasList(int page = 1)
+        {
+            var channel = (ITextChannel)ctx.Channel;
+            page -= 1;
+
+            if (page < 0)
+                return;
+
+            if (!_service.AliasMaps.TryGetValue(ctx.Guild.Id, out var maps) || !maps.Any())
+            {
+                await ReplyErrorLocalizedAsync(strs.aliases_none);
+                return;
+            }
+
+            var arr = maps.ToArray();
+
+            await ctx.SendPaginatedConfirmAsync(page,
+                curPage =>
+                {
+                    return _eb.Create()
+                              .WithOkColor()
+                              .WithTitle(GetText(strs.alias_list))
+                              .WithDescription(string.Join("\n",
+                                  arr.Skip(curPage * 10).Take(10).Select(x => $"`{x.Key}` => `{x.Value}`")));
+                },
+                arr.Length,
+                10);
+        }
+    }
+}

src/NadekoBot/Modules/Utility/CommandMap/CommandMapService.cs

@@ -0,0 +1,91 @@
+#nullable disable
+using Microsoft.EntityFrameworkCore;
+using NadekoBot.Common.ModuleBehaviors;
+using NadekoBot.Db;
+using NadekoBot.Services.Database.Models;
+
+namespace NadekoBot.Modules.Utility.Services;
+
+public class CommandMapService : IInputTransformer, INService
+{
+    public ConcurrentDictionary<ulong, ConcurrentDictionary<string, string>> AliasMaps { get; } = new();
+    private readonly IEmbedBuilderService _eb;
+
+    private readonly DbService _db;
+
+    //commandmap
+    public CommandMapService(DiscordSocketClient client, DbService db, IEmbedBuilderService eb)
+    {
+        _eb = eb;
+
+        using var uow = db.GetDbContext();
+        var guildIds = client.Guilds.Select(x => x.Id).ToList();
+        var configs = uow.Set<GuildConfig>()
+                         .Include(gc => gc.CommandAliases)
+                         .Where(x => guildIds.Contains(x.GuildId))
+                         .ToList();
+
+        AliasMaps = new(configs.ToDictionary(x => x.GuildId,
+            x => new ConcurrentDictionary<string, string>(x.CommandAliases.DistinctBy(ca => ca.Trigger)
+                                                           .ToDictionary(ca => ca.Trigger, ca => ca.Mapping))));
+
+        _db = db;
+    }
+
+    public int ClearAliases(ulong guildId)
+    {
+        AliasMaps.TryRemove(guildId, out _);
+
+        int count;
+        using var uow = _db.GetDbContext();
+        var gc = uow.GuildConfigsForId(guildId, set => set.Include(x => x.CommandAliases));
+        count = gc.CommandAliases.Count;
+        gc.CommandAliases.Clear();
+        uow.SaveChanges();
+        return count;
+    }
+
+    public async Task<string> TransformInput(
+        IGuild guild,
+        IMessageChannel channel,
+        IUser user,
+        string input)
+    {
+        await Task.Yield();
+
+        if (guild is null || string.IsNullOrWhiteSpace(input))
+            return input;
+
+        if (guild is not null)
+            if (AliasMaps.TryGetValue(guild.Id, out var maps))
+            {
+                var keys = maps.Keys.OrderByDescending(x => x.Length);
+
+                foreach (var k in keys)
+                {
+                    string newInput;
+                    if (input.StartsWith(k + " ", StringComparison.InvariantCultureIgnoreCase))
+                        newInput = maps[k] + input.Substring(k.Length, input.Length - k.Length);
+                    else if (input.Equals(k, StringComparison.InvariantCultureIgnoreCase))
+                        newInput = maps[k];
+                    else
+                        continue;
+
+                    try
+                    {
+                        var toDelete = await channel.SendConfirmAsync(_eb, $"{input} => {newInput}");
+                        var _ = Task.Run(async () =>
+                        {
+                            await Task.Delay(1500);
+                            await toDelete.DeleteAsync(new() { RetryMode = RetryMode.AlwaysRetry });
+                        });
+                    }
+                    catch { }
+
+                    return newInput;
+                }
+            }
+
+        return input;
+    }
+}