public static EmbedBuilder GetHelpListEmbed(IDMCommandContext context) { string contextType = ""; if (GuildCommandContext.TryConvert(context, out IGuildCommandContext guildContext)) { contextType = "Guild"; } else { contextType = "PM"; } string embedTitle = "List of all Commands"; string embedDesc = "This list only shows commands where all preconditions have been met!"; List <EmbedFieldBuilder> helpFields = new List <EmbedFieldBuilder>(); foreach (CommandCollection collection in CommandCollection.AllCollections) { bool collectionAllowed = true; if (context.IsGuildContext) { collectionAllowed = guildContext.ChannelMeta.allowedCommandCollections.Count == 0 || guildContext.ChannelMeta.allowedCommandCollections.Contains(collection.Name); } int availableCommands = collection.ViewableCommands(context, guildContext); if (availableCommands > 0 && collectionAllowed) { helpFields.Add(Macros.EmbedField($"Collection \"{collection.Name}\"", $"{availableCommands} commands.{(string.IsNullOrEmpty(collection.Description) ? string.Empty : $" {collection.Description}.")} Use `{MessageHandler.CommandParser.CommandSyntax("man")}` to see a summary of commands in this command family!", true)); } }
protected override Task <ArgumentParseResult> ParseArguments(IDMCommandContext context) { SystemName = context.Arguments.First; if (context.Arguments.TotalCount == 1) { Mode = CommandMode.Default; JumpRange = 20; return(Task.FromResult(ArgumentParseResult.SuccessfullParse)); } context.Arguments.Index++; if (!Enum.TryParse(context.Arguments.First, out Mode)) { return(Task.FromResult(new ArgumentParseResult(Arguments[1]))); } if (context.Arguments.TotalCount == 2) { JumpRange = 20; return(Task.FromResult(ArgumentParseResult.SuccessfullParse)); } context.Arguments.Index++; if (!double.TryParse(context.Arguments.First, out JumpRange)) { return(Task.FromResult(new ArgumentParseResult(Arguments[2]))); } return(Task.FromResult(ArgumentParseResult.SuccessfullParse)); }
private Task <ArgumentParseResult> parseArguments(IDMCommandContext context, IGuildCommandContext guildContext) { switch (ArgumentParserMethod) { case HandledContexts.None: return(Task.FromResult(ArgumentParseResult.DefaultNoArguments)); case HandledContexts.DMOnly: return(ParseArguments(context)); case HandledContexts.GuildOnly: return(ParseArgumentsGuildAsync(guildContext)); case HandledContexts.Both: if (context.IsGuildContext) { return(ParseArgumentsGuildAsync(guildContext)); } else { return(ParseArguments(context)); } } return(Task.FromResult(new ArgumentParseResult("INTERNAL ERROR"))); }
internal static bool TryParseArgument <T>(IDMCommandContext context, out T value, out string error) where T : class { if (parsers.TryGetValue(typeof(T), out ArgumentParser rawParser)) { ArgumentParser <T> parser = rawParser as ArgumentParser <T>; if (parser != null) { if (parser.TryParseArgument(context, out value)) { error = null; return(true); } else { error = parser.ErrorMessage; return(false); } } else { value = null; error = $"Internal Error at: {Macros.GetCodeLocation()}"; return(false); } } else { value = null; error = $"Could not locate an argument parser for the type \"{typeof(T)}\"!"; return(false); } }
/// <summary> /// Parses a user given a commandcontext. Because it works without guild context it needs to be asynchronous /// </summary> /// <param name="context">The commandcontext to parse the user from</param> /// <param name="argument">The argument string to parse the user from</param> /// <param name="allowMention">Wether mentioning is enabled for parsing user</param> /// <param name="allowSelf">Wether pointing to self is allowed</param> /// <param name="allowId">Wether the ulong id is enabled for parsing user</param> /// <returns>The parsed user if parsing succeeded, null instead</returns> public static async Task <SocketUser> ParseUser(IDMCommandContext context, string argument, bool allowMention = true, bool allowSelf = true, bool allowId = true) { SocketUser result = null; if (allowSelf && argument.Equals("self")) { result = context.User; } else if (allowMention && argument.StartsWith("<@") && argument.EndsWith('>') && argument.Length > 3) { if (ulong.TryParse(argument.Substring(2, argument.Length - 3), out ulong userId)) { result = await context.Channel.GetUserAsync(userId) as SocketUser; } } else if (allowMention && argument.StartsWith("<@!") && argument.EndsWith('>') && argument.Length > 3) { if (ulong.TryParse(argument.Substring(3, argument.Length - 3), out ulong userId)) { result = await context.Channel.GetUserAsync(userId) as SocketUser; } } else if (allowId && ulong.TryParse(argument, out ulong userId)) { result = await context.Channel.GetUserAsync(userId) as SocketUser; } return(result); }
private static bool TryParseUlongArgument(IDMCommandContext context, out ObjectWrapper <ulong> value) { bool success = ulong.TryParse(context.Arguments.First, out ulong rawValue); value = rawValue; return(success); }
protected override async Task Execute(IDMCommandContext context) { string webrequest = WebRequestService.EDSM_MultipleSystemsInfo_URL(new string[] { SystemA_name, SystemB_name }, showId: true, showCoords: true); RequestJSONResult requestResult = await WebRequestService.GetWebJSONAsync(webrequest); if (requestResult.IsSuccess) { if (requestResult.JSON.IsArray && requestResult.JSON.Array.Count < 1) { await context.Channel.SendEmbedAsync("System not found in database!", true); } else { if (printJson) { await context.Channel.SendEmbedAsync("General System Info", string.Format("```json\n{0}```", requestResult.JSON.Build(true).MaxLength(2037))); } EmbedBuilder distanceEmbed = GetDistanceEmbed(requestResult.JSON); await context.Channel.SendEmbedAsync(distanceEmbed); } } else if (requestResult.IsException) { await context.Channel.SendEmbedAsync(string.Format("Could not connect to EDSMs services. Exception Message: `{0}`", requestResult.ThrownException.Message), true); } else { await context.Channel.SendEmbedAsync(string.Format("Could not connect to EDSMs services. HTTP Error: `{0} {1}`", (int)requestResult.Status, requestResult.Status.ToString()), true); } }
private Task executeAsyncMode(IDMCommandContext context, IGuildCommandContext guildContext, object parsedArgs) { switch (ExecutionMethod) { case HandledContexts.None: return(context.Channel.SendEmbedAsync("INTERNAL ERROR", true)); case HandledContexts.DMOnly: AsyncCommandContainer.NewAsyncCommand(Execute, context, parsedArgs); break; case HandledContexts.GuildOnly: AsyncCommandContainer.NewAsyncCommand(ExecuteGuild, guildContext, parsedArgs); break; case HandledContexts.Both: if (context.IsGuildContext) { AsyncCommandContainer.NewAsyncCommand(ExecuteGuild, guildContext, parsedArgs); } else { AsyncCommandContainer.NewAsyncCommand(Execute, context, parsedArgs); } break; } return(Task.CompletedTask); }
private static bool TryParseDoubleArgument(IDMCommandContext context, out ObjectWrapper <double> value) { bool success = double.TryParse(context.Arguments.First, out double rawValue); value = rawValue; return(success); }
private static void NewAsyncCommand(AsyncDelegate task, IDMCommandContext context) { AsyncCommandContainer container = new AsyncCommandContainer(task, context); container.typingState = context.Channel.EnterTypingState(); AsyncCommandHandler.AddCommandContainer(container); }
private Task executeSyncMode(IDMCommandContext context, IGuildCommandContext guildContext, object parsedArgs) { switch (ExecutionMethod) { case HandledContexts.None: return(context.Channel.SendEmbedAsync("INTERNAL ERROR", true)); case HandledContexts.DMOnly: return(Execute(context, parsedArgs)); case HandledContexts.GuildOnly: return(ExecuteGuild(guildContext, parsedArgs)); case HandledContexts.Both: if (context.IsGuildContext) { return(ExecuteGuild(guildContext, parsedArgs)); } else { return(Execute(context, parsedArgs)); } default: return(Task.CompletedTask); } }
private bool CheckPreconditions(Precondition[] preconditions, IDMCommandContext context, IGuildCommandContext guildContext, bool isBotAdmin, out List <string> errors) { errors = new List <string>(); if (!context.IsGuildContext && RequireGuildContext) { errors.Add("This command can not be used in DM channels!"); return(false); } foreach (Precondition precondition in preconditions) { if (precondition.RequireGuild) { if (!precondition.PreconditionCheckGuild(guildContext, out string error)) { if (!precondition.OverrideAsBotadmin || !precondition.OverrideAsBotadmin) { errors.Add(error); } } } else { if (!precondition.PreconditionCheck(context, out string error)) { if (!precondition.OverrideAsBotadmin || !precondition.OverrideAsBotadmin) { errors.Add(error); } } } } return(errors.Count == 0); }
public static Task SendHelpList(IDMCommandContext context, ISocketMessageChannel outputchannel = null) { EmbedBuilder embed = GetHelpListEmbed(context); if (outputchannel == null) { outputchannel = context.Channel; } return(outputchannel.SendEmbedAsync(embed)); }
public static Task SendCommandCollectionHelp(IDMCommandContext context, CommandCollection collection, ISocketMessageChannel outputchannel = null) { EmbedBuilder embed = GetCommandCollectionEmbed(context, collection); if (outputchannel == null) { outputchannel = context.Channel; } return(outputchannel.SendEmbedAsync(embed)); }
private Task execute(IDMCommandContext context, IGuildCommandContext guildContext, object parsedArgs) { if (RunInAsyncMode) { return(executeAsyncMode(context, guildContext, parsedArgs)); } else { return(executeSyncMode(context, guildContext, parsedArgs)); } }
protected override Task Execute(IDMCommandContext context, object argObj) { if (AboutEmbed.Author == null) { AboutEmbed.Author = new EmbedAuthorBuilder() { IconUrl = BotCore.Client.CurrentUser.GetDefaultAvatarUrl() }; } return(context.Channel.SendEmbedAsync(AboutEmbed)); }
protected override async Task Execute(IDMCommandContext context) { string requestSystem = WebRequestService.EDSM_SystemInfo_URL(systemName, true, true, true, true, true); string requestStations = WebRequestService.EDSM_SystemStations_URL(systemName); string requestTraffic = WebRequestService.EDSM_SystemTraffic_URL(systemName); string requestDeaths = WebRequestService.EDSM_SystemDeaths_URL(systemName); if (webRequests) { EmbedBuilder embed = new EmbedBuilder() { Title = "Webrequests", Color = BotCore.EmbedColor, Description = $"[System]({requestSystem}) `{requestSystem}`\n[Stations]({requestStations}) `{requestStations}`\n[Traffic]({requestTraffic}) `{requestTraffic}`\n[Deaths]({requestDeaths}) `{requestDeaths}`" }; await context.Channel.SendEmbedAsync(embed); } RequestJSONResult requestResultSystem = await WebRequestService.GetWebJSONAsync(requestSystem); RequestJSONResult requestResultStations = await WebRequestService.GetWebJSONAsync(requestStations); RequestJSONResult requestResultTraffic = await WebRequestService.GetWebJSONAsync(requestTraffic); RequestJSONResult requestResultDeaths = await WebRequestService.GetWebJSONAsync(requestDeaths); if (requestResultSystem.IsSuccess) { if (requestResultSystem.JSON.IsArray && requestResultSystem.JSON.Array.Count < 1) { await context.Channel.SendEmbedAsync("System not found in database!", true); } else { if (printJson) { await context.Channel.SendEmbedAsync("General System Info", string.Format("```json\n{0}```", requestResultSystem.JSON.Build(true).MaxLength(2037))); await context.Channel.SendEmbedAsync("Station Info", string.Format("```json\n{0}```", requestResultStations.JSON.Build(true).MaxLength(2037))); } EmbedBuilder systemEmbed = GetSystemInfoEmbed(requestResultSystem.JSON, requestResultStations.JSON, requestResultTraffic.JSON, requestResultDeaths.JSON, out List <EmbedFieldBuilder> allStations); await context.Channel.SendEmbedAsync(systemEmbed); } } else if (requestResultSystem.IsException) { await context.Channel.SendEmbedAsync(string.Format("Could not connect to EDSMs services. Exception Message: `{0}`", requestResultSystem.ThrownException.Message), true); } else { await context.Channel.SendEmbedAsync(string.Format("Could not connect to EDSMs services. HTTP Error: `{0} {1}`", (int)requestResultSystem.Status, requestResultSystem.Status.ToString()), true); } }
public override bool PreconditionCheck(IDMCommandContext context, out string message) { if (context.UserInfo.IsBotAdmin) { message = null; return(true); } else { message = "BotAdmin privileges required!"; return(false); } }
public int ViewableCommands(IDMCommandContext context, IGuildCommandContext guildContext) { int count = 0; foreach (Command c in commandsInCollection) { if (c.CanView(context, guildContext, context.UserInfo.IsBotAdmin, out _)) { count++; } } return(count); }
private static bool tryGetCommandCollectionEmbedField(IDMCommandContext context, IGuildCommandContext guildContext, CommandCollection collection, out EmbedFieldBuilder embedField) { bool collectionAllowed = true; if (context.IsGuildContext) { collectionAllowed = guildContext.ChannelMeta.allowedCommandCollections.Count == 0 || guildContext.ChannelMeta.allowedCommandCollections.Contains(collection.Name); } int availableCommands = collection.ViewableCommands(context, guildContext); if (availableCommands > 0 && collectionAllowed) { embedField = Macros.EmbedField($"Collection \"{collection.Name}\"", $"{availableCommands} commands.{(string.IsNullOrEmpty(collection.Description) ? string.Empty : $" {collection.Description}.")} Use `{MessageHandler.CommandParser.CommandSyntax("man", collection.Name)}` to see a summary of commands in this command family!", true); return(true); }
protected override Task <ArgumentParseResult> ParseArguments(IDMCommandContext context) { if (context.Message.Content.Length > Identifier.Length + 1) { string embedText = context.ArgumentSection.Replace("[3`]", "```"); if (JSONContainer.TryParse(embedText, out JSONContainer json, out string errormessage)) { return(Task.FromResult(EmbedHelper.TryParseEmbedFromJSONObject(json, out embed, out messageContent))); } else { return(Task.FromResult(new ArgumentParseResult(Arguments[0], $"Unable to parse JSON text to a json data structure! Error: `{errormessage}`"))); } }
public static bool TryParseGuild(IDMCommandContext context, string argument, out SocketGuild guild, bool allowthis = true, bool allowId = true) { if (allowthis && argument.ToLower() == "this" && GuildCommandContext.TryConvert(context, out IGuildCommandContext guildContext)) { guild = guildContext.Guild; return(guild != null); } else if (allowId && ulong.TryParse(argument, out ulong guildId)) { guild = BotCore.Client.GetGuild(guildId); return(guild != null); } guild = null; return(false); }
protected override Task Execute(IDMCommandContext context) { if (collection != null) { return(CommandManual.SendCommandCollectionHelp(context, collection)); } else if (command != null) { return(CommandManual.SendCommandHelp(context, command)); } else { return(CommandManual.SendHelpList(context)); } }
public static EmbedBuilder GetCommandCollectionEmbed(IDMCommandContext context, CommandCollection collection) { string contextType = ""; if (GuildCommandContext.TryConvert(context, out IGuildCommandContext guildContext)) { contextType = "Guild"; } else { contextType = "PM"; } string embedTitle = $"Command Collection \"{collection.Name}\""; string embedDesc = "This list only shows commands where all preconditions have been met!"; List <EmbedFieldBuilder> helpFields = new List <EmbedFieldBuilder>(); foreach (Command command in collection.Commands) { if (command.CanView(context, guildContext, context.UserInfo.IsBotAdmin, out _)) { helpFields.Add(Macros.EmbedField(command.Syntax, command.Summary, true)); } } if (helpFields.Count == 0) { embedDesc = "No command's precondition has been met!"; return(new EmbedBuilder() { Title = embedTitle, Description = embedDesc, Color = BotCore.ErrorColor, Footer = new EmbedFooterBuilder() { Text = "Context: " + contextType } }); } else { return(new EmbedBuilder() { Title = embedTitle, Description = embedDesc, Color = BotCore.EmbedColor, Footer = new EmbedFooterBuilder() { Text = "Context: " + contextType }, Fields = helpFields }); } }
protected override Task <ArgumentParseResult> ParseArguments(IDMCommandContext context) { cmdrName = context.Arguments.First; if (context.Arguments.TotalCount == 1) { printJson = false; return(Task.FromResult(ArgumentParseResult.SuccessfullParse)); } context.Arguments.Index++; printJson = context.Arguments.First.Contains("json"); return(Task.FromResult(ArgumentParseResult.SuccessfullParse)); }
protected override Task Execute(IDMCommandContext context, object argObj) { ArgumentContainer args = argObj as ArgumentContainer; if (args != null) { if (args.collection != null) { return(CommandManual.SendCommandCollectionHelp(context, args.collection)); } else if (args.command != null) { return(CommandManual.SendCommandHelp(context, args.command)); } } return(CommandManual.SendHelpList(context)); }
internal async Task HandleCommandAsync(IDMCommandContext context, IGuildCommandContext guildContext) { string stage = "Checking Preconditions"; try { if (CanExecute(context, guildContext, context.UserInfo.IsBotAdmin, out List <string> errors)) { stage = "Parsing Arguments"; ArgumentParseResult parseResult = await parseArguments(context, guildContext); if (!parseResult.Success) { EmbedBuilder parseFailed = new EmbedBuilder() { Color = BotCore.ErrorColor, Title = "Argument Parsing Failed!", Description = parseResult.ToString() }; await context.Channel.SendEmbedAsync(parseFailed); } else { stage = "Executing Command"; await execute(context, guildContext); } } else { EmbedBuilder embed = new EmbedBuilder() { Title = "Command Execution Failed", Color = BotCore.ErrorColor, Description = errors.Join("\n") }; await context.Channel.SendEmbedAsync(embed); } } catch (Exception e) { await context.Channel.SendMessageAsync($"Exception at stage `{stage}`", embed : Macros.EmbedFromException(e).Build()); } }
protected override Task <ArgumentParseResult> ParseArguments(IDMCommandContext context) { systemName = context.Arguments.First; if (context.Arguments.TotalCount == 1) { webRequests = false; printJson = false; listAllStations = false; return(Task.FromResult(ArgumentParseResult.SuccessfullParse)); } context.Arguments.Index++; webRequests = context.Arguments.First.Contains("webrequests"); printJson = context.Arguments.First.Contains("json"); listAllStations = context.Arguments.First.Contains("list"); return(Task.FromResult(ArgumentParseResult.SuccessfullParse)); }
protected override Task <ArgumentParseResult> ParseArguments(IDMCommandContext context) { SystemA_name = context.Arguments.First; context.Arguments.Index++; SystemB_name = context.Arguments.First; if (context.Arguments.TotalCount == 2) { printJson = false; } else { context.Arguments.Index++; printJson = context.Arguments.First.ToLower().Contains("json"); } return(Task.FromResult(ArgumentParseResult.SuccessfullParse)); }
protected override Task <ArgumentParseResult> ParseArguments(IDMCommandContext context) { if (context.Arguments.TotalCount == 0) { identifier = null; command = null; return(Task.FromResult(ArgumentParseResult.DefaultNoArguments)); } identifier = context.Arguments.First; if (!CommandCollection.TryFindCommand(identifier, out command)) { if (!CommandCollection.AllCollections.TryFind(collection => { return(collection.Name.ToLower() == identifier.ToLower()); }, out collection)) { return(Task.FromResult(ArgumentParseResult.SuccessfullParse)); } } return(Task.FromResult(ArgumentParseResult.SuccessfullParse)); }