Emotions-stuff/SupportChild
1
0
Fork 0
Code Issues Pull requests Projects Releases 3 Packages Wiki Activity

working?

Browse source
This commit is contained in:
EmotionChild 2022-05-19 23:38:59 +12:00
parent c9180130f9
commit b565047517
28 changed files with 1634 additions and 1635 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
.github/dependabot.yml vendored
View file

@ -1,4 +1,4 @@
# To get started with Dependabot version updates, you'll need to specify which # To get started with Dependabot version updates, you'll need to specify which
# package ecosystems to update and where the package manifests are located. # package ecosystems to update and where the package manifests are located.
# Please see the documentation for all configuration options: # Please see the documentation for all configuration options:
# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates # https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
@ -12,7 +12,7 @@ updates:
open-pull-requests-limit: 5 open-pull-requests-limit: 5
reviewers: reviewers:
- EmotionChild - EmotionChild
target-branch: "main" target-branch: "development"
labels: labels:
- "nuget" - "nuget"
- "dependencies" - "dependencies"

24
.github/workflows/dotnet.yml vendored
View file

@ -1,4 +1,4 @@
name: .NET name: .NET
on: on:
push: push:
@ -12,14 +12,14 @@ jobs:
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v3
- name: Setup .NET - name: Setup .NET
uses: actions/setup-dotnet@v2 uses: actions/setup-dotnet@v2
with: with:
dotnet-version: 6.0.x dotnet-version: 6.0.x
- name: Restore dependencies - name: Restore dependencies
run: dotnet restore run: dotnet restore
- name: Build - name: Build
run: dotnet build --no-restore run: dotnet build --no-restore
- name: Test - name: Test
run: dotnet test --no-build --verbosity normal run: dotnet test --no-build --verbosity normal

7
SupportChild/Commands/AddMessageCommand.cs
View file

@ -39,7 +39,7 @@ namespace SupportChild.Commands
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
if (Database.TryGetMessage(identifier.ToLower(), out Database.Message _)) if (Database.TryGetMessage(identifier.ToLower(), out Database.Message _))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
@ -51,7 +51,7 @@ namespace SupportChild.Commands
return; return;
} }
if (Database.AddMessage(identifier, command.Member.Id, message)) if(Database.AddMessage(identifier, command.Member.Id, message))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
@ -71,7 +71,6 @@ namespace SupportChild.Commands
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
} }
} }
} }

156
SupportChild/Commands/AddStaffCommand.cs
View file

@ -9,88 +9,88 @@ using MySql.Data.MySqlClient;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class AddStaffCommand : BaseCommandModule public class AddStaffCommand : BaseCommandModule
{ {
[Command("addstaff")] [Command("addstaff")]
[Cooldown(1, 5, CooldownBucketType.User)] [Cooldown(1, 5, CooldownBucketType.User)]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "addstaff")) if (!Config.HasPermission(command.Member, "addstaff"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the addstaff command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the addstaff command but did not have permission.");
return; return;
} }
ulong userID; ulong userID;
string[] parsedArgs = Utilities.ParseIDs(commandArgs); string[] parsedArgs = Utilities.ParseIDs(commandArgs);
if (!parsedArgs.Any()) if (!parsedArgs.Any())
{ {
userID = command.Member.Id; userID = command.Member.Id;
} }
else if (!ulong.TryParse(parsedArgs[0], out userID)) else if (!ulong.TryParse(parsedArgs[0], out userID))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Invalid ID/Mention. (Could not convert to numerical)" Description = "Invalid ID/Mention. (Could not convert to numerical)"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
DiscordMember member; DiscordMember member;
try try
{ {
member = await command.Guild.GetMemberAsync(userID); member = await command.Guild.GetMemberAsync(userID);
} }
catch (Exception) catch (Exception)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Invalid ID/Mention. (Could not find user on this server)" Description = "Invalid ID/Mention. (Could not find user on this server)"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
using (MySqlConnection c = Database.GetConnection()) using (MySqlConnection c = Database.GetConnection())
{ {
MySqlCommand cmd = Database.IsStaff(userID) ? new MySqlCommand(@"UPDATE staff SET name = @name WHERE user_id = @user_id", c) : new MySqlCommand(@"INSERT INTO staff (user_id, name) VALUES (@user_id, @name);", c); MySqlCommand cmd = Database.IsStaff(userID) ? new MySqlCommand(@"UPDATE staff SET name = @name WHERE user_id = @user_id", c) : new MySqlCommand(@"INSERT INTO staff (user_id, name) VALUES (@user_id, @name);", c);
c.Open(); c.Open();
cmd.Parameters.AddWithValue("@user_id", userID); cmd.Parameters.AddWithValue("@user_id", userID);
cmd.Parameters.AddWithValue("@name", member.DisplayName); cmd.Parameters.AddWithValue("@name", member.DisplayName);
cmd.ExecuteNonQuery(); cmd.ExecuteNonQuery();
cmd.Dispose(); cmd.Dispose();
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = member.Mention + " was added to staff." Description = member.Mention + " was added to staff."
}; };
await command.RespondAsync(message); await command.RespondAsync(message);
// Log it if the log channel exists // Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel); DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null) if (logChannel != null)
{ {
DiscordEmbed logMessage = new DiscordEmbedBuilder DiscordEmbed logMessage = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = member.Mention + " was added to staff.\n", Description = member.Mention + " was added to staff.\n",
}; };
await logChannel.SendMessageAsync(logMessage); await logChannel.SendMessageAsync(logMessage);
} }
} }
} }
} }
} }

228
SupportChild/Commands/AssignCommand.cs
View file

@ -8,128 +8,128 @@ using Microsoft.Extensions.Logging;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class AssignCommand : BaseCommandModule public class AssignCommand : BaseCommandModule
{ {
[Command("assign")] [Command("assign")]
[Description("Assigns a staff member to a ticket.")] [Description("Assigns a staff member to a ticket.")]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "assign")) if (!Config.HasPermission(command.Member, "assign"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the assign command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the assign command but did not have permission.");
return; return;
} }
// Check if ticket exists in the database // Check if ticket exists in the database
if (!Database.TryGetOpenTicket(command.Channel.Id, out Database.Ticket ticket)) if (!Database.TryGetOpenTicket(command.Channel.Id, out Database.Ticket ticket))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "This channel is not a ticket." Description = "This channel is not a ticket."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
ulong staffID; ulong staffID;
string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString); string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString);
if (!parsedMessage.Any()) if (!parsedMessage.Any())
{ {
staffID = command.Member.Id; staffID = command.Member.Id;
} }
else if (!ulong.TryParse(parsedMessage[0], out staffID)) else if (!ulong.TryParse(parsedMessage[0], out staffID))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Invalid ID/Mention. (Could not convert to numerical)" Description = "Invalid ID/Mention. (Could not convert to numerical)"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
DiscordMember staffMember = null; DiscordMember staffMember = null;
try try
{ {
staffMember = await command.Guild.GetMemberAsync(staffID); staffMember = await command.Guild.GetMemberAsync(staffID);
} }
catch (NotFoundException) { } catch (NotFoundException) { }
if (staffMember == null) if (staffMember == null)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: Could not find user." Description = "Error: Could not find user."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
if (!Database.IsStaff(staffMember.Id)) if (!Database.IsStaff(staffMember.Id))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: User is not registered as staff." Description = "Error: User is not registered as staff."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
if (!Database.AssignStaff(ticket, staffID)) if (!Database.AssignStaff(ticket, staffID))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: Failed to assign " + staffMember.Mention + " to ticket." Description = "Error: Failed to assign " + staffMember.Mention + " to ticket."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
DiscordEmbed feedback = new DiscordEmbedBuilder DiscordEmbed feedback = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Assigned " + staffMember.Mention + " to ticket." Description = "Assigned " + staffMember.Mention + " to ticket."
}; };
await command.RespondAsync(feedback); await command.RespondAsync(feedback);
if (Config.assignmentNotifications) if (Config.assignmentNotifications)
{ {
try try
{ {
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "You have been assigned to a support ticket: " + command.Channel.Mention Description = "You have been assigned to a support ticket: " + command.Channel.Mention
}; };
await staffMember.SendMessageAsync(message); await staffMember.SendMessageAsync(message);
} }
catch (UnauthorizedException) { } catch (UnauthorizedException) {}
} }
// Log it if the log channel exists // Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel); DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null) if (logChannel != null)
{ {
DiscordEmbed logMessage = new DiscordEmbedBuilder DiscordEmbed logMessage = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = staffMember.Mention + " was assigned to " + command.Channel.Mention + " by " + command.Member.Mention + "." Description = staffMember.Mention + " was assigned to " + command.Channel.Mention + " by " + command.Member.Mention + "."
}; };
await logChannel.SendMessageAsync(logMessage); await logChannel.SendMessageAsync(logMessage);
} }
} }
} }
} }

