private async Task HandleMessageAsync(SocketMessage message)
{
if (!CommandUtilities.HasPrefix(message.Content, config["prefix"], StringComparison.OrdinalIgnoreCase, out string output))
{
return;
}
if (!(message.Channel is SocketTextChannel textChannel) || !(message.Author is SocketGuildUser guildUser))
{
await message.Channel.SendMessageAsync(embed : EmbedUtils.UnsupportedEnvironment);
return;
}
if (!guildUser.Guild.CurrentUser.GetPermissions(textChannel).SendMessages)
{
return;
}
var context = new ScrapContext(client, message as SocketUserMessage, provider);
var result = await commands.ExecuteAsync(output, context);
if (!(result is FailedResult failedResult))
{
return;
}
if (failedResult is CommandNotFoundResult)
{
return;
}
await message.Channel.SendMessageAsync(embed : EmbedUtils.FailedResultEmbed(failedResult));
}
private async Task HandleMessageReceivedAsync(MessageReceivedEventArgs args)
{
_ = Executor.ExecuteAsync(async() => await _autoResponse.OnMessageReceivedAsync(args));
_ = Executor.ExecuteAsync(async() => await _dad.OnMessageReceivedAsync(args));
_ = Executor.ExecuteAsync(async() => await _reaction.OnMessageReceivedAsync(args));
_ = Executor.ExecuteAsync(async() => await _moderation.OnMessageReceivedAsync(args));
_ = Executor.ExecuteAsync(async() => await _owo.OnMessageReceivedAsync(args));
_ = Executor.ExecuteAsync(async() => await _counting.OnMessageReceivedAsync(args));
if (CommandUtilities.HasPrefix(args.Message.Content, Config.CommandPrefix, out var cmd))
{
var sw = Stopwatch.StartNew();
var res = await _service.ExecuteAsync(cmd, args.Context, DepressedBot.ServiceProvider);
sw.Stop();
if (res is CommandNotFoundResult)
{
return;
}
var targetCommand = _service.GetAllCommands()
.FirstOrDefault(x => x.FullAliases.ContainsIgnoreCase(cmd))
?? _service.GetAllCommands()
.FirstOrDefault(x => x.FullAliases.ContainsIgnoreCase(cmd.Split(' ')[0]));
await OnCommandAsync(targetCommand, res, args.Context, sw);
}
}
private async Task CommandHandler(SocketMessage msg)
{
// Do not respond to bot accounts or system messages.
if (!(msg is SocketUserMessage message) || msg.Author.IsBot)
{
return;
}
// Respond to both mentions and your prefix.
#warning Ensure that this configuration variable is set.
if (!CommandUtilities.HasPrefix(message.Content, _config["prefix"], out var output))
{
return;
}
var context = new DiscordCommandContext(_client, message, _services);
IResult res = await _commands.ExecuteAsync(output, context);
switch (res)
{
case FailedResult fRes:
_logger.LogError("Command execution failed with reason: {0}", fRes.Reason);
break;
}
}
public async Task <bool> ExecuteCommand(string input)
{
if (!CommandUtilities.HasPrefix(input, '/', out string output))
{
return(false);
}
IResult result = await _service.ExecuteAsync(output, new CustomCommandContext(input));
if (result is FailedResult failedResult)
{
switch (result)
{
case CommandNotFoundResult err:
return(false);
case TypeParseFailedResult err:
IRC.Messages.AddSystemMessage($"Type error in `{err.Parameter}` excepted type: `{err.Parameter.Type}` got: `{err.Value.GetType()}`");
break;
case ArgumentParseFailedResult err:
IRC.Messages.AddSystemMessage(err.FailureReason);
break;
}
}
return(true);
}
public async Task MessageReceived(SlackMessage message)
{
if (message.User.IsBot)
{
return;
}
if (!CommandUtilities.HasPrefix(message.Text, $"<@{_connection.Self.Id}> ", out var output))
{
return;
}
var context = new CustomCommandContext(message, _connection);
await _commandService.ExecuteAsync(output, context, _serviceProvider);
}
private async Task ClientOnMessageReceived(SocketMessage arg)
{
if (!(arg is SocketUserMessage msg))
{
return;
}
if (arg.Author.IsBot)
{
return;
}
if (!CommandUtilities.HasPrefix(arg.Content, ";", StringComparison.CurrentCultureIgnoreCase, out var output))
{
return;
}
await _command.ExecuteAsync(output, new SocketCommandContext(_client, msg, msg.Author), _provider);
}
private async void HandleMessageAsync(object sender, MessageEventArgs args)
{
var message = args.Message;
if (!CommandUtilities.HasPrefix(message.Text, _config["prefix"], out string output))
{
return;
}
var context = new BotContext(_client, message, _provider);
var result = await _commands.ExecuteAsync(output, context);
if (result is FailedResult failedResult)
{
await _client.SendTextMessageAsync(message.Chat, failedResult.Reason);
}
}
internal async Task ParseMessage(string message, Client source, sbyte position = 0)
{
if (!CommandUtilities.HasPrefix(message, '/', out string output))
{
await this.BroadcastAsync($"<{source.Player.Username}> {message}", position);
return;
}
//TODO command logging
var context = new ObsidianContext(source, this, this.Services);
IResult result = await Commands.ExecuteAsync(output, context);
if (!result.IsSuccessful)
{
await context.Player.SendMessageAsync($"{ChatColor.Red}Command error: {(result as FailedResult).Reason}", position);
}
}
public async Task ParseMessage(string message, Client source, byte position = 0)
{
if (!CommandUtilities.HasPrefix(message, '/', out string output))
{
_chatmessages.Enqueue(new QueueChat()
{
Message = $"<{source.Player.Username}> {message}", Position = position
});
Logger.LogMessage($"<{source.Player.Username}> {message}");
return;
}
var context = new CommandContext(source, this);
IResult result = await Commands.ExecuteAsync(output, context);
if (!result.IsSuccessful)
{
await context.Player.SendMessageAsync($"{ChatColor.Red}Command error: {(result as FailedResult).Reason}", position);
}
}
private async Task MessageReceivedAsync(MessageReceivedEventArgs args)
{
if (!(args.Message is CachedUserMessage userMessage))
{
return;
}
if (userMessage.Author.IsBot)
{
return;
}
var guildChannel = userMessage.Channel as CachedTextChannel;
if (guildChannel != null)
{
await RunTaskAsync(_botService.AddAssignableRoleAsync((CachedMember)userMessage.Author));
await RunTaskAsync(_xpService.AddUserXpAsync(userMessage.Author));
await RunTaskAsync(_xpService.AddGuildUserXpAsync((CachedMember)userMessage.Author, userMessage.Channel));
}
var prefix = await GetGuildPrefixAsync(guildChannel?.Guild);
if (CommandUtilities.HasPrefix(userMessage.Content, prefix, out var output) ||
RiasUtilities.HasMentionPrefix(userMessage, out output))
{
await RunTaskAsync(ExecuteCommandAsync(userMessage, userMessage.Channel, prefix, output));
return;
}
if (userMessage.Client.CurrentUser is null)
{
return;
}
if (CommandUtilities.HasPrefix(userMessage.Content, userMessage.Client.CurrentUser.Name, StringComparison.InvariantCultureIgnoreCase, out output))
{
await RunTaskAsync(ExecuteCommandAsync(userMessage, userMessage.Channel, prefix, output));
}
}
public async Task HandleMessageAsync(SocketMessage socketMessage)
{
if (!(socketMessage is SocketUserMessage message) || message.Channel is IDMChannel)
{
return;
}
var context = new GuildContext(_client, message);
var blacklist = await _database.BlacklistedUsers.AsNoTracking().FirstOrDefaultAsync(x => x.UserId == message.Author.Id);
var botConfig = await _database.BotConfigs.AsNoTracking().FirstAsync();
var guild = await _database.Guilds.AsNoTracking().Include(x => x.Users).Include(x => x.Profanities).FirstAsync(x => x.GuildId == context.Guild.Id);
if (!(blacklist is null) || message.Source != MessageSource.User)
{
return;
}
await ProfanityHandler(message, guild);
// Inline Wiki command, just because the users want it so bad
if (message.Content.Contains("[["))
{
var item = message.Content.Split('[', ']')[2];
var result = await _commands.ExecuteAsync("Wiki " + item, context, _services);
}
else
{
if (!CommandUtilities.HasPrefix(message.Content, botConfig.Prefix, out string output))
{
return;
}
var result = await _commands.ExecuteAsync(output, context, _services);
await CommandExecutedResultAsync(result, context);
}
}
/// <inheritdoc/> public bool TryFind(IGatewayUserMessage message, out string output) => CommandUtilities.HasPrefix(message.Content, Value, Comparison, out output);
public async Task HandleMessageAsync(MessageReceivedEventArgs args)
{
if (Config.EnabledFeatures.Blacklist)
{
await _blacklist.CheckMessageAsync(args);
}
if (Config.EnabledFeatures.Antilink)
{
await _antilink.CheckMessageAsync(args);
}
if (Config.EnabledFeatures.PingChecks)
{
await _pingchecks.CheckMessageAsync(args);
}
var prefixes = new List <string>
{
args.Data.Configuration.CommandPrefix, $"<@{args.Context.Client.CurrentUser.Id}> ",
$"<@!{args.Context.Client.CurrentUser.Id}> "
};
if (CommandUtilities.HasAnyPrefix(args.Message.Content, prefixes, StringComparison.OrdinalIgnoreCase, out _,
out var cmd))
{
var sw = Stopwatch.StartNew();
var result = await _commandService.ExecuteAsync(cmd, args.Context);
sw.Stop();
if (!(result is CommandNotFoundResult))
{
await OnCommandAsync(new CommandCalledEventArgs(result, args.Context, sw));
}
}
else
{
if (args.Message.Content.EqualsAnyIgnoreCase($"<@{args.Context.Client.CurrentUser.Id}>",
$"<@!{args.Context.Client.CurrentUser.Id}>"))
{
await args.Context.CreateEmbed(
$"The prefix for this guild is **{args.Data.Configuration.CommandPrefix}**; " +
$"alternatively you can just mention me as a prefix, i.e. `@{args.Context.Guild.CurrentUser} help`.")
.ReplyToAsync(args.Message);
}
else if (!await _quoteService.CheckMessageAsync(args))
{
if (CommandUtilities.HasPrefix(args.Message.Content, '%', out var tagName))
{
var tag = args.Context.GuildData.Extras.Tags.FirstOrDefault(t =>
t.Name.EqualsIgnoreCase(tagName));
if (tag is null)
{
return;
}
if (args.Context.GuildData.Configuration.EmbedTagsAndShowAuthor)
{
await tag.AsEmbed(args.Context).SendToAsync(args.Message.Channel);
}
else
{
await args.Message.Channel.SendMessageAsync(tag.FormatContent(args.Context));
}
}
}
}
}
private async Task HandleReceivedMessageAsync(CachedUserMessage message)
{
if (message.Author.IsBot)
{
return;
}
if (!(message.Channel is CachedTextChannel textChannel) ||
!textChannel.Guild.CurrentMember.GetPermissionsFor(textChannel).Has(Permission.SendMessages))
{
return;
}
if (CommandUtilities.HasAnyPrefix(message.Content, Prefixes, StringComparison.CurrentCulture, out var prefix, out var output) ||
CommandUtilities.HasPrefix(message.Content, $"<@{Client.CurrentUser.Id}>", StringComparison.Ordinal, out output) ||
CommandUtilities.HasPrefix(message.Content, $"<@!{Client.CurrentUser.Id}>", StringComparison.Ordinal, out output))
{
if (string.IsNullOrWhiteSpace(output))
{
return;
}
try
{
if (prefix is null)
{
prefix = Client.CurrentUser.Mention;
}
var ctx = MummyContext.Create(Client, message, Services, prefix);
ActiveTimings[ctx.UserId] = Stopwatch.StartNew();
var r = await Commands.ExecuteAsync(output, ctx);
ActiveTimings[ctx.UserId].Stop();
ActiveTimings.Remove(ctx.UserId, out var st);
if (r.IsSuccessful)
{
LogService.LogInformation($"command: {ctx.Command.Name} has successful finished execution in {st.ElapsedMilliseconds}ms.", LogSource.MessagesService, ctx.GuildId);
}
else
{
switch (r)
{
case ExecutionFailedResult executionfailed:
{
LogService.LogError(executionfailed.ToString(), LogSource.MessagesService, ctx.GuildId, executionfailed.Exception);
break;
}
case ArgumentParseFailedResult parsefailed:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithTitle("ArmgumentParseFailure");
eb.AddField(parsefailed.Reason, parsefailed.RawArguments);
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case ArgumentParserResult parseresult:
{
LogService.LogCritical("dunno argumentparse", LogSource.MessagesService, ctx.GuildId);
await ctx.Channel.SendMessageAsync("a error has occoured and not been handled this error will be resolved shortly. (hopefully)");
break;
}
case ChecksFailedResult checksfailed:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithTitle($"{checksfailed.FailedChecks.Count} checks have failed");
foreach (var(Check, Result) in checksfailed.FailedChecks)
{
eb.AddField((Check as MummyCheckBase).Name, Result.Reason, true);
}
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case CommandDisabledResult disabled:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
await ctx.Channel.SendMessageAsync();
eb.WithTitle($"{disabled.Command} is currently diabled");
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case CommandNotFoundResult notfound:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithTitle($"command with name {notfound.Reason}");
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case CommandOnCooldownResult oncooldown:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithTitle($"{oncooldown.Command.Name} is currently on cooldown");
foreach (var(cooldown, retryafter) in oncooldown.Cooldowns)
{
int index = cooldown.ToString().LastIndexOf('.');
var bucketype = (CooldownBucketType)cooldown.BucketType;
eb.AddField(cooldown.ToString().Substring(index + 1), $"is only allowed to be run {cooldown.Amount} per {cooldown.Per.Humanize()} and it forced per {bucketype}, currently locked for {retryafter.TotalMinutes} Minutes", true);
}
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case OverloadsFailedResult overloadsFailed:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithDescription(overloadsFailed.Reason);
foreach (var(command, overloadResult) in overloadsFailed.FailedOverloads)
{
eb.AddField($"{command.Name} {string.Join(' ', command.Parameters.Select(x => x.Name))}", overloadResult.Reason);
}
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case ParameterChecksFailedResult paramcheckfailed:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithTitle($"checks on {paramcheckfailed.Parameter} have failed with provided argument: {paramcheckfailed.Argument}");
foreach (var(Check, Result) in paramcheckfailed.FailedChecks)
{
var index = Check.ToString().LastIndexOf('.');
var name = Check.ToString().Substring(index + 1);
eb.AddField(name, Result.Reason);
}
break;
}
case TypeParseFailedResult typeParseFailed:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.AddField(typeParseFailed.Parameter.Name, typeParseFailed.Reason);
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
}
}
}
catch (Exception ex)
{
LogService.LogError("Issue with message service", LogSource.MessagesService, exception: ex);
}
}
}
public bool TryFind(CachedUserMessage message, out string output)
{
return(CommandUtilities.HasPrefix(message.Content, Prefix,
StringComparison.OrdinalIgnoreCase, out output));
}
public bool TryFind(CachedUserMessage message, out string output) => CommandUtilities.HasPrefix(message.Content, Value, IsCaseSensitive, out output);