public async Task <RuntimeResult> Help()
{
IEnumerable <ModuleInfo> modules = Store.Get <IEnumerable <ModuleInfo> >();
Embed embed = EmbedFactory.Create(builder =>
{
builder.WithColor(Color.Purple);
builder.WithTitle("Help ");
builder.WithDescription($"Commands are separated per module. To get all the commands in a module, use {Prefix}Help moduleName");
foreach (var module in modules)
{
if (module.Name == nameof(Module))
{
continue;
}
string remarks = string.IsNullOrEmpty(module.Remarks) ? string.Empty : $"({module.Remarks})";
builder.AddField(module.Name.Replace("Module", string.Empty), $"{(!string.IsNullOrEmpty(module.Summary) ? module.Summary : "No summary available")}\n{remarks}");
}
});
return(new SuccessResult(embed));
}
public async Task OsuUser(
[Name("Username")] string name = "",
[Name("Game mode")] int?gameMode = null
)
{
if (name == "")
{
var query = _context.OsuUsers.FirstOrDefault(u => u.DiscordId == Context.User.Id);
if (query is null)
{
await ReplyAsync("User not registered");
return;
}
gameMode ??= query.DefaultGameMode;
name = query.OsuUsername;
}
gameMode ??= 0;
var user = await _client.GetUserByUsernameAsync(name, (GameMode)gameMode);
await ReplyAsync(embed : EmbedFactory.OsuProfile(user));
}
public async Task AddDealAsync(string url, string timeLeft = null)
{
IEnumerable <IMessage> messages = await(Context.Channel as ITextChannel)?.GetMessagesAsync(1)?.FlattenAsync();
await(Context.Channel as ITextChannel)?.DeleteMessagesAsync(messages);
IUserMessage reply = await ReplyAsync("Adding your deal...");
Deal deal = new Deal
{
Url = url,
User = User
};
if (timeLeft != null)
{
TimeSpan.TryParse(timeLeft, out TimeSpan expires);
deal.ExpireDate = DateTime.Now.Add(expires);
}
Embed embed = EmbedFactory.Create(ResultType.Success, builder => {
builder.WithTitle((messages.First() as IUserMessage).Content);
});
IUserMessage message = await ReplyAsync(embed);
deal.MessageId = message.Id;
Database.Deals.Add(deal);
}
public async Task <RuntimeResult> ListJokesAsync(SocketGuildUser user = null)
{
List <Joke> jokesList;
if (user is null)
{
jokesList = await Database.Jokes
.OrderBy(x => Guid.NewGuid())
.Take(10)
.ToListAsync();
}
else
{
jokesList = await Database.Jokes
.Where(x => x.User.Id == user.Id)
.OrderBy(x => Guid.NewGuid())
.Take(10)
.ToListAsync();
}
if (jokesList.Count is 0)
{
return(new ErrorResult(CommandError.ObjectNotFound, "No jokes in the database"));
}
Embed embed = EmbedFactory.Create(ResultType.Info, builder => {
builder.WithTitle("Here's the list of jokes");
foreach (Joke joke in jokesList)
{
builder.AddField($"{joke.Id} - {joke.Text}", $"Submitted by {joke.User.Username}");
}
});
return(new InfoResult(embed));
}
public async Task <RuntimeResult> ShowJokeAsync(SocketGuildUser user = null)
{
Joke joke;
if (user is null)
{
joke = await Database.Jokes
.OrderBy(x => Guid.NewGuid())
.FirstOrDefaultAsync();
}
else
{
joke = await Database.Jokes
.Where(x => x.User.Id == user.Id)
.OrderBy(x => Guid.NewGuid())
.FirstOrDefaultAsync();
}
if (joke is null)
{
return(new ErrorResult(CommandError.ObjectNotFound, "No jokes in the database"));
}
Embed embed = EmbedFactory.Create(ResultType.Info, builder => {
builder.WithTitle($"{joke.Id} - {joke.Text}");
builder.WithFooter($"Submitted by {joke.User.Username}", joke.User.AvatarUrl);
});
return(new InfoResult(embed));
}
public async Task <RuntimeResult> ListAlertsAsync()
{
List <Alert> alertList = await Database.Alerts
.Where(x => x.User.Id == User.Id)
.Include(x => x.User)
.Include(x => x.TargetUser)
.ToListAsync();
if (alertList.Count is 0)
{
return(new ErrorResult("No alerts were found"));
}
Embed embed = EmbedFactory.Create(ResultType.Success, builder => {
string description = "";
foreach (Alert alert in alertList)
{
description += $"Alert for **{alert.TargetUser.Username}**\n";
}
builder.WithDescription(description);
});
return(new SuccessResult(embed));
}
public async Task SetLanguage(string language)
{
var eb = new EmbedBuilder();
var ts = await TranslationManager.CreateFor(Context.Channel);
eb.Title = ts.GetMessage("commands/language:embed_title");
try
{
CultureInfo lang = new CultureInfo(language);
if (!TranslationManager.HasLanguage(lang))
{
// Please translate :)
eb = EmbedFactory.CreateError()
.WithTitle(ts.GetMessage("commands/language:embed_title"))
.WithDescription(MessageFormatter.Format(ts.GetMessage("commands/language:error_language_not_found"), lang.TwoLetterISOLanguageName));
}
else
{
eb.Color = EmbedFactory.Success;
eb.Description = MessageFormatter.Format(ts.GetMessage("commands/language:language_set_message"), lang.TwoLetterISOLanguageName);
await TranslationManager.SetLanguageAsync(TranslationManager.GetId(Context.Channel), lang);
}
}
catch (CultureNotFoundException)
{
eb.Description = ts.GetMessage("commands/language:error_unknown_language");
eb.Color = EmbedFactory.Error;
}
await ReplyAsync(embed : eb.Build());
}
public async Task <RuntimeResult> ShowRandomMemeAsync()
{
string meme = string.Format("http://images.memes.com/meme/{0}.jpg", new Random().Next(33000));
Embed embed = EmbedFactory.Create(ResultType.Info, builder => {
builder.WithTitle(meme);
builder.WithImageUrl(meme);
});
return(new SuccessResult(embed));
}
public async Task <RuntimeResult> Reply(SocketGuildUser userToReplyTo, int prevMessageIndex, [Remainder] string reply)
{
if (prevMessageIndex < 1)
{
return(new ErrorResult("The number telling me which message you want to reply to, must be at least 1!"));
}
const int messageLogLength = 20;
IEnumerable <IMessage> lastMessages = await Context.Channel.GetMessagesAsync(messageLogLength).FlattenAsync();
IEnumerable <IMessage> enumerable = lastMessages as IMessage[] ?? lastMessages.ToArray();
if (enumerable.Count() < prevMessageIndex)
{
return(new ErrorResult(EmbedFactory.Create(x =>
{
x.CreateError($"There are less than {prevMessageIndex} messages in this channel, let alone from {userToReplyTo.Username}... Please reconsider the command!");
})));
}
if (enumerable.First(x => x.Author == userToReplyTo) is null)
{
return(new ErrorResult(EmbedFactory.Create(x =>
{
x.CreateError($"{userToReplyTo.Username} hasn't sent a message in the last {messageLogLength} messages.");
})));
}
if (enumerable.Count(x => x.Author == userToReplyTo) < prevMessageIndex)
{
return(new ErrorResult(EmbedFactory.Create(x =>
{
x.CreateError($"{userToReplyTo.Username} hasn't sent {prevMessageIndex} messages in the last {messageLogLength} messages.");
})));
}
var messageToReplyTo = enumerable.Where(x => x.Author == userToReplyTo).ToArray()[prevMessageIndex - (userToReplyTo == Context.User ? 0 : 1)];
if (messageToReplyTo.Attachments.Count > 0 || messageToReplyTo.Embeds.Count > 0)
{
return(new ErrorResult(EmbedFactory.Create(x =>
{
x.CreateError("Sadly, I'm unable to handle replying to messages containing attachments or embeds... sorry 😕");
})));
}
return(new InfoResult(EmbedFactory.Create(x =>
{
x.WithColor(Color.Purple);
x.WithDescription(userToReplyTo.Mention);
x.AddField("Original:", messageToReplyTo.Content);
x.AddField("Reply:", reply);
})));
}
private async Task ProcessCommandAsync(SocketMessage arg)
{
// Source filter
if (arg.Source != MessageSource.User)
{
return;
}
var message = (SocketUserMessage)arg;
// Get the prefix
string pfx;
try
{
pfx = await GetPrefix(arg);
}
catch (Exception e)
{
string src = message.Channel is IGuildChannel gc ? $"{gc.Guild.Name} ({gc.Guild.Id})" : $"{message.Channel.Name}";
Logger.GetLogger("Commands").Warning($"Failed to get prefix. {src}", e);
return;
}
// Command check
int argPos = 0;
if (message.HasStringPrefix(pfx, ref argPos))
{
// Refresh the cached prefix
if (message.Channel is IGuildChannel c)
{
pm.RestoreCache(c.GuildId).Release();
}
var context = new SocketCommandContext(client, message);
// Log message for debugging (doesn't check if the command exists)
Logger.GetLogger("Commands").Debug($"Executing command: {GetExecutionInfo(context)}");
// Execute command
await commands.ExecuteAsync(context, argPos, services);
}
else if (message.Content.TrimEnd() == $"{pm.DefaultPrefix}prefix")
{
// Info
var context = new SocketCommandContext(client, message);
Logger.GetLogger("Commands").Debug($"Executing prefix get with default prefix: {GetExecutionInfo(context)}");
var ts = await TranslationManager.CreateFor(context.Channel);
message.Channel.SendMessageAsync(embed: EmbedFactory.CreateSuccess()
.WithTitle(ts.GetMessage("commands/prefix:embed_title"))
.WithDescription(MessageFormatter.Format(ts.GetMessage("commands/prefix:my_prefix_is"),
PrefixManagerService.PrettyPrefix(pfx)))
.Build()).Release();
}
}
public async Task <RuntimeResult> ShowDefaultAuditChannelAsync()
{
SocketTextChannel channel = Context.Client.GetChannel(Guild.AuditChannelId) as SocketTextChannel;
if (channel is null)
{
return(new ErrorResult(CommandError.UnmetPrecondition, "No default audit channel set for this guild"));
}
Embed embed = EmbedFactory.Create(ResultType.Info, builder => {
builder.WithTitle("Here's the audit channel");
builder.WithDescription(channel.Mention);
});
return(new InfoResult(embed));
}
public async Task ResetPrefix()
{
// Prepare reply
var ts = await TranslationManager.CreateFor(Context.Channel);
var eb = EmbedFactory.CreateSuccess()
.WithTitle(ts.GetMessage("commands/prefix:embed_title"));
var messageSend = ReplyAsync(embed: eb.Build());
await pm.CachePrefix(Context.Guild.Id, pm.DefaultPrefix);
await pm.SetPrefixAsync(Context.Guild.Id, pm.DefaultPrefix);
await messageSend;
}
public async Task Info()
{
Embed embed = EmbedFactory.Create(x =>
{
x.WithColor(Color.Purple);
x.ThumbnailUrl = Guild.IconUrl;
x.AddField("Server Name", Guild.Name ?? "null");
if (Guild.AuditChannelId != null)
{
SocketTextChannel auditChannel = (SocketTextChannel)Context.Guild.GetChannel(Guild.AuditChannelId.Value);
x.AddField("Audit Channel", auditChannel != null ? auditChannel.Mention : "Invalid channel!");
}
x.AddField("Command prefix", Prefix);
});
await ReplyAsync(embed);
}
public async Task CreatePollAsync([Remainder] string question)
{
IEnumerable <IMessage> messages = await Context.Channel.GetMessagesAsync(1).FlattenAsync();
await(Context.Channel as ITextChannel).DeleteMessagesAsync(messages);
Embed embed = EmbedFactory.Create(ResultType.Info, builder => {
builder.WithTitle(question);
builder.WithFooter($"Asked by {Context.User.Username}", Context.User.GetAvatarUrl() ?? null);
});
IUserMessage message = await ReplyAsync(embed);
foreach (Emoji reaction in _reactions)
{
await message.AddReactionAsync(reaction);
await Task.Delay(250);
}
}
public async Task Help([Name("(Optional) Command name")] string commandName = "")
{
if (commandName == "")
{
await ReplyAsync(embed : EmbedFactory.ListCommands(_commands.Modules));
return;
}
var command = _commands.Commands.FirstOrDefault(c => c.Name == commandName);
if (command is null)
{
await ReplyAsync("Command not found");
return;
}
await ReplyAsync(embed : EmbedFactory.CommandInfo(command));
}
public async Task <RuntimeResult> ListRemindersAsync()
{
List <Reminder> reminderList = await Database.Reminders
.Where(x => x.User.Id == User.Id)
.ToListAsync();
if (reminderList.Count is 0)
{
return(new ErrorResult(CommandError.ObjectNotFound, "No reminders in the database"));
}
Embed embed = EmbedFactory.Create(ResultType.Info, builder => {
builder.WithTitle("Here's your reminders");
foreach (Reminder reminder in reminderList)
{
builder.AddField($"{reminder.Id} - {reminder.Message ?? "No message"}", $"{reminder.DueDate}");
}
});
return(new InfoResult(embed));
}
public async Task <RuntimeResult> ShowDealsAsync()
{
List <Deal> dealList = await Database.Deals
.ToListAsync();
if (dealList.Count is 0)
{
return(new ErrorResult(CommandError.ObjectNotFound, "No deals were found"));
}
Embed embed = EmbedFactory.Create(ResultType.Success, builder => {
builder.WithTitle("Here's the deals");
foreach (Deal deal in dealList)
{
builder.AddField($"{deal.Url}", $"{deal.ExpireDate}");
}
});
return(new SuccessResult("Success", embed));
}
public async Task League([Name("Summoner name")] string name = "", [Name("Region")] string region = "")
{
if (name == "")
{
var query = _context.LeagueSummoners.SingleOrDefault(u => u.DiscordId == Context.User.Id);
if (query is null)
{
await ReplyAsync("User not registered");
return;
}
name = query.SummonerName;
}
var summoner = _api.SummonerV4.GetBySummonerName(Region.Get(region), name);
var topChampions = await _api.ChampionMasteryV4.GetAllChampionMasteriesAsync(
Region.Get(region), summoner.Id);
await ReplyAsync(embed : EmbedFactory.LeagueProfile(summoner, topChampions));
}
public async Task <Embed> HelpAsync(ICommandContext context, string query, SearchContext searchContext)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (query is null)
{
throw new ArgumentNullException(nameof(query));
}
var commands = (await SearchCommands(context, query, searchContext)).ToList();
if (commands.Count == 0)
{
var ts = await TranslationManager.CreateFor(context.Channel);
return(EmbedFactory.CreateNeutral()
.WithTitle(ts.GetMessage("help:embed_title"))
.WithDescription(ts.GetMessage("help:command_not_found"))
.Build());
}
// NOTE: This system breaks when there are two commands with the same alias. Avoid using same aliases
if (commands.Count > 1)
{
var ts = await TranslationManager.CreateFor(context.Channel);
return(EmbedFactory.CreateNeutral()
.WithTitle(ts.GetMessage("help:embed_title"))
.WithDescription($"{ts.GetMessage("help:multiple_matches")}\n{String.Join("\n", commands.Select(x => Format.Code(x.GetUsage())))}")
.Build());
}
else
{
return(await commands[0].CreateHelpEmbedAsync(context));
}
}
public async Task LeagueHistory([Name("Summoner name")] string summonerName = "", [Name("Region")] string region = "")
{
var summonerRegion = Region.Get(region);
var summoner = await _api.SummonerV4.GetBySummonerNameAsync(summonerRegion, summonerName);
if (summoner is null)
{
await ReplyAsync("User not found");
return;
}
var matchList = await _api.MatchV4.GetMatchlistAsync(
summonerRegion,
summoner.AccountId,
endIndex : 10);
var matchTasks = matchList.Matches.Select(
matchData => _api.MatchV4.GetMatchAsync(summonerRegion, matchData.GameId)
).ToArray();
var history = await Task.WhenAll(matchTasks);
await ReplyAsync(embed : EmbedFactory.LeagueHistory(summoner, history));
}
public async Task <RuntimeResult> ListAllGamesAsync()
{
List <Domain.Game> gamesList = await Database.Games
.ToListAsync();
if (gamesList.Count is 0)
{
return(new ErrorResult(CommandError.ObjectNotFound, "No games found in the database"));
}
Embed embed = EmbedFactory.Create(ResultType.Info, builder => {
builder.WithTitle("Here are the currently registered game servers");
builder.WithCurrentTimestamp();
foreach (Domain.Game game in gamesList)
{
string st = game.IsOnline ? "Online " : "Offline ";
builder.AddField(game.Name, st + $"on port {game.Port}, version {game.Version}");
}
});
return(new InfoResult("Info", embed));
}
/// <summary>
/// Attempts to post a new announcement
/// </summary>
/// <param name="discordService">The discord service</param>
/// <param name="tracker">The tracker</param>
/// <param name="race">The race</param>
/// <returns>On Success, returns the announcement</returns>
private static async Task <Announcement?> PostAnnouncementAsync(DiscordService discordService, Tracker tracker, Race race, List <Entrant> entrants)
{
Logger.Info($"({race.SrlId}) Posting announcement in channel {tracker.ChannelId}: {tracker.Channel.Guild.DisplayName}/{tracker.Channel.DisplayName}.");
try
{
RestUserMessage?message = await discordService
.SendEmbedAsync(tracker.Channel.Snowflake, EmbedFactory.Build(race, entrants)).ConfigureAwait(false);
if (message != null)
{
return(new Announcement(tracker.Channel, tracker, race, message.Id)
{
MessageCreatedAt = DateTime.UtcNow
});
}
}
catch (Exception ex)
{
Logger.Error($"({race.SrlId}) Exception thrown", ex);
}
return(null);
}
/// <summary>
/// Attempts to update an existing announcement
/// </summary>
/// <param name="discordService">The discord service</param>
/// <param name="announcement">The target announcement</param>
private static async Task UpdateAnnouncementAsync(DiscordService discordService, Announcement announcement, List <Entrant> entrants)
{
Logger.Info($"({announcement.Race.SrlId}) Updating announcement {announcement.Snowflake} in channel {announcement.ChannelId}: {announcement.Channel.Guild.DisplayName}/{announcement.Channel.DisplayName}.");
RestUserMessage?message = await discordService.FindMessageAsync(announcement.Channel, announcement.Snowflake).ConfigureAwait(false);
if (message != null)
{
try
{
await discordService.ModifyMessageAsync(message, EmbedFactory.Build(announcement.Race, entrants)).ConfigureAwait(false);
announcement.MessageUpdatedAt = DateTime.UtcNow;
}
catch (Exception ex)
{
Logger.Error($"({announcement.Race.SrlId}) Exception thrown", ex);
}
}
else
{
Logger.Info($"({announcement.Race.SrlId}) Failed to fetch message {announcement.Snowflake} in channel {announcement.ChannelId}: {announcement.Channel.Guild.DisplayName}/{announcement.Channel.DisplayName}.");
}
}
public async Task <RuntimeResult> ShowActivitiesAsync()
{
List <Domain.Activity> activityList = await Database.Activities
.Where(x => x.User.Id == User.Id)
.ToListAsync();
if (activityList.Count is 0)
{
return(new ErrorResult(CommandError.ObjectNotFound, "No activities were found"));
}
Embed embed = EmbedFactory.Create(ResultType.Success, builder => {
foreach (Domain.Activity activity in activityList)
{
builder.AddField(field => {
field.WithName(activity.Name);
field.WithValue(activity.Arguments);
field.WithIsInline(false);
});
}
});
return(new SuccessResult(embed));
}
public async Task <RuntimeResult> Reply(ulong messageId, [Remainder] string reply)
{
if (!(Context.Channel is ITextChannel currentChannel))
{
return(new ErrorResult(EmbedFactory.Create(x =>
{
x.CreateError("Sorry, was unable to cast the current channel to ITextChannel");
})));
}
IMessage message = await currentChannel.GetMessageAsync(messageId);
if (message is null)
{
return(new ErrorResult(EmbedFactory.Create(x =>
{
x.CreateError("Sorry, was unable to find the requested message");
})));
}
if (message.Attachments.Count > 0 || message.Embeds.Count > 0)
{
return(new ErrorResult(EmbedFactory.Create(x =>
{
x.CreateError("Sadly, I'm unable to handle replying to messages containing attachments or embeds... sorry 😕");
})));
}
return(new InfoResult(EmbedFactory.Create(x =>
{
x.WithColor(Color.Purple);
x.WithDescription(message.Author.Mention);
x.AddField("Original: ", message.Content);
x.AddField("Reply: ", reply);
})));
}
public async Task BotInfo() => await Context.Channel.SendMessageAsync(embed : EmbedFactory.About(Context));
public async Task Avatar() => await Context.Channel.SendMessageAsync(embed : EmbedFactory.Avatar(Context));
public CommandErrorHandler(EmbedFactory embedFactory)
{
_embedFactory = embedFactory;
}
public async Task Prefix([Summary("commands/prefix:parameter_prefix")][Remainder] string prefix = null)
{
// Prepare reply
EmbedBuilder eb;
var reply = new StringBuilder();
var ts = await TranslationManager.CreateFor(Context.Channel);
// Get the prefix
if (prefix is null)
{
// Get prefix
var prefixGet = pm.GetPrefixAsync(Context.Guild?.Id);
// Prepare message
eb = EmbedFactory.CreateSuccess()
.WithTitle(ts.GetMessage("commands/prefix:embed_title"));
// Send a message
reply.AppendLine(MessageFormatter.Format(ts.GetMessage("commands/prefix:my_prefix_is"), PrefixManagerService.PrettyPrefix(await prefixGet)));
if (Context.IsPrivate)
{
reply.AppendLine(ts.GetMessage("commands/prefix:error_private_messages"));
}
eb.Description = reply.ToString();
await ReplyAsync(embed : eb.Build());
// Return!
return;
}
// Check if in guild
if (Context.Guild is null)
{
// No
eb = EmbedFactory.CreateError()
.WithTitle(ts.GetMessage("errors:permission_denied"));
reply.AppendLine(ts.GetMessage("commands/prefix:error_private_messages"));
}
else
{
// In guild
string currentPrefix = await pm.GetPrefixAsync(Context.Guild.Id);
if (currentPrefix == prefix)
{
eb = EmbedFactory.CreateError()
.WithTitle(ts.GetMessage("errors:permission_denied"));
reply.AppendLine(ts.GetMessage("commands/prefix:error_same_prefix"));
}
else
{
if (!Regex.IsMatch(prefix, @"[A-Za-zÅÖÄåöä0-9!?+\/%$#]*"))
{
eb = EmbedFactory.CreateError()
.WithTitle(ts.GetMessage("commands/prefix:embed_title"))
.WithDescription("commands/prefix:error_invalid_prefix");
await ReplyAsync(embed : eb.Build());
return;
}
// Update the prefix cache
await pm.CachePrefix(Context.Guild.Id, prefix);
// Send the info message here for seemingly better performance. The prefix is cached in Redis so it will still work.
eb = EmbedFactory.CreateSuccess()
.WithTitle(ts.GetMessage("commands/prefix:embed_title"));
reply.AppendLine(MessageFormatter.Format(ts.GetMessage("commands/prefix:prefix_set_message"),
PrefixManagerService.PrettyPrefix(prefix)));
// Send message
eb.Description = reply.ToString();
ReplyAsync(embed: eb.Build()).Release();
try
{
// Set prefix in the actual database.
await pm.SetPrefixAsync(Context.Guild.Id, prefix);
}
catch (Exception e)
{
// Log the error so that it can be debugged
var log = Logger.GetLogger(this);
log.Warning($"Failed to store prefix for guild {Context.Guild.Name} ({Context.Guild.Id}): pfx: {prefix} Exception:", e);
}
return;
}
}
// Send message
eb.Description = reply.ToString();
await ReplyAsync(embed : eb.Build());
}
public Music(IMusicService musicService, EmbedFactory embedFactory)
{
_musicService = musicService;
_embedFactory = embedFactory;
}