168
SupportChild/Commands/BlacklistCommand.cs
View file

@ -8,92 +8,92 @@ using Microsoft.Extensions.Logging;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class BlacklistCommand : BaseCommandModule public class BlacklistCommand : BaseCommandModule
{ {
[Command("blacklist")] [Command("blacklist")]
[Description("Blacklists a user from opening tickets.")] [Description("Blacklists a user from opening tickets.")]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "blacklist")) if (!Config.HasPermission(command.Member, "blacklist"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the blacklist command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the blacklist command but did not have permission.");
return; return;
} }
string[] parsedArgs = Utilities.ParseIDs(command.RawArgumentString); string[] parsedArgs = Utilities.ParseIDs(command.RawArgumentString);
foreach (string parsedArg in parsedArgs) foreach (string parsedArg in parsedArgs)
{ {
if (ulong.TryParse(parsedArg, out ulong userId)) if (ulong.TryParse(parsedArg, out ulong userId))
{ {
DiscordUser blacklistedUser = null; DiscordUser blacklistedUser = null;
try try
{ {
blacklistedUser = await command.Client.GetUserAsync(userId); blacklistedUser = await command.Client.GetUserAsync(userId);
} }
catch (NotFoundException) { } catch (NotFoundException) { }
if (blacklistedUser == null) if (blacklistedUser == null)
{ {
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: Could not find user." Description = "Error: Could not find user."
}; };
await command.RespondAsync(message); await command.RespondAsync(message);
continue; continue;
} }
try try
{ {
if (!Database.Blacklist(blacklistedUser.Id, command.User.Id)) if (!Database.Blacklist(blacklistedUser.Id, command.User.Id))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = blacklistedUser.Mention + " is already blacklisted." Description = blacklistedUser.Mention + " is already blacklisted."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
continue; continue;
} }
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Blacklisted " + blacklistedUser.Mention + "." Description = "Blacklisted " + blacklistedUser.Mention + "."
}; };
await command.RespondAsync(message); await command.RespondAsync(message);
// Log it if the log channel exists // Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel); DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null) if (logChannel != null)
{ {
DiscordEmbed logMessage = new DiscordEmbedBuilder DiscordEmbed logMessage = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = blacklistedUser.Mention + " was blacklisted from opening tickets by " + command.Member.Mention + "." Description = blacklistedUser.Mention + " was blacklisted from opening tickets by " + command.Member.Mention + "."
}; };
await logChannel.SendMessageAsync(logMessage); await logChannel.SendMessageAsync(logMessage);
} }
} }
catch (Exception) catch (Exception)
{ {
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error occured while blacklisting " + blacklistedUser.Mention + "." Description = "Error occured while blacklisting " + blacklistedUser.Mention + "."
}; };
await command.RespondAsync(message); await command.RespondAsync(message);
throw; throw;
} }
} }
} }
} }
} }
} }

186
SupportChild/Commands/CloseCommand.cs
View file

@ -10,109 +10,109 @@ using Microsoft.Extensions.Logging;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class CloseCommand : BaseCommandModule public class CloseCommand : BaseCommandModule
{ {
[Command("close")] [Command("close")]
[Cooldown(1, 5, CooldownBucketType.User)] [Cooldown(1, 5, CooldownBucketType.User)]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "close")) if (!Config.HasPermission(command.Member, "close"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the close command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the close command but did not have permission.");
return; return;
} }
ulong channelID = command.Channel.Id; ulong channelID = command.Channel.Id;
string channelName = command.Channel.Name; string channelName = command.Channel.Name;
// Check if ticket exists in the database // Check if ticket exists in the database
if (!Database.TryGetOpenTicket(channelID, out Database.Ticket ticket)) if (!Database.TryGetOpenTicket(channelID, out Database.Ticket ticket))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "This channel is not a ticket." Description = "This channel is not a ticket."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
// Build transcript // Build transcript
try try
{ {
await Transcriber.ExecuteAsync(command.Channel.Id, ticket.id); await Transcriber.ExecuteAsync(command.Channel.Id, ticket.id);
} }
catch (Exception) catch (Exception)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "ERROR: Could not save transcript file. Aborting..." Description = "ERROR: Could not save transcript file. Aborting..."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
throw; throw;
} }
// Log it if the log channel exists // Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel); DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null) if (logChannel != null)
{ {
DiscordEmbed embed = new DiscordEmbedBuilder DiscordEmbed embed = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Ticket " + ticket.id.ToString("00000") + " closed by " + command.Member.Mention + ".\n", Description = "Ticket " + ticket.id.ToString("00000") + " closed by " + command.Member.Mention + ".\n",
Footer = new DiscordEmbedBuilder.EmbedFooter { Text = '#' + channelName } Footer = new DiscordEmbedBuilder.EmbedFooter { Text = '#' + channelName }
}; };
using (FileStream file = new FileStream(Transcriber.GetPath(ticket.id), FileMode.Open, FileAccess.Read)) using (FileStream file = new FileStream(Transcriber.GetPath(ticket.id), FileMode.Open, FileAccess.Read))
{ {
DiscordMessageBuilder message = new DiscordMessageBuilder(); DiscordMessageBuilder message = new DiscordMessageBuilder();
message.WithEmbed(embed); message.WithEmbed(embed);
message.WithFiles(new Dictionary<string, Stream>() { { Transcriber.GetFilename(ticket.id), file } }); message.WithFiles(new Dictionary<string, Stream>() { { Transcriber.GetFilename(ticket.id), file } });
await logChannel.SendMessageAsync(message); await logChannel.SendMessageAsync(message);
} }
} }
if (Config.closingNotifications) if (Config.closingNotifications)
{ {
DiscordEmbed embed = new DiscordEmbedBuilder DiscordEmbed embed = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Ticket " + ticket.id.ToString("00000") + " which you opened has now been closed, check the transcript for more info.\n", Description = "Ticket " + ticket.id.ToString("00000") + " which you opened has now been closed, check the transcript for more info.\n",
Footer = new DiscordEmbedBuilder.EmbedFooter { Text = '#' + channelName } Footer = new DiscordEmbedBuilder.EmbedFooter { Text = '#' + channelName }
}; };
try try
{ {
DiscordMember staffMember = await command.Guild.GetMemberAsync(ticket.creatorID); DiscordMember staffMember = await command.Guild.GetMemberAsync(ticket.creatorID);
using (FileStream file = new FileStream(Transcriber.GetPath(ticket.id), FileMode.Open, FileAccess.Read)) using (FileStream file = new FileStream(Transcriber.GetPath(ticket.id), FileMode.Open, FileAccess.Read))
{ {
DiscordMessageBuilder message = new DiscordMessageBuilder(); DiscordMessageBuilder message = new DiscordMessageBuilder();
message.WithEmbed(embed); message.WithEmbed(embed);
message.WithFiles(new Dictionary<string, Stream>() { { Transcriber.GetFilename(ticket.id), file } }); message.WithFiles(new Dictionary<string, Stream>() { { Transcriber.GetFilename(ticket.id), file } });
await staffMember.SendMessageAsync(message); await staffMember.SendMessageAsync(message);
} }
} }
catch (NotFoundException) { } catch (NotFoundException) { }
catch (UnauthorizedException) { } catch (UnauthorizedException) { }
} }
Database.ArchiveTicket(ticket); Database.ArchiveTicket(ticket);
// Delete the channel and database entry // Delete the channel and database entry
await command.Channel.DeleteAsync("Ticket closed."); await command.Channel.DeleteAsync("Ticket closed.");
Database.DeleteOpenTicket(ticket.id); Database.DeleteOpenTicket(ticket.id);
} }
} }
} }

120
SupportChild/Commands/ListAssignedCommand.cs
View file

