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);