public async Task ResetProfile(string confirm = "")
{
if (confirm.ToLower() == "info")
{
await Context.Channel.SendMessageAsync(
"Resting your profile will reset your XP back down to 0 and reset your profile message.\n**THIS WILL NOT RESET SERVER DATA ASSOCIATED WITH YOUR PROFILE!**\n\nTo confirm you want to reset your profile data do `resetprofile yes`.");
return;
}
if (confirm.ToLower() != "yes")
{
await Context.Channel.SendMessageAsync(
"For more info on profile resets do `resetprofile info`. To confirm you want to reset your profile data do `resetprofile yes`.");
return;
}
UserAccount user = UserAccountsManager.GetAccount((SocketGuildUser)Context.User);
user.ProfileMsg = "";
user.Xp = 0;
UserAccountsManager.SaveAccounts();
await Context.Channel.SendMessageAsync("Your profile data has been reset!");
}
private static string Warn(SocketUser user)
{
if (user.IsBot)
{
return("You cannot give a warning to a bot!");
}
if (((SocketGuildUser)user).GuildPermissions.Administrator)
{
return("You cannot warn an administrator!");
}
SocketGuildUser userGuild = (SocketGuildUser)user;
UserAccountServerData userAccount =
UserAccountsManager.GetAccount(userGuild).GetOrCreateServer(userGuild.Guild.Id);
if (userAccount.IsAccountNotWarnable)
{
return($"A warning cannot be given to **{user}**. That person's account is set to not warnable.");
}
userAccount.Warnings++;
UserAccountsManager.SaveAccounts();
return($"A warning was given to **{user}**");
}
public async Task ProfileMsg([Remainder] string message = "")
{
UserAccount account = UserAccountsManager.GetAccount((SocketGuildUser)Context.User);
account.ProfileMsg = message;
UserAccountsManager.SaveAccounts();
await Context.Channel.SendMessageAsync($"Your public profile message was set to '{message}'");
}
/// <summary>
/// Ends a vote running on a guild
/// <para>If the vote is running, it will END it!</para>
/// </summary>
/// <param name="vote">The vote to end</param>
/// <param name="guild"></param>
/// <returns></returns>
public static async Task EndVote(Vote vote, SocketGuild guild)
{
Logger.Log("The vote ended.", LogVerbosity.Debug);
vote.CancellationToken.Cancel();
SocketUser user = guild.GetUser(vote.VoteStarterUserId);
//Remove from user's last vote
UserAccountsManager.GetAccount((SocketGuildUser)user).UserLastVoteId = 0;
UserAccountsManager.SaveAccounts();
//Create a new embed with the results
EmbedBuilder embed = new EmbedBuilder();
embed.WithTitle(vote.VoteTitle);
embed.WithDescription(vote.VoteDescription +
$"\nThe vote is now over! Here are the results:\n**Yes**: {vote.YesCount}\n**No**: {vote.NoCount}");
if (user != null)
{
embed.WithFooter($"Vote started by {user} and ended at {DateTime.Now:g}.", user.GetAvatarUrl());
}
else
{
embed.WithFooter("Vote started by: a person who left the guild :(");
}
//Modify the message
IMessage message =
await guild.GetTextChannel(vote.VoteMessageChannelId).GetMessageAsync(vote.VoteMessageId);
await MessageUtils.ModifyMessage(message as IUserMessage, embed);
//Send the user who started the vote a message about their vote is over
if (user != null)
{
EmbedBuilder userDmEmbed = new EmbedBuilder();
userDmEmbed.WithTitle("Vote: " + vote.VoteTitle);
userDmEmbed.WithDescription($"Your vote that you started on the **{guild.Name}** guild is now over.\n" +
$"You can see the results [here](https://discordapp.com/channels/{guild.Id}/{vote.VoteMessageChannelId}/{vote.VoteMessageId}).");
IDMChannel userDm = await user.GetOrCreateDMChannelAsync();
await userDm.SendMessageAsync("", false, userDmEmbed.Build());
}
//Remove our vote from the server's vote list
ServerListsManager.GetServer(guild).Votes.Remove(vote);
ServerListsManager.SaveServerList();
}
/// <summary>
/// Checks how many users are mention in a single message, if it is higher then the threshold then remove it
/// </summary>
/// <param name="message">The message to check</param>
/// <param name="guild">The guild of the message</param>
/// <returns>Whether the user is allowed to do that action</returns>
public bool CheckMentionUsers(SocketUserMessage message, SocketGuild guild)
{
SocketGuildUser user = (SocketGuildUser)message.Author;
UserAccountServerData serverAccount =
UserAccountsManager.GetAccount(user).GetOrCreateServer(guild.Id);
if (serverAccount.IsAccountNotWarnable)
{
return(false);
}
//If it is the owner of the Discord server, ignore
if (user.Id == guild.OwnerId)
{
return(false);
}
//If user is a admin, ignore
if (user.GuildPermissions.Administrator)
{
return(false);
}
int guildMemberCount = guild.Users.Count;
int mentionCount = message.MentionedUsers.Count;
int percentage = mentionCount / guildMemberCount * 100;
if (percentage > ServerListsManager.GetServer(guild).AntiSpamSettings.MentionUsersPercentage)
{
return(false);
}
message.Channel.SendMessageAsync(
$"Hey {message.Author.Mention}, listing all members of this Discord server is not allowed!")
.GetAwaiter().GetResult();
message.DeleteAsync().GetAwaiter().GetResult();
serverAccount.Warnings++;
UserAccountsManager.CheckUserWarnStatus(user);
UserAccountsManager.SaveAccounts();
return(true);
}
public async Task UserJoined(SocketGuildUser user)
{
try
{
if (!user.IsBot)
{
ServerList server = ServerListsManager.GetServer(user.Guild);
//Pre create the user account
UserAccountsManager.GetAccount(user);
UserAccountsManager.SaveAccounts();
//If the server has welcome messages enabled then we give them a warm welcome UwU
if (server.WelcomeMessageEnabled)
{
//Format the message to include username and the server name
string addUserMention = server.WelcomeMessage.Replace("[user]", user.Mention);
string addServerName = addUserMention.Replace("[server]", user.Guild.Name);
//Welcomes the new user with the server's message
SocketTextChannel channel =
_client.GetGuild(server.GuildId).GetTextChannel(server.WelcomeChannelId);
if (channel != null)
{
await channel.SendMessageAsync(addServerName);
}
else
{
server.WelcomeMessageEnabled = false;
server.WelcomeChannelId = 0;
ServerListsManager.SaveServerList();
}
}
}
}
catch (Exception ex)
{
#if DEBUG
Logger.Log(ex.ToString(), LogVerbosity.Error);
#else
Logger.Log(ex.Message, LogVerbosity.Error);
#endif
}
}
/// <summary>
/// Levels up a user
/// </summary>
/// <param name="user"></param>
/// <param name="channel"></param>
/// <param name="amount"></param>
public static async void GiveUserXp(SocketGuildUser user, SocketTextChannel channel, uint amount)
{
UserAccount userAccount = UserAccountsManager.GetAccount(user);
uint oldLevel = userAccount.LevelNumber;
//Nice one EternalClickbait...
userAccount.Xp += amount;
UserAccountsManager.SaveAccounts();
if (oldLevel != userAccount.LevelNumber)
{
await channel.SendMessageAsync(
$"{user.Mention} leveled up! Now on level **{userAccount.LevelNumber}**!");
}
Logger.Debug("{@Username} now has {@Xp} XP", user.Username, userAccount.Xp);
}
public async Task MuteUser(SocketGuildUser user = null)
{
//Check to see if the user is null
if (user == null)
{
await Context.Channel.SendMessageAsync("You need to input a username of a user!");
return;
}
//Make sure the user being muted isn't the owner of the guild, because that would be retarded.
if (user.Id == Context.Guild.OwnerId)
{
await Context.Channel.SendMessageAsync(
"Excuse me, you are trying to mute... the owner? That is a terrible idea.");
return;
}
//Yea, muting your self isn't normal either.
if (user == Context.User)
{
await Context.Channel.SendMessageAsync(
"Are you trying to mute your self? I don't think that is normal.");
return;
}
UserAccount account = UserAccountsManager.GetAccount(user);
UserAccountServerData accountServer = account.GetOrCreateServer(Context.Guild.Id);
accountServer.IsMuted = true;
UserAccountsManager.SaveAccounts();
if (accountServer.IsMuted)
{
await Context.Channel.SendMessageAsync($"**{user.Username}** is now muted.");
}
else
{
await Context.Channel.SendMessageAsync($"**{user.Username}** is now un-muted.");
}
}
private static string MakeNotWarnable(IEnumerable <SocketGuildUser> users)
{
List <SocketGuildUser> usersToChange = new List <SocketGuildUser>();
foreach (SocketGuildUser user in users)
{
if (user.IsBot)
{
return("You cannot change the warnable status of a bot!");
}
if (user.GuildPermissions.Administrator)
{
return("You cannot change the warnable status of an administrator!");
}
if (UserAccountsManager.GetAccount(user).GetOrCreateServer(user.Guild.Id).IsAccountNotWarnable)
{
return($"**{user.Username}** is already not warnable!");
}
usersToChange.Add(user);
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < usersToChange.Count; i++)
{
UserAccountServerData userAccount =
UserAccountsManager.GetAccount(usersToChange[i]).GetOrCreateServer(usersToChange[i].Guild.Id);
userAccount.IsAccountNotWarnable = true;
userAccount.Warnings = 0;
sb.Append(i + 1 == usersToChange.Count ? usersToChange[i].Username : $"{usersToChange[i].Username}, ");
}
UserAccountsManager.SaveAccounts();
return(usersToChange.Count == 1
? $"**{sb}** was made not warnable."
: $"The accounts **{sb}** were all made not warnable.");
}
public Task UserBanned(SocketUser user, SocketGuild guild)
{
//We remove the user's server data from the user account ONLY if they are banned since their chance of coming back if very low.
//If the data was deleted when they left/kicked they would also loose their warnings. I am sure you can see what the issue would be if we allowed that.
UserAccount userAccount = UserAccountsManager.GetAccountById(user.Id);
//This should NEVER be true, but if it does SOMEHOW happen then well it is here just in case...
if (userAccount == null)
{
return(Task.CompletedTask);
}
userAccount.Servers.Remove(userAccount.GetOrCreateServer(guild.Id));
UserAccountsManager.SaveAccounts();
return(Task.CompletedTask);
}
/// <summary>
/// Checks if a given user is allowed to @mention a certain role, and warns them if not
/// </summary>
/// <param name="message">The message to check</param>
/// <param name="user">The author of the message</param>
/// <returns>Whether the user is allowed to do that action</returns>
public bool CheckRoleMentions(SocketUserMessage message, SocketGuildUser user)
{
UserAccountServerData serverAccount =
UserAccountsManager.GetAccount(user).GetOrCreateServer(user.Guild.Id);
if (serverAccount.IsAccountNotWarnable)
{
return(false);
}
//If it is the owner of the Discord server, ignore
if (user.Id == user.Guild.OwnerId)
{
return(false);
}
ServerList server = ServerListsManager.GetServer(user.Guild);
//Go over each role a user has
foreach (SocketRole role in user.Roles)
{
foreach (ServerRoleToRoleMention notToMentionRoles in server.RoleToRoleMentions.Where(notToMentionRoles =>
role.Id == notToMentionRoles.RoleNotToMentionId))
{
message.DeleteAsync();
if (serverAccount.RoleToRoleMentionWarnings >=
server.AntiSpamSettings.RoleToRoleMentionWarnings)
{
message.Channel.SendMessageAsync(
$"Hey {user.Mention}, you have been pinging the **{RoleUtils.GetGuildRole(user.Guild, notToMentionRoles.RoleId).Name}** role, which you are not allowed to ping!\nA warning has been added to your account, for info see your profile.");
serverAccount.Warnings++;
UserAccountsManager.SaveAccounts();
}
serverAccount.RoleToRoleMentionWarnings++;
return(true);
}
}
return(false);
}
/// <summary>
/// Gives a user server points, and gives them a role if they past a certain amount of points
/// </summary>
/// <param name="user"></param>
/// <param name="channel"></param>
/// <param name="amount"></param>
public static async void GiveUserServerPoints(SocketGuildUser user, SocketTextChannel channel, uint amount)
{
UserAccountServerData userAccount = UserAccountsManager.GetAccount(user).GetOrCreateServer(user.Guild.Id);
userAccount.Points += amount;
UserAccountsManager.SaveAccounts();
//Give the user a role if they have enough points for it.
ServerList server = ServerListsManager.GetServer(user.Guild);
ServerRolePoints serverRole =
server.GetServerRolePoints(userAccount.Points);
Logger.Debug("{@Username} now has {@Points} points on guild {@GuildId}", user.Username, userAccount.Points, user.Guild.Id);
if (serverRole.PointsRequired == 0)
{
return;
}
await user.AddRoleAsync(RoleUtils.GetGuildRole(user.Guild, serverRole.RoleId));
await channel.SendMessageAsync(
$"Congrats {user.Mention}, you got {userAccount.Points} points and got the **{RoleUtils.GetGuildRole(user.Guild, serverRole.RoleId).Name}** role!");
}
private static void SaveAccountsCmd()
{
UserAccountsManager.SaveAccounts();
Logger.Log("User accounts saved!");
}
/// <summary>
/// Starts and adds a new vote to a server
/// </summary>
/// <param name="voteTitle"></param>
/// <param name="voteDescription"></param>
/// <param name="lastTime"></param>
/// <param name="yesEmoji"></param>
/// <param name="noEmoji"></param>
/// <param name="guild"></param>
/// <param name="channel"></param>
/// <param name="userWhoExecuted"></param>
/// <returns></returns>
public static async Task StartVote(string voteTitle, string voteDescription, TimeSpan lastTime, string yesEmoji,
string noEmoji, SocketGuild guild, IMessageChannel channel, SocketUser userWhoExecuted)
{
if (lastTime.TotalMilliseconds > Config.bot.VoteSettings.MaxVoteTime.TotalMilliseconds)
{
await channel.SendMessageAsync("The vote time succeeds the maximum allowed time for a vote to last!");
return;
}
ServerList server = ServerListsManager.GetServer(guild);
if (server.Votes.Count >= Config.bot.VoteSettings.MaxRunningVotesPerGuild)
{
await channel.SendMessageAsync(
$"There are already {Config.bot.VoteSettings.MaxRunningVotesPerGuild} votes running on this guild right now!\nEnd a vote to start a new one.");
return;
}
//Setup Emojis
Emoji yesEmote = new Emoji(yesEmoji);
Emoji noEmote = new Emoji(noEmoji);
//Setup embed
EmbedBuilder embed = new EmbedBuilder();
embed.WithTitle("Setting up vote...");
//Send the message and add the initial reactions
IUserMessage voteMessage = await channel.SendMessageAsync("", false, embed.Build());
await voteMessage.AddReactionAsync(yesEmote);
await voteMessage.AddReactionAsync(noEmote);
Vote newVote = new Vote
{
VoteMessageId = voteMessage.Id,
VoteMessageChannelId = channel.Id,
VoteTitle = voteTitle,
VoteDescription = voteDescription,
VoteStarterUserId = userWhoExecuted.Id,
NoCount = 0,
YesCount = 0,
NoEmoji = noEmoji,
YesEmoji = yesEmoji,
VoteLastTime = lastTime,
VoteStartTime = DateTime.Now,
CancellationToken = new CancellationTokenSource()
};
//User last vote
UserAccountsManager.GetAccount((SocketGuildUser)userWhoExecuted).UserLastVoteId = voteMessage.Id;
UserAccountsManager.SaveAccounts();
//Add our vote to the server list
server.Votes.Add(newVote);
ServerListsManager.SaveServerList();
embed.WithTitle(voteTitle);
embed.WithDescription(voteDescription +
$"\nReact to this message with {yesEmoji} to say **YES** or react with {noEmoji} to say **NO**.");
embed.WithFooter($"Vote started by {userWhoExecuted} at {DateTime.Now:g} and will end at {DateTime.Now.Add(lastTime):g}.", userWhoExecuted.GetAvatarUrl());
await MessageUtils.ModifyMessage(voteMessage, embed);
await RunVote(newVote, guild);
}