@ -8,69 +8,69 @@ using Microsoft.Extensions.Logging;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class ListAssignedCommand : BaseCommandModule public class ListAssignedCommand : BaseCommandModule
{ {
[Command("listassigned")] [Command("listassigned")]
[Aliases("la")] [Aliases("la")]
[Cooldown(1, 5, CooldownBucketType.User)] [Cooldown(1, 5, CooldownBucketType.User)]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "listassigned")) if (!Config.HasPermission(command.Member, "listassigned"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the listassigned command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the listassigned command but did not have permission.");
return; return;
} }
ulong staffID; ulong staffID;
string[] parsedIDs = Utilities.ParseIDs(command.RawArgumentString); string[] parsedIDs = Utilities.ParseIDs(command.RawArgumentString);
if (!parsedIDs.Any()) if (!parsedIDs.Any())
{ {
staffID = command.Member.Id; staffID = command.Member.Id;
} }
else if (!ulong.TryParse(parsedIDs[0], out staffID)) else if (!ulong.TryParse(parsedIDs[0], out staffID))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Invalid ID/Mention. (Could not convert to numerical)" Description = "Invalid ID/Mention. (Could not convert to numerical)"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
if (!Database.TryGetAssignedTickets(staffID, out List<Database.Ticket> assignedTickets)) if (!Database.TryGetAssignedTickets(staffID, out List<Database.Ticket> assignedTickets))
{ {
DiscordEmbed error = new DiscordEmbedBuilder() DiscordEmbed error = new DiscordEmbedBuilder()
.WithColor(DiscordColor.Red) .WithColor(DiscordColor.Red)
.WithDescription("User does not have any assigned tickets."); .WithDescription("User does not have any assigned tickets.");
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
List<string> listItems = new List<string>(); List<string> listItems = new List<string>();
foreach (Database.Ticket ticket in assignedTickets) foreach (Database.Ticket ticket in assignedTickets)
{ {
listItems.Add("**" + ticket.FormattedCreatedTime() + ":** <#" + ticket.channelID + "> by <@" + ticket.creatorID + ">\n"); listItems.Add("**" + ticket.FormattedCreatedTime() + ":** <#" + ticket.channelID + "> by <@" + ticket.creatorID + ">\n");
} }
LinkedList<string> messages = Utilities.ParseListIntoMessages(listItems); LinkedList<string> messages = Utilities.ParseListIntoMessages(listItems);
foreach (string message in messages) foreach (string message in messages)
{ {
DiscordEmbed channelInfo = new DiscordEmbedBuilder() DiscordEmbed channelInfo = new DiscordEmbedBuilder()
.WithTitle("Assigned tickets: ") .WithTitle("Assigned tickets: ")
.WithColor(DiscordColor.Green) .WithColor(DiscordColor.Green)
.WithDescription(message); .WithDescription(message);
await command.RespondAsync(channelInfo); await command.RespondAsync(channelInfo);
} }
} }
} }
} }

170
SupportChild/Commands/ListCommand.cs
View file

@ -8,94 +8,94 @@ using Microsoft.Extensions.Logging;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class ListCommand : BaseCommandModule public class ListCommand : BaseCommandModule
{ {
[Command("list")] [Command("list")]
[Cooldown(1, 5, CooldownBucketType.User)] [Cooldown(1, 5, CooldownBucketType.User)]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "list")) if (!Config.HasPermission(command.Member, "list"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the list command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the list command but did not have permission.");
return; return;
} }
ulong userID; ulong userID;
string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString); string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString);
if (!parsedMessage.Any()) if (!parsedMessage.Any())
{ {
userID = command.Member.Id; userID = command.Member.Id;
} }
else if (!ulong.TryParse(parsedMessage[0], out userID)) else if (!ulong.TryParse(parsedMessage[0], out userID))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Invalid ID/Mention. (Could not convert to numerical)" Description = "Invalid ID/Mention. (Could not convert to numerical)"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
if (Database.TryGetOpenTickets(userID, out List<Database.Ticket> openTickets)) if (Database.TryGetOpenTickets(userID, out List<Database.Ticket> openTickets))
{ {
List<string> listItems = new List<string>(); List<string> listItems = new List<string>();
foreach (Database.Ticket ticket in openTickets) foreach (Database.Ticket ticket in openTickets)
{ {
listItems.Add("**" + ticket.FormattedCreatedTime() + ":** <#" + ticket.channelID + ">\n"); listItems.Add("**" + ticket.FormattedCreatedTime() + ":** <#" + ticket.channelID + ">\n");
} }
LinkedList<string> messages = Utilities.ParseListIntoMessages(listItems); LinkedList<string> messages = Utilities.ParseListIntoMessages(listItems);
foreach (string message in messages) foreach (string message in messages)
{ {
DiscordEmbed channelInfo = new DiscordEmbedBuilder() DiscordEmbed channelInfo = new DiscordEmbedBuilder()
.WithTitle("Open tickets: ") .WithTitle("Open tickets: ")
.WithColor(DiscordColor.Green) .WithColor(DiscordColor.Green)
.WithDescription(message); .WithDescription(message);
await command.RespondAsync(channelInfo); await command.RespondAsync(channelInfo);
} }
} }
else else
{ {
DiscordEmbed channelInfo = new DiscordEmbedBuilder() DiscordEmbed channelInfo = new DiscordEmbedBuilder()
.WithColor(DiscordColor.Green) .WithColor(DiscordColor.Green)
.WithDescription("User does not have any open tickets."); .WithDescription("User does not have any open tickets.");
await command.RespondAsync(channelInfo); await command.RespondAsync(channelInfo);
} }
if (Database.TryGetClosedTickets(userID, out List<Database.Ticket> closedTickets)) if (Database.TryGetClosedTickets(userID, out List<Database.Ticket> closedTickets))
{ {
List<string> listItems = new List<string>(); List<string> listItems = new List<string>();
foreach (Database.Ticket ticket in closedTickets) foreach (Database.Ticket ticket in closedTickets)
{ {
listItems.Add("**" + ticket.FormattedCreatedTime() + ":** Ticket " + ticket.id.ToString("00000") + "\n"); listItems.Add("**" + ticket.FormattedCreatedTime() + ":** Ticket " + ticket.id.ToString("00000") + "\n");
} }
LinkedList<string> messages = Utilities.ParseListIntoMessages(listItems); LinkedList<string> messages = Utilities.ParseListIntoMessages(listItems);
foreach (string message in messages) foreach (string message in messages)
{ {
DiscordEmbed channelInfo = new DiscordEmbedBuilder() DiscordEmbed channelInfo = new DiscordEmbedBuilder()
.WithTitle("Closed tickets: ") .WithTitle("Closed tickets: ")
.WithColor(DiscordColor.Red) .WithColor(DiscordColor.Red)
.WithDescription(message); .WithDescription(message);
await command.RespondAsync(channelInfo); await command.RespondAsync(channelInfo);
} }
} }
else else
{ {
DiscordEmbed channelInfo = new DiscordEmbedBuilder() DiscordEmbed channelInfo = new DiscordEmbedBuilder()
.WithColor(DiscordColor.Red) .WithColor(DiscordColor.Red)
.WithDescription("User does not have any closed tickets."); .WithDescription("User does not have any closed tickets.");
await command.RespondAsync(channelInfo); await command.RespondAsync(channelInfo);
} }
} }
} }
} }

116
SupportChild/Commands/ListOldestCommand.cs
View file

@ -7,65 +7,65 @@ using Microsoft.Extensions.Logging;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class ListOldestCommand : BaseCommandModule public class ListOldestCommand : BaseCommandModule
{ {
[Command("listoldest")] [Command("listoldest")]
[Aliases("lo")] [Aliases("lo")]
[Cooldown(1, 5, CooldownBucketType.User)] [Cooldown(1, 5, CooldownBucketType.User)]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "listoldest")) if (!Config.HasPermission(command.Member, "listoldest"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the listoldest command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the listoldest command but did not have permission.");
return; return;
} }
int listLimit = 20; int listLimit = 20;
if (!string.IsNullOrEmpty(command.RawArgumentString?.Trim() ?? "")) if (!string.IsNullOrEmpty(command.RawArgumentString?.Trim() ?? ""))
{ {
if (!int.TryParse(command.RawArgumentString?.Trim(), out listLimit) || listLimit < 5 || listLimit > 100) if (!int.TryParse(command.RawArgumentString?.Trim(), out listLimit) || listLimit < 5 || listLimit > 100)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Invalid list amount. (Must be an integer between 5 and 100)" Description = "Invalid list amount. (Must be integer between 5 and 100)"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
} }
if (!Database.TryGetOldestTickets(command.Member.Id, out List<Database.Ticket> openTickets, listLimit)) if (!Database.TryGetOldestTickets(command.Member.Id, out List<Database.Ticket> openTickets, listLimit))
{ {
DiscordEmbed channelInfo = new DiscordEmbedBuilder() DiscordEmbed channelInfo = new DiscordEmbedBuilder()
.WithColor(DiscordColor.Red) .WithColor(DiscordColor.Red)
.WithDescription("Could not fetch any open tickets."); .WithDescription("Could not fetch any open tickets.");
await command.RespondAsync(channelInfo); await command.RespondAsync(channelInfo);
return; return;
} }
List<string> listItems = new List<string>(); List<string> listItems = new List<string>();
foreach (Database.Ticket ticket in openTickets) foreach (Database.Ticket ticket in openTickets)
{ {
listItems.Add("**" + ticket.FormattedCreatedTime() + ":** <#" + ticket.channelID + "> by <@" + ticket.creatorID + ">\n"); listItems.Add("**" + ticket.FormattedCreatedTime() + ":** <#" + ticket.channelID + "> by <@" + ticket.creatorID + ">\n");
} }
LinkedList<string> messages = Utilities.ParseListIntoMessages(listItems); LinkedList<string> messages = Utilities.ParseListIntoMessages(listItems);
foreach (string message in messages) foreach (string message in messages)
{ {
DiscordEmbed channelInfo = new DiscordEmbedBuilder() DiscordEmbed channelInfo = new DiscordEmbedBuilder()
.WithTitle("The " + openTickets.Count + " oldest open tickets: ") .WithTitle("The " + openTickets.Count + " oldest open tickets: ")
.WithColor(DiscordColor.Green) .WithColor(DiscordColor.Green)
.WithDescription(message?.Trim()); .WithDescription(message?.Trim());
await command.RespondAsync(channelInfo); await command.RespondAsync(channelInfo);
} }
} }
} }
} }

