public void ConstructorMessage_SetsValues()
{
const string message = "This is a message.";
var commandNotFoundException = new CommandNotFoundException(message);
Assert.That(commandNotFoundException.Message, Is.EqualTo(message));
}
public static async Task OnError(CommandsNextExtension _, CommandErrorEventArgs e)
{
if (e.Context.User.IsBotSafeCheck())
{
return;
}
var ex = e.Exception;
if (ex is InvalidOperationException && ex.Message.Contains("No matching subcommands were found"))
{
ex = new CommandNotFoundException(e.Command.Name);
}
if (ex is not CommandNotFoundException cnfe)
{
Config.Log.Error(e.Exception);
return;
}
if (string.IsNullOrEmpty(cnfe.CommandName))
{
return;
}
if (e.Context.Prefix != Config.CommandPrefix &&
e.Context.Prefix != Config.AutoRemoveCommandPrefix &&
(e.Context.Message.Content?.EndsWith("?") ?? false) &&
e.Context.CommandsNext.RegisteredCommands.TryGetValue("8ball", out var cmd))
{
var updatedContext = e.Context.CommandsNext.CreateContext(
e.Context.Message,
e.Context.Prefix,
cmd,
e.Context.Message.Content[e.Context.Prefix.Length..].Trim()
private static void CheckErrors(this PowerShell ps, CancellationToken cancellationToken = default(CancellationToken))
{
PSDataCollection <ErrorRecord> errors = (ps.Streams == null) ? null : ps.Streams.Error;
if (errors != null && errors.Count > 0)
{
if (errors.Count == 1)
{
throw RestoreCommandNotFoundException(errors[0]);
}
else
{
List <Exception> innerExceptions = errors.Select(e => RestoreCommandNotFoundException(e)).ToList();
CommandNotFoundException notFoundException = innerExceptions.OfType <CommandNotFoundException>().FirstOrDefault();
if (notFoundException != null)
{
throw notFoundException;
}
else
{
throw new AggregateException(string.Join(Environment.NewLine, errors.Select(e => e.Exception.Message)), innerExceptions);
}
}
}
if (ps.HadErrors)
{
cancellationToken.ThrowIfCancellationRequested(); // PipelineStoppedException();
throw new InvalidPowerShellStateException();
}
}
public void ConstructorMessageInnerException_SetsValues()
{
const string message = "This is another message.";
var innerException = new IOException();
var commandNotFoundException = new CommandNotFoundException(message, innerException);
Assert.That(commandNotFoundException.Message, Is.EqualTo(message));
Assert.That(commandNotFoundException.InnerException, Is.EqualTo(innerException));
}
public void ConstructorCommandNameCommandArgs_SetsValues()
{
const string commandName = "This is yet another message.";
var commandArgs = new[] { "Arg0", "Arg1" };
var commandNotFoundException = new CommandNotFoundException(commandName, commandArgs);
Assert.That(commandNotFoundException.Message, Is.EqualTo("Invalid command name."));
Assert.That(commandNotFoundException.CommandName, Is.EqualTo(commandName));
Assert.That(commandNotFoundException.CommandArgs, Is.EqualTo(commandArgs));
}
internal IEnumerator <DSResource> InvokeCmdletAsync(System.Management.Automation.PowerShell powerShell, Expression expression, EventHandler <DataAddedEventArgs> dataAddedEventHandler, AsyncCallback executionCompletionCallback, bool noStreamingResponse)
{
Tracer tracer = new Tracer();
this.dataStore = new AsyncDataStore <DSResource>(expression, noStreamingResponse);
this.output = new PSDataCollection <PSObject>();
tracer.CommandInvocationStart(this.cmdletInfo.CmdletName);
powerShell.Runspace = this.runspace.Item.Runspace;
powerShell.AddCommand(this.cmdletInfo.CmdletName);
foreach (string key in this.parameters.Keys)
{
if (!this.cmdletInfo.IsSwitch(key))
{
powerShell.AddParameter(key, this.parameters[key]);
}
else
{
powerShell.AddParameter(key);
}
}
this.isExecutionCompleted = false;
using (OperationTracer operationTracer = new OperationTracer(new Action <string>(TraceHelper.Current.CmdletExecutionStart), new Action <string>(TraceHelper.Current.CmdletExecutionEnd), powerShell.Commands.ToTraceMessage()))
{
try
{
this.timer.Start();
powerShell.Invoke <PSObject>(null, this.output, Utils.GetPSInvocationSettings());
}
catch (CommandNotFoundException commandNotFoundException1)
{
CommandNotFoundException commandNotFoundException = commandNotFoundException1;
throw new CommandInvocationFailedException(powerShell.Commands.Commands[0].CommandText, commandNotFoundException);
}
catch (ParameterBindingException parameterBindingException1)
{
ParameterBindingException parameterBindingException = parameterBindingException1;
throw new CommandInvocationFailedException(powerShell.Commands.Commands[0].CommandText, parameterBindingException);
}
catch (CmdletInvocationException cmdletInvocationException1)
{
CmdletInvocationException cmdletInvocationException = cmdletInvocationException1;
throw new CommandInvocationFailedException(powerShell.Commands.Commands[0].CommandText, cmdletInvocationException);
}
}
return(new BlockingEnumerator <DSResource>(this.dataStore));
}
public Command Select(string commandName, List <Command> availableCommands)
{
var command = new MatchSelector <Command>().Match(commandName, availableCommands, c => c.Name);
if (command != null)
{
return(command);
}
var exception = new CommandNotFoundException(commandName);
exception.AvailableCommands.AddRange(availableCommands);
var possibleCommands = new MatchSelector <Command>().PartialMatch(commandName, availableCommands, c => c.Name);
exception.PossibleCommands.AddRange(possibleCommands);
throw exception;
}
public void Serialization_Successful()
{
const string commandName = "This is yet again another message!";
var commandArgs = new[] { "Arg0", "Arg1", "Arg2", "Arg3" };
var innerException = new IOException();
var commandNotFoundExceptionOriginal =
new CommandNotFoundException(commandName, commandArgs, innerException);
CommandNotFoundException commandNotFoundException;
using (var memoryStream = new MemoryStream())
{
var binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(memoryStream, commandNotFoundExceptionOriginal);
memoryStream.Position = 0;
commandNotFoundException = (CommandNotFoundException)binaryFormatter
.Deserialize(memoryStream);
}
Assert.That(commandNotFoundException.Message, Is.EqualTo("Invalid command name."));
Assert.That(commandNotFoundException.CommandName, Is.EqualTo(commandName));
Assert.That(commandNotFoundException.CommandArgs, Is.EqualTo(commandArgs));
Assert.That(commandNotFoundException.InnerException, Is.TypeOf <IOException>());
}
public Wall_E()
{
Config = JsonConvert.DeserializeObject <Config>(File.ReadAllText(Directory.GetCurrentDirectory() + @"\Config.json"));
Discord = new DiscordClient(new DiscordConfiguration {
Token = Config.Token,
UseInternalLogHandler = true,
TokenType = Config.TokenType,
AutoReconnect = true,
ReconnectIndefinitely = true,
GatewayCompressionLevel = GatewayCompressionLevel.Stream,
LargeThreshold = 250,
LogLevel = LogLevel.Info,
WebSocketClientFactory = WebSocket4NetCoreClient.CreateNew,
});
Lavalink = Discord.UseLavalink();
CommandsNext = Discord.UseCommandsNext(new CommandsNextConfiguration {
EnableDms = Config.EnableDms,
EnableMentionPrefix = true,
EnableDefaultHelp = false,
StringPrefixes = new[] { Config.Prefix },
Services = new ServiceCollection()
.AddSingleton <CSPRNG>()
.AddSingleton(new MusicService(Discord))
.BuildServiceProvider(true)
});
DiscordChannel Log = Discord.GetChannelAsync(valores.IdLogWall_E).Result;
int iterate = 0;
CommandsNext.CommandErrored += async(args) => {
var ctx = args.Context;
CommandNotFoundException cntfe = (CommandNotFoundException)args.Exception;
if (!String.IsNullOrEmpty(cntfe.CommandName))
{
if (iterate == 1)
{
await args.Context.RespondAsync($"Nononononononono, esse comando: `{Config.Prefix}{cntfe.CommandName}` também non ecziste!");
iterate = 0;
}
else
{
await args.Context.RespondAsync($"Padre Quevedo te alerta, esse comando: `{Config.Prefix}{cntfe.CommandName}` non ecziste!");
iterate++;
}
Console.WriteLine(args.Exception.ToString());
await Log.SendMessageAsync($"O membro `{ctx.Member.DisplayName}` executou um comando inexistente: `{Config.Prefix}{cntfe.CommandName}`.\nChat: `{ctx.Channel}`\nDia e Hora: `{DateTime.Now}`\n-------------------------------------------------------\n");
}
};
Discord.Ready += DiscordClient_Ready;
async Task DiscordClient_Ready(ReadyEventArgs e)
{
await Discord.UpdateStatusAsync(new DiscordActivity("no Discord da UBGE!"));
await Log.SendMessageAsync($"**Wall-E da Ética online!**\nLigado às: ``{DateTime.Now}``");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine($"[{DateTime.Now.Year}-{DateTime.Now.Month}-{DateTime.Now.Day} {DateTime.Now.Hour}:{DateTime.Now.Minute}:{DateTime.Now.Second} -03:00] [Wall-E] [DSharpPlus] Meu ping é: {Discord.Ping}ms!");
Console.ResetColor();
DiscordChannel Paulo = Discord.GetChannelAsync(valores.PauloCanal).Result;
//await Paulo.SendMessageAsync($"Tenho: **{Discord.GetCommandsNext().RegisteredCommands.Count}** comandos!");
Console.WriteLine($"[Wall-E] [DSharpPlus] Tenho: {Discord.GetCommandsNext().RegisteredCommands.Count} comandos!");
IRC(Discord);
}
CommandsNext.RegisterCommands(Assembly.GetEntryAssembly());
Interactivity = Discord.UseInteractivity(new InteractivityConfiguration {
PaginationBehavior = TimeoutBehaviour.DeleteMessage,
PaginationTimeout = TimeSpan.FromMinutes(3),
Timeout = TimeSpan.FromMinutes(3)
});
}
private static Task CommandNotFoundHandler(CommandNotFoundException ex, DiscordChannel logChannel)
{
return(Task.CompletedTask); // may add command suggestions to send the user based on what they typed
}
private void AccumulateMatchingCommands(IEnumerable <string> commandNames)
{
SearchResolutionOptions none = SearchResolutionOptions.None;
if (this.All != false)
{
none = SearchResolutionOptions.SearchAllScopes;
}
if ((this.CommandType & CommandTypes.Alias) != 0)
{
none |= SearchResolutionOptions.ResolveAliasPatterns;
}
if ((this.CommandType & (CommandTypes.Workflow | CommandTypes.Filter | CommandTypes.Function)) != 0)
{
none |= SearchResolutionOptions.ResolveFunctionPatterns;
}
foreach (string str in commandNames)
{
try
{
string str2 = null;
string pattern = str;
bool flag = false;
if ((str.IndexOf('\\') > 0) && (str.Split(new char[] { '\\' }).Length == 2))
{
string[] strArray = str.Split(new char[] { '\\' }, 2);
str2 = strArray[0];
pattern = strArray[1];
flag = true;
}
if ((this.Module.Length == 1) && !WildcardPattern.ContainsWildcardCharacters(this.Module[0]))
{
str2 = this.Module[0];
}
bool isPattern = WildcardPattern.ContainsWildcardCharacters(pattern);
if (isPattern)
{
none |= SearchResolutionOptions.CommandNameIsPattern;
}
int currentCount = 0;
bool flag3 = this.FindCommandForName(none, str, isPattern, true, ref currentCount);
if (!flag3 || isPattern)
{
if (!isPattern || !string.IsNullOrEmpty(str2))
{
string commandName = str;
if (!flag && !string.IsNullOrEmpty(str2))
{
commandName = str2 + @"\" + str;
}
try
{
CommandDiscovery.LookupCommandInfo(commandName, base.MyInvocation.CommandOrigin, base.Context);
}
catch (CommandNotFoundException)
{
}
flag3 = this.FindCommandForName(none, str, isPattern, false, ref currentCount);
}
else if ((this.ListImported == false) && ((this.TotalCount < 0) || (currentCount < this.TotalCount)))
{
foreach (CommandInfo info in ModuleUtils.GetMatchingCommands(pattern, base.Context, base.MyInvocation.CommandOrigin, true))
{
CommandInfo current = info;
if ((this.IsCommandMatch(ref current) && !this.IsCommandInResult(current)) && this.IsParameterMatch(current))
{
this.accumulatedResults.Add(current);
currentCount++;
if ((this.TotalCount >= 0) && (currentCount >= this.TotalCount))
{
break;
}
}
}
}
}
if (!flag3 && !isPattern)
{
CommandNotFoundException replaceParentContainsErrorRecordException = new CommandNotFoundException(str, null, "CommandNotFoundException", DiscoveryExceptions.CommandNotFoundException, new object[0]);
base.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
}
}
catch (CommandNotFoundException exception2)
{
base.WriteError(new ErrorRecord(exception2.ErrorRecord, exception2));
}
}
}