- Removed NadekoCommand and Aliases attribute from all commands

- All commands must be marked as partial
- Added [Cmd] Attribute to all commands
- Cmd Attribute comes from the source generator which adds [NadekoCommand] and [Aliases] Attribute to each command
- Should be updated in the future probably to be more performant and maybe add extra data to the commands
- Started reorganizing modules and submodules

src/NadekoBot/Modules/Administration/PermOverrides/DiscordPermOverrideCommands.cs

@@ -0,0 +1,78 @@
+#nullable disable
+using NadekoBot.Common.TypeReaders;
+using NadekoBot.Modules.Administration.Services;
+
+namespace NadekoBot.Modules.Administration;
+
+public partial class Administration
+{
+    [Group]
+    public partial class DiscordPermOverrideCommands : NadekoSubmodule<DiscordPermOverrideService>
+    {
+        // override stats, it should require that the user has managessages guild permission
+        // .po 'stats' add user guild managemessages
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [UserPerm(GuildPerm.Administrator)]
+        public async partial Task DiscordPermOverride(CommandOrCrInfo cmd, params GuildPerm[] perms)
+        {
+            if (perms is null || perms.Length == 0)
+            {
+                await _service.RemoveOverride(ctx.Guild.Id, cmd.Name);
+                await ReplyConfirmLocalizedAsync(strs.perm_override_reset);
+                return;
+            }
+
+            var aggregatePerms = perms.Aggregate((acc, seed) => seed | acc);
+            await _service.AddOverride(ctx.Guild.Id, cmd.Name, aggregatePerms);
+
+            await ReplyConfirmLocalizedAsync(strs.perm_override(Format.Bold(aggregatePerms.ToString()),
+                Format.Code(cmd.Name)));
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [UserPerm(GuildPerm.Administrator)]
+        public async partial Task DiscordPermOverrideReset()
+        {
+            var result = await PromptUserConfirmAsync(_eb.Create()
+                                                         .WithOkColor()
+                                                         .WithDescription(GetText(strs.perm_override_all_confirm)));
+
+            if (!result)
+                return;
+            await _service.ClearAllOverrides(ctx.Guild.Id);
+
+            await ReplyConfirmLocalizedAsync(strs.perm_override_all);
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [UserPerm(GuildPerm.Administrator)]
+        public async partial Task DiscordPermOverrideList(int page = 1)
+        {
+            if (--page < 0)
+                return;
+
+            var overrides = await _service.GetAllOverrides(ctx.Guild.Id);
+
+            await ctx.SendPaginatedConfirmAsync(page,
+                curPage =>
+                {
+                    var eb = _eb.Create().WithTitle(GetText(strs.perm_overrides)).WithOkColor();
+
+                    var thisPageOverrides = overrides.Skip(9 * curPage).Take(9).ToList();
+
+                    if (thisPageOverrides.Count == 0)
+                        eb.WithDescription(GetText(strs.perm_override_page_none));
+                    else
+                        eb.WithDescription(string.Join("\n",
+                            thisPageOverrides.Select(ov => $"{ov.Command} => {ov.Perm.ToString()}")));
+
+                    return eb;
+                },
+                overrides.Count,
+                9);
+        }
+    }
+}

src/NadekoBot/Modules/Administration/PermOverrides/DiscordPermOverrideService.cs

@@ -0,0 +1,126 @@
+#nullable disable
+using Microsoft.EntityFrameworkCore;
+using NadekoBot.Common.ModuleBehaviors;
+using NadekoBot.Services.Database.Models;
+
+namespace NadekoBot.Modules.Administration.Services;
+
+public class DiscordPermOverrideService : INService, ILateBlocker
+{
+    public int Priority { get; } = int.MaxValue;
+    private readonly DbService _db;
+    private readonly IServiceProvider _services;
+
+    private readonly ConcurrentDictionary<(ulong, string), DiscordPermOverride> _overrides;
+
+    public DiscordPermOverrideService(DbService db, IServiceProvider services)
+    {
+        _db = db;
+        _services = services;
+        using var uow = _db.GetDbContext();
+        _overrides = uow.DiscordPermOverrides.AsNoTracking()
+                        .AsEnumerable()
+                        .ToDictionary(o => (o.GuildId ?? 0, o.Command), o => o)
+                        .ToConcurrent();
+    }
+
+    public bool TryGetOverrides(ulong guildId, string commandName, out GuildPerm? perm)
+    {
+        commandName = commandName.ToLowerInvariant();
+        if (_overrides.TryGetValue((guildId, commandName), out var dpo))
+        {
+            perm = dpo.Perm;
+            return true;
+        }
+
+        perm = null;
+        return false;
+    }
+
+    public Task<PreconditionResult> ExecuteOverrides(
+        ICommandContext ctx,
+        CommandInfo command,
+        GuildPerm perms,
+        IServiceProvider services)
+    {
+        var rupa = new RequireUserPermissionAttribute(perms);
+        return rupa.CheckPermissionsAsync(ctx, command, services);
+    }
+
+    public async Task AddOverride(ulong guildId, string commandName, GuildPerm perm)
+    {
+        commandName = commandName.ToLowerInvariant();
+        await using var uow = _db.GetDbContext();
+        var over = await uow.Set<DiscordPermOverride>()
+                            .AsQueryable()
+                            .FirstOrDefaultAsync(x => x.GuildId == guildId && commandName == x.Command);
+
+        if (over is null)
+            uow.Set<DiscordPermOverride>().Add(over = new() { Command = commandName, Perm = perm, GuildId = guildId });
+        else
+            over.Perm = perm;
+
+        _overrides[(guildId, commandName)] = over;
+
+        await uow.SaveChangesAsync();
+    }
+
+    public async Task ClearAllOverrides(ulong guildId)
+    {
+        await using var uow = _db.GetDbContext();
+        var overrides = await uow.Set<DiscordPermOverride>()
+                                 .AsQueryable()
+                                 .AsNoTracking()
+                                 .Where(x => x.GuildId == guildId)
+                                 .ToListAsync();
+
+        uow.RemoveRange(overrides);
+        await uow.SaveChangesAsync();
+
+        foreach (var over in overrides) _overrides.TryRemove((guildId, over.Command), out _);
+    }
+
+    public async Task RemoveOverride(ulong guildId, string commandName)
+    {
+        commandName = commandName.ToLowerInvariant();
+
+        await using var uow = _db.GetDbContext();
+        var over = await uow.Set<DiscordPermOverride>()
+                            .AsQueryable()
+                            .AsNoTracking()
+                            .FirstOrDefaultAsync(x => x.GuildId == guildId && x.Command == commandName);
+
+        if (over is null)
+            return;
+
+        uow.Remove(over);
+        await uow.SaveChangesAsync();
+
+        _overrides.TryRemove((guildId, commandName), out _);
+    }
+
+    public async Task<List<DiscordPermOverride>> GetAllOverrides(ulong guildId)
+    {
+        await using var uow = _db.GetDbContext();
+        return await uow.Set<DiscordPermOverride>()
+                        .AsQueryable()
+                        .AsNoTracking()
+                        .Where(x => x.GuildId == guildId)
+                        .ToListAsync();
+    }
+
+    public async Task<bool> TryBlockLate(ICommandContext context, string moduleName, CommandInfo command)
+    {
+        if (TryGetOverrides(context.Guild?.Id ?? 0, command.Name, out var perm) && perm is not null)
+        {
+            var result =
+                await new RequireUserPermissionAttribute((GuildPermission)perm).CheckPermissionsAsync(context,
+                    command,
+                    _services);
+
+            return !result.IsSuccess;
+        }
+
+        return false;
+    }
+}