2
SupportChild/Commands/ListUnassignedCommand.cs
View file

@ -52,4 +52,4 @@ namespace SupportChild.Commands
} }
} }
} }
} }

170
SupportChild/Commands/MoveCommand.cs
View file

@ -10,95 +10,95 @@ using Microsoft.Extensions.Logging;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class MoveCommand : BaseCommandModule public class MoveCommand : BaseCommandModule
{ {
[Command("move")] [Command("move")]
[Description("Moves a ticket to another category.")] [Description("Moves a ticket to another category.")]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "move")) if (!Config.HasPermission(command.Member, "move"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the move command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the move command but did not have permission.");
return; return;
} }
// Check if ticket exists in the database // Check if ticket exists in the database
if (!Database.TryGetOpenTicket(command.Channel.Id, out Database.Ticket ticket)) if (!Database.TryGetOpenTicket(command.Channel.Id, out Database.Ticket ticket))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "This channel is not a ticket." Description = "This channel is not a ticket."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
if (string.IsNullOrEmpty(command.RawArgumentString)) if (string.IsNullOrEmpty(command.RawArgumentString))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: No category provided." Description = "Error: No category provided."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
IReadOnlyList<DiscordChannel> channels = await command.Guild.GetChannelsAsync(); IReadOnlyList<DiscordChannel> channels = await command.Guild.GetChannelsAsync();
IEnumerable<DiscordChannel> categories = channels.Where(x => x.IsCategory); IEnumerable<DiscordChannel> categories = channels.Where(x => x.IsCategory);
DiscordChannel category = categories.FirstOrDefault(x => x.Name.StartsWith(command.RawArgumentString.Trim(), StringComparison.OrdinalIgnoreCase)); DiscordChannel category = categories.FirstOrDefault(x => x.Name.StartsWith(command.RawArgumentString.Trim(), StringComparison.OrdinalIgnoreCase));
if (category == null) if (category == null)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: Could not find a category by that name." Description = "Error: Could not find a category by that name."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
if (command.Channel.Id == category.Id) if (command.Channel.Id == category.Id)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: The ticket is already in that category." Description = "Error: The ticket is already in that category."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
try try
{ {
await command.Channel.ModifyAsync(modifiedAttributes => modifiedAttributes.Parent = category); await command.Channel.ModifyAsync(modifiedAttributes => modifiedAttributes.Parent = category);
} }
catch (UnauthorizedException) catch (UnauthorizedException)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: Not authorized to move this ticket to that category." Description = "Error: Not authorized to move this ticket to that category."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
DiscordEmbed feedback = new DiscordEmbedBuilder DiscordEmbed feedback = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Ticket was moved to " + category.Mention Description = "Ticket was moved to " + category.Mention
}; };
await command.RespondAsync(feedback); await command.RespondAsync(feedback);
} }
} }
} }

250
SupportChild/Commands/NewCommand.cs
View file

@ -9,142 +9,142 @@ using Microsoft.Extensions.Logging;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class NewCommand : BaseCommandModule public class NewCommand : BaseCommandModule
{ {
[Command("new")] [Command("new")]
[Cooldown(1, 5, CooldownBucketType.User)] [Cooldown(1, 5, CooldownBucketType.User)]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "new")) if (!Config.HasPermission(command.Member, "new"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the new command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the new command but did not have permission.");
return; return;
} }
// Check if user is blacklisted // Check if user is blacklisted
if (Database.IsBlacklisted(command.User.Id)) if (Database.IsBlacklisted(command.User.Id))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You are banned from opening tickets." Description = "You are banned from opening tickets."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
if (Database.IsOpenTicket(command.Channel.Id)) if (Database.IsOpenTicket(command.Channel.Id))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You cannot use this command in a ticket channel." Description = "You cannot use this command in a ticket channel."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
DiscordChannel category = command.Guild.GetChannel(Config.ticketCategory); DiscordChannel category = command.Guild.GetChannel(Config.ticketCategory);
DiscordChannel ticketChannel; DiscordChannel ticketChannel;
try try
{ {
ticketChannel = await command.Guild.CreateChannelAsync("ticket", ChannelType.Text, category); ticketChannel = await command.Guild.CreateChannelAsync("ticket", ChannelType.Text, category);
} }
catch (Exception) catch (Exception)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error occured while creating ticket, " + command.Member.Mention + Description = "Error occured while creating ticket, " + command.Member.Mention +
"!\nIs the channel limit reached in the server or ticket category?" "!\nIs the channel limit reached in the server or ticket category?"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
if (ticketChannel == null) if (ticketChannel == null)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error occured while creating ticket, " + command.Member.Mention + Description = "Error occured while creating ticket, " + command.Member.Mention +
"!\nIs the channel limit reached in the server or ticket category?" "!\nIs the channel limit reached in the server or ticket category?"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
ulong staffID = 0; ulong staffID = 0;
if (Config.randomAssignment) if (Config.randomAssignment)
{ {
staffID = Database.GetRandomActiveStaff(0)?.userID ?? 0; staffID = Database.GetRandomActiveStaff(0)?.userID ?? 0;
} }
long id = Database.NewTicket(command.Member.Id, staffID, ticketChannel.Id); long id = Database.NewTicket(command.Member.Id, staffID, ticketChannel.Id);
string ticketID = id.ToString("00000"); string ticketID = id.ToString("00000");
await ticketChannel.ModifyAsync(modifiedAttributes => modifiedAttributes.Name = "ticket-" + ticketID); await ticketChannel.ModifyAsync(modifiedAttributes => modifiedAttributes.Name = "ticket-" + ticketID);
await ticketChannel.AddOverwriteAsync(command.Member, Permissions.AccessChannels, Permissions.None); await ticketChannel.AddOverwriteAsync(command.Member, Permissions.AccessChannels, Permissions.None);
await ticketChannel.SendMessageAsync("Hello, " + command.Member.Mention + "!\n" + Config.welcomeMessage); await ticketChannel.SendMessageAsync("Hello, " + command.Member.Mention + "!\n" + Config.welcomeMessage);
// Refreshes the channel as changes were made to it above // Refreshes the channel as changes were made to it above
ticketChannel = command.Guild.GetChannel(ticketChannel.Id); ticketChannel = command.Guild.GetChannel(ticketChannel.Id);
if (staffID != 0) if (staffID != 0)
{ {
DiscordEmbed assignmentMessage = new DiscordEmbedBuilder DiscordEmbed assignmentMessage = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Ticket was randomly assigned to <@" + staffID + ">." Description = "Ticket was randomly assigned to <@" + staffID + ">."
}; };
await ticketChannel.SendMessageAsync(assignmentMessage); await ticketChannel.SendMessageAsync(assignmentMessage);
if (Config.assignmentNotifications) if (Config.assignmentNotifications)
{ {
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "You have been randomly assigned to a newly opened support ticket: " + Description = "You have been randomly assigned to a newly opened support ticket: " +
ticketChannel.Mention ticketChannel.Mention
}; };
try try
{ {
DiscordMember staffMember = await command.Guild.GetMemberAsync(staffID); DiscordMember staffMember = await command.Guild.GetMemberAsync(staffID);
await staffMember.SendMessageAsync(message); await staffMember.SendMessageAsync(message);
} }
catch (NotFoundException) { } catch (NotFoundException) {}
catch (UnauthorizedException) { } catch (UnauthorizedException) {}
} }
} }
DiscordEmbed response = new DiscordEmbedBuilder DiscordEmbed response = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Ticket opened, " + command.Member.Mention + "!\n" + ticketChannel.Mention Description = "Ticket opened, " + command.Member.Mention + "!\n" + ticketChannel.Mention
}; };
await command.RespondAsync(response); await command.RespondAsync(response);
// Log it if the log channel exists // Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel); DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null) if (logChannel != null)
{ {
DiscordEmbed logMessage = new DiscordEmbedBuilder DiscordEmbed logMessage = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Ticket " + ticketChannel.Mention + " opened by " + command.Member.Mention + ".\n", Description = "Ticket " + ticketChannel.Mention + " opened by " + command.Member.Mention + ".\n",
Footer = new DiscordEmbedBuilder.EmbedFooter { Text = "Ticket " + ticketID } Footer = new DiscordEmbedBuilder.EmbedFooter {Text = "Ticket " + ticketID}
}; };
await logChannel.SendMessageAsync(logMessage); await logChannel.SendMessageAsync(logMessage);
} }
} }
} }
} }

