Restructured the project structure back to the way it was, there's no reasonable way to split the modules

2025-09-12 02:08:27 -04:00 · 2024-04-26 22:26:24 +00:00
parent 6c9c8bf63e
commit e0819f760c
768 changed files with 192 additions and 1047 deletions
--- a/src/NadekoBot/Modules/Administration/SelfAssignableRoles/SelfAssignedRolesCommands.cs
+++ b/src/NadekoBot/Modules/Administration/SelfAssignableRoles/SelfAssignedRolesCommands.cs
@@ -0,0 +1,234 @@
+#nullable disable
+using NadekoBot.Modules.Administration.Services;
+using System.Text;
+
+namespace NadekoBot.Modules.Administration;
+
+public partial class Administration
+{
+    [Group]
+    public partial class SelfAssignedRolesCommands : NadekoModule<SelfAssignedRolesService>
+    {
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [UserPerm(GuildPerm.ManageMessages)]
+        [BotPerm(GuildPerm.ManageMessages)]
+        public async Task AdSarm()
+        {
+            var newVal = _service.ToggleAdSarm(ctx.Guild.Id);
+
+            if (newVal)
+                await ReplyConfirmLocalizedAsync(strs.adsarm_enable(prefix));
+            else
+                await ReplyConfirmLocalizedAsync(strs.adsarm_disable(prefix));
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [UserPerm(GuildPerm.ManageRoles)]
+        [BotPerm(GuildPerm.ManageRoles)]
+        [Priority(1)]
+        public Task Asar([Leftover] IRole role)
+            => Asar(0, role);
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [UserPerm(GuildPerm.ManageRoles)]
+        [BotPerm(GuildPerm.ManageRoles)]
+        [Priority(0)]
+        public async Task Asar(int group, [Leftover] IRole role)
+        {
+            var guser = (IGuildUser)ctx.User;
+            if (ctx.User.Id != guser.Guild.OwnerId && guser.GetRoles().Max(x => x.Position) <= role.Position)
+                return;
+
+            var succ = _service.AddNew(ctx.Guild.Id, role, group);
+
+            if (succ)
+            {
+                await ReplyConfirmLocalizedAsync(strs.role_added(Format.Bold(role.Name),
+                    Format.Bold(@group.ToString())));
+            }
+            else
+                await ReplyErrorLocalizedAsync(strs.role_in_list(Format.Bold(role.Name)));
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [UserPerm(GuildPerm.ManageRoles)]
+        [BotPerm(GuildPerm.ManageRoles)]
+        [Priority(0)]
+        public async Task Sargn(int group, [Leftover] string name = null)
+        {
+            var set = await _service.SetNameAsync(ctx.Guild.Id, group, name);
+
+            if (set)
+            {
+                await ReplyConfirmLocalizedAsync(
+                    strs.group_name_added(Format.Bold(@group.ToString()), Format.Bold(name)));
+            }
+            else
+                await ReplyConfirmLocalizedAsync(strs.group_name_removed(Format.Bold(group.ToString())));
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [UserPerm(GuildPerm.ManageRoles)]
+        public async Task Rsar([Leftover] IRole role)
+        {
+            var guser = (IGuildUser)ctx.User;
+            if (ctx.User.Id != guser.Guild.OwnerId && guser.GetRoles().Max(x => x.Position) <= role.Position)
+                return;
+
+            var success = _service.RemoveSar(role.Guild.Id, role.Id);
+            if (!success)
+                await ReplyErrorLocalizedAsync(strs.self_assign_not);
+            else
+                await ReplyConfirmLocalizedAsync(strs.self_assign_rem(Format.Bold(role.Name)));
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        public async Task Lsar(int page = 1)
+        {
+            if (--page < 0)
+                return;
+
+            var (exclusive, roles, groups) = _service.GetRoles(ctx.Guild);
+
+            await ctx.SendPaginatedConfirmAsync(page,
+                cur =>
+                {
+                    var rolesStr = new StringBuilder();
+                    var roleGroups = roles.OrderBy(x => x.Model.Group)
+                                          .Skip(cur * 20)
+                                          .Take(20)
+                                          .GroupBy(x => x.Model.Group)
+                                          .OrderBy(x => x.Key);
+
+                    foreach (var kvp in roleGroups)
+                    {
+                        string groupNameText;
+                        if (!groups.TryGetValue(kvp.Key, out var name))
+                            groupNameText = Format.Bold(GetText(strs.self_assign_group(kvp.Key)));
+                        else
+                            groupNameText = Format.Bold($"{kvp.Key} - {name.TrimTo(25, true)}");
+
+                        rolesStr.AppendLine("\t\t\t\t ⟪" + groupNameText + "⟫");
+                        foreach (var (model, role) in kvp.AsEnumerable())
+                        {
+                            if (role is null)
+                            {
+                            }
+                            else
+                            {
+                                // first character is invisible space
+                                if (model.LevelRequirement == 0)
+                                    rolesStr.AppendLine("‌‌   " + role.Name);
+                                else
+                                    rolesStr.AppendLine("‌‌   " + role.Name + $" (lvl {model.LevelRequirement}+)");
+                            }
+                        }
+
+                        rolesStr.AppendLine();
+                    }
+
+                    return _eb.Create()
+                              .WithOkColor()
+                              .WithTitle(Format.Bold(GetText(strs.self_assign_list(roles.Count()))))
+                              .WithDescription(rolesStr.ToString())
+                              .WithFooter(exclusive
+                                  ? GetText(strs.self_assign_are_exclusive)
+                                  : GetText(strs.self_assign_are_not_exclusive));
+                },
+                roles.Count(),
+                20);
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [UserPerm(GuildPerm.ManageRoles)]
+        [BotPerm(GuildPerm.ManageRoles)]
+        public async Task Togglexclsar()
+        {
+            var areExclusive = _service.ToggleEsar(ctx.Guild.Id);
+            if (areExclusive)
+                await ReplyConfirmLocalizedAsync(strs.self_assign_excl);
+            else
+                await ReplyConfirmLocalizedAsync(strs.self_assign_no_excl);
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [UserPerm(GuildPerm.ManageRoles)]
+        [BotPerm(GuildPerm.ManageRoles)]
+        public async Task RoleLevelReq(int level, [Leftover] IRole role)
+        {
+            if (level < 0)
+                return;
+
+            var succ = _service.SetLevelReq(ctx.Guild.Id, role, level);
+
+            if (!succ)
+            {
+                await ReplyErrorLocalizedAsync(strs.self_assign_not);
+                return;
+            }
+
+            await ReplyConfirmLocalizedAsync(strs.self_assign_level_req(Format.Bold(role.Name),
+                Format.Bold(level.ToString())));
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        public async Task Iam([Leftover] IRole role)
+        {
+            var guildUser = (IGuildUser)ctx.User;
+
+            var (result, autoDelete, extra) = await _service.Assign(guildUser, role);
+
+            IUserMessage msg;
+            if (result == SelfAssignedRolesService.AssignResult.ErrNotAssignable)
+                msg = await ReplyErrorLocalizedAsync(strs.self_assign_not);
+            else if (result == SelfAssignedRolesService.AssignResult.ErrLvlReq)
+                msg = await ReplyErrorLocalizedAsync(strs.self_assign_not_level(Format.Bold(extra.ToString())));
+            else if (result == SelfAssignedRolesService.AssignResult.ErrAlreadyHave)
+                msg = await ReplyErrorLocalizedAsync(strs.self_assign_already(Format.Bold(role.Name)));
+            else if (result == SelfAssignedRolesService.AssignResult.ErrNotPerms)
+                msg = await ReplyErrorLocalizedAsync(strs.self_assign_perms);
+            else
+                msg = await ReplyConfirmLocalizedAsync(strs.self_assign_success(Format.Bold(role.Name)));
+
+            if (autoDelete)
+            {
+                msg.DeleteAfter(3);
+                ctx.Message.DeleteAfter(3);
+            }
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        public async Task Iamnot([Leftover] IRole role)
+        {
+            var guildUser = (IGuildUser)ctx.User;
+
+            var (result, autoDelete) = await _service.Remove(guildUser, role);
+
+            IUserMessage msg;
+            if (result == SelfAssignedRolesService.RemoveResult.ErrNotAssignable)
+                msg = await ReplyErrorLocalizedAsync(strs.self_assign_not);
+            else if (result == SelfAssignedRolesService.RemoveResult.ErrNotHave)
+                msg = await ReplyErrorLocalizedAsync(strs.self_assign_not_have(Format.Bold(role.Name)));
+            else if (result == SelfAssignedRolesService.RemoveResult.ErrNotPerms)
+                msg = await ReplyErrorLocalizedAsync(strs.self_assign_perms);
+            else
+                msg = await ReplyConfirmLocalizedAsync(strs.self_assign_remove(Format.Bold(role.Name)));
+
+            if (autoDelete)
+            {
+                msg.DeleteAfter(3);
+                ctx.Message.DeleteAfter(3);
+            }
+        }
+    }
+}
--- a/src/NadekoBot/Modules/Administration/SelfAssignableRoles/SelfAssignedRolesService.cs
+++ b/src/NadekoBot/Modules/Administration/SelfAssignableRoles/SelfAssignedRolesService.cs
@@ -0,0 +1,234 @@
+#nullable disable
+using Microsoft.EntityFrameworkCore;
+using NadekoBot.Db;
+using Nadeko.Bot.Db.Models;
+
+namespace NadekoBot.Modules.Administration.Services;
+
+public class SelfAssignedRolesService : INService
+{
+    public enum AssignResult
+    {
+        Assigned, // successfully removed
+        ErrNotAssignable, // not assignable (error)
+        ErrAlreadyHave, // you already have that role (error)
+        ErrNotPerms, // bot doesn't have perms (error)
+        ErrLvlReq // you are not required level (error)
+    }
+
+    public enum RemoveResult
+    {
+        Removed, // successfully removed
+        ErrNotAssignable, // not assignable (error)
+        ErrNotHave, // you don't have a role you want to remove (error)
+        ErrNotPerms // bot doesn't have perms (error)
+    }
+
+    private readonly DbService _db;
+
+    public SelfAssignedRolesService(DbService db)
+        => _db = db;
+
+    public bool AddNew(ulong guildId, IRole role, int group)
+    {
+        using var uow = _db.GetDbContext();
+        var roles = uow.Set<SelfAssignedRole>().GetFromGuild(guildId);
+        if (roles.Any(s => s.RoleId == role.Id && s.GuildId == role.Guild.Id))
+            return false;
+
+        uow.Set<SelfAssignedRole>().Add(new()
+        {
+            Group = group,
+            RoleId = role.Id,
+            GuildId = role.Guild.Id
+        });
+        uow.SaveChanges();
+        return true;
+    }
+
+    public bool ToggleAdSarm(ulong guildId)
+    {
+        bool newval;
+        using var uow = _db.GetDbContext();
+        var config = uow.GuildConfigsForId(guildId, set => set);
+        newval = config.AutoDeleteSelfAssignedRoleMessages = !config.AutoDeleteSelfAssignedRoleMessages;
+        uow.SaveChanges();
+        return newval;
+    }
+
+    public async Task<(AssignResult Result, bool AutoDelete, object extra)> Assign(IGuildUser guildUser, IRole role)
+    {
+        LevelStats userLevelData;
+        await using (var uow = _db.GetDbContext())
+        {
+            var stats = uow.GetOrCreateUserXpStats(guildUser.Guild.Id, guildUser.Id);
+            userLevelData = new(stats.Xp + stats.AwardedXp);
+        }
+
+        var (autoDelete, exclusive, roles) = GetAdAndRoles(guildUser.Guild.Id);
+
+        var theRoleYouWant = roles.FirstOrDefault(r => r.RoleId == role.Id);
+        if (theRoleYouWant is null)
+            return (AssignResult.ErrNotAssignable, autoDelete, null);
+        if (theRoleYouWant.LevelRequirement > userLevelData.Level)
+            return (AssignResult.ErrLvlReq, autoDelete, theRoleYouWant.LevelRequirement);
+        if (guildUser.RoleIds.Contains(role.Id))
+            return (AssignResult.ErrAlreadyHave, autoDelete, null);
+
+        var roleIds = roles.Where(x => x.Group == theRoleYouWant.Group).Select(x => x.RoleId).ToArray();
+        if (exclusive)
+        {
+            var sameRoles = guildUser.RoleIds.Where(r => roleIds.Contains(r));
+
+            foreach (var roleId in sameRoles)
+            {
+                var sameRole = guildUser.Guild.GetRole(roleId);
+                if (sameRole is not null)
+                {
+                    try
+                    {
+                        await guildUser.RemoveRoleAsync(sameRole);
+                        await Task.Delay(300);
+                    }
+                    catch
+                    {
+                        // ignored
+                    }
+                }
+            }
+        }
+
+        try
+        {
+            await guildUser.AddRoleAsync(role);
+        }
+        catch (Exception ex)
+        {
+            return (AssignResult.ErrNotPerms, autoDelete, ex);
+        }
+
+        return (AssignResult.Assigned, autoDelete, null);
+    }
+
+    public async Task<bool> SetNameAsync(ulong guildId, int group, string name)
+    {
+        var set = false;
+        await using var uow = _db.GetDbContext();
+        var gc = uow.GuildConfigsForId(guildId, y => y.Include(x => x.SelfAssignableRoleGroupNames));
+        var toUpdate = gc.SelfAssignableRoleGroupNames.FirstOrDefault(x => x.Number == group);
+
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            if (toUpdate is not null)
+                gc.SelfAssignableRoleGroupNames.Remove(toUpdate);
+        }
+        else if (toUpdate is null)
+        {
+            gc.SelfAssignableRoleGroupNames.Add(new()
+            {
+                Name = name,
+                Number = group
+            });
+            set = true;
+        }
+        else
+        {
+            toUpdate.Name = name;
+            set = true;
+        }
+
+        await uow.SaveChangesAsync();
+
+        return set;
+    }
+
+    public async Task<(RemoveResult Result, bool AutoDelete)> Remove(IGuildUser guildUser, IRole role)
+    {
+        var (autoDelete, _, roles) = GetAdAndRoles(guildUser.Guild.Id);
+
+        if (roles.FirstOrDefault(r => r.RoleId == role.Id) is null)
+            return (RemoveResult.ErrNotAssignable, autoDelete);
+        if (!guildUser.RoleIds.Contains(role.Id))
+            return (RemoveResult.ErrNotHave, autoDelete);
+        try
+        {
+            await guildUser.RemoveRoleAsync(role);
+        }
+        catch (Exception)
+        {
+            return (RemoveResult.ErrNotPerms, autoDelete);
+        }
+
+        return (RemoveResult.Removed, autoDelete);
+    }
+
+    public bool RemoveSar(ulong guildId, ulong roleId)
+    {
+        bool success;
+        using var uow = _db.GetDbContext();
+        success = uow.Set<SelfAssignedRole>().DeleteByGuildAndRoleId(guildId, roleId);
+        uow.SaveChanges();
+        return success;
+    }
+
+    public (bool AutoDelete, bool Exclusive, IReadOnlyCollection<SelfAssignedRole>) GetAdAndRoles(ulong guildId)
+    {
+        using var uow = _db.GetDbContext();
+        var gc = uow.GuildConfigsForId(guildId, set => set);
+        var autoDelete = gc.AutoDeleteSelfAssignedRoleMessages;
+        var exclusive = gc.ExclusiveSelfAssignedRoles;
+        var roles = uow.Set<SelfAssignedRole>().GetFromGuild(guildId);
+
+        return (autoDelete, exclusive, roles);
+    }
+
+    public bool SetLevelReq(ulong guildId, IRole role, int level)
+    {
+        using var uow = _db.GetDbContext();
+        var roles = uow.Set<SelfAssignedRole>().GetFromGuild(guildId);
+        var sar = roles.FirstOrDefault(x => x.RoleId == role.Id);
+        if (sar is not null)
+        {
+            sar.LevelRequirement = level;
+            uow.SaveChanges();
+        }
+        else
+            return false;
+
+        return true;
+    }
+
+    public bool ToggleEsar(ulong guildId)
+    {
+        bool areExclusive;
+        using var uow = _db.GetDbContext();
+        var config = uow.GuildConfigsForId(guildId, set => set);
+
+        areExclusive = config.ExclusiveSelfAssignedRoles = !config.ExclusiveSelfAssignedRoles;
+        uow.SaveChanges();
+        return areExclusive;
+    }
+
+    public (bool Exclusive, IReadOnlyCollection<(SelfAssignedRole Model, IRole Role)> Roles, IDictionary<int, string>
+        GroupNames
+        ) GetRoles(IGuild guild)
+    {
+        var exclusive = false;
+
+        IReadOnlyCollection<(SelfAssignedRole Model, IRole Role)> roles;
+        IDictionary<int, string> groupNames;
+        using (var uow = _db.GetDbContext())
+        {
+            var gc = uow.GuildConfigsForId(guild.Id, set => set.Include(x => x.SelfAssignableRoleGroupNames));
+            exclusive = gc.ExclusiveSelfAssignedRoles;
+            groupNames = gc.SelfAssignableRoleGroupNames.ToDictionary(x => x.Number, x => x.Name);
+            var roleModels = uow.Set<SelfAssignedRole>().GetFromGuild(guild.Id);
+            roles = roleModels.Select(x => (Model: x, Role: guild.GetRole(x.RoleId)))
+                              .ToList();
+            uow.Set<SelfAssignedRole>().RemoveRange(roles.Where(x => x.Role is null).Select(x => x.Model).ToArray());
+            uow.SaveChanges();
+        }
+
+        return (exclusive, roles.Where(x => x.Role is not null).ToList(), groupNames);
+    }
+}