private async Task <IResult> ExecuteAsync(IInteractionContext context, IEnumerable <SlashCommandParameterInfo> paramList,
List <IApplicationCommandInteractionDataOption> argList, IServiceProvider services)
{
try
{
if (paramList?.Count() < argList?.Count())
{
return(ExecuteResult.FromError(InteractionCommandError.BadArgs, "Command was invoked with too many parameters"));
}
var args = new object[paramList.Count()];
for (var i = 0; i < paramList.Count(); i++)
{
var parameter = paramList.ElementAt(i);
var arg = argList?.Find(x => string.Equals(x.Name, parameter.Name, StringComparison.OrdinalIgnoreCase));
if (arg == default)
{
if (parameter.IsRequired)
{
return(ExecuteResult.FromError(InteractionCommandError.BadArgs, "Command was invoked with too few parameters"));
}
else
{
args[i] = parameter.DefaultValue;
}
}
else
{
var typeConverter = parameter.TypeConverter;
var readResult = await typeConverter.ReadAsync(context, arg, services).ConfigureAwait(false);
if (!readResult.IsSuccess)
{
await InvokeModuleEvent(context, readResult).ConfigureAwait(false);
return(readResult);
}
args[i] = readResult.Value;
}
}
return(await RunAsync(context, args, services).ConfigureAwait(false));
}
catch (Exception ex)
{
return(ExecuteResult.FromError(ex));
}
}
/// <summary>
/// Execute this command using dependency injection.
/// </summary>
/// <param name="context">Context that will be injected to the <see cref="InteractionModuleBase{T}"/>.</param>
/// <param name="services">Services that will be used while initializing the <see cref="InteractionModuleBase{T}"/>.</param>
/// <param name="additionalArgs">Provide additional string parameters to the method along with the auto generated parameters.</param>
/// <returns>
/// A task representing the asynchronous command execution process.
/// </returns>
public async Task <IResult> ExecuteAsync(IInteractionContext context, IServiceProvider services, params string[] additionalArgs)
{
if (context.Interaction is not IModalInteraction modalInteraction)
{
return(ExecuteResult.FromError(InteractionCommandError.ParseFailed, $"Provided {nameof(IInteractionContext)} doesn't belong to a Modal Interaction."));
}
try
{
var args = new object[Parameters.Count];
var captureCount = additionalArgs?.Length ?? 0;
for (var i = 0; i < Parameters.Count; i++)
{
var parameter = Parameters.ElementAt(i);
if (i < captureCount)
{
var readResult = await parameter.TypeReader.ReadAsync(context, additionalArgs[i], services).ConfigureAwait(false);
if (!readResult.IsSuccess)
{
return(await InvokeEventAndReturn(context, readResult).ConfigureAwait(false));
}
args[i] = readResult.Value;
}
else
{
var modalResult = await Modal.CreateModalAsync(context, services, Module.CommandService._exitOnMissingModalField).ConfigureAwait(false);
if (!modalResult.IsSuccess)
{
return(await InvokeEventAndReturn(context, modalResult).ConfigureAwait(false));
}
if (modalResult is not ParseResult parseResult)
{
return(await InvokeEventAndReturn(context, ExecuteResult.FromError(InteractionCommandError.BadArgs, "Command parameter parsing failed for an unknown reason.")));
}
args[i] = parseResult.Value;
}
}
return(await RunAsync(context, args, services));
}
catch (Exception ex)
{
return(await InvokeEventAndReturn(context, ExecuteResult.FromError(ex)).ConfigureAwait(false));
}
}
/// <summary>
/// Execute this command using dependency injection.
/// </summary>
/// <param name="context">Context that will be injected to the <see cref="InteractionModuleBase{T}"/>.</param>
/// <param name="services">Services that will be used while initializing the <see cref="InteractionModuleBase{T}"/>.</param>
/// <param name="additionalArgs">Provide additional string parameters to the method along with the auto generated parameters.</param>
/// <returns>
/// A task representing the asynchronous command execution process.
/// </returns>
public async Task<IResult> ExecuteAsync(IInteractionContext context, IServiceProvider services, params string[] additionalArgs)
{
if (context.Interaction is not IComponentInteraction componentInteraction)
return ExecuteResult.FromError(InteractionCommandError.ParseFailed, $"Provided {nameof(IInteractionContext)} doesn't belong to a Message Component Interaction");
var args = new List<string>();
if (additionalArgs is not null)
args.AddRange(additionalArgs);
if (componentInteraction.Data?.Values is not null)
args.AddRange(componentInteraction.Data.Values);
return await ExecuteAsync(context, Parameters, args, services);
}
/// <inheritdoc/>
public override async Task <IResult> ExecuteAsync(IInteractionContext context, IServiceProvider services)
{
if (context.Interaction is not ISlashCommandInteraction slashCommand)
{
return(ExecuteResult.FromError(InteractionCommandError.ParseFailed, $"Provided {nameof(IInteractionContext)} doesn't belong to a Slash Command Interaction"));
}
var options = slashCommand.Data.Options;
while (options != null && options.Any(x => x.Type == ApplicationCommandOptionType.SubCommand || x.Type == ApplicationCommandOptionType.SubCommandGroup))
{
options = options.ElementAt(0)?.Options;
}
return(await ExecuteAsync(context, Parameters, options?.ToList(), services));
}
/// <inheritdoc/>
public override async Task <IResult> ExecuteAsync(IInteractionContext context, IServiceProvider services)
{
if (context.Interaction is not IAutocompleteInteraction)
{
return(ExecuteResult.FromError(InteractionCommandError.ParseFailed, $"Provided {nameof(IInteractionContext)} doesn't belong to a Autocomplete Interaction"));
}
try
{
return(await RunAsync(context, Array.Empty <object>(), services).ConfigureAwait(false));
}
catch (Exception ex)
{
return(ExecuteResult.FromError(ex));
}
}
/// <inheritdoc/>
public async Task <IResult> ExecuteAsync(IInteractionContext context, IEnumerable <CommandParameterInfo> paramList, IEnumerable <string> values,
IServiceProvider services)
{
if (context.Interaction is not SocketMessageComponent messageComponent)
{
return(ExecuteResult.FromError(InteractionCommandError.ParseFailed, $"Provided {nameof(IInteractionContext)} doesn't belong to a Component Command Interaction"));
}
try
{
var strCount = Parameters.Count(x => x.ParameterType == typeof(string));
if (strCount > values?.Count())
{
return(ExecuteResult.FromError(InteractionCommandError.BadArgs, "Command was invoked with too few parameters"));
}
var componentValues = messageComponent.Data?.Values;
var args = new object[Parameters.Count];
if (componentValues is not null)
{
if (Parameters.Last().ParameterType == typeof(string[]))
{
args[args.Length - 1] = componentValues.ToArray();
}
else
{
return(ExecuteResult.FromError(InteractionCommandError.BadArgs, $"Select Menu Interaction handlers must accept a {typeof(string[]).FullName} as its last parameter"));
}
}
for (var i = 0; i < strCount; i++)
{
args[i] = values.ElementAt(i);
}
return(await RunAsync(context, args, services).ConfigureAwait(false));
}
catch (Exception ex)
{
return(ExecuteResult.FromError(ex));
}
}
private async Task <IResult> ParseArgument(SlashCommandParameterInfo parameterInfo, IInteractionContext context, List <IApplicationCommandInteractionDataOption> argList,
IServiceProvider services)
{
if (parameterInfo.IsComplexParameter)
{
var ctorArgs = new object[parameterInfo.ComplexParameterFields.Count];
for (var i = 0; i < ctorArgs.Length; i++)
{
var result = await ParseArgument(parameterInfo.ComplexParameterFields.ElementAt(i), context, argList, services).ConfigureAwait(false);
if (!result.IsSuccess)
{
return(result);
}
if (result is not ParseResult parseResult)
{
return(ExecuteResult.FromError(InteractionCommandError.BadArgs, "Complex command parsing failed for an unknown reason."));
}
ctorArgs[i] = parseResult.Value;
}
return(ParseResult.FromSuccess(parameterInfo._complexParameterInitializer(ctorArgs)));
}
var arg = argList?.Find(x => string.Equals(x.Name, parameterInfo.Name, StringComparison.OrdinalIgnoreCase));
if (arg == default)
{
return(parameterInfo.IsRequired ? ExecuteResult.FromError(InteractionCommandError.BadArgs, "Command was invoked with too few parameters") :
ParseResult.FromSuccess(parameterInfo.DefaultValue));
}
var typeConverter = parameterInfo.TypeConverter;
var readResult = await typeConverter.ReadAsync(context, arg, services).ConfigureAwait(false);
if (!readResult.IsSuccess)
{
return(readResult);
}
return(ParseResult.FromSuccess(readResult.Value));
}
/// <inheritdoc/>
public async Task <IResult> ExecuteAsync(IInteractionContext context, IEnumerable <CommandParameterInfo> paramList, IEnumerable <string> wildcardCaptures, IComponentInteractionData data,
IServiceProvider services)
{
var paramCount = paramList.Count();
var captureCount = wildcardCaptures?.Count() ?? 0;
if (context.Interaction is not IComponentInteraction messageComponent)
{
return(ExecuteResult.FromError(InteractionCommandError.ParseFailed, $"Provided {nameof(IInteractionContext)} doesn't belong to a Component Command Interaction"));
}
try
{
var args = new object[paramCount];
for (var i = 0; i < paramCount; i++)
{
var parameter = Parameters.ElementAt(i);
var isCapture = i < captureCount;
if (isCapture ^ parameter.IsRouteSegmentParameter)
{
return(await InvokeEventAndReturn(context, ExecuteResult.FromError(InteractionCommandError.BadArgs, "Argument type and parameter type didn't match (Wild Card capture/Component value)")).ConfigureAwait(false));
}
var readResult = isCapture ? await parameter.TypeReader.ReadAsync(context, wildcardCaptures.ElementAt(i), services).ConfigureAwait(false) :
await parameter.TypeConverter.ReadAsync(context, data, services).ConfigureAwait(false);
if (!readResult.IsSuccess)
{
return(await InvokeEventAndReturn(context, readResult).ConfigureAwait(false));
}
args[i] = readResult.Value;
}
return(await RunAsync(context, args, services).ConfigureAwait(false));
}
catch (Exception ex)
{
return(await InvokeEventAndReturn(context, ExecuteResult.FromError(ex)).ConfigureAwait(false));
}
}
/// <inheritdoc/>
public override async Task <IResult> ExecuteAsync(IInteractionContext context, IServiceProvider services)
{
if (context.Interaction is not IMessageCommandInteraction messageCommand)
{
return(ExecuteResult.FromError(InteractionCommandError.ParseFailed, $"Provided {nameof(IInteractionContext)} doesn't belong to a Message Command Interation"));
}
try
{
object[] args = new object[1] {
messageCommand.Data.Message
};
return(await RunAsync(context, args, services).ConfigureAwait(false));
}
catch (Exception ex)
{
return(ExecuteResult.FromError(ex));
}
}
private async Task <IResult> ExecuteAsync(IInteractionContext context, IEnumerable <SlashCommandParameterInfo> paramList,
List <IApplicationCommandInteractionDataOption> argList, IServiceProvider services)
{
try
{
var args = new object[paramList.Count()];
for (var i = 0; i < paramList.Count(); i++)
{
var parameter = paramList.ElementAt(i);
var result = await ParseArgument(parameter, context, argList, services).ConfigureAwait(false);
if (!result.IsSuccess)
{
var execResult = ExecuteResult.FromError(result);
await InvokeModuleEvent(context, execResult).ConfigureAwait(false);
return(execResult);
}
if (result is ParseResult parseResult)
{
args[i] = parseResult.Value;
}
else
{
return(ExecuteResult.FromError(InteractionCommandError.BadArgs, "Command parameter parsing failed for an unknown reason."));
}
}
return(await RunAsync(context, args, services).ConfigureAwait(false));
}
catch (Exception ex)
{
var result = ExecuteResult.FromError(ex);
await InvokeModuleEvent(context, result).ConfigureAwait(false);
return(result);
}
}
private async Task <IResult> ExecuteInternalAsync(IInteractionContext context, object[] args, IServiceProvider services)
{
await CommandService._cmdLogger.DebugAsync($"Executing {GetLogString(context)}").ConfigureAwait(false);
try
{
var preconditionResult = await CheckPreconditionsAsync(context, services).ConfigureAwait(false);
if (!preconditionResult.IsSuccess)
{
await InvokeModuleEvent(context, preconditionResult).ConfigureAwait(false);
return(preconditionResult);
}
var index = 0;
foreach (var parameter in Parameters)
{
var result = await parameter.CheckPreconditionsAsync(context, args[index++], services).ConfigureAwait(false);
if (!result.IsSuccess)
{
await InvokeModuleEvent(context, result).ConfigureAwait(false);
return(result);
}
}
var task = _action(context, args, services, this);
if (task is Task <IResult> resultTask)
{
var result = await resultTask.ConfigureAwait(false);
await InvokeModuleEvent(context, result).ConfigureAwait(false);
if (result is RuntimeResult || result is ExecuteResult)
{
return(result);
}
}
else
{
await task.ConfigureAwait(false);
var result = ExecuteResult.FromSuccess();
await InvokeModuleEvent(context, result).ConfigureAwait(false);
return(result);
}
var failResult = ExecuteResult.FromError(InteractionCommandError.Unsuccessful, "Command execution failed for an unknown reason");
await InvokeModuleEvent(context, failResult).ConfigureAwait(false);
return(failResult);
}
catch (Exception ex)
{
var originalEx = ex;
while (ex is TargetInvocationException)
{
ex = ex.InnerException;
}
await Module.CommandService._cmdLogger.ErrorAsync(ex).ConfigureAwait(false);
var result = ExecuteResult.FromError(ex);
await InvokeModuleEvent(context, result).ConfigureAwait(false);
if (Module.CommandService._throwOnError)
{
if (ex == originalEx)
{
throw;
}
else
{
ExceptionDispatchInfo.Capture(ex).Throw();
}
}
return(result);
}
finally
{
await CommandService._cmdLogger.VerboseAsync($"Executed {GetLogString(context)}").ConfigureAwait(false);
}
}