312
SupportChild/Commands/RandomAssignCommand.cs
View file

@ -10,173 +10,173 @@ using Microsoft.Extensions.Logging;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class RandomAssignCommand : BaseCommandModule public class RandomAssignCommand : BaseCommandModule
{ {
[Command("rassign")] [Command("rassign")]
[Description("Randomly assigns a staff member to a ticket.")] [Description("Randomly assigns a staff member to a ticket.")]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArguments) public async Task OnExecute(CommandContext command, [RemainingText] string commandArguments)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "rassign")) if (!Config.HasPermission(command.Member, "rassign"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the rassign command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the rassign command but did not have permission.");
return; return;
} }
// Check if ticket exists in the database // Check if ticket exists in the database
if (!Database.TryGetOpenTicket(command.Channel.Id, out Database.Ticket ticket)) if (!Database.TryGetOpenTicket(command.Channel.Id, out Database.Ticket ticket))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "This channel is not a ticket." Description = "This channel is not a ticket."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
// Get a random staff member who is verified to have the correct role if applicable // Get a random staff member who is verified to have the correct role if applicable
DiscordMember staffMember = await GetRandomVerifiedStaffMember(command, ticket); DiscordMember staffMember = await GetRandomVerifiedStaffMember(command, ticket);
if (staffMember == null) if (staffMember == null)
{ {
return; return;
} }
// Attempt to assign the staff member to the ticket // Attempt to assign the staff member to the ticket
if (!Database.AssignStaff(ticket, staffMember.Id)) if (!Database.AssignStaff(ticket, staffMember.Id))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: Failed to assign " + staffMember.Mention + " to ticket." Description = "Error: Failed to assign " + staffMember.Mention + " to ticket."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
// Respond that the command was successful // Respond that the command was successful
DiscordEmbed feedback = new DiscordEmbedBuilder DiscordEmbed feedback = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Randomly assigned " + staffMember.Mention + " to ticket." Description = "Randomly assigned " + staffMember.Mention + " to ticket."
}; };
await command.RespondAsync(feedback); await command.RespondAsync(feedback);
// Send a notification to the staff member if applicable // Send a notification to the staff member if applicable
if (Config.assignmentNotifications) if (Config.assignmentNotifications)
{ {
try try
{ {
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "You have been randomly assigned to a support ticket: " + command.Channel.Mention Description = "You have been randomly assigned to a support ticket: " + command.Channel.Mention
}; };
await staffMember.SendMessageAsync(message); await staffMember.SendMessageAsync(message);
} }
catch (UnauthorizedException) { } catch (UnauthorizedException) {}
} }
// Log it if the log channel exists // Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel); DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null) if (logChannel != null)
{ {
DiscordEmbed logMessage = new DiscordEmbedBuilder DiscordEmbed logMessage = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = staffMember.Mention + " was assigned to " + command.Channel.Mention + " by " + command.Member.Mention + "." Description = staffMember.Mention + " was assigned to " + command.Channel.Mention + " by " + command.Member.Mention + "."
}; };
await logChannel.SendMessageAsync(logMessage); await logChannel.SendMessageAsync(logMessage);
} }
} }
private async Task<DiscordMember> GetRandomVerifiedStaffMember(CommandContext command, Database.Ticket ticket) private async Task<DiscordMember> GetRandomVerifiedStaffMember(CommandContext command, Database.Ticket ticket)
{ {
if (command.RawArguments.Any()) // An argument was provided, check if this can be parsed into a role if (command.RawArguments.Any()) // An argument was provided, check if this can be parsed into a role
{ {
ulong roleID = 0; ulong roleID = 0;
// Try to parse either discord mention or ID // Try to parse either discord mention or ID
string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString); string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString);
if (!ulong.TryParse(parsedMessage[0], out roleID)) if (!ulong.TryParse(parsedMessage[0], out roleID))
{ {
// Try to find role by name // Try to find role by name
roleID = Utilities.GetRoleByName(command.Guild, command.RawArgumentString)?.Id ?? 0; roleID = Utilities.GetRoleByName(command.Guild, command.RawArgumentString)?.Id ?? 0;
} }
// Check if a role was found // Check if a role was found
if (roleID == 0) if (roleID == 0)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Could not find a role by that name/ID." Description = "Could not find a role by that name/ID."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return null; return null;
} }
// Check if role rassign should override staff's active status // Check if role rassign should override staff's active status
List<Database.StaffMember> staffMembers = Config.randomAssignRoleOverride List<Database.StaffMember> staffMembers = Config.randomAssignRoleOverride
? Database.GetAllStaff(ticket.assignedStaffID) ? Database.GetAllStaff(ticket.assignedStaffID)
: Database.GetActiveStaff(ticket.assignedStaffID); : Database.GetActiveStaff(ticket.assignedStaffID);
// Randomize the list before checking for roles in order to reduce number of API calls // Randomize the list before checking for roles in order to reduce number of API calls
staffMembers = Utilities.RandomizeList(staffMembers); staffMembers = Utilities.RandomizeList(staffMembers);
// Get the first staff member that has the role // Get the first staff member that has the role
foreach (Database.StaffMember sm in staffMembers) foreach (Database.StaffMember sm in staffMembers)
{ {
try try
{ {
DiscordMember verifiedMember = await command.Guild.GetMemberAsync(sm.userID); DiscordMember verifiedMember = await command.Guild.GetMemberAsync(sm.userID);
if (verifiedMember?.Roles?.Any(role => role.Id == roleID) ?? false) if (verifiedMember?.Roles?.Any(role => role.Id == roleID) ?? false)
{ {
return verifiedMember; return verifiedMember;
} }
} }
catch (Exception e) catch (Exception e)
{ {
command.Client.Logger.Log(LogLevel.Information, e, "Error occured trying to find a staff member in the rassign command."); command.Client.Logger.Log(LogLevel.Information, e, "Error occured trying to find a staff member in the rassign command.");
} }
} }
} }
else // No role was specified, any active staff will be picked else // No role was specified, any active staff will be picked
{ {
Database.StaffMember staffEntry = Database.GetRandomActiveStaff(ticket.assignedStaffID); Database.StaffMember staffEntry = Database.GetRandomActiveStaff(ticket.assignedStaffID);
if (staffEntry == null) if (staffEntry == null)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: There are no other staff members to choose from." Description = "Error: There are no other staff members to choose from."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return null; return null;
} }
// Get the staff member from discord // Get the staff member from discord
try try
{ {
return await command.Guild.GetMemberAsync(staffEntry.userID); return await command.Guild.GetMemberAsync(staffEntry.userID);
} }
catch (NotFoundException) { } catch (NotFoundException) { }
} }
// Send a more generic error if we get to this point and still haven't found the staff member // Send a more generic error if we get to this point and still haven't found the staff member
DiscordEmbed err = new DiscordEmbedBuilder DiscordEmbed err = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: Could not find an applicable staff member." Description = "Error: Could not find an applicable staff member."
}; };
await command.RespondAsync(err); await command.RespondAsync(err);
return null; return null;
} }
} }
} }

2
SupportChild/Commands/ReloadCommand.cs
View file

@ -35,4 +35,4 @@ namespace SupportChild.Commands
SupportChild.instance.Reload(); SupportChild.instance.Reload();
} }
} }
} }

4
SupportChild/Commands/RemoveMessageCommand.cs
View file

@ -40,7 +40,7 @@ namespace SupportChild.Commands
return; return;
} }
if (Database.RemoveMessage(identifier)) if(Database.RemoveMessage(identifier))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
@ -63,4 +63,4 @@ namespace SupportChild.Commands
} }
} }
} }

172
SupportChild/Commands/RemoveStaffCommand.cs
View file

