Applied codestyle to all .cs files

2025-09-11 09:48:26 -04:00 · 2021-12-29 06:07:16 +01:00
parent 723447c7d4
commit 82000c97a4
543 changed files with 13221 additions and 14059 deletions
--- a/src/NadekoBot/Modules/Permissions/Permissions.cs
+++ b/src/NadekoBot/Modules/Permissions/Permissions.cs
@@ -1,21 +1,24 @@
 #nullable disable
-using NadekoBot.Services.Database.Models;
 using NadekoBot.Common.TypeReaders;
 using NadekoBot.Common.TypeReaders.Models;
 using NadekoBot.Db;
 using NadekoBot.Modules.Permissions.Common;
 using NadekoBot.Modules.Permissions.Services;
+using NadekoBot.Services.Database.Models;

 namespace NadekoBot.Modules.Permissions;

 public partial class Permissions : NadekoModule<PermissionService>
 {
+    public enum Reset { Reset }
+
    private readonly DbService _db;

    public Permissions(DbService db)
        => _db = db;

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task Verbose(PermissionAction action = null)
    {
@@ -27,17 +30,15 @@ public partial class Permissions : NadekoModule<PermissionService>
            await uow.SaveChangesAsync();
            _service.UpdateCache(config);
        }
+
        if (action.Value)
-        {
            await ReplyConfirmLocalizedAsync(strs.verbose_true);
-        }
        else
-        {
            await ReplyConfirmLocalizedAsync(strs.verbose_false);
-        }
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    [UserPerm(GuildPerm.Administrator)]
    [Priority(0)]
@@ -45,19 +46,15 @@ public partial class Permissions : NadekoModule<PermissionService>
    {
        if (role != null && role == role.Guild.EveryoneRole)
            return;
-            
+
        if (role is null)
        {
            var cache = _service.GetCacheFor(ctx.Guild.Id);
-            if (!ulong.TryParse(cache.PermRole, out var roleId) ||
-                (role = ((SocketGuild)ctx.Guild).GetRole(roleId)) is null)
-            {
+            if (!ulong.TryParse(cache.PermRole, out var roleId)
+                || (role = ((SocketGuild)ctx.Guild).GetRole(roleId)) is null)
                await ReplyConfirmLocalizedAsync(strs.permrole_not_set);
-            }
            else
-            {
                await ReplyConfirmLocalizedAsync(strs.permrole(Format.Bold(role.ToString())));
-            }
            return;
        }

@@ -72,9 +69,8 @@ public partial class Permissions : NadekoModule<PermissionService>
        await ReplyConfirmLocalizedAsync(strs.permrole_changed(Format.Bold(role.Name)));
    }

-    public enum Reset { Reset };
-
-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    [UserPerm(GuildPerm.Administrator)]
    [Priority(1)]
@@ -91,7 +87,8 @@ public partial class Permissions : NadekoModule<PermissionService>
        await ReplyConfirmLocalizedAsync(strs.permrole_reset);
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task ListPerms(int page = 1)
    {
@@ -101,32 +98,31 @@ public partial class Permissions : NadekoModule<PermissionService>
        IList<Permissionv2> perms;

        if (_service.Cache.TryGetValue(ctx.Guild.Id, out var permCache))
-        {
            perms = permCache.Permissions.Source.ToList();
-        }
        else
-        {
            perms = Permissionv2.GetDefaultPermlist;
-        }

        var startPos = 20 * (page - 1);
-        var toSend = Format.Bold(GetText(strs.page(page))) + "\n\n" + string.Join("\n",
-            perms.Reverse()
-                .Skip(startPos)
-                .Take(20)
-                .Select(p =>
-                {
-                    var str =
-                        $"`{p.Index + 1}.` {Format.Bold(p.GetCommand(Prefix, (SocketGuild)ctx.Guild))}";
-                    if (p.Index == 0)
-                        str += $" [{GetText(strs.uneditable)}]";
-                    return str;
-                }));
+        var toSend = Format.Bold(GetText(strs.page(page)))
+                     + "\n\n"
+                     + string.Join("\n",
+                         perms.Reverse()
+                              .Skip(startPos)
+                              .Take(20)
+                              .Select(p =>
+                              {
+                                  var str =
+                                      $"`{p.Index + 1}.` {Format.Bold(p.GetCommand(Prefix, (SocketGuild)ctx.Guild))}";
+                                  if (p.Index == 0)
+                                      str += $" [{GetText(strs.uneditable)}]";
+                                  return str;
+                              }));

        await ctx.Channel.SendMessageAsync(toSend);
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task RemovePerm(int index)
    {
@@ -147,8 +143,7 @@ public partial class Permissions : NadekoModule<PermissionService>
                _service.UpdateCache(config);
            }

-            await ReplyConfirmLocalizedAsync(strs.removed(
-                index + 1,
+            await ReplyConfirmLocalizedAsync(strs.removed(index + 1,
                Format.Code(p.GetCommand(Prefix, (SocketGuild)ctx.Guild))));
        }
        catch (IndexOutOfRangeException)
@@ -157,14 +152,14 @@ public partial class Permissions : NadekoModule<PermissionService>
        }
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task MovePerm(int from, int to)
    {
        from -= 1;
        to -= 1;
        if (!(from == to || from < 0 || to < 0))
-        {
            try
            {
                Permissionv2 fromPerm;
@@ -187,6 +182,7 @@ public partial class Permissions : NadekoModule<PermissionService>
                        await ReplyErrorLocalizedAsync(strs.perm_not_found(++to));
                        return;
                    }
+
                    fromPerm = permsCol[from];

                    permsCol.RemoveAt(from);
@@ -199,334 +195,287 @@ public partial class Permissions : NadekoModule<PermissionService>
                    Format.Code(fromPerm.GetCommand(Prefix, (SocketGuild)ctx.Guild)),
                    ++from,
                    ++to));
-                    
+
                return;
            }
            catch (Exception e) when (e is ArgumentOutOfRangeException or IndexOutOfRangeException)
            {
            }
-        }
+
        await ReplyConfirmLocalizedAsync(strs.perm_out_of_range);
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task SrvrCmd(CommandOrCrInfo command, PermissionAction action)
    {
-        await _service.AddPermissions(ctx.Guild.Id, new Permissionv2
-        {
-            PrimaryTarget = PrimaryPermissionType.Server,
-            PrimaryTargetId = 0,
-            SecondaryTarget = SecondaryPermissionType.Command,
-            SecondaryTargetName = command.Name.ToLowerInvariant(),
-            State = action.Value,
-            IsCustomCommand = command.IsCustom,
-        });
+        await _service.AddPermissions(ctx.Guild.Id,
+            new Permissionv2
+            {
+                PrimaryTarget = PrimaryPermissionType.Server,
+                PrimaryTargetId = 0,
+                SecondaryTarget = SecondaryPermissionType.Command,
+                SecondaryTargetName = command.Name.ToLowerInvariant(),
+                State = action.Value,
+                IsCustomCommand = command.IsCustom
+            });

        if (action.Value)
-        {
-            await ReplyConfirmLocalizedAsync(strs.sx_enable(
-                Format.Code(command.Name),
-                GetText(strs.of_command)));
-        }
+            await ReplyConfirmLocalizedAsync(strs.sx_enable(Format.Code(command.Name), GetText(strs.of_command)));
        else
-        {
-            await ReplyConfirmLocalizedAsync(strs.sx_disable(
-                Format.Code(command.Name),
-                GetText(strs.of_command)));
-        }
+            await ReplyConfirmLocalizedAsync(strs.sx_disable(Format.Code(command.Name), GetText(strs.of_command)));
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task SrvrMdl(ModuleOrCrInfo module, PermissionAction action)
    {
-        await _service.AddPermissions(ctx.Guild.Id, new Permissionv2
-        {
-            PrimaryTarget = PrimaryPermissionType.Server,
-            PrimaryTargetId = 0,
-            SecondaryTarget = SecondaryPermissionType.Module,
-            SecondaryTargetName = module.Name.ToLowerInvariant(),
-            State = action.Value,
-        });
+        await _service.AddPermissions(ctx.Guild.Id,
+            new Permissionv2
+            {
+                PrimaryTarget = PrimaryPermissionType.Server,
+                PrimaryTargetId = 0,
+                SecondaryTarget = SecondaryPermissionType.Module,
+                SecondaryTargetName = module.Name.ToLowerInvariant(),
+                State = action.Value
+            });

        if (action.Value)
-        {
-            await ReplyConfirmLocalizedAsync(strs.sx_enable(
-                Format.Code(module.Name),
-                GetText(strs.of_module)));
-        }
+            await ReplyConfirmLocalizedAsync(strs.sx_enable(Format.Code(module.Name), GetText(strs.of_module)));
        else
-        {
-            await ReplyConfirmLocalizedAsync(strs.sx_disable(
-                Format.Code(module.Name),
-                GetText(strs.of_module)));
-        }
+            await ReplyConfirmLocalizedAsync(strs.sx_disable(Format.Code(module.Name), GetText(strs.of_module)));
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task UsrCmd(CommandOrCrInfo command, PermissionAction action, [Leftover] IGuildUser user)
    {
-        await _service.AddPermissions(ctx.Guild.Id, new Permissionv2
-        {
-            PrimaryTarget = PrimaryPermissionType.User,
-            PrimaryTargetId = user.Id,
-            SecondaryTarget = SecondaryPermissionType.Command,
-            SecondaryTargetName = command.Name.ToLowerInvariant(),
-            State = action.Value,
-            IsCustomCommand = command.IsCustom,
-        });
+        await _service.AddPermissions(ctx.Guild.Id,
+            new Permissionv2
+            {
+                PrimaryTarget = PrimaryPermissionType.User,
+                PrimaryTargetId = user.Id,
+                SecondaryTarget = SecondaryPermissionType.Command,
+                SecondaryTargetName = command.Name.ToLowerInvariant(),
+                State = action.Value,
+                IsCustomCommand = command.IsCustom
+            });

        if (action.Value)
-        {
-            await ReplyConfirmLocalizedAsync(strs.ux_enable(
-                Format.Code(command.Name),
+            await ReplyConfirmLocalizedAsync(strs.ux_enable(Format.Code(command.Name),
                GetText(strs.of_command),
                Format.Code(user.ToString())));
-        }
        else
-        {
-            await ReplyConfirmLocalizedAsync(strs.ux_disable(
-                Format.Code(command.Name),
+            await ReplyConfirmLocalizedAsync(strs.ux_disable(Format.Code(command.Name),
                GetText(strs.of_command),
                Format.Code(user.ToString())));
-        }
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task UsrMdl(ModuleOrCrInfo module, PermissionAction action, [Leftover] IGuildUser user)
    {
-        await _service.AddPermissions(ctx.Guild.Id, new Permissionv2
-        {
-            PrimaryTarget = PrimaryPermissionType.User,
-            PrimaryTargetId = user.Id,
-            SecondaryTarget = SecondaryPermissionType.Module,
-            SecondaryTargetName = module.Name.ToLowerInvariant(),
-            State = action.Value,
-        });
+        await _service.AddPermissions(ctx.Guild.Id,
+            new Permissionv2
+            {
+                PrimaryTarget = PrimaryPermissionType.User,
+                PrimaryTargetId = user.Id,
+                SecondaryTarget = SecondaryPermissionType.Module,
+                SecondaryTargetName = module.Name.ToLowerInvariant(),
+                State = action.Value
+            });

        if (action.Value)
-        {
-            await ReplyConfirmLocalizedAsync(strs.ux_enable(
-                Format.Code(module.Name),
+            await ReplyConfirmLocalizedAsync(strs.ux_enable(Format.Code(module.Name),
                GetText(strs.of_module),
                Format.Code(user.ToString())));
-        }
        else
-        {
-            await ReplyConfirmLocalizedAsync(strs.ux_disable(
-                Format.Code(module.Name),
+            await ReplyConfirmLocalizedAsync(strs.ux_disable(Format.Code(module.Name),
                GetText(strs.of_module),
                Format.Code(user.ToString())));
-        }
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task RoleCmd(CommandOrCrInfo command, PermissionAction action, [Leftover] IRole role)
    {
        if (role == role.Guild.EveryoneRole)
            return;

-        await _service.AddPermissions(ctx.Guild.Id, new Permissionv2
-        {
-            PrimaryTarget = PrimaryPermissionType.Role,
-            PrimaryTargetId = role.Id,
-            SecondaryTarget = SecondaryPermissionType.Command,
-            SecondaryTargetName = command.Name.ToLowerInvariant(),
-            State = action.Value,
-            IsCustomCommand = command.IsCustom,
-        });
+        await _service.AddPermissions(ctx.Guild.Id,
+            new Permissionv2
+            {
+                PrimaryTarget = PrimaryPermissionType.Role,
+                PrimaryTargetId = role.Id,
+                SecondaryTarget = SecondaryPermissionType.Command,
+                SecondaryTargetName = command.Name.ToLowerInvariant(),
+                State = action.Value,
+                IsCustomCommand = command.IsCustom
+            });

        if (action.Value)
-        {
-            await ReplyConfirmLocalizedAsync(strs.rx_enable(
-                Format.Code(command.Name),
+            await ReplyConfirmLocalizedAsync(strs.rx_enable(Format.Code(command.Name),
                GetText(strs.of_command),
                Format.Code(role.Name)));
-        }
        else
-        {
-            await ReplyConfirmLocalizedAsync(strs.rx_disable(
-                Format.Code(command.Name),
+            await ReplyConfirmLocalizedAsync(strs.rx_disable(Format.Code(command.Name),
                GetText(strs.of_command),
                Format.Code(role.Name)));
-        }
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task RoleMdl(ModuleOrCrInfo module, PermissionAction action, [Leftover] IRole role)
    {
        if (role == role.Guild.EveryoneRole)
            return;

-        await _service.AddPermissions(ctx.Guild.Id, new Permissionv2
-        {
-            PrimaryTarget = PrimaryPermissionType.Role,
-            PrimaryTargetId = role.Id,
-            SecondaryTarget = SecondaryPermissionType.Module,
-            SecondaryTargetName = module.Name.ToLowerInvariant(),
-            State = action.Value,
-        });
+        await _service.AddPermissions(ctx.Guild.Id,
+            new Permissionv2
+            {
+                PrimaryTarget = PrimaryPermissionType.Role,
+                PrimaryTargetId = role.Id,
+                SecondaryTarget = SecondaryPermissionType.Module,
+                SecondaryTargetName = module.Name.ToLowerInvariant(),
+                State = action.Value
+            });


        if (action.Value)
-        {
-            await ReplyConfirmLocalizedAsync(strs.rx_enable(
-                Format.Code(module.Name),
+            await ReplyConfirmLocalizedAsync(strs.rx_enable(Format.Code(module.Name),
                GetText(strs.of_module),
                Format.Code(role.Name)));
-        }
        else
-        {
-            await ReplyConfirmLocalizedAsync(strs.rx_disable(
-                Format.Code(module.Name),
+            await ReplyConfirmLocalizedAsync(strs.rx_disable(Format.Code(module.Name),
                GetText(strs.of_module),
                Format.Code(role.Name)));
-        }
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task ChnlCmd(CommandOrCrInfo command, PermissionAction action, [Leftover] ITextChannel chnl)
    {
-        await _service.AddPermissions(ctx.Guild.Id, new Permissionv2
-        {
-            PrimaryTarget = PrimaryPermissionType.Channel,
-            PrimaryTargetId = chnl.Id,
-            SecondaryTarget = SecondaryPermissionType.Command,
-            SecondaryTargetName = command.Name.ToLowerInvariant(),
-            State = action.Value,
-            IsCustomCommand = command.IsCustom,
-        });
+        await _service.AddPermissions(ctx.Guild.Id,
+            new Permissionv2
+            {
+                PrimaryTarget = PrimaryPermissionType.Channel,
+                PrimaryTargetId = chnl.Id,
+                SecondaryTarget = SecondaryPermissionType.Command,
+                SecondaryTargetName = command.Name.ToLowerInvariant(),
+                State = action.Value,
+                IsCustomCommand = command.IsCustom
+            });

        if (action.Value)
-        {
-            await ReplyConfirmLocalizedAsync(strs.cx_enable(
-                Format.Code(command.Name),
+            await ReplyConfirmLocalizedAsync(strs.cx_enable(Format.Code(command.Name),
                GetText(strs.of_command),
                Format.Code(chnl.Name)));
-        }
        else
-        {
-            await ReplyConfirmLocalizedAsync(strs.cx_disable(
-                Format.Code(command.Name),
+            await ReplyConfirmLocalizedAsync(strs.cx_disable(Format.Code(command.Name),
                GetText(strs.of_command),
                Format.Code(chnl.Name)));
-        }
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task ChnlMdl(ModuleOrCrInfo module, PermissionAction action, [Leftover] ITextChannel chnl)
    {
-        await _service.AddPermissions(ctx.Guild.Id, new Permissionv2
-        {
-            PrimaryTarget = PrimaryPermissionType.Channel,
-            PrimaryTargetId = chnl.Id,
-            SecondaryTarget = SecondaryPermissionType.Module,
-            SecondaryTargetName = module.Name.ToLowerInvariant(),
-            State = action.Value,
-        });
+        await _service.AddPermissions(ctx.Guild.Id,
+            new Permissionv2
+            {
+                PrimaryTarget = PrimaryPermissionType.Channel,
+                PrimaryTargetId = chnl.Id,
+                SecondaryTarget = SecondaryPermissionType.Module,
+                SecondaryTargetName = module.Name.ToLowerInvariant(),
+                State = action.Value
+            });

        if (action.Value)
-        {
-            await ReplyConfirmLocalizedAsync(strs.cx_enable(
-                Format.Code(module.Name),
+            await ReplyConfirmLocalizedAsync(strs.cx_enable(Format.Code(module.Name),
                GetText(strs.of_module),
                Format.Code(chnl.Name)));
-        }
        else
-        {
-            await ReplyConfirmLocalizedAsync(strs.cx_disable(
-                Format.Code(module.Name),
+            await ReplyConfirmLocalizedAsync(strs.cx_disable(Format.Code(module.Name),
                GetText(strs.of_module),
                Format.Code(chnl.Name)));
-        }
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task AllChnlMdls(PermissionAction action, [Leftover] ITextChannel chnl)
    {
-        await _service.AddPermissions(ctx.Guild.Id, new Permissionv2
-        {
-            PrimaryTarget = PrimaryPermissionType.Channel,
-            PrimaryTargetId = chnl.Id,
-            SecondaryTarget = SecondaryPermissionType.AllModules,
-            SecondaryTargetName = "*",
-            State = action.Value,
-        });
+        await _service.AddPermissions(ctx.Guild.Id,
+            new Permissionv2
+            {
+                PrimaryTarget = PrimaryPermissionType.Channel,
+                PrimaryTargetId = chnl.Id,
+                SecondaryTarget = SecondaryPermissionType.AllModules,
+                SecondaryTargetName = "*",
+                State = action.Value
+            });

        if (action.Value)
-        {
-            await ReplyConfirmLocalizedAsync(strs.acm_enable(
-                Format.Code(chnl.Name)));
-        }
+            await ReplyConfirmLocalizedAsync(strs.acm_enable(Format.Code(chnl.Name)));
        else
-        {
-            await ReplyConfirmLocalizedAsync(strs.acm_disable(
-                Format.Code(chnl.Name)));
-        }
+            await ReplyConfirmLocalizedAsync(strs.acm_disable(Format.Code(chnl.Name)));
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task AllRoleMdls(PermissionAction action, [Leftover] IRole role)
    {
        if (role == role.Guild.EveryoneRole)
            return;

-        await _service.AddPermissions(ctx.Guild.Id, new Permissionv2
-        {
-            PrimaryTarget = PrimaryPermissionType.Role,
-            PrimaryTargetId = role.Id,
-            SecondaryTarget = SecondaryPermissionType.AllModules,
-            SecondaryTargetName = "*",
-            State = action.Value,
-        });
+        await _service.AddPermissions(ctx.Guild.Id,
+            new Permissionv2
+            {
+                PrimaryTarget = PrimaryPermissionType.Role,
+                PrimaryTargetId = role.Id,
+                SecondaryTarget = SecondaryPermissionType.AllModules,
+                SecondaryTargetName = "*",
+                State = action.Value
+            });

        if (action.Value)
-        {
-            await ReplyConfirmLocalizedAsync(strs.arm_enable(
-                Format.Code(role.Name)));
-        }
+            await ReplyConfirmLocalizedAsync(strs.arm_enable(Format.Code(role.Name)));
        else
-        {
-            await ReplyConfirmLocalizedAsync(strs.arm_disable(
-                Format.Code(role.Name)));
-        }
+            await ReplyConfirmLocalizedAsync(strs.arm_disable(Format.Code(role.Name)));
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task AllUsrMdls(PermissionAction action, [Leftover] IUser user)
    {
-        await _service.AddPermissions(ctx.Guild.Id, new Permissionv2
-        {
-            PrimaryTarget = PrimaryPermissionType.User,
-            PrimaryTargetId = user.Id,
-            SecondaryTarget = SecondaryPermissionType.AllModules,
-            SecondaryTargetName = "*",
-            State = action.Value,
-        });
+        await _service.AddPermissions(ctx.Guild.Id,
+            new Permissionv2
+            {
+                PrimaryTarget = PrimaryPermissionType.User,
+                PrimaryTargetId = user.Id,
+                SecondaryTarget = SecondaryPermissionType.AllModules,
+                SecondaryTargetName = "*",
+                State = action.Value
+            });

        if (action.Value)
-        {
-            await ReplyConfirmLocalizedAsync(strs.aum_enable(
-                Format.Code(user.ToString())));
-        }
+            await ReplyConfirmLocalizedAsync(strs.aum_enable(Format.Code(user.ToString())));
        else
-        {
-            await ReplyConfirmLocalizedAsync(strs.aum_disable(
-                Format.Code(user.ToString())));
-        }
+            await ReplyConfirmLocalizedAsync(strs.aum_disable(Format.Code(user.ToString())));
    }

-    [NadekoCommand, Aliases]
+    [NadekoCommand]
+    [Aliases]
    [RequireContext(ContextType.Guild)]
    public async Task AllSrvrMdls(PermissionAction action)
    {
@@ -536,7 +485,7 @@ public partial class Permissions : NadekoModule<PermissionService>
            PrimaryTargetId = 0,
            SecondaryTarget = SecondaryPermissionType.AllModules,
            SecondaryTargetName = "*",
-            State = action.Value,
+            State = action.Value
        };

        var allowUser = new Permissionv2
@@ -545,20 +494,14 @@ public partial class Permissions : NadekoModule<PermissionService>
            PrimaryTargetId = ctx.User.Id,
            SecondaryTarget = SecondaryPermissionType.AllModules,
            SecondaryTargetName = "*",
-            State = true,
+            State = true
        };

-        await _service.AddPermissions(ctx.Guild.Id,
-            newPerm,
-            allowUser);
+        await _service.AddPermissions(ctx.Guild.Id, newPerm, allowUser);

        if (action.Value)
-        {
            await ReplyConfirmLocalizedAsync(strs.asm_enable);
-        }
        else
-        {
            await ReplyConfirmLocalizedAsync(strs.asm_disable);
-        }
    }
-}
+}