public InvalidRegExException(IInteractionContext ic, string format, string validation, bool caseSensitive, string message)
: base(ic, message)
{
this.format = format;
this.validation = validation;
this.caseSensitive = caseSensitive;
}
public async override Task <PreconditionResult> CheckRequirementsAsync(IInteractionContext context, Discord.Interactions.ICommandInfo commandInfo, IServiceProvider services)
{
if (context.Guild == null)
{
return(PreconditionResult.FromError("This command can only be executed from within server channels."));
}
// possible to pass the context in?
var db = services.GetService <DataBase>();
var guild = await FindOrCreateGuild.Perform(context.Guild, db);
if (guild.AdminRole != null)
{
var role = context.Guild.Roles.FirstOrDefault(x => x.Id.ToString() == guild.AdminRole);
if (role != null)
{
var p = (SocketRole)role;
if (p.Members.Any(x => x.Id == context.User.Id))
{
return(PreconditionResult.FromSuccess());
}
}
}
Console.WriteLine("returning default");
return(await new RequireUserPermissionAttribute(GuildPermission.Administrator).CheckRequirementsAsync(context, commandInfo, services));
}
protected InteractionException(IInteractionContext ic, string message)
: base(message)
{
InteractionType = ic.InteractionType;
Identifier = ic.Id;
Target = ic.Target;
}
private async Task <IResult> ExecuteAsync(IInteractionContext context, IEnumerable <SlashCommandParameterInfo> paramList,
List <IApplicationCommandInteractionDataOption> argList, IServiceProvider services)
{
try
{
var slashCommandParameterInfos = paramList.ToList();
var args = new object[slashCommandParameterInfos.Count];
for (var i = 0; i < slashCommandParameterInfos.Count; i++)
{
var parameter = slashCommandParameterInfos[i];
var result = await ParseArgument(parameter, context, argList, services).ConfigureAwait(false);
if (!result.IsSuccess)
{
return(await InvokeEventAndReturn(context, result).ConfigureAwait(false));
}
if (result is not ParseResult parseResult)
{
return(ExecuteResult.FromError(InteractionCommandError.BadArgs, "Command parameter parsing failed for an unknown reason."));
}
args[i] = parseResult.Value;
}
return(await RunAsync(context, args, services).ConfigureAwait(false));
}
catch (Exception ex)
{
return(await InvokeEventAndReturn(context, ExecuteResult.FromError(ex)).ConfigureAwait(false));
}
}
public virtual string Invalidates(IInteractionContext ic) {
INakedObjectAdapter proposedArgument = ic.ProposedArgument;
if (!Exceeds(proposedArgument)) {
return null;
}
return string.Format(Resources.NakedObjects.MaximumLengthMismatch, Value);
}
public string Disables(IInteractionContext ic) {
if (!ic.TypeEquals(InteractionType.ObjectPersist)) {
return null;
}
INakedObjectAdapter target = ic.Target;
return DisabledReason(target);
}
/// <inheritdoc/>
public async Task<IResult> ExecuteAsync(IInteractionContext context, IEnumerable<CommandParameterInfo> paramList, IEnumerable<string> values,
IServiceProvider services)
{
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 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);
}
}
public override Task <AutocompletionResult> GenerateSuggestionsAsync(
IInteractionContext context,
IAutocompleteInteraction autocompleteInteraction,
IParameterInfo parameter,
IServiceProvider services
)
{
var input = autocompleteInteraction.Data.Current.Value as string;
var matches = _cmdHelpService.GetCmdsStartsWithInput(context.User, input)
.Select(cmd =>
{
if (cmd is CommandInfo regCmdInfo)
{
return(regCmdInfo.Name);
}
else
{
return((cmd as IApplicationCommandInfo)?.Name);
}
})
.Distinct()
.PartialSort(25);
var results = AutocompletionResult.FromSuccess(matches.Select(cmdName => new AutocompleteResult(cmdName, cmdName)));
return(Task.FromResult(results));
}
public InvalidRegExException(IInteractionContext ic, string format, string validation, bool caseSensitive, string message)
: base(ic, message)
{
FormatPattern = format;
ValidationPattern = validation;
IsCaseSensitive = caseSensitive;
}
private static IInteractionBuffer IsUsable(ISpecification specification, IInteractionContext ic, IInteractionBuffer buf) {
IEnumerable<IDisablingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IDisablingInteractionAdvisor).Cast<IDisablingInteractionAdvisor>();
foreach (IDisablingInteractionAdvisor advisor in facets) {
buf.Append(advisor.Disables(ic));
}
return buf;
}
private Task ContextCommandExecuted(ContextCommandInfo context, IInteractionContext arg2, IResult result)
{
if (!result.IsSuccess)
{
switch (result.Error)
{
case InteractionCommandError.UnmetPrecondition:
// implement
break;
case InteractionCommandError.UnknownCommand:
// implement
break;
case InteractionCommandError.BadArgs:
// implement
break;
case InteractionCommandError.Exception:
// implement
break;
case InteractionCommandError.Unsuccessful:
// implement
break;
default:
break;
}
}
return(Task.CompletedTask);
}
public override async Task <TypeConverterResult> ReadAsync(IInteractionContext context, IComponentInteractionData option, IServiceProvider services)
{
var results = new List <TypeConverterResult>();
foreach (var value in option.Values)
{
var result = await _typeReader.ReadAsync(context, value, services).ConfigureAwait(false);
if (!result.IsSuccess)
{
return(result);
}
results.Add(result);
}
var destination = Array.CreateInstance(_underlyingType, results.Count);
for (var i = 0; i < results.Count; i++)
{
destination.SetValue(results[i].Value, i);
}
return(TypeConverterResult.FromSuccess(destination));
}
private async Task <IResult> ExecuteInternalAsync(IInteractionContext context, IAutocompleteInteraction autocompleteInteraction, IParameterInfo parameter,
IServiceProvider services)
{
try
{
var result = await GenerateSuggestionsAsync(context, autocompleteInteraction, parameter, services).ConfigureAwait(false);
if (result.IsSuccess)
{
switch (autocompleteInteraction)
{
case RestAutocompleteInteraction restAutocomplete:
var payload = restAutocomplete.Respond(result.Suggestions);
if (context is IRestInteractionContext restContext && restContext.InteractionResponseCallback != null)
{
await restContext.InteractionResponseCallback.Invoke(payload).ConfigureAwait(false);
}
else
{
await InteractionService._restResponseCallback(context, payload).ConfigureAwait(false);
}
break;
case SocketAutocompleteInteraction socketAutocomplete:
await socketAutocomplete.RespondAsync(result.Suggestions).ConfigureAwait(false);
break;
}
public static IInteractionBuffer IsValid(ISpecification specification, IInteractionContext ic, IInteractionBuffer buf) {
IEnumerable<IValidatingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IValidatingInteractionAdvisor).Cast<IValidatingInteractionAdvisor>();
foreach (IValidatingInteractionAdvisor advisor in facets) {
buf.Append(advisor.Invalidates(ic));
}
return buf;
}
/// <summary>
/// Loops over all <see cref="IDisablingInteractionAdvisor" /> <see cref="IFacet" />s and
/// returns <c>true</c> only if none disables the member.
/// </summary>
public virtual IConsent IsUsable(INakedObjectAdapter target)
{
IInteractionContext ic = InteractionContext
.AccessMember(Session, Persistor, false, target, Identifier);
return(InteractionUtils.IsUsable(this, ic));
}
protected override string GetLogString(IInteractionContext context)
{
if (context.Guild != null)
return $"Component Interaction: \"{base.ToString()}\" for {context.User} in {context.Guild}/{context.Channel}";
else
return $"Component Interaction: \"{base.ToString()}\" for {context.User} in {context.Channel}";
}
public Task <bool> JudgeAsync(IInteractionContext sourceContext, SocketMessage parameter)
{
var input = parameter.Content.ConvertTypesetterToTypewriter();
Answer = PossibleAnswers.FirstOrDefault(possibleAnswer => possibleAnswer.EqualsIgnoreCase(input));
return(Task.FromResult(!string.IsNullOrEmpty(Answer)));
}
public static bool IsVisible(ISpecification specification, IInteractionContext ic, ILifecycleManager lifecycleManager, IMetamodelManager manager) {
var buf = new InteractionBuffer();
IEnumerable<IHidingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IHidingInteractionAdvisor).Cast<IHidingInteractionAdvisor>();
foreach (IHidingInteractionAdvisor advisor in facets) {
buf.Append(advisor.Hides(ic, lifecycleManager, manager));
}
return IsVisible(buf);
}
public void Setup()
{
Interactions = MockRepository.GenerateStub<IInteractionContext>();
FileSync = MockRepository.GenerateStub<IFileSync>();
Context();
Because();
}
/// <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"));
}
return(await ExecuteAsync(context, Parameters, additionalArgs, componentInteraction.Data, 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"));
}
return(await RunAsync(context, Array.Empty <object>(), services).ConfigureAwait(false));
}
private async Task SlashCommandExecutedAsync(SlashCommandInfo command, IInteractionContext context, Discord.Interactions.IResult result)
{
// the command was successful, we don't care about this result, unless we want to log that a command succeeded.
if (result.IsSuccess)
{
return;
}
await context.Interaction.RespondAsync(result.ErrorReason, ephemeral : true);
}
public virtual string Invalidates(IInteractionContext ic)
{
INakedObjectAdapter proposedArgument = ic.ProposedArgument;
if (!Exceeds(proposedArgument))
{
return(null);
}
return(string.Format(Resources.NakedObjects.MaximumLengthMismatch, Value));
}
public string Disables(IInteractionContext ic)
{
if (!ic.TypeEquals(InteractionType.ObjectPersist))
{
return(null);
}
INakedObjectAdapter target = ic.Target;
return(DisabledReason(target));
}
private static IInteractionBuffer IsUsable(ISpecification specification, IInteractionContext ic, IInteractionBuffer buf)
{
IEnumerable <IDisablingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IDisablingInteractionAdvisor).Cast <IDisablingInteractionAdvisor>();
foreach (IDisablingInteractionAdvisor advisor in facets)
{
buf.Append(advisor.Disables(ic));
}
return(buf);
}
public static IInteractionBuffer IsValid(ISpecification specification, IInteractionContext ic, IInteractionBuffer buf)
{
IEnumerable <IValidatingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IValidatingInteractionAdvisor).Cast <IValidatingInteractionAdvisor>();
foreach (IValidatingInteractionAdvisor advisor in facets)
{
buf.Append(advisor.Invalidates(ic));
}
return(buf);
}
/// <summary>
/// Converts a slash param array to a string.
/// Used for error handling and reporting.
/// </summary>
/// <returns></returns>
public static string SlashParamToString(IInteractionContext arg2)
{
string output = "";
foreach (var param in (arg2.Interaction.Data as SocketSlashCommandData).Options)
{
output += param.Name + ": " + param.Value + " ";
}
return(output);
}
public string Invalidates(IInteractionContext ic)
{
INakedObjectAdapter proposedArgument = ic.ProposedArgument;
if (DoesNotMatch(proposedArgument))
{
return(string.Format(Resources.NakedObjects.MaskMismatch, proposedArgument.TitleString(), Value));
}
return(null);
}
public override Task <TypeConverterResult> ReadAsync(IInteractionContext context, IApplicationCommandInteractionDataOption option, IServiceProvider services)
{
if (Enum.TryParse <T>((string)option.Value, out var result))
{
return(Task.FromResult(TypeConverterResult.FromSuccess(result)));
}
else
{
return(Task.FromResult(TypeConverterResult.FromError(InteractionCommandError.ConvertFailed, $"Value {option.Value} cannot be converted to {nameof(T)}")));
}
}
public static bool IsVisible(ISpecification specification, IInteractionContext ic, ILifecycleManager lifecycleManager, IMetamodelManager manager)
{
var buf = new InteractionBuffer();
IEnumerable <IHidingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IHidingInteractionAdvisor).Cast <IHidingInteractionAdvisor>();
foreach (IHidingInteractionAdvisor advisor in facets)
{
buf.Append(advisor.Hides(ic, lifecycleManager, manager));
}
return(IsVisible(buf));
}
public override Task <TypeConverterResult> ReadAsync(IInteractionContext context, IComponentInteractionData option, IServiceProvider services)
{
try
{
return(option.Type switch
{
ComponentType.SelectMenu => Task.FromResult(TypeConverterResult.FromSuccess(Convert.ChangeType(string.Join(",", option.Values), typeof(T)))),
ComponentType.TextInput => Task.FromResult(TypeConverterResult.FromSuccess(Convert.ChangeType(option.Value, typeof(T)))),
_ => Task.FromResult(TypeConverterResult.FromError(InteractionCommandError.ConvertFailed, $"{option.Type} doesn't have a convertible value."))
});
}
protected override string GetLogString(IInteractionContext context)
{
if (context.Guild != null)
{
return($"Slash Command: \"{base.ToString()}\" for {context.User} in {context.Guild}/{context.Channel}");
}
else
{
return($"Slash Command: \"{base.ToString()}\" for {context.User} in {context.Channel}");
}
}
public override async Task <AutocompletionResult> GenerateSuggestionsAsync(IInteractionContext context, IAutocompleteInteraction autocompleteInteraction, IParameterInfo parameter, IServiceProvider services)
{
// Create a collection with suggestions for autocomplete
IEnumerable <AutocompleteResult> results = new[]
{
new AutocompleteResult("Name1", "value111"),
new AutocompleteResult("Name2", "value2")
};
// max - 25 suggestions at a time (API limit)
return(AutocompletionResult.FromSuccess(results.Take(25)));
}
public string Invalidates(IInteractionContext ic) {
INakedObjectAdapter proposedArgument = ic.ProposedArgument;
if (proposedArgument == null) {
return null;
}
string titleString = proposedArgument.TitleString();
if (!DoesNotMatch(titleString)) {
return null;
}
return failureMessage ?? Resources.NakedObjects.InvalidEntry;
}
public override async Task <TypeConverterResult> ReadAsync(IInteractionContext context, string option, IServiceProvider services)
{
if (!ulong.TryParse(option, out var snowflake))
{
return(TypeConverterResult.FromError(InteractionCommandError.ConvertFailed, $"{option} isn't a valid snowflake thus cannot be converted into {typeof(T).Name}"));
}
var result = await GetEntity(snowflake, context).ConfigureAwait(false);
return(result is not null?
TypeConverterResult.FromSuccess(result) : TypeConverterResult.FromError(InteractionCommandError.ConvertFailed, $"{option} must be a valid {typeof(T).Name} snowflake to be parsed."));
}
public override Task <TypeConverterResult> ReadAsync(IInteractionContext context, string option, IServiceProvider services)
{
try
{
var converted = Convert.ChangeType(option, typeof(T));
return(Task.FromResult(TypeConverterResult.FromSuccess(converted)));
}
catch (InvalidCastException castEx)
{
return(Task.FromResult(TypeConverterResult.FromError(castEx)));
}
}
public Task HandleInteractionExecuted(ICommandInfo _, IInteractionContext __, IResult result)
{
Task.Run(() =>
{
if (!result.IsSuccess)
{
SourceToLogger.GetOrAdd("Interaction", source => _loggerFactory.CreateLogger(source)).Error(result.ErrorReason);
}
});
return(Task.CompletedTask);
}
public static bool IsVisibleWhenPersistent(ISpecification specification, IInteractionContext ic, ILifecycleManager lifecycleManager, IMetamodelManager manager) {
var buf = new InteractionBuffer();
IEnumerable<IHidingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IHidingInteractionAdvisor).Cast<IHidingInteractionAdvisor>();
foreach (IHidingInteractionAdvisor advisor in facets) {
var facet = advisor as IHiddenFacet;
if (facet != null) {
if (facet.Value == WhenTo.OncePersisted) {
continue;
}
}
buf.Append(advisor.Hides(ic, lifecycleManager, manager));
}
return IsVisible(buf);
}
/// <summary>
/// Uses dependency injection and inversion of control. By using these
/// techniques we make the object constructing this object provide all
/// of the external dependencies. The code is less fragile, reuse is
/// encouraged, and there should be less bugs.
/// Look at the DependencyLoader to see how we're telling the system to
/// load the implementation classes for this class.
/// </summary>
/// <param name="fileSync"></param>
/// <param name="userInteractions"></param>
/// <param name="settings"></param>
/// <param name="backupAccess"></param>
public RunBackup(
IFileSync fileSync,
IInteractionContext userInteractions,
ISettingsProvider settings,
IBackupAccess backupAccess)
{
_FileSystem = fileSync;
_Interactions = userInteractions;
_Settings = settings;
_BackupDirectory = backupAccess;
_FileSystem.AppliedChange += OnAppliedChange;
_FileSystem.SkippedChange += OnSkippedChange;
}
public void Setup()
{
//Here we're doing all of the set up for this clump of tests.
// Mocks basically allow us to pretend like we have a class
// when we really don't just so the program runs. This really
// comes in handy when you have a large interface and don't want to
// create a huge real class that has to have a bunch of empty methods
// that never get called.
Interactions = MockRepository.GenerateStub<IInteractionContext>();
FileSync = MockRepository.GenerateStub<IFileSync>();
BackupAccess = MockRepository.GenerateStub<IBackupAccess>();
Settings = MockRepository.GenerateStub<ISettingsProvider>();
BackupRunner = new RunBackup(FileSync, Interactions, Settings, BackupAccess);
Context();
Because();
}
public MainView(
IInteractionContext interactionContext,
IMessagingServiceManager messagingService,
IContactProvider contactRepo)
{
if(interactionContext == null)
throw new ArgumentNullException("interactionContext");
if(messagingService == null)
throw new ArgumentNullException("messagingService");
_CurrentThread = Thread.CurrentThread;
_CurrentDispatcher = Dispatcher.CurrentDispatcher;
_ContactRepo = contactRepo;
_MessagingService = messagingService;
PropertyChanged += MainView_PropertyChanged;
_MessagingService.CredentialsRequested += messagingService_CredentialsRequested;
_MessagingService.AuthorizationFailed += _MessagingService_AuthorizationFailed;
_MessagingService.MessagesReceived += _MessagingService_MessagesReceived;
Messages = new ObservableCollection<UiMessage>();
Interactions = interactionContext;
SendMessage = new SendMessageCommand(
() =>
{
_MessagingService.SendMessage(Recipient, MessageToSend);
Recipient = "";
MessageToSend = "";
if(ReceiveMessage.CanExecute(null))
ReceiveMessage.Execute(null);
});
ReceiveMessage = new ReceiveMessagesCommand(
() =>
{
var result = _MessagingService.GetMessages();
_UpdateUIWithMessages(result);
});
}
public static void BootstrapStructureMap(
IInteractionContext gui,
IPluginFinder pluginFinder,
ISettingsProvider settings,
IMessagingService plugin)
{
// Initialize the static ObjectFactory container
ObjectFactory.Initialize(x =>
{
x.ForRequestedType<MainView>().TheDefaultIsConcreteType<MainView>();
x.ForRequestedType<IInteractionContext>().TheDefault.IsThis(gui);
x.ForRequestedType<IMessagingService>().TheDefault.IsThis(plugin);
x.ForRequestedType<ISettingsProvider>().TheDefault.IsThis(settings);
x.ForRequestedType<IMessagingServiceManager>().TheDefaultIsConcreteType<ServicesManager>();
x.ForRequestedType<IContactProvider>().TheDefaultIsConcreteType<ContactProvider>();
x.ForRequestedType<IServiceProvider>().TheDefaultIsConcreteType<ServiceProvider>();
x.ForRequestedType<IPluginFinder>().TheDefault.IsThis(pluginFinder);
});
}
public Exception CreateExceptionFor(IInteractionContext ic) {
return new InvalidRegExException(ic, FormatPattern, ValidationPattern, IsCaseSensitive, Invalidates(ic));
}
public virtual Exception CreateExceptionFor(IInteractionContext ic) {
return new DisabledException(ic, Disables(ic));
}
public virtual string Disables(IInteractionContext ic) {
INakedObjectAdapter target = ic.Target;
return DisabledReason(target);
}
public InvalidMaskException(IInteractionContext ic, string message)
: base(ic, message) {}
public InvalidMaskException(IInteractionContext ic)
: this(ic, Resources.NakedObjects.MaskError) {}
public static IConsent IsValid(ISpecification specification, IInteractionContext ic) {
IInteractionBuffer buf = IsValid(specification, ic, new InteractionBuffer());
return IsValid(buf);
}
public virtual string Invalidates(IInteractionContext ic) {
return IsRequiredButNull(ic.ProposedArgument) ? Resources.NakedObjects.Mandatory : null;
}
public HiddenException(IInteractionContext ic, string message)
: base(ic, message) {}
public HiddenException(IInteractionContext ic)
: this(ic, Resources.NakedObjects.Hidden) {}
public virtual Exception CreateExceptionFor(IInteractionContext ic) {
return new InvalidMaxLengthException(ic, Value, Invalidates(ic));
}
public virtual string Invalidates(IInteractionContext ic) {
return InvalidReason(ic.Target, ic.ProposedArgument);
}
public InvalidMandatoryException(IInteractionContext ic)
: this(ic, Resources.NakedObjects.Mandatory) {}
public string Hides(IInteractionContext ic, ILifecycleManager lifecycleManager, IMetamodelManager manager) {
return HiddenReason(ic.Target);
}
public virtual Exception CreateExceptionFor(IInteractionContext ic) {
return new InvalidMandatoryException(ic, Invalidates(ic));
}
public virtual string Hides(IInteractionContext ic, ILifecycleManager lifecycleManager, IMetamodelManager manager) {
return HiddenReason(ic.Session, ic.Target, lifecycleManager, manager);
}
public InvalidRegExException(IInteractionContext ic, string format, string validation, bool caseSensitive)
: this(ic, format, validation, caseSensitive, Resources.NakedObjects.PatternMessage) {}
public InvalidRegExException(IInteractionContext ic, string format, string validation, bool caseSensitive, string message)
: base(ic, message) {
this.format = format;
this.validation = validation;
this.caseSensitive = caseSensitive;
}
public virtual Exception CreateExceptionFor(IInteractionContext ic, ILifecycleManager lifecycleManager, IMetamodelManager manager) {
return new HiddenException(ic, Hides(ic, lifecycleManager, manager));
}