@ -9,96 +9,96 @@ using MySql.Data.MySqlClient;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class RemoveStaffCommand : BaseCommandModule public class RemoveStaffCommand : BaseCommandModule
{ {
[Command("removestaff")] [Command("removestaff")]
[Cooldown(1, 5, CooldownBucketType.User)] [Cooldown(1, 5, CooldownBucketType.User)]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "removestaff")) if (!Config.HasPermission(command.Member, "removestaff"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the removestaff command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the removestaff command but did not have permission.");
return; return;
} }
ulong userID; ulong userID;
string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString); string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString);
if (!parsedMessage.Any()) if (!parsedMessage.Any())
{ {
userID = command.Member.Id; userID = command.Member.Id;
} }
else if (!ulong.TryParse(parsedMessage[0], out userID)) else if (!ulong.TryParse(parsedMessage[0], out userID))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Invalid ID/Mention. (Could not convert to numerical)" Description = "Invalid ID/Mention. (Could not convert to numerical)"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
try try
{ {
await command.Client.GetUserAsync(userID); await command.Client.GetUserAsync(userID);
} }
catch (Exception) catch (Exception)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Invalid ID/Mention. (Could not find user on Discord)" Description = "Invalid ID/Mention. (Could not find user on Discord)"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
if (!Database.IsStaff(userID)) if (!Database.IsStaff(userID))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "User is already not registered as staff." Description = "User is already not registered as staff."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
using (MySqlConnection c = Database.GetConnection()) using (MySqlConnection c = Database.GetConnection())
{ {
c.Open(); c.Open();
MySqlCommand deletion = new MySqlCommand(@"DELETE FROM staff WHERE user_id=@user_id", c); MySqlCommand deletion = new MySqlCommand(@"DELETE FROM staff WHERE user_id=@user_id", c);
deletion.Parameters.AddWithValue("@user_id", userID); deletion.Parameters.AddWithValue("@user_id", userID);
deletion.Prepare(); deletion.Prepare();
deletion.ExecuteNonQuery(); deletion.ExecuteNonQuery();
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "User was removed from staff." Description = "User was removed from staff."
}; };
await command.RespondAsync(message); await command.RespondAsync(message);
// Log it if the log channel exists // Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel); DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null) if (logChannel != null)
{ {
DiscordEmbed logMessage = new DiscordEmbedBuilder DiscordEmbed logMessage = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "User was removed from staff.\n", Description = "User was removed from staff.\n",
}; };
await logChannel.SendMessageAsync(logMessage); await logChannel.SendMessageAsync(logMessage);
} }
} }
} }
} }
} }

158
SupportChild/Commands/SayCommand.cs
View file

@ -8,89 +8,89 @@ using System.Threading.Tasks;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class SayCommand : BaseCommandModule public class SayCommand : BaseCommandModule
{ {
[Command("say")] [Command("say")]
[Cooldown(1, 2, CooldownBucketType.Channel)] [Cooldown(1, 2, CooldownBucketType.Channel)]
[Description("Prints a message with information from staff.")] [Description("Prints a message with information from staff.")]
public async Task OnExecute(CommandContext command, string identifier) public async Task OnExecute(CommandContext command, string identifier)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "say")) if (!Config.HasPermission(command.Member, "say"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the say command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the say command but did not have permission.");
return; return;
} }
if (!Database.TryGetMessage(identifier.ToLower(), out Database.Message message)) if (!Database.TryGetMessage(identifier.ToLower(), out Database.Message message))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "There is no message with that identifier." Description = "There is no message with that identifier."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
DiscordEmbed reply = new DiscordEmbedBuilder DiscordEmbed reply = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = message.message Description = message.message
}; };
await command.RespondAsync(reply); await command.RespondAsync(reply);
} }
[Command("say")] [Command("say")]
[Cooldown(1, 2.0, CooldownBucketType.Channel)] [Cooldown(1, 2.0, CooldownBucketType.Channel)]
[Description("Prints a list of staff messages.")] [Description("Prints a list of staff messages.")]
public async Task OnExecute(CommandContext command) public async Task OnExecute(CommandContext command)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "say")) if (!Config.HasPermission(command.Member, "say"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the say command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the say command but did not have permission.");
return; return;
} }
List<Database.Message> messages = Database.GetAllMessages(); List<Database.Message> messages = Database.GetAllMessages();
if (!messages.Any()) if (!messages.Any())
{ {
DiscordEmbed error = new DiscordEmbedBuilder() DiscordEmbed error = new DiscordEmbedBuilder()
.WithColor(DiscordColor.Red) .WithColor(DiscordColor.Red)
.WithDescription("There are no messages registered."); .WithDescription("There are no messages registered.");
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
List<string> listItems = new List<string>(); List<string> listItems = new List<string>();
foreach (Database.Message message in messages) foreach (Database.Message message in messages)
{ {
listItems.Add("**" + message.identifier + "** Added by <@" + message.userID + ">\n"); listItems.Add("**" + message.identifier + "** Added by <@" + message.userID + ">\n");
} }
LinkedList<string> listMessages = Utilities.ParseListIntoMessages(listItems); LinkedList<string> listMessages = Utilities.ParseListIntoMessages(listItems);
foreach (string listMessage in listMessages) foreach (string listMessage in listMessages)
{ {
DiscordEmbed channelInfo = new DiscordEmbedBuilder() DiscordEmbed channelInfo = new DiscordEmbedBuilder()
.WithTitle("Available messages: ") .WithTitle("Available messages: ")
.WithColor(DiscordColor.Green) .WithColor(DiscordColor.Green)
.WithDescription(listMessage); .WithDescription(listMessage);
await command.RespondAsync(channelInfo); await command.RespondAsync(channelInfo);
} }
} }
} }
} }

2
SupportChild/Commands/SetSummaryCommand.cs
View file

@ -60,4 +60,4 @@ namespace SupportChild.Commands
} }
} }
} }
} }

162
SupportChild/Commands/SetTicketCommand.cs
View file

@ -8,91 +8,91 @@ using MySql.Data.MySqlClient;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class SetTicketCommand : BaseCommandModule public class SetTicketCommand :BaseCommandModule
{ {
[Command("setticket")] [Command("setticket")]
[Description("Turns a channel into a ticket, warning: this will let anyone with write access delete the channel using the close command.")] [Description("Turns a channel into a ticket, warning: this will let anyone with write access delete the channel using the close command.")]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
using (MySqlConnection c = Database.GetConnection()) using (MySqlConnection c = Database.GetConnection())
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "setticket")) if (!Config.HasPermission(command.Member, "setticket"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the setticket command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the setticket command but did not have permission.");
return; return;
} }
// Check if ticket exists in the database // Check if ticket exists in the database
if (Database.IsOpenTicket(command.Channel.Id)) if (Database.IsOpenTicket(command.Channel.Id))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "This channel is already a ticket." Description = "This channel is already a ticket."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
ulong userID; ulong userID;
string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString); string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString);
if (!parsedMessage.Any()) if (!parsedMessage.Any())
{ {
userID = command.Member.Id; userID = command.Member.Id;
} }
else if (!ulong.TryParse(parsedMessage[0], out userID)) else if (!ulong.TryParse(parsedMessage[0], out userID))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Invalid ID/Mention. (Could not convert to numerical)" Description = "Invalid ID/Mention. (Could not convert to numerical)"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
DiscordUser user = await command.Client.GetUserAsync(userID); DiscordUser user = await command.Client.GetUserAsync(userID);
if (user == null) if (user == null)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Invalid ID/Mention." Description = "Invalid ID/Mention."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
long id = Database.NewTicket(userID, 0, command.Channel.Id); long id = Database.NewTicket(userID, 0, command.Channel.Id);
string ticketID = id.ToString("00000"); string ticketID = id.ToString("00000");
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Channel has been designated ticket " + ticketID + "." Description = "Channel has been designated ticket " + ticketID + "."
}; };
await command.RespondAsync(message); await command.RespondAsync(message);
// Log it if the log channel exists // Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel); DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null) if (logChannel != null)
{ {
DiscordEmbed logMessage = new DiscordEmbedBuilder DiscordEmbed logMessage = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = command.Channel.Mention + " has been designated ticket " + ticketID + " by " + command.Member.Mention + "." Description = command.Channel.Mention + " has been designated ticket " + ticketID + " by " + command.Member.Mention + "."
}; };
await logChannel.SendMessageAsync(logMessage); await logChannel.SendMessageAsync(logMessage);
} }
} }
} }
} }
} }

2
SupportChild/Commands/StatusCommand.cs
View file

@ -38,4 +38,4 @@ namespace SupportChild.Commands
await command.RespondAsync(botInfo); await command.RespondAsync(botInfo);
} }
} }
} }

2
SupportChild/Commands/SummaryCommand.cs
View file

@ -48,4 +48,4 @@ namespace SupportChild.Commands
} }
} }
} }
} }

126
SupportChild/Commands/ToggleActiveCommand.cs
View file

