internal override Embed Run(SocketSlashCommand command, DiscordSocketClient client, IReadOnlyDictionary <SlashCommandOptions, string> options, Team team) { League league = LeagueManager.League; if (!league.NextMatchLookup.ContainsKey(team)) { return(null); } MatchResult match = league.NextMatchLookup[team]; EmbedBuilder builder = new EmbedBuilder().WithThumbnailUrl(team.ImageURL);; builder.Title = CeaNextCommand.GetNextMatchString(team); if (!match.Bye) { CeaTeamCommand.AddRosterToEmbed(builder, match.HomeTeam); CeaRecordCommand.AddRecordStatsToEmbed(builder, match.HomeTeam); CeaHistoryCommand.AddFullHistoryToEmbed(builder, match.HomeTeam); CeaTeamCommand.AddRosterToEmbed(builder, match.AwayTeam); CeaRecordCommand.AddRecordStatsToEmbed(builder, match.AwayTeam); CeaHistoryCommand.AddFullHistoryToEmbed(builder, match.AwayTeam); } return(builder.Build()); }
private async Task HandleSlashCommand(SocketSlashCommand interaction) { if (interaction.User.IsBot) { return; } var user = interaction.User; switch (interaction.Channel) { case SocketDMChannel: _logger.Info("{Username:l}#{Discriminator:l} in DM's", user.Username, user.Discriminator); break; case SocketTextChannel txtChannel: _logger.Info("{Username:l}#{Discriminator:l} from {GuildName:l}/{ChannelName:l}", txtChannel.Guild.Name, txtChannel.Name); break; } _logger.Info(interaction.GetCmdString()); var context = new ShardedInteractionContext <SocketSlashCommand>(_client, interaction); var result = await _interactionService.ExecuteCommandAsync(context, _serviceProvider); if (!result.IsSuccess) { _logger.Error(result.ErrorReason); } }
public async Task ExecuteCommandAsync(SocketSlashCommand command, IServiceScopeFactory scopeFactory) { await command.RespondAsync(embed : CommandHelper.WaitResponceBuilder.Build()); var option = command.Data.Options.FirstOrDefault(); using var scope = scopeFactory.CreateScope(); var clanActivities = scope.ServiceProvider.GetRequiredService <IClanActivities>(); var modeContainer = option is null ? await clanActivities.GetClanActivitiesAsync() : await clanActivities.GetClanActivitiesAsync(CommandHelper.GetPeriod((string)option.Value)); var sb = new StringBuilder($"{CommandHelper.GetActivityCountImpression(modeContainer.TotalCount, "клану")}"); sb.Append("\n\n***За типом активности:***"); foreach (var mode in modeContainer.Counters) { var emoji = CommonData.DiscordEmoji.Emoji.GetActivityEmoji(mode.ActivityMode); var modes = Translation.ActivityNames[mode.ActivityMode]; sb.Append($"\n{emoji} **{modes[0]}** | {modes[1]} – **{mode.Count}**"); } var builder = new EmbedBuilder() .WithColor(0xFFB95A) .WithThumbnailUrl((command.Channel as IGuildChannel).Guild.IconUrl) .WithTitle($"Активності клану {(command.Channel as IGuildChannel).Guild.Name}{(option is null ? string.Empty : $" за {option.Value}")}")
internal static async Task SlashCommandExecuted(SocketSlashCommand command) { if (command.Data.Name != "pronoun" || command.User is not IGuildUser author || command.Channel is not SocketTextChannel channel) { return; } var role = (string)command.Data.Options.First(); ulong?idNull = role switch { "she/her" => SheHer, "he/him" => HeHim, "they/them" => TheyThem, "him/her/they" => HimHerThey, "fae/faer" => FaeFaer, _ => null, }; if (idNull != null) { var id = idNull.Value; if (author.RoleIds.Contains(id)) { await author.RemoveRoleAsync(channel.Guild.GetRole(id)); await command.RespondAsync("Pronoun role removed", ephemeral : true); } else { await author.AddRoleAsync(channel.Guild.GetRole(id)); await command.RespondAsync("Pronoun role added", ephemeral : true); } } }
public static async Task Run(SocketSlashCommand command, DiscordSocketClient client, StorageClient storageClient, Dictionary <string, SocketSlashCommandDataOption> options, Guild guild, ISocketMessageChannel recruitingChannel, List <Team> teams) { var guildUser = (SocketGuildUser)options["username"].Value; var discordUser = guildUser.Nickname ?? guildUser.Username; // Player not exist? -> respond with error (var oldTeam, var player) = Team.FindPlayer(teams, discordUser); if (player == null) { await command.FollowupAsync($"User {discordUser} does not exist in the recruiting table", ephemeral : true); return; } oldTeam.RemovePlayer(player); // Update old team message if (oldTeam.Players.Count > 0) { await recruitingChannel.ModifyMessageAsync(oldTeam.MsgId, (message) => message.Content = oldTeam.ToMessage()); await storageClient.SaveTableRow(Team.TableName, oldTeam.Name, guild.RowKey, oldTeam); } else { await recruitingChannel.DeleteMessageAsync(oldTeam.MsgId); await storageClient.DeleteTableRow(Team.TableName, oldTeam.Name, guild.RowKey); } await command.FollowupAsync($"You have removed user {discordUser} from {oldTeam.Name}", ephemeral : true); }
public async Task TestButtons(SocketSlashCommand cmd, [Option("number", true)] double number) { var builder = await _component.Components <SkyrimButtons>(cmd); await cmd.Respond("This is a button: " + number, components : builder); }
internal override Embed Run(SocketSlashCommand command, DiscordSocketClient client, IReadOnlyDictionary <SlashCommandOptions, string> options, Team team) { EmbedBuilder builder = new(); AddFullHistoryToEmbed(builder, team); return(builder.Build()); }
async Task ICeaSubCommand.Run(SocketSlashCommand command, DiscordSocketClient client, IReadOnlyDictionary <SlashCommandOptions, string> options, Lazy <List <Team> > lazyTeams) { // Responding prior to update as update may take longer than 3s which is the maximum timeout for discord command. await command.RespondAsync("Refresh Started.", ephemeral : true); LeagueManager.ForceUpdate(); }
public async Task TestReactions(SocketSlashCommand cmd) { var msg = await cmd.Respond("This is a test!"); await _reactions.Reactions(msg, t => { t //.OnlyOn(a => a.UserId == cmd.User.Id) .React("✔️", async reaction => { await msg.ModifyAsync(t => t.Content = "This has been a test, good night."); }, a => a.UserId == cmd.User.Id) .React("🎅", async reaction => { await msg.ModifyAsync(t => t.Content = "Ho ho ho!"); }) .React("<:5head:614356868134993921>", async reaction => { await msg.ModifyAsync(t => t.Content = "That's a large forehead you have there."); }) .React("🤶", async reaction => { await msg.ModifyAsync(t => t.Content = "Mrs. Clause, can I have a cookie?"); }) .AllowMultipleExecutions(); }); }
public override async Task HandleCommandAsync(SocketSlashCommand command, DiscordSocketClient client, StorageClient storageClient, Guild guild) { var subCommand = command.Data.Options.Where(o => o.Type.Equals(ApplicationCommandOptionType.SubCommand)).First(); string configuration = (string)subCommand.Options.Where(o => o.Name.Equals("configuration")).First().Value; try { BracketConfiguration newConfiguration = JsonSerializer.Deserialize <BracketConfiguration>(configuration); ConfigurationManager.UpdateInMemoryConfiguration(newConfiguration); await command.RespondAsync($"New Configuration Set.\n{configuration}", ephemeral : true); LeagueManager.ForceUpdate(); } catch (JsonException) { await command.RespondAsync("Invalid BracketConfiguration JSON.", ephemeral : true); throw; } catch (Exception e) { await command.RespondAsync($"Unknown Exception.\n{e}", ephemeral : true); throw; } }
public static async Task Run(SocketSlashCommand command, DiscordSocketClient client, Dictionary <string, SocketSlashCommandDataOption> options, ISocketMessageChannel recruitingChannel, List <IMessage> messages, List <Team> teams) { var guildUser = (SocketGuildUser)options["username"].Value; var discordUser = guildUser.Nickname ?? guildUser.Username; // Player not exist? -> respond with error (var oldTeam, var player) = Team.FindPlayer(teams, discordUser); if (player == null) { await command.RespondAsync($"User {discordUser} does not exist in the recruiting table", ephemeral : true); return; } // If player was captain of old team remove that teams captain if (oldTeam.Captain?.DiscordUser == player.DiscordUser) { oldTeam.Captain = null; } // Move Player oldTeam.Players.Remove(player); // Update old team message if (oldTeam.Players.Count > 0) { await recruitingChannel.ModifyMessageAsync(oldTeam.MsgId, (message) => message.Content = oldTeam.ToMessage()); } else { await recruitingChannel.DeleteMessageAsync(oldTeam.MsgId); } await command.RespondAsync($"You have removed user {discordUser} from {oldTeam.Name}", ephemeral : true); }
private async Task ActivitySlashCommandExecutedAsync(SocketSlashCommand command) { var container = TryParseActivityContainer(command); if (container is not null) { var builder = new EmbedBuilder() .WithColor(new Color(0xA6F167)) .WithTitle("Збір у активність") .WithDescription($"Створюю активність…"); await command.RespondAsync(embed : builder.Build(), ephemeral : true); await InitActivityAsync(container); } else { var builder = new EmbedBuilder() .WithColor(new Color(0xD50000)) .WithTitle("Збір у активність") .WithDescription($"Сталася помилка під час створення активності. Перевірте, чи формат команди коректний.\n" + $"Щоби переглянути довідку, скористайтеся командою **допомога**."); await command.RespondAsync(embed : builder.Build(), ephemeral : true); } }
public static async Task Run(SocketSlashCommand command, DiscordSocketClient client, StorageClient storageClient, Dictionary <string, SocketSlashCommandDataOption> options, Guild guild, ISocketMessageChannel recruitingChannel, List <Team> teams) { var guildUser = (SocketGuildUser)options["username"].Value; var teamName = String.Empty; if (options.TryGetValue("team", out SocketSlashCommandDataOption teamOption)) { teamName = teamOption.Value.ToString(); } // Construct new player from parameters var newPlayer = new Player(); newPlayer.DiscordUser = guildUser.Nickname ?? guildUser.Username; newPlayer.Platform = (Platform)Enum.Parse(typeof(Platform), options["platform"].Value.ToString()); newPlayer.PlatformId = options["id"].Value.ToString(); if (newPlayer.Platform == Platform.Tracker && !Player.ValidateTrackerLink(newPlayer.PlatformId)) { await command.FollowupAsync($"Your RL tracker link is invalid", ephemeral : true); return; } // Is player just updating tracker link? -> Update link (var team, var existingPlayer) = Team.FindPlayer(teams, newPlayer.DiscordUser); if (existingPlayer != null && !string.Equals(team.Name, teamName, StringComparison.InvariantCultureIgnoreCase)) { await command.FollowupAsync($"Invalid use of add command. Please use the move command to change a user between teams", ephemeral : true); return; } if (team == null) { teamName = string.IsNullOrEmpty(teamName) ? "Free_Agents" : teamName; team = Team.AddPlayer(teams, teamName, newPlayer); } else { existingPlayer.Platform = newPlayer.Platform; existingPlayer.PlatformId = newPlayer.PlatformId; } // Have we added this team message yet? -> Write team message and move to next team if (team.MsgId == 0) { team.MsgId = (await recruitingChannel.SendMessageAsync(team.ToMessage())).Id; } else { // This is an existing team -> Modify old team message await recruitingChannel.ModifyMessageAsync(team.MsgId, (message) => message.Content = team.ToMessage()); } await storageClient.SaveTableRow(Team.TableName, team.Name, guild.RowKey, team); await command.FollowupAsync($"{newPlayer.DiscordUser}'s RL tracker has been added to the recruiting board in channel <#{recruitingChannel.Id}>", ephemeral : true); }
private ActivityContainer TryParseActivityContainer(SocketSlashCommand command) { try { var options = command.Data.Options; var modeOption = options.First(x => x.Name is "режим"); var activityType = Translation.GetActivityType(((string)modeOption.Value).ToLower()); var dateOption = options.First(x => x.Name is "дата"); DateTime plannedDate = DateTime.ParseExact((string)dateOption.Value, "d.M-H:m", CultureInfo.CurrentCulture); var nameOption = options.FirstOrDefault(x => x.Name is "назва"); var activityName = nameOption?.Value.ToString(); var descriptionOption = options.FirstOrDefault(x => x.Name is "опис"); var description = descriptionOption?.Value.ToString(); var users = new ulong[] { command.User.Id }; return(new ActivityContainer { ChannelID = command.Channel.Id, ActivityType = activityType, ActivityName = activityName, Description = description, PlannedDate = plannedDate, Users = users }); } catch { return(null); } }
/// <summary> /// Attempts to handle the given slash command /// </summary> /// <param name="command">The command that needs to be handled</param> /// <returns>Whether or not the command was handled</returns> public bool Handle(SocketSlashCommand command) { var cmd = command.CommandName.ToLower().Trim(); if (_commands == null || _commands.ReflectionCommands.Count <= 0 || !_commands.ReflectionCommands.ContainsKey(cmd)) { return(false); } _ = Task.Run(async() => { try { await HandleCommand(command, cmd); } catch (Exception ex) { _logger.LogError(ex, "Error occurred while processing command: {0}", command.CommandName); await command.Modify("An error occurred! Please try again later."); } }); return(true); }
public async Task ExecuteCommandAsync(SocketSlashCommand command, IServiceScopeFactory scopeFactory) { await command.RespondAsync(embed : CommandHelper.WaitResponceBuilder.Build()); var option = command.Data.Options.FirstOrDefault(); using var scope = scopeFactory.CreateScope(); var clanActivities = scope.ServiceProvider.GetRequiredService <IClanActivities>(); var userContainer = option is null ? await clanActivities.GetUserPartnersAsync(command.User.Id) : await clanActivities.GetUserPartnersAsync(command.User.Id, CommandHelper.GetPeriod((string)option.Value)); if (userContainer is null) { await command.ModifyOriginalResponseAsync(x => x.Embed = CommandHelper.UserIsNotRegisteredBuilder.Build()); return; } var sb = new StringBuilder($"Всього кооперативних активностей: "); sb.Append($"**{userContainer.CoopCount}/{userContainer.TotalCount} ({Math.Round(userContainer.CoopCount * 100.0 / userContainer.TotalCount, 2)}%)**\n"); foreach (var partner in userContainer.Partners) { sb.Append($"\n**{partner.UserName}** – **{partner.Count}**"); } var builder = new EmbedBuilder() .WithColor(0xB4A647) .WithThumbnailUrl(command.User.GetAvatarUrl()) .WithTitle($"Побратими {userContainer.UserName}{(option is null ? string.Empty : $" за {option.Value}")}")
public async Task ExecuteCommandAsync(SocketSlashCommand command, IServiceScopeFactory scopeFactory) { var builder = new EmbedBuilder() .WithColor(0xAE52D4) .WithTitle("буп…"); await command.RespondAsync(embed : builder.Build()); }
/// <summary> /// Handler for slash commands that are executed /// </summary> /// <param name="arg">The socket slash command that was executed</param> /// <returns>A task representing the completion of the handler</returns> public Task Client_SlashCommandExecuted(SocketSlashCommand arg) { if (!HandleFluentCommand(arg)) { _slashRef.Handle(arg); } return(Task.CompletedTask); }
async Task ICeaSubCommand.Run(SocketSlashCommand command, DiscordSocketClient client, IReadOnlyDictionary<SlashCommandOptions, string> options, Lazy<List<Team>> lazyTeams) { Bracket bracket = LeagueManager.League.Bracket.Brackets.First(); string stage = StageMatcher.Lookup(bracket.Rounds.Last().RoundName); string rematches = StageRematchFinder.FindRematches(bracket, stage); await command.RespondAsync(rematches, ephemeral: true); }
/// <summary> /// Modifies the exisitng socket message with the given content /// </summary> /// <param name="cmd">The slash command that triggered the request</param> /// <param name="message">The content to update the response to</param> /// <returns>The interaction result</returns> public static Task <RestInteractionMessage> Modify(this SocketSlashCommand cmd, EmbedBuilder message) { return(cmd.ModifyOriginalResponseAsync(f => { f.Content = null; f.Embed = message.Build(); })); }
public static string GetCmdString(this SocketSlashCommand cmd) { var strBuilder = new StringBuilder("/").Append(cmd.CommandName); var cmdData = cmd.Data; var parameters = cmdData.Options.Aggregate(strBuilder, (accumulator, option) => accumulator.Append(' ').Append(option.Value)); return(strBuilder.ToString()); }
/// <summary> /// Modifies the exisitng socket message with the given content /// </summary> /// <param name="cmd">The slash command that triggered the request</param> /// <param name="message">The content to update the response to</param> /// <returns>The interaction result</returns> public static Task <RestInteractionMessage> Modify(this SocketSlashCommand cmd, Action <EmbedBuilder> message) { var em = new EmbedBuilder(); message(em); var res = em.Build(); return(cmd.Modify(res)); }
async Task ICeaSubCommand.Run(SocketSlashCommand command, DiscordSocketClient client, IReadOnlyDictionary <SlashCommandOptions, string> options, Lazy <List <Team> > lazyTeams) { bool ephemeral = !options.ContainsKey(SlashCommandOptions.post) || !options[SlashCommandOptions.post].Equals("True"); BracketSet currentBrackets = LeagueManager.League.Bracket; if (currentBrackets == null) { await command.RespondAsync(text : "No Current Brackets.", ephemeral : ephemeral); } List <Tuple <string, string, string> > bracketResults = new(); foreach (Bracket bracket in currentBrackets.Brackets) { List <BracketRound> rounds = bracket.Rounds; int roundIndex = !options.ContainsKey(SlashCommandOptions.week) ? rounds.Count - 1 : int.Parse(options[SlashCommandOptions.week]); BracketRound round = rounds[roundIndex]; StringBuilder sb = new(); foreach (MatchResult match in round.NonByeMatches) { sb.AppendLine($"[{match.HomeGamesWon}-{match.AwayGamesWon}] (**{match.HomeTeam.RoundRanking[round]}**){match.HomeTeam} vs (**{match.AwayTeam.RoundRanking[round]}**){match.AwayTeam}"); } foreach (MatchResult match in round.ByeMatches) { sb.AppendLine($"[BYE] (**{match.HomeTeam.RoundRanking[round]}**){match.HomeTeam} vs *BYE*"); } bracketResults.Add(new Tuple <string, string, string>(bracket.Name, round.RoundName, sb.ToString())); } if (bracketResults.All(s => s.Item3.Length < 1024)) { List <Embed> embeds = new(); foreach (Tuple <string, string, string> bracketResult in bracketResults) { EmbedBuilder builder = new(); builder.Title = bracketResult.Item1; builder.AddField(bracketResult.Item2, bracketResult.Item3); embeds.Add(builder.Build()); } await command.RespondAsync(embeds : embeds.ToArray(), ephemeral : ephemeral); } else { StringBuilder result = new StringBuilder(); foreach (Tuple <string, string, string> bracketResult in bracketResults) { result.AppendLine(bracketResult.Item1); result.AppendLine(bracketResult.Item2); result.AppendLine(bracketResult.Item3); } await command.RespondAsync(text : result.ToString(), ephemeral : ephemeral); } }
public async Task ExecuteCommandAsync(SocketSlashCommand command, IServiceScopeFactory scopeFactory) { await command.RespondAsync(embed : CommandHelper.WaitResponceBuilder.Build()); var option = command.Data.Options.FirstOrDefault(); var mode = Translation.GetActivityType(((string)option.Value).ToLower()); if (mode is DestinyActivityModeType.None) { await command.ModifyOriginalResponseAsync(x => x.Embed = CommandHelper.WrongActivityTypeBuilder.Build()); return; } using var scope = scopeFactory.CreateScope(); var clanActivities = scope.ServiceProvider.GetRequiredService <IClanActivities>(); var leaderboard = await clanActivities.GetLeaderboardAsync(command.User.Id, mode); if (leaderboard is null) { await command.ModifyOriginalResponseAsync(x => x.Embed = CommandHelper.UserIsNotRegisteredBuilder.Build()); return; } if (!leaderboard.LeaderboardStats.Any()) { await command.ModifyOriginalResponseAsync(x => x.Embed = CommandHelper.BungieSideErrorBuilder.Build()); return; } var fields = leaderboard.LeaderboardStats .Select(x => new EmbedFieldBuilder { IsInline = false, Name = x.StatName, Value = string.Join("\n", x.Leaders .Select(y => y.IsCurrUser ? $"**{y.Rank}, {y.UserName}, {Translation.ClassNames[y.DestinyClass]}, {y.Value}**" : $"{y.Rank}, {y.UserName}, {Translation.ClassNames[y.DestinyClass]}, {y.Value}")) }).ToList(); var builder = new EmbedBuilder() .WithColor(0x25C486) .WithThumbnailUrl(Emote.Parse(CommonData.DiscordEmoji.Emoji.GetActivityEmoji(mode)).Url) .WithTitle($"БЕТА | Дошка лідерів | {Translation.ActivityNames[mode][0]}") .WithImageUrl(leaderboard.ChartImageURL) .WithFields(fields); await command.ModifyOriginalResponseAsync(x => x.Embed = builder.Build()); }
public async Task ExecuteCommandHelpAsync(SocketSlashCommand command) { var builder = new EmbedBuilder() .WithColor(0xBE5BEF) .WithTitle($"Допомога \"{CommandName}\"") .WithDescription($"Команда виводить список наявних типів активностей, " + $"які можна використовувати у якості параметрів для інших команд."); await command.RespondAsync(embed : builder.Build()); }
public async Task SlashCommandExecute(SocketSlashCommand command) { switch (command.Data.Name) { case "register-message": await RegisterMessageAsync(command); break; } }
/// <summary> /// Handles fluently registered slash commands /// </summary> /// <param name="arg">The slash command that triggered the handler</param> /// <returns>Whether or not the command was handled</returns> public bool HandleFluentCommand(SocketSlashCommand arg) { try { var cmd = arg.CommandName.ToLower().Trim(); if (_slash.Commands == null || _slash.Commands.Count <= 0) { return(false); } if (!_slash.Commands.ContainsKey(cmd)) { return(false); } var handler = _slash.Commands[cmd]; if (handler?.Parent == null) { _logger.LogWarning($"Parent Handler cannot be null: {arg.CommandName}"); return(false); } var parent = _services.GetService(handler.Parent); if (parent == null) { _logger.LogWarning($"Slash command registered, but parent object is not found: {cmd}"); return(false); } if (handler?.Method == null) { _logger.LogWarning($"Handler method cannot be null: {arg.CommandName}"); return(false); } _ = Task.Run(async() => { try { var method = handler.Method(parent); await method(arg); } catch (Exception ex) { _logger.LogError(ex, $"Error occurred while executing slash command {arg.CommandName}"); } }); return(true); } catch (Exception ex) { _logger.LogError(ex, $"Error occurred while executing slash command: {arg.CommandName}"); return(false); } }
private async Task PostImage(SocketSlashCommand command, ulong channelID) { string folderPath = Path.Combine(Environment.CurrentDirectory, "Backup"); if (!Directory.Exists(folderPath)) { await command.RespondAsync("Backup folder not found", ephemeral : true); return; } string[] whitelistPaths = Directory.GetDirectories(folderPath); string channelPath = null; foreach (string testDir in whitelistPaths) { string testPath = Path.Combine(testDir, channelID.ToString()); if (Directory.Exists(testPath)) { channelPath = testPath; break; } } if (channelPath == null) { await command.RespondAsync("Backup of channel not found", ephemeral : true); return; } string[] filesPath = Directory.GetFiles(channelPath); if (filesPath.Length == 0) { await command.RespondAsync("Backup of channel has no files", ephemeral : true); return; } for (int tries = 0; tries < 10; tries++) { int fileID = rand.Next(filesPath.Length - 1); string filePath = filesPath[fileID]; if (!File.Exists(filePath)) { continue; } long fileLength = new FileInfo(filePath).Length; if (fileLength > 7 * 1024 * 1024) { continue; } Log(LogSeverity.Info, $"Sending {filePath}"); await command.RespondWithFileAsync(filePath, text : ""); return; } await command.RespondAsync("Failed to find an image to post", ephemeral : true); }
public override async Task HandleCommandAsync(SocketSlashCommand command, DiscordSocketClient client) { var channel = command.Channel as SocketGuildChannel; if (!recruitingChannelForGuild.TryGetValue(channel.Guild.Id, out var recruitingChannelId)) { await command.RespondAsync("Channel is not part of a guild that supports recruiting", ephemeral : true); return; } // Get all messages in channel var recruitingChannel = await client.GetChannelAsync(recruitingChannelId) as ISocketMessageChannel; var messages = await GetAllChannelMessages(recruitingChannel); // Parse messages into teams var teams = ParseMessageAsync(messages); var subCommand = command.Data.Options.First(); var options = subCommand.Options.ToDictionary(o => o.Name, o => o); switch (subCommand.Name) { case "add": await AddTrackerCommand.Run(command, client, options, recruitingChannel, messages, teams); break; case "adminadd": await AdminAddTrackerCommand.Run(command, client, options, recruitingChannel, messages, teams); break; case "move": await MoveTrackedUserCommand.Run(command, client, options, recruitingChannel, messages, teams); break; case "remove": await RemoveTrackedUserCommand.Run(command, client, options, recruitingChannel, messages, teams); break; case "deleteteam": await DeleteTeamTrackerCommand.Run(command, client, options, recruitingChannel, messages, teams); break; default: await command.RespondAsync($"SubCommand {subCommand} not supported", ephemeral : true); return; } }
public async Task ExecuteCommandHelpAsync(SocketSlashCommand command) { var builder = new EmbedBuilder() .WithColor(0xBE5BEF) .WithTitle($"Допомога \"{CommandName}\"") .WithDescription($"Команда виводить список закритих вами рейдів цього тижня на різних персонажах.\n" + $"Враховуються лише ті рейди, які ви закрили перебуваючи учасником клану.\n" + $"Використання цієї команди вимагає реєстрації в боті."); await command.RespondAsync(embed : builder.Build()); }