public virtual async Task AddUserCommand(CommandContext ctx, [RemainingText][Description("Your username")]
string username)
{
this.Logger.LogInformation("Trying to add {ProviderUsername} {Member} to {Name} update provider", username, ctx.Member, UserService.Name);
BaseUser user;
try
{
user = await this.UserService.AddUserAsync(username, ctx.Member.Id, ctx.Member.Guild.Id).ConfigureAwait(false);
}
catch (Exception ex)
{
var embed = ex is UserProcessingException?EmbedTemplate.ErrorEmbed(ctx, ex.Message) : EmbedTemplate.UnknownErrorEmbed(ctx);
await ctx.RespondAsync(embed : embed.Build()).ConfigureAwait(false);
this.Logger.LogError(ex, "Failed to add {ProviderUsername} {Member} to {Name} update provider", username, ctx.Member, UserService.Name);
throw;
}
this.Logger.LogInformation("Successfully added {ProviderUsername} {Member} to {Name} update provider", username, ctx.Member, UserService.Name);
await ctx.RespondAsync(embed : EmbedTemplate.SuccessEmbed(ctx,
$"Successfully added {user.Username} to {this.UserService.Name} update checker")).ConfigureAwait(false);
}
public async Task ShowMemeAsync(SocketUser user = null)
{
List <Meme> Memes;
Random rn = new Random();
User localUser;
switch (user)
{
case null:
localUser = DatabaseHandler.GetFromDb(Context.User);
Memes = DatabaseHandler.ListAll(new Meme());
break;
default:
localUser = DatabaseHandler.GetFromDb(user);
Memes = DatabaseHandler.ListAll(new Meme(), localUser);
break;
}
if (Memes.Count > 0)
{
Meme meme = Memes[rn.Next(Memes.Count)];
EmbedBuilder embed = EmbedTemplate.Create(Context.Client.CurrentUser, Context.User);
embed.WithFooter($"Submitted by: {meme.User.Username}#{meme.User.Discriminator}", meme.User.AvatarUrl);
embed.WithImageUrl(meme.Url);
embed.WithTitle($"{meme.Id} - {meme.Url}");
await ReplyAsync(Message.Info.Generic, false, embed.Build());
}
else
{
await ReplyAsync(Message.Error.NoContent(localUser));
}
}
public async Task ListMemesAsync(SocketUser user = null)
{
List <Meme> Memes;
User local;
switch (user)
{
case null:
Memes = DatabaseHandler.ListAll(new Meme());
local = DatabaseHandler.GetFromDb(Context.User);
break;
default:
local = DatabaseHandler.GetFromDb(user);
Memes = DatabaseHandler.ListAll(new Meme(), local);
break;
}
if (Memes.Count > 0)
{
EmbedBuilder embed = EmbedTemplate.Create(Context.Client.CurrentUser, Context.User);
foreach (Meme meme in Memes)
{
embed.AddField($"{meme.Id} - {meme.Url}", $"Submitted by {meme.User.Username} on {meme.CreatedAt}");
}
await ReplyAsync(Message.Info.Generic, false, embed.Build());
}
else
{
await ReplyAsync(Message.Error.NoContent(local));
}
}
public virtual async Task ListUsersCommand(CommandContext ctx)
{
var sb = new StringBuilder();
try
{
var i = 1;
await foreach (var user in this.UserService.ListUsersAsync(ctx.Guild.Id))
{
if (sb.Length + user.Username.Length > 2048)
{
if (sb.Length + "...".Length > 2048)
{
break;
}
sb.Append("...");
break;
}
sb.AppendLine(
$"{i++.ToString()}{user.Username} {(user.DiscordUser == null ? "" : Helpers.ToDiscordMention(user.DiscordUser.DiscordUserId))}");
}
}
catch (Exception ex)
{
var embed = ex is UserProcessingException?EmbedTemplate.ErrorEmbed(ctx, ex.Message) : EmbedTemplate.UnknownErrorEmbed(ctx);
await ctx.RespondAsync(embed : embed).ConfigureAwait(false);
throw;
}
await ctx.RespondAsync(embed : EmbedTemplate.SuccessEmbed(ctx, "Users").WithDescription(sb.ToString())).ConfigureAwait(false);
}
public virtual async Task DisableFeatureCommand(CommandContext context, params T[] features)
{
if (!features.Any())
{
return;
}
this.Logger.LogInformation("Trying to disable {Features} feature for {Username}", features, context.Member.DisplayName);
try
{
await this.UserFeaturesService.DisableFeaturesAsync(features, context.User.Id).ConfigureAwait(false);
}
catch (Exception ex)
{
var embed = ex is UserFeaturesException ufe
? EmbedTemplate.ErrorEmbed(context, ufe.Message, $"Failed disabling {features.Humanize().ToLowerInvariant()}")
: EmbedTemplate.UnknownErrorEmbed(context);
await context.RespondAsync(embed : embed.Build()).ConfigureAwait(false);
this.Logger.LogError(ex, "Failed to disable {Features} for {Username}", features, context.Member.DisplayName);
throw;
}
this.Logger.LogInformation("Successfully disabled {Features} feature for {Username}", features, context.Member.DisplayName);
await context.RespondAsync(embed : EmbedTemplate.SuccessEmbed(context,
$"Successfully disabled {features.Humanize()} for you")).ConfigureAwait(false);
}
public async Task ShowJokeAsync(SocketUser user = null)
{
List <Joke> Jokes;
Random rn = new Random();
User localUser;
switch (user)
{
case null:
localUser = DatabaseHandler.GetFromDb(Context.User);
Jokes = DatabaseHandler.ListAll(new Joke());
break;
default:
localUser = DatabaseHandler.GetFromDb(user);
Jokes = DatabaseHandler.ListAll(new Joke(), localUser);
break;
}
if (Jokes.Count > 0)
{
Joke joke = Jokes[rn.Next(Jokes.Count)];
EmbedBuilder embed = EmbedTemplate.Create(Context.Client.CurrentUser, Context.User);
embed.WithTitle($"{joke.Id} - {joke.Text}");
embed.WithFooter($"Submitted by: {joke.User.Username}#{joke.User.Discriminator}", joke.User.AvatarUrl);
await ReplyAsync($"Here you go:", false, embed.Build());
}
else
{
await ReplyAsync(Message.Error.NoContent(localUser));
}
}
public async Task ForceCheckCommand(CommandContext context, [RemainingText, Description("Update provider name")]
string name)
{
name = name.Trim();
BaseUpdateProvider?baseUpdateProvider;
if (this._providersConfigurationService.Providers.TryGetValue(name, out var provider) && provider is BaseUpdateProvider bup)
{
baseUpdateProvider = bup;
}
else
{
var upc = this._providersConfigurationService.Providers.Values.FirstOrDefault(p => p.Name.Where(char.IsUpper).ToString() == name);
baseUpdateProvider = upc as BaseUpdateProvider;
}
if (baseUpdateProvider != null)
{
baseUpdateProvider.RestartTimer(TimeSpan.Zero);
await context.RespondAsync(embed : EmbedTemplate.SuccessEmbed(context, "Success")).ConfigureAwait(false);
}
else
{
await context.RespondAsync(embed : EmbedTemplate.ErrorEmbed(context, "Haven't found such update provider")).ConfigureAwait(false);
}
}
public async Task UpdateChannelCommand(CommandContext ctx, [Description("New channel where updates should be posted")]
DiscordChannel?channel = null)
{
if (channel == null)
{
channel = ctx.Channel;
}
try
{
var perms = channel.PermissionsFor(ctx.Guild.CurrentMember);
if (!perms.HasPermission(Permissions.SendMessages))
{
throw new GuildManagementException(
$"Bot wouldn't be able to send updates to channel {channel} because it lacks permission to send messages");
}
await this._managementService.UpdateChannelAsync(channel.GuildId !.Value, channel.Id).ConfigureAwait(false);
}
catch (Exception ex)
{
var embed = ex is GuildManagementException?EmbedTemplate.ErrorEmbed(ctx, ex.Message) : EmbedTemplate.UnknownErrorEmbed(ctx);
await ctx.RespondAsync(embed : embed).ConfigureAwait(false);
throw;
}
await ctx.RespondAsync(embed : EmbedTemplate.SuccessEmbed(ctx, $"Successfully updated to {channel}")).ConfigureAwait(false);
}
public async Task ListJokesAsync(SocketUser user = null)
{
List <Joke> Jokes;
User localUser;
switch (user)
{
case null:
Jokes = DatabaseHandler.ListAll(new Joke());
localUser = DatabaseHandler.GetFromDb(Context.User);
break;
default:
localUser = DatabaseHandler.GetFromDb(user);
Jokes = DatabaseHandler.ListAll(new Joke(), localUser);
break;
}
if (Jokes.Count > 0)
{
EmbedBuilder embed = EmbedTemplate.Create(Context.Client.CurrentUser, Context.User);
foreach (Joke joke in Jokes)
{
embed.AddField($"{joke.Id} - {joke.Text}", $"Submitted by {joke.User.Username} on {joke.CreatedAt}");
}
await ReplyAsync(Message.Info.Generic, false, embed.Build());
}
else
{
await ReplyAsync(Message.Error.NoContent(localUser));
}
}
public async Task ShowRandomMemeAsync()
{
Random rn = new Random();
int limit = 33000;
string Path(int n) => $"http://images.memes.com/meme/{n}.jpg";
string meme = Path(rn.Next(limit));
EmbedBuilder embed = EmbedTemplate.Create(Context.Client.CurrentUser, Context.User);
embed.WithImageUrl(meme);
embed.WithTitle(meme);
await ReplyAsync(Message.Info.Generic, false, embed.Build());
}
public virtual async Task RemoveUserHereCommand(CommandContext ctx)
{
try
{
await this.UserService.RemoveUserHereAsync(ctx.User.Id, ctx.Guild.Id).ConfigureAwait(false);
}
catch (Exception ex)
{
var embed = ex is UserProcessingException?EmbedTemplate.ErrorEmbed(ctx, ex.Message) : EmbedTemplate.UnknownErrorEmbed(ctx);
await ctx.RespondAsync(embed : embed).ConfigureAwait(false);
throw;
}
await ctx.RespondAsync(embed : EmbedTemplate.SuccessEmbed(ctx, $"Now your updates won't appear in this server")).ConfigureAwait(false);
}
public async Task RemoveGuildCommand(CommandContext ctx)
{
try
{
await this._managementService.RemoveGuildAsync(ctx.Guild.Id).ConfigureAwait(false);
}
catch (Exception ex)
{
var embed = ex is GuildManagementException?EmbedTemplate.ErrorEmbed(ctx, ex.Message) : EmbedTemplate.UnknownErrorEmbed(ctx);
await ctx.RespondAsync(embed : embed).ConfigureAwait(false);
throw;
}
await ctx.RespondAsync(embed : EmbedTemplate.SuccessEmbed(ctx, "Successfully removed this server from being tracked"))
.ConfigureAwait(false);
}
public async Task ForceRemoveUserCommand(CommandContext ctx, [Description("Discord user's id which should be to removed from being tracked")]
ulong userId)
{
try
{
await this._managementService.RemoveUserAsync(ctx.Guild.Id, userId).ConfigureAwait(false);
}
catch (Exception ex)
{
var embed = ex is GuildManagementException?EmbedTemplate.ErrorEmbed(ctx, ex.Message) : EmbedTemplate.UnknownErrorEmbed(ctx);
await ctx.RespondAsync(embed : embed).ConfigureAwait(false);
throw;
}
await ctx.RespondAsync(embed : EmbedTemplate.SuccessEmbed(ctx, $"Successfully removed {userId.ToString()} this server from being tracked"))
.ConfigureAwait(false);
}
public async Task Help()
{
var embed = EmbedTemplate.Create(Context.Client.CurrentUser, Context.User);
embed.Title = "Inquisition Help:";
foreach (var c in _commands.Commands)
{
string str = "";
foreach (var a in c.Aliases.Skip(1))
{
if (a != null)
{
str += a + " | ";
}
}
embed.AddField(c.Module.Aliases.FirstOrDefault() + " " + c.Name, $"Aliases: {str}\n\n{c.Summary ?? "No specific description"}");
}
await Context.User.SendMessageAsync(Message.Info.Generic, false, embed.Build());
}
public static async Task SendEmbed(this ISocketMessageChannel channel, EmbedTemplates template, string message)
{
switch (template)
{
case EmbedTemplates.Error:
await channel.SendMessageAsync("", false, EmbedTemplate.Error(message));
break;
case EmbedTemplates.Forbidden:
await channel.SendMessageAsync("", false, EmbedTemplate.Forbidden(message));
break;
case EmbedTemplates.Info:
await channel.SendMessageAsync("", false, EmbedTemplate.Info(message));
break;
}
}
public async Task ListAllGamesAsync()
{
List <Data.Game> Games = DatabaseHandler.ListAll(new Data.Game());
if (Games.Count > 0)
{
EmbedBuilder builder = EmbedTemplate.Create(Context.Client.CurrentUser, Context.User);
foreach (Data.Game game in Games)
{
string st = game.IsOnline ? "Online " : "Offline ";
builder.AddInlineField(game.Name, st + $"on: {game.Port}, v: {game.Version}");
}
await ReplyAsync(Message.Info.Generic, false, builder.Build());
}
else
{
await ReplyAsync(Message.Error.NoContent(Context.User));
}
}
public async Task ListAlertsAsync()
{
User localUser = DatabaseHandler.GetFromDb(Context.User);
List <Alert> Alerts = DatabaseHandler.ListAll(new Alert(), localUser);
if (Alerts.Count == 0)
{
await ReplyAsync(Message.Error.NoContentGeneric);
return;
}
EmbedBuilder embed = EmbedTemplate.Create(Context.Client.CurrentUser, Context.User);
foreach (Alert n in Alerts)
{
embed.AddField($"For when {n.TargetUser.Username} joins", $"Created: {n.CreatedAt}");
}
await ReplyAsync(Message.Info.Generic, false, embed.Build());
}
public async Task ListRemindersAsync()
{
User localUser = DatabaseHandler.GetFromDb(Context.User);
List <Reminder> Reminders = DatabaseHandler.ListAll(new Reminder(), localUser);
if (Reminders.Count > 0)
{
EmbedBuilder embed = EmbedTemplate.Create(Context.Client.CurrentUser, Context.User);
foreach (Reminder reminder in Reminders)
{
embed.AddField($"{reminder.Id} - {reminder.Message ?? "No message"}", $"{reminder.DueDate}");
}
await ReplyAsync(Message.Info.Generic, false, embed.Build());
}
else
{
await ReplyAsync(Message.Error.NoContentGeneric);
}
}
public async Task CreatePollAsync([Remainder] string r = "")
{
List <Emoji> reactions = new List <Emoji> {
new Emoji("👍🏻"), new Emoji("👎🏻"), new Emoji("🤷🏻")
};
var messages = await Context.Channel.GetMessagesAsync(1).Flatten();
await Context.Channel.DeleteMessagesAsync(messages);
EmbedBuilder embed = EmbedTemplate.Create(Context.Client.CurrentUser, Context.User);
embed.WithTitle(r);
embed.WithFooter($"Asked by: {Context.User}", Context.User.GetAvatarUrl());
var msg = await ReplyAsync("", false, embed.Build());
foreach (Emoji e in reactions)
{
await msg.AddReactionAsync(e);
}
}
public virtual async Task RemoveUserInGuildCommand(CommandContext ctx)
{
this.Logger.LogInformation("Trying to remove {Member} from {Name} update provider", ctx.Member, UserService.Name);
BaseUser user;
try
{
user = await this.UserService.RemoveUserAsync(ctx.User.Id).ConfigureAwait(false);
}
catch (Exception ex)
{
var embed = ex is UserProcessingException?EmbedTemplate.ErrorEmbed(ctx, ex.Message) : EmbedTemplate.UnknownErrorEmbed(ctx);
await ctx.RespondAsync(embed : embed).ConfigureAwait(false);
this.Logger.LogError(ex, "Failed to remove {Member} from {Name} update provider", ctx.Member, UserService.Name);
throw;
}
this.Logger.LogInformation("Successfully removed {Member} from {Name} update provider", ctx.Member, UserService.Name);
await ctx.RespondAsync(embed : EmbedTemplate.SuccessEmbed(ctx,
$"Successfully removed {user.Username} from {this.UserService.Name} update checker")).ConfigureAwait(false);
}
public virtual async Task EnabledFeaturesCommand(CommandContext context)
{
var featuresDesc = await this.UserFeaturesService.EnabledFeaturesAsync(context.User.Id).ConfigureAwait(false);
await context.RespondAsync(embed : EmbedTemplate.SuccessEmbed(context, "Your enabled features").WithDescription(featuresDesc)).ConfigureAwait(false);
}
public virtual Task ListFeaturesCommand(CommandContext context) =>
context.RespondAsync(embed: EmbedTemplate.SuccessEmbed(context, "All features")
.WithDescription(string.Join(";\n",
this.UserFeaturesService.Descriptions.Values
.Select(tuple => $"[{tuple.Item1}] - {tuple.Item2}"))));