@ -8,71 +8,71 @@ using MySql.Data.MySqlClient;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class ToggleActiveCommand : BaseCommandModule public class ToggleActiveCommand : BaseCommandModule
{ {
[Command("toggleactive")] [Command("toggleactive")]
[Aliases("ta")] [Aliases("ta")]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
using (MySqlConnection c = Database.GetConnection()) using (MySqlConnection c = Database.GetConnection())
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "toggleactive")) if (!Config.HasPermission(command.Member, "toggleactive"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the toggleactive command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the toggleactive command but did not have permission.");
return; return;
} }
ulong staffID; ulong staffID;
string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString); string[] parsedMessage = Utilities.ParseIDs(command.RawArgumentString);
if (!parsedMessage.Any()) if (!parsedMessage.Any())
{ {
staffID = command.Member.Id; staffID = command.Member.Id;
} }
else if (!ulong.TryParse(parsedMessage[0], out staffID)) else if (!ulong.TryParse(parsedMessage[0], out staffID))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Invalid ID/Mention. (Could not convert to numerical)" Description = "Invalid ID/Mention. (Could not convert to numerical)"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
// Check if ticket exists in the database // Check if ticket exists in the database
if (!Database.TryGetStaff(staffID, out Database.StaffMember staffMember)) if (!Database.TryGetStaff(staffID, out Database.StaffMember staffMember))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You have not been registered as staff." Description = "You have not been registered as staff."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
c.Open(); c.Open();
MySqlCommand update = new MySqlCommand(@"UPDATE staff SET active = @active WHERE user_id = @user_id", c); MySqlCommand update = new MySqlCommand(@"UPDATE staff SET active = @active WHERE user_id = @user_id", c);
update.Parameters.AddWithValue("@user_id", staffID); update.Parameters.AddWithValue("@user_id", staffID);
update.Parameters.AddWithValue("@active", !staffMember.active); update.Parameters.AddWithValue("@active", !staffMember.active);
update.Prepare(); update.Prepare();
update.ExecuteNonQuery(); update.ExecuteNonQuery();
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = staffMember.active ? "Staff member is now set as inactive and will no longer be randomly assigned any support tickets." : "Staff member is now set as active and will be randomly assigned support tickets again." Description = staffMember.active ? "Staff member is now set as inactive and will no longer be randomly assigned any support tickets." : "Staff member is now set as active and will be randomly assigned support tickets again."
}; };
await command.RespondAsync(message); await command.RespondAsync(message);
} }
} }
} }
} }

298
SupportChild/Commands/TranscriptCommand.cs
View file

@ -10,163 +10,163 @@ using Microsoft.Extensions.Logging;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class TranscriptCommand : BaseCommandModule public class TranscriptCommand : BaseCommandModule
{ {
[Command("transcript")] [Command("transcript")]
[Cooldown(1, 5, CooldownBucketType.User)] [Cooldown(1, 5, CooldownBucketType.User)]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "transcript")) if (!Config.HasPermission(command.Member, "transcript"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the transcript command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the transcript command but did not have permission.");
return; return;
} }
Database.Ticket ticket; Database.Ticket ticket;
string strippedMessage = command.Message.Content.Replace(Config.prefix, ""); string strippedMessage = command.Message.Content.Replace(Config.prefix, "");
string[] parsedMessage = strippedMessage.Replace("<@!", "").Replace("<@", "").Replace(">", "").Split(); string[] parsedMessage = strippedMessage.Replace("<@!", "").Replace("<@", "").Replace(">", "").Split();
// If there are no arguments use current channel // If there are no arguments use current channel
if (parsedMessage.Length < 2) if (parsedMessage.Length < 2)
{ {
if (Database.TryGetOpenTicket(command.Channel.Id, out ticket)) if (Database.TryGetOpenTicket(command.Channel.Id, out ticket))
{ {
try try
{ {
await Transcriber.ExecuteAsync(command.Channel.Id, ticket.id); await Transcriber.ExecuteAsync(command.Channel.Id, ticket.id);
} }
catch (Exception) catch (Exception)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "ERROR: Could not save transcript file. Aborting..." Description = "ERROR: Could not save transcript file. Aborting..."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
throw; throw;
} }
} }
else else
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "This channel is not a ticket." Description = "This channel is not a ticket."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
} }
else else
{ {
// Check if argument is numerical, if not abort // Check if argument is numerical, if not abort
if (!uint.TryParse(parsedMessage[1], out uint ticketID)) if (!uint.TryParse(parsedMessage[1], out uint ticketID))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Argument must be a number." Description = "Argument must be a number."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
// If the ticket is still open, generate a new fresh transcript // If the ticket is still open, generate a new fresh transcript
if (Database.TryGetOpenTicketByID(ticketID, out ticket) && ticket?.creatorID == command.Member.Id) if (Database.TryGetOpenTicketByID(ticketID, out ticket) && ticket?.creatorID == command.Member.Id)
{ {
try try
{ {
await Transcriber.ExecuteAsync(command.Channel.Id, ticket.id); await Transcriber.ExecuteAsync(command.Channel.Id, ticket.id);
} }
catch (Exception) catch (Exception)
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "ERROR: Could not save transcript file. Aborting..." Description = "ERROR: Could not save transcript file. Aborting..."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
throw; throw;
} }
} }
// If there is no open or closed ticket, send an error. If there is a closed ticket we will simply use the old transcript from when the ticket was closed. // If there is no open or closed ticket, send an error. If there is a closed ticket we will simply use the old transcript from when the ticket was closed.
else if (!Database.TryGetClosedTicket(ticketID, out ticket) || ticket?.creatorID != command.Member.Id && !Database.IsStaff(command.Member.Id)) else if (!Database.TryGetClosedTicket(ticketID, out ticket) || (ticket?.creatorID != command.Member.Id && !Database.IsStaff(command.Member.Id)))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Could not find a closed ticket with that number which you opened." + (Config.HasPermission(command.Member, "list") ? "\n(Use the " + Config.prefix + "list command to see all your tickets)" : "") Description = "Could not find a closed ticket with that number which you opened." + (Config.HasPermission(command.Member, "list") ? "\n(Use the " + Config.prefix + "list command to see all your tickets)" : "")
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
} }
// Log it if the log channel exists // Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel); DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null) if (logChannel != null)
{ {
DiscordEmbed embed = new DiscordEmbedBuilder DiscordEmbed embed = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Ticket " + ticket.id.ToString("00000") + " transcript generated by " + command.Member.Mention + ".\n", Description = "Ticket " + ticket.id.ToString("00000") + " transcript generated by " + command.Member.Mention + ".\n",
Footer = new DiscordEmbedBuilder.EmbedFooter { Text = '#' + command.Channel.Name } Footer = new DiscordEmbedBuilder.EmbedFooter { Text = '#' + command.Channel.Name }
}; };
using (FileStream file = new FileStream(Transcriber.GetPath(ticket.id), FileMode.Open, FileAccess.Read)) using (FileStream file = new FileStream(Transcriber.GetPath(ticket.id), FileMode.Open, FileAccess.Read))
{ {
DiscordMessageBuilder message = new DiscordMessageBuilder(); DiscordMessageBuilder message = new DiscordMessageBuilder();
message.WithEmbed(embed); message.WithEmbed(embed);
message.WithFiles(new Dictionary<string, Stream>() { { Transcriber.GetFilename(ticket.id), file } }); message.WithFiles(new Dictionary<string, Stream>() { { Transcriber.GetFilename(ticket.id), file } });
await logChannel.SendMessageAsync(message); await logChannel.SendMessageAsync(message);
} }
} }
try try
{ {
// Send transcript privately // Send transcript privately
DiscordEmbed directMessageEmbed = new DiscordEmbedBuilder DiscordEmbed directMessageEmbed = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Transcript generated, " + command.Member.Mention + "!\n" Description = "Transcript generated, " + command.Member.Mention + "!\n"
}; };
using (FileStream file = new FileStream(Transcriber.GetPath(ticket.id), FileMode.Open, FileAccess.Read)) using (FileStream file = new FileStream(Transcriber.GetPath(ticket.id), FileMode.Open, FileAccess.Read))
{ {
DiscordMessageBuilder directMessage = new DiscordMessageBuilder(); DiscordMessageBuilder directMessage = new DiscordMessageBuilder();
directMessage.WithEmbed(directMessageEmbed); directMessage.WithEmbed(directMessageEmbed);
directMessage.WithFiles(new Dictionary<string, Stream>() { { Transcriber.GetFilename(ticket.id), file } }); directMessage.WithFiles(new Dictionary<string, Stream>() { { Transcriber.GetFilename(ticket.id), file } });
await command.Member.SendMessageAsync(directMessage); await command.Member.SendMessageAsync(directMessage);
} }
// Respond to message directly // Respond to message directly
DiscordEmbed response = new DiscordEmbedBuilder DiscordEmbed response = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Transcript sent, " + command.Member.Mention + "!\n" Description = "Transcript sent, " + command.Member.Mention + "!\n"
}; };
await command.RespondAsync(response); await command.RespondAsync(response);
} }
catch (UnauthorizedException) catch (UnauthorizedException)
{ {
// Send transcript privately // Send transcript privately
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Not allowed to send direct message to you, " + command.Member.Mention + ", please check your privacy settings.\n" Description = "Not allowed to send direct message to you, " + command.Member.Mention + ", please check your privacy settings.\n"
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
} }
} }
} }
} }

