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());
}
