public bool HasDuplicateServerPermissions()
{
var duplicates = ServerPermissions
.Where(i => !i.IsDeleted)
.GroupBy(i => i.WindowsGroup)
.Where(g => g.Count() > 1)
.Select(g => g.Key);
return(duplicates.Any());
}
private async Task <Discord.Role> addToRole(string roleName, ServerPermissions permissions, Discord.User target, MessageEventArgs e)
{
Discord.Role newrole = null;
try
{
newrole = await e.Server.CreateRole(roleName, permissions);
await target.AddRoles(newrole);
} catch (Exception)
{
await newrole.Delete();
await e.Channel.SendMessage(SystemMessages.MESSAGE_ROLESETEXCEPTION);
return(null);
}
return(newrole);
}
void OnPermissionPropertyChanged(object sender, PropertyChangedEventArgs args)
{
IsDirty = true;
UpdateOverridingPermission(sender as WindowsGroupPermission, args.PropertyName);
if (args.PropertyName == "WindowsGroup" || args.PropertyName == "ResourceName")
{
var permission = (WindowsGroupPermission)sender;
if (permission.IsNew)
{
if (permission.IsValid)
{
permission.IsNew = false;
var newPermission = CreateNewPermission(permission.IsServer);
if (permission.IsServer)
{
ServerPermissions.Add(newPermission);
}
else
{
ResourcePermissions.Add(newPermission);
}
}
}
else
{
var isEmpty = string.IsNullOrEmpty(permission.WindowsGroup);
if (isEmpty)
{
if (permission.IsServer)
{
ServerPermissions.Remove(permission);
}
else
{
ResourcePermissions.Remove(permission);
}
}
}
}
}
private static Task WriteServerToJson(ServerPermissions serverPerms) => Task.Run(() =>
{
string pathToFile = $"data/permissions/{serverPerms.Id}.json";
File.WriteAllText(pathToFile,
Newtonsoft.Json.JsonConvert.SerializeObject(serverPerms, Newtonsoft.Json.Formatting.Indented));
});
private async void parseInput(string input, MessageEventArgs e)
{
string[] toParse = input.Split(' ');
string command = toParse[0];
int inputLen = toParse.Length;
Server server = e.Server;
if (e.Channel.IsPrivate)
{
return;
}
else if (command == "")
{
return;
}
else if (inputLen == 1)
{
if (command == Constants.COMMAND_HELP)
{
await e.Channel.SendMessage("Testing Testing 1 2 3");
}
else if (command == Constants.COMMAND_DEVTESTNEWLINE)
{
string sentence = "```";
for (int i = 0; i < 5; i++)
{
sentence += i + ") " + "Satsuo" + "\n";
}
sentence += "```";
await e.Channel.SendMessage(sentence);
}
else if (command == Constants.COMMAND_LISTUSERS)
{
foreach (Discord.User user in e.Channel.Users)
{
//TODO: Check for users in a voice channel and only list those
await e.Channel.SendMessage(user.ToString());
await user.SendMessage("Will this work?");
}
}
else if (command == Constants.COMMAND_GITHUB)
{
await e.Channel.SendMessage(Constants.URL_GITHUB);
}
else if (command == Constants.COMMAND_LISTSERVERSWITHGAMES)
{
if (!PartyGames.Any())
{
await e.Channel.SendMessage("No server is running a game right now!");
}
else
{
for (int i = 0; i < PartyGames.Count(); i++)
{
Game game = PartyGames.ElementAt(i);
await e.Channel.SendMessage("Server " + game.getGameServerID().ToString() + " running game type " + game.getGameType() + " on text channel " +
game.getTextChannelID().ToString() + " and on voice channel " + game.getVoiceChannelID().ToString());
}
}
}
else if (command == Constants.COMMAND_JOINPARTYGAME)
{
Game game = ServerStartingGame(server);
if (game != null)
{
if (game.playerAlreadyJoined(e.User))
{
await e.Channel.SendMessage(SystemMessages.MESSAGE_GAMEALREADYJOINED);
}
else
{
bool added = await addToRole(game.getPlayerRole(), e.User, e);
if (added)
{
game.addPlayer(e.User);
await e.Channel.SendMessage(e.User.NicknameMention + " has joined the " + game.getGameType() + " game. Click " + client.GetChannel(game.getTextChannelID()).Mention + " to enter the text channel.");
}
}
}
else
{
await e.Channel.SendMessage(SystemMessages.MESSAGE_GAMESTARTEDORNONE);
}
}
else if (command == Constants.COMMAND_LEAVEPARTYGAME)
{
Game game = ServerStartingGame(server);
if (game != null)
{
if (game.playerAlreadyJoined(e.User))
{
game.removePlayer(e.User);
await e.Channel.SendMessage(e.User.NicknameMention + " has left the " + game.getGameType() + " game.");
}
else
{
await e.Channel.SendMessage("You haven't even joined the game!");
}
}
else
{
await e.Channel.SendMessage(SystemMessages.MESSAGE_GAMESTARTEDNOLEAVE);
}
}
else if (commandRollDice(command))
{
string value = command.Remove(0, 2);
if (isValidDiceRoll(value))
{
int rollValue = getDiceRoll(value);
await e.Channel.SendMessage(e.User.Mention + " rolled a d" + value + " and got: " + rollValue);
return;
}
else
{
await e.Channel.SendMessage("USAGE: !d#, where # is between 1-" + Int32.MaxValue + ".");
return;
}
}
//The Secret Santa module
else if (command == Constants.COMMAND_STARTSECRETSANTA)
{
if (secretSanta == null)
{
secretSanta = new SecretSanta(server, client);
await e.Channel.SendMessage("The Secret Santa module has been initialized!");
}
}
}
else if (inputLen > 1)
{
if (command == Constants.COMMAND_SETGAME)
{
string game = input.Remove(0, Constants.COMMAND_SETGAME.Length + 1);
client.SetGame(game);
}
else if (command == Constants.COMMAND_CREATECHANNEL)
{
string channelname = input.Remove(0, Constants.COMMAND_CREATECHANNEL.Length + 1);
await createNewChannel(channelname, ChannelType.Text, e);
}
else if (command == Constants.COMMAND_TTS)
{
string message = input.Remove(0, Constants.COMMAND_TTS.Length + 1);
await e.Channel.SendTTSMessage(message);
}
else if (command == Constants.COMMAND_SETROLE)
{
string rolename = input.Remove(0, Constants.COMMAND_SETROLE.Length + 1);
ServerPermissions permissions = new ServerPermissions(true);
try {
await addToRole(rolename, permissions, e.User, e);
}
catch (Exception) {
return;
}
}
else if (command == Constants.COMMAND_STARTDND)
{
if (!isHostingGame)
{
Discord.Channel text, voice = null;
Discord.Role gamerole = null;
string channelname = input.Remove(0, Constants.COMMAND_STARTDND.Length + 1);
ServerPermissions permissions = new ServerPermissions();
gamerole = await addToRole(Constants.GAME_DNDGAME, permissions, e.User, e);
if (gamerole != null)
{
text = await createNewChannel(channelname, ChannelType.Text, e);
if (text != null)
{
isHostingGame = true;
voice = await createNewChannel(channelname + " Voice", ChannelType.Voice, e);
ChannelPermissionOverrides memberPermOverride = new ChannelPermissionOverrides(PermValue.Deny, PermValue.Deny, PermValue.Allow,
PermValue.Allow, PermValue.Allow, PermValue.Deny, PermValue.Allow, PermValue.Deny, PermValue.Allow, PermValue.Deny, PermValue.Deny,
PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny);
ChannelPermissionOverrides everyonePermOverride = new ChannelPermissionOverrides(PermValue.Deny, PermValue.Deny, PermValue.Allow,
PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny,
PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny);
await text.AddPermissionsRule(gamerole, memberPermOverride);
await text.AddPermissionsRule(e.Server.EveryoneRole, everyonePermOverride);
Game DnDGame = new DnDGame(server, text, voice, e.Channel, gamerole, client, e.User.Id);
DnDGame.addPlayer(e.User);
PartyGames.Add(DnDGame);
await setChannelToTop(text);
await setChannelToTop(voice);
await e.Channel.SendMessage(DnDGame.getGameType() + SystemMessages.MESSAGE_GAMECREATED + text.Mention);
Console.WriteLine("Game was created at server: " + server.Id);
}
else
{
await gamerole.Delete();
}
}
}
else
{
Console.WriteLine(SystemMessages.MESSAGE_GAMEHASSTARTED);
}
}
else if (command == Constants.COMMAND_STARTRESISTANCE)
{
bool createGame = false;
if (!PartyGames.Any())
{
createGame = true;
}
Game game = null;
if (!createGame && PartyGames.Any())
{
int i = 0; bool found = false;
while (i < PartyGames.Count())
{
game = PartyGames.ElementAt(i);
if (game.getGameServerID() == server.Id)
{
found = true;
}
i++;
}
createGame = found ? false : true;
}
if (createGame && !isHostingGame)
{
Discord.Channel text, voice = null;
Discord.Role gamerole = null;
string channelname = input.Remove(0, Constants.COMMAND_STARTRESISTANCE.Length + 1);
ServerPermissions permissions = new ServerPermissions();
gamerole = await addToRole(Constants.GAME_RESISTANCE, permissions, e.User, e);
if (gamerole != null)
{
text = await createNewChannel(channelname, ChannelType.Text, e);
if (text != null)
{
isHostingGame = true;
voice = await createNewChannel(channelname + " Voice", ChannelType.Voice, e);
ChannelPermissionOverrides memberPermOverride = new ChannelPermissionOverrides(PermValue.Deny, PermValue.Deny, PermValue.Allow,
PermValue.Allow, PermValue.Allow, PermValue.Deny, PermValue.Allow, PermValue.Deny, PermValue.Allow, PermValue.Deny, PermValue.Deny,
PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny);
ChannelPermissionOverrides everyonePermOverride = new ChannelPermissionOverrides(PermValue.Deny, PermValue.Deny, PermValue.Allow,
PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny,
PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny);
await text.AddPermissionsRule(gamerole, memberPermOverride);
await text.AddPermissionsRule(e.Server.EveryoneRole, everyonePermOverride);
Game resistanceGame = new ResistanceGame(server, text, voice, e.Channel, gamerole, client, e.User.Id);
resistanceGame.addPlayer(e.User);
PartyGames.Add(resistanceGame);
await setChannelToTop(text);
await setChannelToTop(voice);
await e.Channel.SendMessage(resistanceGame.getGameType() + SystemMessages.MESSAGE_GAMECREATED + text.Mention);
Console.WriteLine("Game was created at server: " + server.Id);
}
else
{
await gamerole.Delete();
}
}
}
else
{
Console.WriteLine(SystemMessages.MESSAGE_GAMEHASSTARTED);
}
}
else if (command == Constants.COMMAND_FLOODMESSAGE)
{
int repeat;
if (Int32.TryParse(toParse[1], out repeat))
{
string message = input.Remove(0, Constants.COMMAND_FLOODMESSAGE.Length + toParse[1].Length + 2);
for (int i = 0; i < repeat; i++)
{
await e.Channel.SendMessage(message);
}
}
else
{
await e.Channel.SendMessage("Invalid use of command, nerd");
}
}
}
if (Constants.TESTBUILD)
{
await e.Channel.SendMessage("Length of input: " + inputLen);
}
}
void IModule.Install(ModuleManager manager)
{
manager.CreateDynCommands("channel", PermissionLevel.ServerAdmin, group =>
{
group.CreateCommand("list text")
.Description("Lists all text channels in server")
.Do(async e =>
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("**Listing text channels in server:**");
CreateNameIdList(builder, e.Server.TextChannels);
await e.Channel.SafeSendMessage(builder.ToString());
});
group.CreateCommand("list voice")
.Description("Lists all voice channels in server")
.Do(async e =>
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("**Listing voice channels in server:**");
CreateNameIdList(builder, e.Server.VoiceChannels);
await e.Channel.SafeSendMessage(builder.ToString());
});
group.CreateCommand("prune")
.AddCheck((cmd, usr, chnl) => chnl.Server.CurrentUser.ServerPermissions.ManageMessages ||
chnl.Server.CurrentUser.GetPermissions(chnl).ManageMessages)
.Description("Deletes the last 100 messages sent in this channel.")
.Do(async e =>
{
foreach (Message msg in await e.Channel.DownloadMessages())
{
if (msg != null)
{
await msg.Delete();
}
}
});
group.CreateCommand("topic")
.Description("Sets the topic of a channel, found by its id.")
.Parameter(Constants.ChannelIdArg)
.Parameter("topic", ParameterType.Unparsed)
.Do(async e =>
{
Channel channel = e.GetChannel();
string topic = e.GetArg("topic");
if (channel == null)
{
await e.Channel.SendMessage($"Channel not found.");
return;
}
if (!await channel.SafeEditChannel(topic: topic))
{
await
e.Channel.SendMessage($"I don't have sufficient permissions to edit {channel.Mention}");
return;
}
await e.Channel.SendMessage($"Set the topic of {channel.Mention} to `{topic}`.");
});
group.CreateCommand("name")
.Description("Sets the name of a channel, found by its id.")
.Parameter(Constants.ChannelIdArg)
.Parameter("name")
.Do(async e =>
{
Channel channel = e.GetChannel();
string name = e.GetArg("name");
if (channel == null)
{
await e.Channel.SendMessage($"Channel not found.");
return;
}
string nameBefore = channel.Name;
if (!await channel.SafeEditChannel(name))
{
await
e.Channel.SendMessage($"I don't have sufficient permissions to edit {channel.Mention}");
return;
}
await e.Channel.SendMessage($"Set the name of `{nameBefore}` to `{name}`.");
});
});
manager.CreateDynCommands("role", PermissionLevel.ServerAdmin, group =>
{
group.CreateCommand("list")
.Description("Lists all the roles the server has")
.Do(async e =>
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("**Listing roles in server:**");
CreateNameIdList(builder, e.Server.Roles);
await e.Channel.SafeSendMessage(builder.ToString());
});
// commands, which can only be called if the bot user has rights to manager roles.
group.CreateGroup("", manageRolesGroup =>
{
manageRolesGroup.AddCheck((cmd, usr, chnl) => chnl.Server.CurrentUser.ServerPermissions.ManageRoles);
manageRolesGroup.CreateCommand("add")
.Description("Adds a role with the given name if it doesn't exist.")
.Parameter("name", ParameterType.Unparsed)
.Do(async e =>
{
string name = e.GetArg("name");
Role role = FindRole(name, e);
if (role != null)
{
await e.Channel.SendMessage("Role not found.");
return;
}
await e.Server.CreateRole(name);
await e.Channel.SafeSendMessage($"Created role `{name}`");
});
manageRolesGroup.CreateCommand("rem")
.Description("Removes a role with the given id if it exists.")
.Parameter(Constants.RoleIdArg)
.Do(async e =>
{
Role role = e.GetRole();
if (role == null)
{
await e.Channel.SendMessage("Role not found.");
return;
}
if (role.IsEveryone || role.IsHoisted || role.IsManaged)
{
await e.Channel.SendMessage("You cannot remove this role.");
return;
}
await role.Delete();
await e.Channel.SafeSendMessage($"Removed role `{role.Name}`");
});
manageRolesGroup.CreateCommand("edit perm")
.Description("Edits permissions for a given role, found by id, if it exists.")
.Parameter(Constants.RoleIdArg)
.Parameter("permission")
.Parameter("value")
.Do(async e =>
{
Role role = e.GetRole();
if (role == null)
{
await e.Channel.SendMessage("Role not found.");
return;
}
ServerPermissions edited = role.Permissions;
PropertyInfo prop = edited.GetType().GetProperty(e.GetArg("permission"));
bool value = bool.Parse(e.GetArg("value"));
prop.SetValue(edited, value);
await role.SafeEdit(perm: edited);
await
e.Channel.SafeSendMessage(
$"Set permission `{prop.Name}` in `{role.Name}` to `{value}`");
});
manageRolesGroup.CreateCommand("edit color")
.Description("Edits the color (RRGGBB) for a given role, found by id, if it exists. ")
.Parameter(Constants.RoleIdArg)
.Parameter("hex")
.Do(async e =>
{
Role role = e.GetRole();
if (role == null)
{
await e.Channel.SendMessage("Role not found.");
return;
}
uint hex;
if (!DiscordUtils.ToHex(e.GetArg("hex"), out hex))
{
return;
}
if (!await role.SafeEdit(color: new Color(hex)))
{
await
e.Channel.SendMessage(
$"Failed editing role. Make sure it's not everyone or managed.");
}
});
});
group.CreateCommand("listperm")
.Description("Lists the permissions for a given roleid")
.Parameter(Constants.RoleIdArg)
.Do(async e =>
{
Role role = e.GetRole();
if (role == null)
{
await e.Channel.SendMessage("Role not found.");
return;
}
ServerPermissions perms = role.Permissions;
await
e.Channel.SafeSendMessage($"**Listing permissions for {role.Name}**\r\n:" +
$"{"CreateInstantInvite",-25}: {perms.CreateInstantInvite}\r\n" +
$"{"KickMembers",-25}: {perms.KickMembers}\r\n" +
$"{"BanMembers",-25}: {perms.BanMembers}\r\n" +
$"{"ManageRoles",-25}: {perms.ManageRoles}\r\n" +
$"{"ManageChannels",-25}: {perms.ManageChannels}\r\n" +
$"{"ManageServer",-25}: {perms.ManageServer}\r\n" +
$"{"ReadMessages",-25}: {perms.ReadMessages}\r\n" +
$"{"SafeSendMessages",-25}: {perms.SendMessages}\r\n" +
$"{"SendTTSMessages",-25}: {perms.SendTTSMessages}\r\n" +
$"{"ManageMessages",-25}: {perms.ManageMessages}\r\n" +
$"{"EmbedLinks",-25}: {perms.EmbedLinks}\r\n" +
$"{"AttachFiles",-25}: {perms.AttachFiles}\r\n" +
$"{"ReadMessageHistory",-25}: {perms.ReadMessageHistory}\r\n" +
$"{"MentionEveryone",-25}: {perms.MentionEveryone}\r\n" +
$"{"Connect",-25}: {perms.Connect}\r\n" +
$"{"Speak",-25}: {perms.Speak}\r\n" +
$"{"MuteMembers",-25}: {perms.MuteMembers}\r\n" +
$"{"DeafenMembers",-25}: {perms.DeafenMembers}\r\n" +
$"{"MoveMembers",-25}: {perms.MoveMembers}\r\n" +
$"{"UseVoiceActivation",-25}: {perms.UseVoiceActivation}`"
);
});
});
manager.CreateDynCommands("ued", PermissionLevel.ServerModerator, group =>
{
group.CreateCommand("list")
.Description("Lists users in server and their UIDs")
.Do(async e =>
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("**Listing users in server:**");
CreateNameIdList(builder, e.Server.Users);
await e.Channel.SafeSendMessage(builder.ToString());
});
group.CreateCommand("mute")
.AddCheck((cmd, usr, chnl) => chnl.Server.CurrentUser.ServerPermissions.MuteMembers)
.Description("Mutes(true)/unmutes(false) the userid")
.Parameter(Constants.UserMentionArg)
.Parameter("val")
.Do(async e =>
{
User user = e.GetUser();
if (user == null)
{
await e.Channel.SendMessage("User not found.");
return;
}
await user.Edit(bool.Parse(e.GetArg("val")));
await e.Channel.SafeSendMessage($"Muted `{user.Name}`");
});
group.CreateCommand("deaf")
.AddCheck((cmd, usr, chnl) => chnl.Server.CurrentUser.ServerPermissions.DeafenMembers)
.Description("Deafens(true)/Undeafens(false) @user")
.Parameter(Constants.UserMentionArg)
.Parameter("val")
.Do(async e =>
{
User user = e.GetUser();
if (user == null)
{
await e.Channel.SendMessage("User not found.");
return;
}
await user.Edit(isDeafened: bool.Parse(e.GetArg("val")));
await e.Channel.SafeSendMessage($"Deafened `{user.Name}`");
});
group.CreateCommand("move")
.AddCheck((cmd, usr, chnl) => chnl.Server.CurrentUser.ServerPermissions.MoveMembers)
.Description("Moves a @user to a given voice channel")
.Parameter(Constants.UserMentionArg)
.Parameter("channelid", ParameterType.Unparsed)
.Do(async e =>
{
User user = e.GetUser();
if (user == null)
{
await e.Channel.SendMessage("User not found.");
return;
}
Channel moveChnl = e.Server.GetChannel(ulong.Parse(e.GetArg("channelid")));
await user.Edit(voiceChannel: moveChnl);
await e.Channel.SafeSendMessage($"Moved `{user.Name}` to `{moveChnl.Name}`");
});
group.CreateCommand("role add")
.AddCheck((cmd, usr, chnl) => chnl.Server.CurrentUser.ServerPermissions.ManageRoles)
.Description("Adds a role, found by id, to @user if they dont have it.")
.Parameter(Constants.UserMentionArg)
.Parameter(Constants.RoleIdArg)
.Do(async e =>
{
User user = e.GetUser();
Role role = e.GetRole();
if (user == null)
{
await e.Channel.SendMessage("User not found.");
return;
}
if (role == null)
{
await e.Channel.SendMessage("Role not found.");
return;
}
if (!user.HasRole(role))
{
await user.Edit(roles: user.Roles.Concat(new[] { role }));
await e.Channel.SafeSendMessage($"Given role `{role.Name}` to `{user.Mention}`");
}
});
group.CreateCommand("role list")
.Description("Returns a list of roles a @user has.")
.Parameter(Constants.UserMentionArg)
.Do(async e =>
{
StringBuilder builder = new StringBuilder();
User user = e.GetUser();
builder.AppendLine($"**Listing roles for {user.Name}:**");
CreateNameIdList(builder, e.Server.Roles);
await e.Channel.SafeSendMessage(builder.ToString());
});
group.CreateCommand("role rem")
.AddCheck((cmd, usr, chnl) => chnl.Server.CurrentUser.ServerPermissions.ManageRoles)
.Description("Removes a roleid from a @user if they have it.")
.Parameter(Constants.UserMentionArg)
.Parameter(Constants.RoleIdArg)
.Do(async e =>
{
User user = e.GetUser();
Role role = e.GetRole();
if (user == null)
{
await e.Channel.SendMessage("User not found.");
return;
}
if (role == null)
{
await e.Channel.SendMessage("Role not found.");
return;
}
if (user.HasRole(role))
{
await user.RemoveRoles(role);
await e.Channel.SafeSendMessage($"Removed role `{role.Name}` from `{user.Name}`.");
}
});
group.CreateCommand("kick")
.Description("Kicks a @user.")
.AddCheck((cmd, usr, chnl) => chnl.Server.CurrentUser.ServerPermissions.KickMembers)
.Parameter("userMention")
.Do(async e =>
{
User user = e.Server.GetUser(DiscordUtils.ParseMention(e.GetArg("userMention")).First());
if (user == null)
{
await e.Channel.SendMessage($"User not found.");
return;
}
string userName = user.Name; // in case user is disposed right after we kick them.
await user.Kick();
await e.Channel.SendMessage($"Kicked {userName}.");
});
group.CreateCommand("ban")
.Description("Bans an @user. Also allows for message pruning for a given amount of days.")
.AddCheck((cmd, usr, chnl) => chnl.Server.CurrentUser.ServerPermissions.BanMembers)
.Parameter("userMention")
.Parameter("pruneDays", ParameterType.Optional)
.Do(async e =>
{
User user = e.Server.GetUser(DiscordUtils.ParseMention(e.GetArg("userMention")).First());
int pruneDays = 0;
string pruneRaw = e.GetArg("pruneDays");
if (!string.IsNullOrEmpty(pruneRaw))
{
pruneDays = int.Parse(pruneRaw);
}
if (user == null)
{
await e.Channel.SendMessage($"User not found.");
return;
}
string userName = user.Name; // in case user is disposed right after we kick them.
await e.Server.Ban(user, pruneDays);
await e.Channel.SendMessage($"Banned {userName}");
});
});
}
public static Task EditRole(this DiscordClient client, Role role, string name = null, ServerPermissions permissions = null, Color color = null, bool? isHoisted = null, int? position = null)
{
if (role == null) throw new ArgumentNullException(nameof(role));
return role.Edit(name, permissions, color, isHoisted, position);
}
public static Task<Role> CreateRole(this DiscordClient client, Server server, string name, ServerPermissions permissions = null, Color color = null, bool isHoisted = false)
{
if (server == null) throw new ArgumentNullException(nameof(server));
return server.CreateRole(name, permissions, color);
}
public static Task EditRole(this DiscordClient client, Role role, string name = null, ServerPermissions permissions = null, Color color = null, bool?isHoisted = null, int?position = null)
{
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
return(role.Edit(name, permissions, color, isHoisted, position));
}
public static Task <Role> CreateRole(this DiscordClient client, Server server, string name, ServerPermissions permissions = null, Color color = null, bool isHoisted = false)
{
if (server == null)
{
throw new ArgumentNullException(nameof(server));
}
return(server.CreateRole(name, permissions, color));
}
private async Task Init()
{
Logger.Writeline("Initializing Stormbot v2");
Logger.Writeline("Installing services... ");
Client.AddService(new HttpService());
Client.AddService(new ModuleService());
DataIoService io = Client.AddService(new DataIoService());
Client.AddService(new PastebinService());
Client.UsingCommands(cmd =>
{
cmd.AllowMentionPrefix = true;
cmd.ErrorHandler += async(s, e) =>
{
switch (e.ErrorType)
{
case CommandErrorType.Exception:
await
e.Channel.SendMessage(
$"{e.User.Mention} Something went wrong while processing your command! Make sure your input is in the valid format. `({e.Exception.GetType().Name})`");
Logger.FormattedWrite("CommandService", $"Exception on command: {e.Exception}",
ConsoleColor.Yellow);
break;
case CommandErrorType.UnknownCommand:
await e.Channel.SendMessage($"{e.User.Mention} that command does not exist.");
break;
case CommandErrorType.BadPermissions:
StringBuilder builder =
new StringBuilder(
$"{e.User.Mention} you do not have sufficient permissions for that command. ");
if (!string.IsNullOrEmpty(e.Exception?.Message))
{
builder.AppendLine($"Error message: ```{e.Exception.Message}```");
}
await e.Channel.SendMessage(builder.ToString());
break;
case CommandErrorType.BadArgCount:
await
e.Channel.SendMessage(
$"{e.User.Mention} bad argument count.");
break;
case CommandErrorType.InvalidInput:
await e.Channel.SendMessage($"{e.User.Mention} invalid command input.");
break;
default:
Logger.FormattedWrite("CommandService", $"e.ErrorType ({e.ErrorType}) is not handled.",
ConsoleColor.Yellow);
break;
}
};
cmd.PrefixChar = '}';
cmd.HelpMode = HelpMode.Public;
});
Client.UsingAudio(audio =>
{
audio.EnableMultiserver = true;
audio.Mode = AudioMode.Outgoing;
audio.Channels = 2;
audio.EnableEncryption = true;
});
Client.UsingPermissionLevels((u, c) =>
{
if (u.Id == Constants.UserOwner)
{
return((int)PermissionLevel.BotOwner);
}
if (u.Server != null)
{
if (Equals(u, c.Server.Owner))
{
return((int)PermissionLevel.ServerOwner);
}
ServerPermissions serverPerms = u.ServerPermissions;
if (serverPerms.ManageRoles)
{
return((int)PermissionLevel.ServerAdmin);
}
if (serverPerms.ManageMessages && serverPerms.KickMembers && serverPerms.BanMembers)
{
return((int)PermissionLevel.ServerModerator);
}
ChannelPermissions channelPerms = u.GetPermissions(c);
if (channelPerms.ManagePermissions)
{
return((int)PermissionLevel.ChannelAdmin);
}
if (channelPerms.ManageMessages)
{
return((int)PermissionLevel.ChannelModerator);
}
}
return((int)PermissionLevel.User);
});
Client.UsingDynamicPerms();
Logger.Writeline("Connecting to Discord... ");
await Client.Connect(_email, _password);
Logger.Writeline("Installing modules... ");
Client.AddModule <BotManagementModule>("Bot", ModuleFilter.ServerWhitelist | ModuleFilter.ChannelWhitelist | ModuleFilter.AlwaysAllowPrivate);
Client.AddModule <ServerManagementModule>("Server Management", ModuleFilter.ServerWhitelist | ModuleFilter.ChannelWhitelist);
Client.AddModule <AudioStreamModule>("Audio", ModuleFilter.ServerWhitelist | ModuleFilter.ChannelWhitelist);
Client.AddModule <QualityOfLifeModule>("QoL", ModuleFilter.ServerWhitelist | ModuleFilter.ChannelWhitelist);
Client.AddModule <TestModule>("Test", ModuleFilter.ServerWhitelist | ModuleFilter.ChannelWhitelist);
Client.AddModule <InfoModule>("Information", ModuleFilter.ServerWhitelist | ModuleFilter.ChannelWhitelist | ModuleFilter.AlwaysAllowPrivate);
Client.AddModule <ModulesModule>("Modules");
Client.AddModule <ExecuteModule>("Execute", ModuleFilter.AlwaysAllowPrivate);
Client.AddModule <TerrariaRelayModule>("Terraria Relay", ModuleFilter.ChannelWhitelist | ModuleFilter.ServerWhitelist);
Client.AddModule <TwitchRelayModule>("Twitch Relay", ModuleFilter.ChannelWhitelist | ModuleFilter.ServerWhitelist);
Client.AddModule <TwitchEmoteModule>("Twitch Emotes", ModuleFilter.ServerWhitelist | ModuleFilter.ChannelWhitelist);
Client.AddModule <AnnouncementModule>("Announcements", ModuleFilter.ServerWhitelist);
Client.AddModule <VermintideModule>("Vermintide", ModuleFilter.ServerWhitelist | ModuleFilter.ChannelWhitelist | ModuleFilter.AlwaysAllowPrivate);
Client.AddModule <PersonalModule>("Personal", ModuleFilter.ServerWhitelist);
#if RELEASE
await DiscordUtils.GenerateCommandMarkdown(Client);
#endif
Client.Log.Message += (sender, args) =>
{
if (_ignoredLogs.Contains(args.Severity))
{
return;
}
Logger.FormattedWrite($"{args.Severity} {args.Source}", $"{args.Message}", _colorMap[args.Severity]);
if (args.Exception != null)
{
Logger.Write($"Exception: {args.Exception}");
}
};
Logger.Writeline("Loading data... ");
io.Load();
Client.SetGame("}help for commands");
Config.Owner = Client.GetUser(Constants.UserOwner);
Logger.Writeline($" -WE ARE LIVE-{Environment.NewLine}");
}