71
SupportChild/Commands/UnassignComand.cs Normal file
View file

@ -0,0 +1,71 @@
using System.Threading.Tasks;
using DSharpPlus.CommandsNext;
using DSharpPlus.CommandsNext.Attributes;
using DSharpPlus.Entities;
using Microsoft.Extensions.Logging;
namespace SupportChild.Commands
{
public class UnassignCommand : BaseCommandModule
{
[Command("unassign")]
[Description("Unassigns a staff member from a ticket.")]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{
// Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "unassign"))
{
DiscordEmbed error = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Description = "You do not have permission to use this command."
};
await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the unassign command but did not have permission.");
return;
}
// Check if ticket exists in the database
if (!Database.TryGetOpenTicket(command.Channel.Id, out Database.Ticket ticket))
{
DiscordEmbed error = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Description = "This channel is not a ticket."
};
await command.RespondAsync(error);
return;
}
if (!Database.UnassignStaff(ticket))
{
DiscordEmbed error = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Description = "Error: Failed to unassign staff from ticket."
};
await command.RespondAsync(error);
return;
}
DiscordEmbed message = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "Unassigned staff from ticket."
};
await command.RespondAsync(message);
// Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null)
{
DiscordEmbed logMessage = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "Staff was unassigned from " + command.Channel.Mention + " by " + command.Member.Mention + "."
};
await logChannel.SendMessageAsync(logMessage);
}
}
}
}

71
SupportChild/Commands/UnassignCommand.cs
View file

@ -1,71 +0,0 @@
using System.Threading.Tasks;
using DSharpPlus.CommandsNext;
using DSharpPlus.CommandsNext.Attributes;
using DSharpPlus.Entities;
using Microsoft.Extensions.Logging;
namespace SupportChild.Commands
{
public class UnassignCommand : BaseCommandModule
{
[Command("unassign")]
[Description("Unassigns a staff member from a ticket.")]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{
// Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "unassign"))
{
DiscordEmbed error = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Description = "You do not have permission to use this command."
};
await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the unassign command but did not have permission.");
return;
}
// Check if ticket exists in the database
if (!Database.TryGetOpenTicket(command.Channel.Id, out Database.Ticket ticket))
{
DiscordEmbed error = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Description = "This channel is not a ticket."
};
await command.RespondAsync(error);
return;
}
if (!Database.UnassignStaff(ticket))
{
DiscordEmbed error = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Description = "Error: Failed to unassign staff from ticket."
};
await command.RespondAsync(error);
return;
}
DiscordEmbed message = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "Unassigned staff from ticket."
};
await command.RespondAsync(message);
// Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null)
{
DiscordEmbed logMessage = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "Staff was unassigned from " + command.Channel.Mention + " by " + command.Member.Mention + "."
};
await logChannel.SendMessageAsync(logMessage);
}
}
}
}

168
SupportChild/Commands/UnblacklistCommand.cs
View file

@ -8,92 +8,92 @@ using Microsoft.Extensions.Logging;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class UnblacklistCommand : BaseCommandModule public class UnblacklistCommand : BaseCommandModule
{ {
[Command("unblacklist")] [Command("unblacklist")]
[Description("Un-blacklists a user from opening tickets.")] [Description("Un-blacklists a user from opening tickets.")]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "unblacklist")) if (!Config.HasPermission(command.Member, "unblacklist"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the unblacklist command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the unblacklist command but did not have permission.");
return; return;
} }
string[] words = Utilities.ParseIDs(command.RawArgumentString); string[] words = Utilities.ParseIDs(command.RawArgumentString);
foreach (string word in words) foreach (string word in words)
{ {
if (ulong.TryParse(word, out ulong userId)) if (ulong.TryParse(word, out ulong userId))
{ {
DiscordUser blacklistedUser = null; DiscordUser blacklistedUser = null;
try try
{ {
blacklistedUser = await command.Client.GetUserAsync(userId); blacklistedUser = await command.Client.GetUserAsync(userId);
} }
catch (NotFoundException) { } catch (NotFoundException) { }
if (blacklistedUser == null) if (blacklistedUser == null)
{ {
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error: Could not find user." Description = "Error: Could not find user."
}; };
await command.RespondAsync(message); await command.RespondAsync(message);
continue; continue;
} }
try try
{ {
if (!Database.Unblacklist(blacklistedUser.Id)) if (!Database.Unblacklist(blacklistedUser.Id))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = blacklistedUser.Mention + " is not blacklisted." Description = blacklistedUser.Mention + " is not blacklisted."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
continue; continue;
} }
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Removed " + blacklistedUser.Mention + " from blacklist." Description = "Removed " + blacklistedUser.Mention + " from blacklist."
}; };
await command.RespondAsync(message); await command.RespondAsync(message);
// Log it if the log channel exists // Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel); DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null) if (logChannel != null)
{ {
DiscordEmbed logMessage = new DiscordEmbedBuilder DiscordEmbed logMessage = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = blacklistedUser.Mention + " was unblacklisted from opening tickets by " + command.Member.Mention + "." Description = blacklistedUser.Mention + " was unblacklisted from opening tickets by " + command.Member.Mention + "."
}; };
await logChannel.SendMessageAsync(logMessage); await logChannel.SendMessageAsync(logMessage);
} }
} }
catch (Exception) catch (Exception)
{ {
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "Error occured while removing " + blacklistedUser.Mention + " from blacklist." Description = "Error occured while removing " + blacklistedUser.Mention + " from blacklist."
}; };
await command.RespondAsync(message); await command.RespondAsync(message);
throw; throw;
} }
} }
} }
} }
} }
} }

116
SupportChild/Commands/UnsetTicketCommand.cs
View file

@ -7,64 +7,64 @@ using MySql.Data.MySqlClient;
namespace SupportChild.Commands namespace SupportChild.Commands
{ {
public class UnsetTicketCommand : BaseCommandModule public class UnsetTicketCommand : BaseCommandModule
{ {
[Command("unsetticket")] [Command("unsetticket")]
[Description( [Description(
"Deletes a channel from the ticket system without deleting the channel.")] "Deletes a channel from the ticket system without deleting the channel.")]
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs) public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{ {
using (MySqlConnection c = Database.GetConnection()) using (MySqlConnection c = Database.GetConnection())
{ {
// Check if the user has permission to use this command. // Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "unsetticket")) if (!Config.HasPermission(command.Member, "unsetticket"))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "You do not have permission to use this command." Description = "You do not have permission to use this command."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the unsetticket command but did not have permission."); command.Client.Logger.Log(LogLevel.Information, "User tried to use the unsetticket command but did not have permission.");
return; return;
} }
// Check if ticket exists in the database // Check if ticket exists in the database
if (!Database.TryGetOpenTicket(command.Channel.Id, out Database.Ticket ticket)) if (!Database.TryGetOpenTicket(command.Channel.Id, out Database.Ticket ticket))
{ {
DiscordEmbed error = new DiscordEmbedBuilder DiscordEmbed error = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Red, Color = DiscordColor.Red,
Description = "This channel is not a ticket." Description = "This channel is not a ticket."
}; };
await command.RespondAsync(error); await command.RespondAsync(error);
return; return;
} }
c.Open(); c.Open();
MySqlCommand deletion = new MySqlCommand(@"DELETE FROM tickets WHERE channel_id=@channel_id", c); MySqlCommand deletion = new MySqlCommand(@"DELETE FROM tickets WHERE channel_id=@channel_id", c);
deletion.Parameters.AddWithValue("@channel_id", command.Channel.Id); deletion.Parameters.AddWithValue("@channel_id", command.Channel.Id);
deletion.Prepare(); deletion.Prepare();
deletion.ExecuteNonQuery(); deletion.ExecuteNonQuery();
DiscordEmbed message = new DiscordEmbedBuilder DiscordEmbed message = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = "Channel has been undesignated as a ticket." Description = "Channel has been undesignated as a ticket."
}; };
await command.RespondAsync(message); await command.RespondAsync(message);
// Log it if the log channel exists // Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel); DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null) if (logChannel != null)
{ {
DiscordEmbed logMessage = new DiscordEmbedBuilder DiscordEmbed logMessage = new DiscordEmbedBuilder
{ {
Color = DiscordColor.Green, Color = DiscordColor.Green,
Description = command.Channel.Mention + " has been undesignated as a ticket by " + command.Member.Mention + "." Description = command.Channel.Mention + " has been undesignated as a ticket by " + command.Member.Mention + "."
}; };
await logChannel.SendMessageAsync(logMessage); await logChannel.SendMessageAsync(logMessage);
} }
} }
} }
} }
} }