public async Task UnBan(CommandContext ctx, DiscordUser user, [RemainingText] string reason = "No reason given.")
{
if (!ctx.Member.HasPermission(Permissions.BanMembers))
{
await ctx.RespondAsync("[You] Can't ban, can't unban. Sorry.").ConfigureAwait(false);
return;
}
if ((await ctx.Guild.GetBansAsync()).Select(b => b.User.Id).Contains(user.Id))
{
await user.UnbanAsync(ctx.Guild, reason);
DiscordEmbedBuilder embed =
new DiscordEmbedBuilder(EmbedHelper.CreateEmbed(ctx, "",
$"Unbanned {user.Username}#{user.Discriminator} `({user.Id})`! ")).AddField("Reason:", reason);
var infraction =
(TimedInfraction)_eventService.Events.FirstOrDefault(e => ((TimedInfraction)e).Id == user.Id);
if (infraction is not null)
{
_eventService.Events.TryRemove(infraction);
}
await ctx.RespondAsync(embed : embed);
}
else
{
DiscordEmbedBuilder embed =
new DiscordEmbedBuilder(EmbedHelper.CreateEmbed(ctx, "", $"{user.Mention} is not banned!"))
.WithColor(new DiscordColor("#d11515"));
await ctx.RespondAsync(embed : embed);
}
}
public async Task GetRequiredPermissions(CommandContext ctx)
{
string prefix = ctx.Prefix;
DiscordEmbedBuilder embed = EmbedHelper.CreateEmbed(ctx, "Permissions:", DiscordColor.CornflowerBlue);
DiscordMember bot = await ctx.Guild.GetMemberAsync(ctx.Client.CurrentUser.Id);
bool manageMessage = bot.HasPermission(Permissions.ManageMessages);
bool kick = bot.HasPermission(Permissions.KickMembers);
bool ban = bot.HasPermission(Permissions.BanMembers);
bool manageRoles = bot.HasPermission(Permissions.ManageRoles);
var sb = new StringBuilder();
sb.AppendLine($"`Manage Messages`: {GetStatusEmoji(manageMessage)}\nAffected commands: `{prefix}clear`, " +
$"`{prefix}clean`; __error messages will persist if false.__\n");
sb.AppendLine($"`Manage Roles`: {GetStatusEmoji(manageRoles)}\nAffected commands: `{prefix}role`\n");
sb.AppendLine($"`Kick Members` {GetStatusEmoji(kick)}\nAffected commands: `{prefix}kick`\n");
sb.AppendLine($"`Ban Members` {GetStatusEmoji(ban)}\nAffected commands: `{prefix}ban`\n");
embed.WithTitle("Permissions:");
embed.WithDescription(sb.ToString());
await ctx.RespondAsync(embed : embed);
}
public async Task GetRequiredPermissions(CommandContext ctx)
{
var prefix = SilkBot.Bot.GuildPrefixes[ctx.Guild.Id];
var embed = EmbedHelper.CreateEmbed(ctx, "Permissions:", DiscordColor.CornflowerBlue);
var bot = await ctx.Guild.GetMemberAsync(ctx.Client.CurrentUser.Id);
var manageMessage = bot.HasPermission(Permissions.ManageMessages);
var kick = bot.HasPermission(Permissions.KickMembers);
var ban = bot.HasPermission(Permissions.BanMembers);
var manageRoles = bot.HasPermission(Permissions.ManageRoles);
var sb = new StringBuilder();
sb.AppendLine($"`Manage Messages`: {(manageMessage ? ":white_check_mark:" : ":x:")}\nAffected commands: `{prefix}clear`, `{prefix}clean`; __error messages will persist if false.__");
sb.AppendLine($"`Manage Roles`: {(manageRoles ? ":white_check_mark:" : ":x:")}\nAffected commands: {prefix}role");
sb.AppendLine($"`Kick Members` {(kick ? ":white_check_mark:" : ":x:")}\nAffected commands: {prefix}kick");
sb.AppendLine($"`Ban Members` {(ban ? ":white_check_mark:" : ":x:")}\nAffected commands: {prefix}ban");
embed.WithTitle("Permissions:");
embed.WithDescription(sb.ToString());
await ctx.RespondAsync(embed : embed);
}
private async Task MessageReceivedAsync(SocketMessage messageParam)
{
// Don't process the command if it was a System Message
if (!(messageParam is SocketUserMessage message))
{
return;
}
// Ignore TF2RJweekly messages for now
if (messageParam.Channel is SocketGuildChannel socketGuildChannel &&
socketGuildChannel.Guild.Id == 310494288570089472)
{
return;
}
// Create a number to track where the prefix ends and the command begins
var commandPosition = 0;
// Determine if the message is a command, based on if it starts with '!' or a mention prefix
if (!(message.HasCharPrefix(DiscordConstants.CommandPrefix, ref commandPosition) ||
message.HasMentionPrefix(_client.CurrentUser, ref commandPosition)))
{
return;
}
// Create a Command Context
var context = new CommandContext(_client, message);
// Execute the command. (result does not indicate a return value,
// rather an object stating if the command executed successfully)
var result = await _commands.ExecuteAsync(context, commandPosition, _services);
if (result.Error != null && !result.IsSuccess && result.Error.Value != CommandError.UnknownCommand)
{
await context.Channel.SendMessageAsync("", embed : EmbedHelper.CreateEmbed(result.ErrorReason, false));
}
}
public static IEnumerable <Embed> GetRoleEmbeds(string roleParam, IGuild guild)
{
var roles = guild.Roles.Where(x => x.Name.ToLower().Contains(roleParam.ToLower())).ToArray();
if (!roles.Any())
{
yield return(EmbedHelper.CreateEmbed("No roles found from name", false));
yield break;
}
foreach (var role in roles.Take(5))
{
var builder = new EmbedBuilder {
Title = "@" + role.Name
};
builder.AddField("Separate from @everyone", role.IsHoisted);
builder.AddField("Mentionable", role.IsMentionable);
builder.AddField("Hierarchical position", role.Position);
builder.AddField("Guild", role.Guild);
builder.AddField("Created at", role.CreatedAt.ToString("d"));
builder.AddField("Permissions", PermissionsToString(role.Permissions));
builder.WithColor(role.Color);
builder.WithFooter(role.Id.ToString());
yield return(builder.Build());
}
}
public async Task TestLogChannelWorks(CommandContext ctx)
{
await ctx.TriggerTypingAsync();
await Task.Delay(1500);
await ctx.RespondAsync("Verifying config is set...");
var embed = EmbedHelper.CreateEmbed(ctx, "", "");
await Task.Delay(3000);
ServerConfigurationManager.LocalConfiguration.TryGetValue(ctx.Guild.Id, out var serverConfigurationObject);
if (serverConfigurationObject is null)
{
var newEmbed = new DiscordEmbedBuilder(embed)
.WithAuthor(ctx.Member.Nickname ?? ctx.Member.DisplayName, iconUrl: ctx.Member.AvatarUrl)
.WithDescription("Server configuration integrety check failed!")
.WithColor(DiscordColor.IndianRed);
await ctx.RespondAsync(embed : newEmbed);
}
else
{
//var testMessage = await ctx.Client.SendMessageAsync(
// await ServerConfig.ReturnChannelFromID(ctx, serverConfigurationObject.LoggingChannel),
// "This message is to ensure the integrity of the logging channel set via the `SetLoggingChannelCommand`. `!help SetLoggingChannel` for more information.");
var newEmbed = new DiscordEmbedBuilder(embed)
.WithAuthor(ctx.Member.Nickname ?? ctx.Member.DisplayName, iconUrl: ctx.Member.AvatarUrl)
.WithDescription("Server configuration integrety check passed!")
.WithColor(DiscordColor.PhthaloGreen);
await ctx.RespondAsync(embed : newEmbed);
}
}
public static async Task <Embed> GetDiscordObjectEmbedAsync(DiscordSocketClient client, ulong id)
{
var guild = client.GetGuild(id);
if (guild != null)
{
return(GetServerEmbed(guild));
}
var channel = client.GetChannel(id);
if (channel != null)
{
return(await GetChannelEmbedAsync(channel));
}
var user = await client.Rest.GetUserAsync(id);
if (user != null)
{
return(GetUserEmbed(user));
}
return(EmbedHelper.CreateEmbed("No global discord object found", false));
}
public async Task SendUpdate(string title, [Remainder] string description)
{
if (_client.GetChannel(Constants.Constants.UpdateChannelId) is IMessageChannel channel)
{
await channel.SendMessageAsync("",
embed : EmbedHelper.CreateEmbed($"**__[{title.ToUpper()}]__**", description, Color.Green));
}
}
public async Task Cash(CommandContext ctx)
{
var userCoins = EconomicUsers.Instance.Users.TryGetValue(ctx.User.Id, out var user) ? user.Cash : 0;
var eb = EmbedHelper.CreateEmbed(ctx, "Account balance:", $"You have {userCoins} coins!");
var betterEmbed = new DiscordEmbedBuilder(eb).WithAuthor(name: ctx.User.Username, iconUrl: ctx.User.AvatarUrl);
await ctx.RespondAsync(embed : betterEmbed);
}
private static Embed GetModulesOverviewEmbed(CommandService commandService, ICommandContext context)
{
var title = $"Per module help commands: ({DiscordConstants.CommandPrefix}help [module])";
var text = commandService.Modules.Where(x => !x.Name.Contains("ModuleBase")).Aggregate("",
(current, module) =>
current +
$"**{module.Name}** ({module.Summary}), {module.Commands.Count} command/s{Environment.NewLine} ");
return(EmbedHelper.CreateEmbed(title, text, false));
}
private static Embed GetModuleHelpEmbed(ModuleInfo module, ICommandContext context)
{
var title = $"Help: **({module.Name})**";
var text = module.Commands.Where(x => x.CheckPreconditionsAsync(context).GetAwaiter().GetResult().IsSuccess).Aggregate("",
(current, command) =>
current +
$"**__{DiscordConstants.CommandPrefix + command.Name}__**{Environment.NewLine}**{command.Summary}**. Parameters: {command.Parameters.Aggregate("", (currentString, nextParameter) => currentString + $"{nextParameter.Name} {GetSummaryString(nextParameter.Summary)}, ").TrimEnd(' ', ',')}{Environment.NewLine}");
return(EmbedHelper.CreateEmbed(title, text, false));
}
private DiscordEmbed CreateEmbedWithSongData()
{
var embed = EmbedHelper.CreateEmbed(new DiscordColor("#5588EE"), "Current playing songs",
"**Radio Anison FM**\n" + currentAnisonPlayingSong + "\n" + RadiosLinksConst.AnisonFm +
"\n\n**Radio Blue Anime Ivana**\n" + currentBlueIvanaPlayingSong + "\n" + RadiosLinksConst.BlueIvana +
"\n\n**J-Pop Project Radio (JMusic)**\n" + currentJMusicPlayingSong + "\n" + RadiosLinksConst.JMusic +
//"\n\n**Anime NFO Radio**\n" + currentAnimeNFOPlayingSong + "\n" + RadiosLinksConst.AnimeNFO +
"\n\nLast update: " + DateTime.UtcNow.ToString(@"HH:mm:ss") + " UTC", null, null);
return(embed);
}
// TODO: Check that this is consistent
public async Task ReplyNewEmbed(string text)
{
var parts = text.SplitInParts(2000);
foreach (var part in parts)
{
await ReplyEmbed(EmbedHelper.CreateEmbed(part));
await Task.Delay(250);
}
}
public async Task ReplyNewEmbedAsync(string title, string text, bool escape = true)
{
if (escape)
{
text = text.EscapeDiscordChars();
}
var parts = text.SplitInParts(2000);
foreach (var part in parts)
{
await ReplyEmbedAsync(EmbedHelper.CreateEmbed(title, part, false));
await Task.Delay(250);
}
}
public async Task Avatar(CommandContext ctx, [Description("If you want other user's avatar, put his mention here.")] DiscordMember member = null)
{
await ctx.TriggerTypingAsync();
if (member == null)
{
var embed = EmbedHelper.CreateEmbed(new DiscordColor("#00a8ff"), "Avatar", ctx.User.Mention, ctx.User.AvatarUrl);
await ctx.RespondAsync(null, false, embed);
}
else
{
var embed = EmbedHelper.CreateEmbed(new DiscordColor("#00a8ff"), "Avatar", member.Mention, member.AvatarUrl);
await ctx.RespondAsync(null, false, embed);
}
}
public async Task Cash(CommandContext ctx)
{
SilkDbContext db = _dbFactory.CreateDbContext();
GlobalUserModel?account = db.GlobalUsers.FirstOrDefault(u => u.Id == ctx.User.Id);
if (account is null)
{
await ctx.RespondAsync("Seems you don't have an account. " +
$"Use `{ctx.Prefix}daily` and I'll set one up for you *:)*");
return;
}
DiscordEmbedBuilder eb = EmbedHelper
.CreateEmbed(ctx, "Account balance:", $"You have {account.Cash} dollars!")
.WithAuthor(ctx.User.Username, iconUrl: ctx.User.AvatarUrl);
await ctx.RespondAsync(embed : eb);
}
public static Embed GetServerEmbed(IGuild guild)
{
if (guild is SocketGuild server)
{
var builder = new EmbedBuilder {
Title = server.Name
};
builder.AddField("Channels", server.Channels.Count)
.AddField("Created", server.CreatedAt.ToString("d"))
.AddField("Default Notifications", server.DefaultMessageNotifications.ToString())
.AddField("Members", server.MemberCount)
.AddField("2FA", server.MfaLevel.ToString())
.AddField("Owner", server.Owner.Username)
.WithColor(ColorConstants.InfoColor)
.WithFooter(server.Id.ToString());
return(builder.Build());
}
return(EmbedHelper.CreateEmbed("Guild is not a SocketGuild", false));
}
public async Task Help(string moduleParam = "")
{
if (moduleParam == "")
{
var title = $"Help commands: ({Constants.Constants.CommandPrefix}help [module])";
var text = CommandService.Modules.Where(x => !x.Name.Contains("ModuleBase")).Aggregate("",
(current, module) =>
current +
$" - **{module.Name}** ({module.Summary}), {module.Commands.Count} command/s{Environment.NewLine} ");
await ReplyEmbed(EmbedHelper.CreateEmbed(title, text));
}
else
{
var module = CommandService.Modules.First(x => x.Name.ToLower().Contains(moduleParam.ToLower()));
var title = $"Help: **({module.Name})**";
var text = module.Commands.Aggregate("",
(current, command) =>
current +
$"**__{Constants.Constants.CommandPrefix + command.Name}__**{Environment.NewLine}**{command.Summary}**. Parameters: {command.Parameters.Aggregate("", (currentString, nextParameter) => currentString + $"{nextParameter.Name} {GetSummaryString(nextParameter.Summary)}, ").TrimEnd(' ', ',')}{Environment.NewLine}");
await ReplyEmbed(EmbedHelper.CreateEmbed(title, text));
}
}
public async Task Kick(CommandContext ctx, DiscordMember user, [RemainingText] string reason = "Not Given.")
{
await ctx.Message.DeleteAsync();
var bot = await ctx.Guild.GetMemberAsync(ctx.Client.CurrentUser.Id);
if (!ctx.Member.HasPermission(Permissions.KickMembers) && !ctx.Member.IsOwner)
{
if (!ctx.Member.HasPermission(Permissions.Administrator))
{
await ctx.RespondAsync("Sorry, only moderators and administrators are allowed to kick people.");
}
return;
}
//var userRole = user.Roles.Last();
if (user.IsAbove(bot))
{
var isBot = user == bot;
var isOwner = user == ctx.Guild.Owner;
var isMod = user.HasPermission(Permissions.KickMembers);
var isAdmin = user.HasPermission(Permissions.Administrator);
string errorReason;
_ = user.IsAbove(bot) switch
{
true when isBot => errorReason = "I wish I could kick myself, but I sadly cannot.",
true when isOwner => errorReason = $"I can't kick the owner ({user.Mention}) out of their own server!",
true when isMod => errorReason = $"I can't kick {user.Mention}! They're a moderator! ({user.Roles.Last().Mention})",
true when isAdmin => errorReason = $"I can't kick {user.Mention}! They're an admin! ({user.Roles.Last().Mention})",
_ => errorReason = "`ROLE_CHECK_NULL_REASON.` That's all I know."
};
await ctx.RespondAsync(embed : EmbedHelper.CreateEmbed(ctx, errorReason, DiscordColor.Red));
}
else
{
var embed = new DiscordEmbedBuilder(EmbedHelper.CreateEmbed(ctx, $"You've been kicked from {ctx.Guild.Name}!", "")).AddField("Reason:", reason);
try
{
await DMCommand.DM(ctx, user, embed);
}
catch (InvalidOperationException invalidop)
{
ctx.Client.DebugLogger.LogMessage(LogLevel.Error, "Silk!", invalidop.Message, DateTime.Now, invalidop);
}
await ctx.Member.RemoveAsync(reason);
ServerConfigurationManager.LocalConfiguration.TryGetValue(ctx.Guild.Id, out var guildConfig);
var logChannelID = guildConfig?.LoggingChannel;
var logChannelValue = logChannelID ?? ctx.Channel.Id;
await ctx.Client.SendMessageAsync(await ServerInfo.Instance.ReturnChannelFromID(ctx, logChannelValue),
embed : new DiscordEmbedBuilder()
.WithAuthor(ctx.Member.DisplayName, "", ctx.Member.AvatarUrl)
.WithColor(DiscordColor.SpringGreen)
.WithDescription($":boot: Kicked {user.Mention}! (User notified with direct message)")
.WithFooter("Silk")
.WithTimestamp(DateTime.Now));
}
}
public async Task Donate(CommandContext ctx, int amount, string recipient)
{
var allMembers = await ctx.Guild.GetAllMembersAsync();
var interactivity = ctx.Client.GetInteractivity();
var matchingMembers = GetMatchingMembers(allMembers);
var multipleMatches = matchingMembers.Count() > 1;
if (matchingMembers.Count() < 1)
{
await ctx.RespondAsync("Sorry, I couldn't find anyone matching that name!");
return;
}
if (multipleMatches)
{
var matches = new StringBuilder();
for (var i = 0; i < matchingMembers.Count(); i++)
{
matches.AppendLine($"[{i}]{matchingMembers.ElementAt(i).Mention}");
}
var embed = EmbedHelper.CreateEmbed(ctx, $"Multiple members matching [{recipient}].", matches.ToString());
await ctx.RespondAsync(embed : embed);
var userResposne = await interactivity.WaitForMessageAsync(message => message.Author == ctx.Member && Regex.IsMatch(message.Content, "[0-9]{1,3}"), TimeSpan.FromSeconds(20));
if (userResposne.TimedOut)
{
await ctx.RespondAsync("Sorry! Your transaction timed out (20 seconds).");
return;
}
var isFailure = int.TryParse(userResposne.Result.Content, out var selection);
if (selection > matchingMembers.Count() || isFailure)
{
await ctx.RespondAsync("Sorry, but that's not a valid selection");
return;
}
var finalizedRecipient = matchingMembers.ElementAt(selection);
if (!EconomicUsers.Instance.UserExists(ctx.Member.Id))
{
CreateEconomicUser(ctx.Member.Id);
}
if (!EconomicUsers.Instance.UserExists(finalizedRecipient.Id))
{
CreateEconomicUser(finalizedRecipient.Id);
}
await ProccessTransaction(ctx, ctx.Member.Id, finalizedRecipient.Id, amount);
}
else
{
var finalizedRecipient = matchingMembers.First();
if (!EconomicUsers.Instance.UserExists(ctx.Member.Id))
{
CreateEconomicUser(ctx.Member.Id);
}
if (!EconomicUsers.Instance.UserExists(finalizedRecipient.Id))
{
CreateEconomicUser(finalizedRecipient.Id);
}
await ProccessTransaction(ctx, ctx.Member.Id, finalizedRecipient.Id, amount);
}
async void CreateEconomicUser(ulong ID)
{
if (!EconomicUsers.Instance.UserExists(ID))
{
EconomicUsers.Instance.Add(await ctx.Guild.GetMemberAsync(ID));
}
}
IEnumerable <DiscordMember> GetMatchingMembers(IEnumerable <DiscordMember> members)
{
foreach (var member in members)
{
if (member.IsBot)
{
continue;
}
var name = member.DisplayName;
var recipientSubstringLength = recipient.Length;
if (name.Length < recipient.Length)
{
recipientSubstringLength = name.Length;
}
if (name.ToLowerInvariant().Contains(recipient.Substring(0, recipientSubstringLength).ToLowerInvariant()))
{
yield return(member);
}
else
{
continue;
}
}
}
}
public async Task SendImage(CommandContext ctx, string endpoint, string title, [Description("Mention")] DiscordMember member = null)
{
var pictureContainer = _nekosLifeImageService.GetImage(endpoint);
var embed = EmbedHelper.CreateEmbed(new DiscordColor("#00a8ff"), title, member?.Mention, pictureContainer.Url, footerText);
await ctx.RespondAsync(null, false, embed);
}
public async Task Ban(CommandContext ctx, [HelpDescription("The person to ban")] DiscordUser target, [RemainingText] string reason = "Not given.")
{
var user = await ctx.Guild.GetMemberAsync(target.Id);
var bot = await ctx.Guild.GetMemberAsync(ctx.Client.CurrentUser.Id);
if (!CanExecuteCommand(out reason))
{
await DenyBanAsync(reason);
return;
}
async Task DenyBanAsync(string reason)
{
await ctx.RespondAsync(embed : new DiscordEmbedBuilder().WithAuthor(ctx.Member.DisplayName, "", ctx.Member.AvatarUrl)
.WithColor(DiscordColor.Red).WithDescription(reason)
.WithFooter("Silk", ctx.Client.CurrentUser.AvatarUrl)
.WithTimestamp(DateTime.Now));
}
bool CanExecuteCommand(out string reason)
{
if (target == bot)
{
reason = $"I can't ban myself!";
return(false);
}
if (!ctx.Member.HasPermission(Permissions.BanMembers))
{
reason = $"You do not have permission to ban members!";
return(false);
}
if (user.IsAbove(bot))
{
reason = $"{target.Mention} has a role {user.GetHighestRoleMention()} that is above mine, and I cannot ban them!";
return(false);
}
reason = null;
return(true);
}
var userBannedEmbed = new DiscordEmbedBuilder(EmbedHelper.CreateEmbed(ctx, $"You've been banned from {ctx.Guild.Name}!", "")).AddField("Reason:", $"{(reason == "" ? "No reason provided." : reason)}");
try
{
await DMCommand.DM(ctx, target, userBannedEmbed);
}
catch (Exception e) { ctx.Client.DebugLogger.LogMessage(LogLevel.Error, "Silk", e.Message, DateTime.Now, e); }
await ctx.Guild.BanMemberAsync(user, 7, reason == ""? "No reason provided" : reason);
await ctx.Channel.SendMessageAsync(embed : new DiscordEmbedBuilder()
.WithAuthor(ctx.Member.DisplayName, "", ctx.Member.AvatarUrl)
.WithColor(DiscordColor.SpringGreen)
.WithDescription($":hammer: banned {target.Mention}!")
.WithFooter("Silk", ctx.Client.CurrentUser.AvatarUrl)
.WithTimestamp(DateTime.Now));
}