480 lines
28 KiB
C#
480 lines
28 KiB
C#
using System;
|
|
using Discord.Modules;
|
|
using Discord.Commands;
|
|
using NadekoBot.Extensions;
|
|
using NadekoBot.Classes;
|
|
using PermsHandler = NadekoBot.Classes.Permissions.PermissionsHandler;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
namespace NadekoBot.Modules {
|
|
class PermissionModule : DiscordModule {
|
|
string prefix = ";";
|
|
public PermissionModule() : base() {
|
|
//Empty for now
|
|
}
|
|
|
|
public override void Install(ModuleManager manager) {
|
|
var client = NadekoBot.client;
|
|
manager.CreateCommands("", cgb => {
|
|
|
|
cgb.AddCheck(Classes.Permissions.PermissionChecker.Instance);
|
|
|
|
commands.ForEach(cmd => cmd.Init(cgb));
|
|
|
|
cgb.CreateCommand(prefix + "permrole")
|
|
.Alias(prefix + "pr")
|
|
.Description("Sets a role which can change permissions. Or supply no parameters to find out the current one. Default one is 'Nadeko'.")
|
|
.Parameter("role", ParameterType.Unparsed)
|
|
.Do(async e => {
|
|
if (string.IsNullOrWhiteSpace(e.GetArg("role"))) {
|
|
await e.Send($"Current permissions role is `{PermsHandler.GetServerPermissionsRoleName(e.Server)}`");
|
|
return;
|
|
}
|
|
|
|
var arg = e.GetArg("role");
|
|
Discord.Role role = null;
|
|
try {
|
|
role = PermissionHelper.ValidateRole(e.Server, arg);
|
|
}
|
|
catch (Exception ex) {
|
|
Console.WriteLine(ex.Message);
|
|
await e.Send($"Role `{arg}` probably doesn't exist. Create the role with that name first.");
|
|
return;
|
|
}
|
|
PermsHandler.SetPermissionsRole(e.Server, role.Name);
|
|
await e.Send($"Role `{role.Name}` is now required in order to change permissions.");
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "verbose")
|
|
.Alias(prefix + "v")
|
|
.Description("Sets whether to show when a command/module is blocked.\n**Usage**: ;verbose true")
|
|
.Parameter("arg", ParameterType.Required)
|
|
.Do(async e => {
|
|
var arg = e.GetArg("arg");
|
|
bool val = PermissionHelper.ValidateBool(arg);
|
|
PermsHandler.SetVerbosity(e.Server, val);
|
|
await e.Send($"Verbosity set to {val}.");
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "serverperms")
|
|
.Alias(prefix + "sp")
|
|
.Description("Shows banned permissions for this server.")
|
|
.Do(async e => {
|
|
var perms = PermsHandler.GetServerPermissions(e.Server);
|
|
if (string.IsNullOrWhiteSpace(perms?.ToString()))
|
|
await e.Send("No permissions set for this server.");
|
|
await e.Send(perms.ToString());
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "roleperms")
|
|
.Alias(prefix + "rp")
|
|
.Description("Shows banned permissions for a certain role. No argument means for everyone.\n**Usage**: ;rp AwesomeRole")
|
|
.Parameter("role", ParameterType.Unparsed)
|
|
.Do(async e => {
|
|
var arg = e.GetArg("role");
|
|
Discord.Role role = e.Server.EveryoneRole;
|
|
if (!string.IsNullOrWhiteSpace(arg))
|
|
try {
|
|
role = PermissionHelper.ValidateRole(e.Server, e.GetArg("role"));
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("💢 Error: " + ex.Message);
|
|
return;
|
|
}
|
|
|
|
var perms = PermsHandler.GetRolePermissionsById(e.Server, role.Id);
|
|
|
|
if (string.IsNullOrWhiteSpace(perms?.ToString()))
|
|
await e.Send($"No permissions set for **{role.Name}** role.");
|
|
await e.Send(perms.ToString());
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "channelperms")
|
|
.Alias(prefix + "cp")
|
|
.Description("Shows banned permissions for a certain channel. No argument means for this channel.\n**Usage**: ;cp #dev")
|
|
.Parameter("channel", ParameterType.Unparsed)
|
|
.Do(async e => {
|
|
var arg = e.GetArg("channel");
|
|
Discord.Channel channel = e.Channel;
|
|
if (!string.IsNullOrWhiteSpace(arg))
|
|
try {
|
|
channel = PermissionHelper.ValidateChannel(e.Server, e.GetArg("channel"));
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("💢 Error: " + ex.Message);
|
|
return;
|
|
}
|
|
|
|
var perms = PermsHandler.GetChannelPermissionsById(e.Server, channel.Id);
|
|
if (string.IsNullOrWhiteSpace(perms?.ToString()))
|
|
await e.Send($"No permissions set for **{channel.Name}** channel.");
|
|
await e.Send(perms.ToString());
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "userperms")
|
|
.Alias(prefix + "up")
|
|
.Description("Shows banned permissions for a certain user. No argument means for yourself.\n**Usage**: ;up Kwoth")
|
|
.Parameter("user", ParameterType.Unparsed)
|
|
.Do(async e => {
|
|
var arg = e.GetArg("user");
|
|
Discord.User user = e.User;
|
|
if (!string.IsNullOrWhiteSpace(e.GetArg("user")))
|
|
try {
|
|
user = PermissionHelper.ValidateUser(e.Server, e.GetArg("user"));
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("💢 Error: " + ex.Message);
|
|
return;
|
|
}
|
|
|
|
var perms = PermsHandler.GetUserPermissionsById(e.Server, user.Id);
|
|
if (string.IsNullOrWhiteSpace(perms?.ToString()))
|
|
await e.Send($"No permissions set for user **{user.Name}**.");
|
|
await e.Send(perms.ToString());
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "sm").Alias(prefix + "servermodule")
|
|
.Parameter("module", ParameterType.Required)
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Description("Sets a module's permission at the server level.\n**Usage**: ;sm <module_name> enable")
|
|
.Do(async e => {
|
|
try {
|
|
string module = PermissionHelper.ValidateModule(e.GetArg("module"));
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
|
|
PermsHandler.SetServerModulePermission(e.Server, module, state);
|
|
await e.Send($"Module **{module}** has been **{(state ? "enabled" : "disabled")}** on this server.");
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "sc").Alias(prefix + "servercommand")
|
|
.Parameter("command", ParameterType.Required)
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Description("Sets a command's permission at the server level.\n**Usage**: ;sc <command_name> disable")
|
|
.Do(async e => {
|
|
try {
|
|
string command = PermissionHelper.ValidateCommand(e.GetArg("command"));
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
|
|
PermsHandler.SetServerCommandPermission(e.Server, command, state);
|
|
await e.Send($"Command **{command}** has been **{(state ? "enabled" : "disabled")}** on this server.");
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "rm").Alias(prefix + "rolemodule")
|
|
.Parameter("module", ParameterType.Required)
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Parameter("role", ParameterType.Unparsed)
|
|
.Description("Sets a module's permission at the role level.\n**Usage**: ;rm <module_name> enable <role_name>")
|
|
.Do(async e => {
|
|
try {
|
|
string module = PermissionHelper.ValidateModule(e.GetArg("module"));
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
|
|
if (e.GetArg("role")?.ToLower() == "all") {
|
|
foreach (var role in e.Server.Roles) {
|
|
PermsHandler.SetRoleModulePermission(role, module, state);
|
|
}
|
|
await e.Send($"Module **{module}** has been **{(state ? "enabled" : "disabled")}** for **ALL** roles.");
|
|
}
|
|
else {
|
|
Discord.Role role = PermissionHelper.ValidateRole(e.Server, e.GetArg("role"));
|
|
|
|
PermsHandler.SetRoleModulePermission(role, module, state);
|
|
await e.Send($"Module **{module}** has been **{(state ? "enabled" : "disabled")}** for **{role.Name}** role.");
|
|
}
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "rc").Alias(prefix + "rolecommand")
|
|
.Parameter("command", ParameterType.Required)
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Parameter("role", ParameterType.Unparsed)
|
|
.Description("Sets a command's permission at the role level.\n**Usage**: ;rc <command_name> disable <role_name>")
|
|
.Do(async e => {
|
|
try {
|
|
string command = PermissionHelper.ValidateCommand(e.GetArg("command"));
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
|
|
if (e.GetArg("role")?.ToLower() == "all") {
|
|
foreach (var role in e.Server.Roles) {
|
|
PermsHandler.SetRoleCommandPermission(role, command, state);
|
|
}
|
|
await e.Send($"Command **{command}** has been **{(state ? "enabled" : "disabled")}** for **ALL** roles.");
|
|
}
|
|
else {
|
|
Discord.Role role = PermissionHelper.ValidateRole(e.Server, e.GetArg("role"));
|
|
|
|
PermsHandler.SetRoleCommandPermission(role, command, state);
|
|
await e.Send($"Command **{command}** has been **{(state ? "enabled" : "disabled")}** for **{role.Name}** role.");
|
|
}
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "cm").Alias(prefix + "channelmodule")
|
|
.Parameter("module", ParameterType.Required)
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Parameter("channel", ParameterType.Unparsed)
|
|
.Description("Sets a module's permission at the channel level.\n**Usage**: ;cm <module_name> enable <channel_name>")
|
|
.Do(async e => {
|
|
try {
|
|
string module = PermissionHelper.ValidateModule(e.GetArg("module"));
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
|
|
if (e.GetArg("channel")?.ToLower() == "all") {
|
|
foreach (var channel in e.Server.TextChannels) {
|
|
PermsHandler.SetChannelModulePermission(channel, module, state);
|
|
}
|
|
await e.Send($"Module **{module}** has been **{(state ? "enabled" : "disabled")}** on **ALL** channels.");
|
|
}
|
|
else {
|
|
Discord.Channel channel = PermissionHelper.ValidateChannel(e.Server, e.GetArg("channel"));
|
|
|
|
PermsHandler.SetChannelModulePermission(channel, module, state);
|
|
await e.Send($"Module **{module}** has been **{(state ? "enabled" : "disabled")}** for **{channel.Name}** channel.");
|
|
}
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "cc").Alias(prefix + "channelcommand")
|
|
.Parameter("command", ParameterType.Required)
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Parameter("channel", ParameterType.Unparsed)
|
|
.Description("Sets a command's permission at the channel level.\n**Usage**: ;cm enable <channel_name>")
|
|
.Do(async e => {
|
|
try {
|
|
string command = PermissionHelper.ValidateCommand(e.GetArg("command"));
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
|
|
if (e.GetArg("channel")?.ToLower() == "all") {
|
|
foreach (var channel in e.Server.TextChannels) {
|
|
PermsHandler.SetChannelCommandPermission(channel, command, state);
|
|
}
|
|
await e.Send($"Command **{command}** has been **{(state ? "enabled" : "disabled")}** on **ALL** channels.");
|
|
}
|
|
else {
|
|
Discord.Channel channel = PermissionHelper.ValidateChannel(e.Server, e.GetArg("channel"));
|
|
|
|
PermsHandler.SetChannelCommandPermission(channel, command, state);
|
|
await e.Send($"Command **{command}** has been **{(state ? "enabled" : "disabled")}** for **{channel.Name}** channel.");
|
|
}
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "um").Alias(prefix + "usermodule")
|
|
.Parameter("module", ParameterType.Required)
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Parameter("user", ParameterType.Unparsed)
|
|
.Description("Sets a module's permission at the user level.\n**Usage**: ;um <module_name> enable <user_name>")
|
|
.Do(async e => {
|
|
try {
|
|
string module = PermissionHelper.ValidateModule(e.GetArg("module"));
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
Discord.User user = PermissionHelper.ValidateUser(e.Server, e.GetArg("user"));
|
|
|
|
PermsHandler.SetUserModulePermission(user, module, state);
|
|
await e.Send($"Module **{module}** has been **{(state ? "enabled" : "disabled")}** for user **{user.Name}**.");
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "uc").Alias(prefix + "usercommand")
|
|
.Parameter("command", ParameterType.Required)
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Parameter("user", ParameterType.Unparsed)
|
|
.Description("Sets a command's permission at the user level.\n**Usage**: ;uc <module_command> enable <user_name>")
|
|
.Do(async e => {
|
|
try {
|
|
string command = PermissionHelper.ValidateCommand(e.GetArg("command"));
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
Discord.User user = PermissionHelper.ValidateUser(e.Server, e.GetArg("user"));
|
|
|
|
PermsHandler.SetUserCommandPermission(user, command, state);
|
|
await e.Send($"Command **{command}** has been **{(state ? "enabled" : "disabled")}** for user **{user.Name}**.");
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "asm").Alias(prefix + "allservermodules")
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Description("Sets permissions for all modules at the server level.\n**Usage**: ;asm <enable/disable>")
|
|
.Do(async e => {
|
|
try {
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
|
|
foreach (var module in NadekoBot.client.GetService<ModuleService>().Modules) {
|
|
PermsHandler.SetServerModulePermission(e.Server, module.Name, state);
|
|
}
|
|
await e.Send($"All modules have been **{(state ? "enabled" : "disabled")}** on this server.");
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "asc").Alias(prefix + "allservercommands")
|
|
.Parameter("module", ParameterType.Required)
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Description("Sets permissions for all commands from a certain module at the server level.\n**Usage**: ;asc <module_name> <enable/disable>")
|
|
.Do(async e => {
|
|
try {
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
string module = PermissionHelper.ValidateModule(e.GetArg("module"));
|
|
|
|
foreach (var command in NadekoBot.client.GetService<CommandService>().AllCommands.Where(c => c.Category == module)) {
|
|
PermsHandler.SetServerCommandPermission(e.Server, command.Text, state);
|
|
}
|
|
await e.Send($"All commands from the **{module}** module have been **{(state ? "enabled" : "disabled")}** on this server.");
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "acm").Alias(prefix + "allchannelmodules")
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Parameter("channel", ParameterType.Unparsed)
|
|
.Description("Sets permissions for all modules at the channel level.\n**Usage**: ;acm <enable/disable> <channel_name>")
|
|
.Do(async e => {
|
|
try {
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
Discord.Channel channel = PermissionHelper.ValidateChannel(e.Server, e.GetArg("channel"));
|
|
foreach (var module in NadekoBot.client.GetService<ModuleService>().Modules) {
|
|
PermsHandler.SetChannelModulePermission(channel, module.Name, state);
|
|
}
|
|
|
|
await e.Send($"All modules have been **{(state ? "enabled" : "disabled")}** for **{channel.Name}** channel.");
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "acc").Alias(prefix + "allchannelcommands")
|
|
.Parameter("module", ParameterType.Required)
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Parameter("channel", ParameterType.Unparsed)
|
|
.Description("Sets permissions for all commands from a certain module at the channel level.\n**Usage**: ;acc <module_name> <enable/disable> <channel_name>")
|
|
.Do(async e => {
|
|
try {
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
string module = PermissionHelper.ValidateModule(e.GetArg("module"));
|
|
Discord.Channel channel = PermissionHelper.ValidateChannel(e.Server, e.GetArg("channel"));
|
|
foreach (var command in NadekoBot.client.GetService<CommandService>().AllCommands.Where(c => c.Category == module)) {
|
|
PermsHandler.SetChannelCommandPermission(channel, command.Text, state);
|
|
}
|
|
await e.Send($"All commands from the **{module}** module have been **{(state ? "enabled" : "disabled")}** for **{channel.Name}** channel.");
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "arm").Alias(prefix + "allrolemodules")
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Parameter("role", ParameterType.Unparsed)
|
|
.Description("Sets permissions for all modules at the role level.\n**Usage**: ;arm <enable/disable> <role_name>")
|
|
.Do(async e => {
|
|
try {
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
Discord.Role role = PermissionHelper.ValidateRole(e.Server, e.GetArg("role"));
|
|
foreach (var module in NadekoBot.client.GetService<ModuleService>().Modules) {
|
|
PermsHandler.SetRoleModulePermission(role, module.Name, state);
|
|
}
|
|
|
|
await e.Send($"All modules have been **{(state ? "enabled" : "disabled")}** for **{role.Name}** role.");
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
|
|
cgb.CreateCommand(prefix + "arc").Alias(prefix + "allrolecommands")
|
|
.Parameter("module", ParameterType.Required)
|
|
.Parameter("bool", ParameterType.Required)
|
|
.Parameter("channel", ParameterType.Unparsed)
|
|
.Description("Sets permissions for all commands from a certain module at the role level.\n**Usage**: ;arc <module_name> <enable/disable> <channel_name>")
|
|
.Do(async e => {
|
|
try {
|
|
bool state = PermissionHelper.ValidateBool(e.GetArg("bool"));
|
|
string module = PermissionHelper.ValidateModule(e.GetArg("module"));
|
|
Discord.Role role = PermissionHelper.ValidateRole(e.Server, e.GetArg("channel"));
|
|
foreach (var command in NadekoBot.client.GetService<CommandService>().AllCommands.Where(c => c.Category == module)) {
|
|
PermsHandler.SetRoleCommandPermission(role, command.Text, state);
|
|
}
|
|
await e.Send($"All commands from the **{module}** module have been **{(state ? "enabled" : "disabled")}** for **{role.Name}** role.");
|
|
}
|
|
catch (ArgumentException exArg) {
|
|
await e.Send(exArg.Message);
|
|
}
|
|
catch (Exception ex) {
|
|
await e.Send("Something went terribly wrong - " + ex.Message);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
}
|
|
}
|