private async Task RunAllChecksAsync(Command cmd, CommandContext ctx)
{
if (cmd.Parent != null)
{
await this.RunAllChecksAsync(cmd.Parent, ctx).ConfigureAwait(false);
}
var fchecks = await cmd.RunChecksAsync(ctx, false).ConfigureAwait(false);
if (fchecks.Any())
{
throw new ChecksFailedException(cmd, ctx, fchecks);
}
}
public async Task DefaultHelpAsync(CommandContext ctx, [Description("Command to provide help for.")] params string[] command)
{
var topLevel = ctx.CommandsNext.TopLevelCommands.Values.Distinct();
var helpBuilder = ctx.CommandsNext.HelpFormatter.Create(ctx);
if (command != null && command.Any())
{
Command cmd = null;
var searchIn = topLevel;
foreach (var c in command)
{
if (searchIn == null)
{
cmd = null;
break;
}
if (ctx.Config.CaseSensitive)
{
cmd = searchIn.FirstOrDefault(xc => xc.Name == c || (xc.Aliases != null && xc.Aliases.Contains(c)));
}
else
{
cmd = searchIn.FirstOrDefault(xc => xc.Name.ToLowerInvariant() == c.ToLowerInvariant() || (xc.Aliases != null && xc.Aliases.Select(xs => xs.ToLowerInvariant()).Contains(c.ToLowerInvariant())));
}
if (cmd == null)
{
break;
}
var failedChecks = await cmd.RunChecksAsync(ctx, true).ConfigureAwait(false);
if (failedChecks.Any())
{
throw new ChecksFailedException(cmd, ctx, failedChecks);
}
if (cmd is CommandGroup)
{
searchIn = (cmd as CommandGroup).Children;
}
else
{
searchIn = null;
}
}
if (cmd == null)
{
throw new CommandNotFoundException(string.Join(" ", command));
}
helpBuilder.WithCommand(cmd);
if (cmd is CommandGroup group)
{
var commandsToSearch = group.Children.Where(xc => !xc.IsHidden);
var eligibleCommands = new List <Command>();
foreach (var candidateCommand in commandsToSearch)
{
if (candidateCommand.ExecutionChecks == null || !candidateCommand.ExecutionChecks.Any())
{
eligibleCommands.Add(candidateCommand);
continue;
}
var candidateFailedChecks = await candidateCommand.RunChecksAsync(ctx, true).ConfigureAwait(false);
if (!candidateFailedChecks.Any())
{
eligibleCommands.Add(candidateCommand);
}
}
if (eligibleCommands.Any())
{
helpBuilder.WithSubcommands(eligibleCommands.OrderBy(xc => xc.Name));
}
}
}
else
{
var commandsToSearch = topLevel.Where(xc => !xc.IsHidden);
var eligibleCommands = new List <Command>();
foreach (var sc in commandsToSearch)
{
if (sc.ExecutionChecks == null || !sc.ExecutionChecks.Any())
{
eligibleCommands.Add(sc);
continue;
}
var candidateFailedChecks = await sc.RunChecksAsync(ctx, true).ConfigureAwait(false);
if (!candidateFailedChecks.Any())
{
eligibleCommands.Add(sc);
}
}
if (eligibleCommands.Any())
{
helpBuilder.WithSubcommands(eligibleCommands.OrderBy(xc => xc.Name));
}
}
var helpMessage = helpBuilder.Build();
var builder = new DiscordMessageBuilder().WithContent(helpMessage.Content).WithEmbed(helpMessage.Embed);
if (!ctx.Config.DmHelp || ctx.Channel is DiscordDmChannel || ctx.Guild == null)
{
await ctx.RespondAsync(builder).ConfigureAwait(false);
}
else
{
await ctx.Member.SendMessageAsync(builder).ConfigureAwait(false);
}
}
/// <summary>
/// Executes this command or its subcommand with specified context.
/// </summary>
/// <param name="ctx">Context to execute the command in.</param>
/// <returns>Command's execution results.</returns>
public override async Task <CommandResult> ExecuteAsync(CommandContext ctx)
{
var findpos = 0;
var cn = CommandsNextUtilities.ExtractNextArgument(ctx.RawArgumentString, ref findpos);
if (cn != null)
{
Command cmd = null;
if (ctx.Config.CaseSensitive)
{
cmd = this.Children.FirstOrDefault(xc => xc.Name == cn || (xc.Aliases != null && xc.Aliases.Contains(cn)));
}
else
{
cmd = this.Children.FirstOrDefault(xc => xc.Name.ToLowerInvariant() == cn.ToLowerInvariant() || (xc.Aliases != null && xc.Aliases.Select(xs => xs.ToLowerInvariant()).Contains(cn.ToLowerInvariant())));
}
if (cmd != null)
{
// pass the execution on
var xctx = new CommandContext
{
Client = ctx.Client,
Message = ctx.Message,
Command = cmd,
Config = ctx.Config,
RawArgumentString = ctx.RawArgumentString.Substring(findpos),
Prefix = ctx.Prefix,
CommandsNext = ctx.CommandsNext,
Services = ctx.Services
};
var fchecks = await cmd.RunChecksAsync(xctx, false).ConfigureAwait(false);
if (fchecks.Any())
{
return new CommandResult
{
IsSuccessful = false,
Exception = new ChecksFailedException(cmd, xctx, fchecks),
Context = xctx
}
}
;
return(await cmd.ExecuteAsync(xctx).ConfigureAwait(false));
}
}
if (!this.IsExecutableWithoutSubcommands)
{
return new CommandResult
{
IsSuccessful = false,
Exception = new InvalidOperationException("No matching subcommands were found, and this group is not executable."),
Context = ctx
}
}
;
return(await base.ExecuteAsync(ctx).ConfigureAwait(false));
}
}
}
public async Task DefaultHelpAsync(CommandContext ctx, [Description("Command to provide help for.")] params string[] command)
{
var toplevel = this.TopLevelCommands.Values.Distinct();
var helpbuilder = Activator.CreateInstance(this.HelpFormatterType) as IHelpFormatter;
if (command != null && command.Any())
{
Command cmd = null;
var search_in = toplevel;
foreach (var c in command)
{
if (search_in == null)
{
cmd = null;
break;
}
if (this.Config.CaseSensitive)
{
cmd = search_in.FirstOrDefault(xc => xc.Name == c || (xc.Aliases != null && xc.Aliases.Contains(c)));
}
else
{
cmd = search_in.FirstOrDefault(xc => xc.Name.ToLowerInvariant() == c.ToLowerInvariant() || (xc.Aliases != null && xc.Aliases.Select(xs => xs.ToLowerInvariant()).Contains(c.ToLowerInvariant())));
}
if (cmd == null)
{
break;
}
var cfl = await cmd.RunChecksAsync(ctx, true).ConfigureAwait(false);
if (cfl.Any())
{
throw new ChecksFailedException(cmd, ctx, cfl);
}
if (cmd is CommandGroup)
{
search_in = (cmd as CommandGroup).Children;
}
else
{
search_in = null;
}
}
if (cmd == null)
{
throw new CommandNotFoundException(string.Join(" ", command));
}
helpbuilder.WithCommandName(cmd.Name).WithDescription(cmd.Description);
if (cmd is CommandGroup g && g.Callable != null)
{
helpbuilder.WithGroupExecutable();
}
if (cmd.Aliases != null && cmd.Aliases.Any())
{
helpbuilder.WithAliases(cmd.Aliases.OrderBy(xs => xs));
}
if (cmd.Arguments != null && cmd.Arguments.Any())
{
helpbuilder.WithArguments(cmd.Arguments);
}
if (cmd is CommandGroup gx)
{
var sxs = gx.Children.Where(xc => !xc.IsHidden);
var scs = new List <Command>();
foreach (var sc in sxs)
{
if (sc.ExecutionChecks == null || !sc.ExecutionChecks.Any())
{
scs.Add(sc);
continue;
}
var cfl = await sc.RunChecksAsync(ctx, true).ConfigureAwait(false);
if (!cfl.Any())
{
scs.Add(sc);
}
}
if (scs.Any())
{
helpbuilder.WithSubcommands(scs.OrderBy(xc => xc.Name));
}
}
}
else
{
var sxs = toplevel.Where(xc => !xc.IsHidden);
var scs = new List <Command>();
foreach (var sc in sxs)
{
if (sc.ExecutionChecks == null || !sc.ExecutionChecks.Any())
{
scs.Add(sc);
continue;
}
var cfl = await sc.RunChecksAsync(ctx, true).ConfigureAwait(false);
if (!cfl.Any())
{
scs.Add(sc);
}
}
if (scs.Any())
{
helpbuilder.WithSubcommands(scs.OrderBy(xc => xc.Name));
}
}
var hmsg = helpbuilder.Build();
await ctx.RespondAsync(hmsg.Content, embed : hmsg.Embed).ConfigureAwait(false);
}
/// <summary>
/// Executes this command or its subcommand with specified context.
/// </summary>
/// <param name="ctx">Context to execute the command in.</param>
/// <returns>Command's execution results.</returns>
public override async Task <CommandResult> ExecuteAsync(CommandContext ctx)
{
//var cn = ctx.RawArguments.FirstOrDefault();
var cn = CommandsNextUtilities.ExtractNextArgument(ctx.RawArgumentString, out var x);
if (x != null)
{
var xi = 0;
for (; xi < x.Length; xi++)
{
if (!char.IsWhiteSpace(x[xi]))
{
break;
}
}
if (xi > 0)
{
x = x.Substring(xi);
}
}
if (cn != null)
{
Command cmd = null;
if (ctx.Config.CaseSensitive)
{
cmd = this.Children.FirstOrDefault(xc => xc.Name == cn || (xc.Aliases != null && xc.Aliases.Contains(cn)));
}
else
{
cmd = this.Children.FirstOrDefault(xc => xc.Name.ToLowerInvariant() == cn.ToLowerInvariant() || (xc.Aliases != null && xc.Aliases.Select(xs => xs.ToLowerInvariant()).Contains(cn.ToLowerInvariant())));
}
if (cmd != null)
{
// pass the execution on
var xctx = new CommandContext
{
Client = ctx.Client,
Message = ctx.Message,
Command = cmd,
Config = ctx.Config,
RawArgumentString = x,
CommandsNext = ctx.CommandsNext,
Dependencies = ctx.Dependencies
};
var fchecks = await cmd.RunChecksAsync(xctx, false);
if (fchecks.Any())
{
return new CommandResult
{
IsSuccessful = false,
Exception = new ChecksFailedException(cmd, xctx, fchecks),
Context = xctx
}
}
;
return(await cmd.ExecuteAsync(xctx));
}
}
if (this.Callable == null)
{
return new CommandResult
{
IsSuccessful = false,
Exception = new InvalidOperationException("No matching subcommands were found, and this group is not executable."),
Context = ctx
}
}
;
return(await base.ExecuteAsync(ctx));
}
}
}
