public async Task WarnAlreadySeasonAlreadyRequestedAsync(TvShow tvShow, TvSeason requestedSeason)
{
var messageContent = Language.Current.DiscordCommandTvRequestAlreadyExistSeason.ReplaceTokens(tvShow, requestedSeason.SeasonNumber);
var buttonMessage = Language.Current.DiscordCommandRequestedButton;
if (requestedSeason is FutureTvSeasons)
{
if (tvShow.AllSeasonsAvailable())
{
messageContent = Language.Current.DiscordCommandTvRequestAlreadyExistFutureSeasonAvailable;
buttonMessage = Language.Current.DiscordCommandAvailableButton;
}
else if (tvShow.AllSeasonsFullyRequested())
{
messageContent = Language.Current.DiscordCommandTvRequestAlreadyExistFutureSeasonRequested;
}
else
{
messageContent = Language.Current.DiscordCommandTvRequestAlreadyExistFutureSeasonFound;
}
}
var embed = GenerateTvShowDetailsAsync(tvShow);
var requestButton = new DiscordButtonComponent(ButtonStyle.Primary, $"TTT/{_interactionContext.User.Id}/{tvShow.TheTvDbId}/999", buttonMessage, true);
var builder = (await AddPreviousDropdownsAsync(tvShow, new DiscordWebhookBuilder().AddEmbed(embed))).WithContent(messageContent).AddComponents(requestButton);
await _interactionContext.EditOriginalResponseAsync(builder);
}
public async Task DisplayRequestDeniedAsync(Movie movie)
{
var deniedButton = new DiscordButtonComponent(ButtonStyle.Danger, $"0/1/0", Language.Current.DiscordCommandRequestButtonDenied);
var builder = (await AddPreviousDropdownsAsync(movie, new DiscordWebhookBuilder().AddEmbed(await GenerateMovieDetailsAsync(movie, _movieSearcher)))).AddComponents(deniedButton).WithContent(Language.Current.DiscordCommandMovieRequestDenied);
await _interactionContext.EditOriginalResponseAsync(builder);
}
public async Task WarnMovieUnavailableAndAlreadyHasNotificationAsync(Movie movie)
{
var requestButton = new DiscordButtonComponent(ButtonStyle.Primary, $"MMM/{_interactionContext.User.Id}/{movie.TheMovieDbId}", Language.Current.DiscordCommandRequestedButton, true);
var builder = (await AddPreviousDropdownsAsync(movie, new DiscordWebhookBuilder().AddEmbed(await GenerateMovieDetailsAsync(movie, _movieSearcher)))).AddComponents(requestButton).WithContent(Language.Current.DiscordCommandMovieRequestAlreadyExistNotified);
await _interactionContext.EditOriginalResponseAsync(builder);
}
public async Task AskForNotificationRequestAsync(Movie movie)
{
var notifyButton = new DiscordButtonComponent(ButtonStyle.Primary, $"MNR/{_interactionContext.User.Id}/{movie.TheMovieDbId}", Language.Current.DiscordCommandNotifyMe, false, new DiscordComponentEmoji(DiscordEmoji.FromUnicode("🔔")));
var builder = (await AddPreviousDropdownsAsync(movie, new DiscordWebhookBuilder().AddEmbed(await GenerateMovieDetailsAsync(movie, _movieSearcher)))).AddComponents(notifyButton).WithContent(Language.Current.DiscordCommandMovieNotificationRequest);
await _interactionContext.EditOriginalResponseAsync(builder);
}
public async Task DisplayNotificationSuccessAsync(Movie movie)
{
var successButton = new DiscordButtonComponent(ButtonStyle.Success, $"0/1/0", Language.Current.DiscordCommandNotifyMeSuccess);
var builder = (await AddPreviousDropdownsAsync(movie, new DiscordWebhookBuilder().AddEmbed(await GenerateMovieDetailsAsync(movie, _movieSearcher)))).AddComponents(successButton).WithContent(Language.Current.DiscordCommandMovieNotificationSuccess.ReplaceTokens(movie));
await _interactionContext.EditOriginalResponseAsync(builder);
}
public async Task AskForSeasonNotificationRequestAsync(TvShow tvShow, TvSeason selectedSeason)
{
var message = Language.Current.DiscordCommandTvNotificationRequestSeason.ReplaceTokens(tvShow, selectedSeason.SeasonNumber);
if (selectedSeason is FutureTvSeasons)
{
if (tvShow.AllSeasonsAvailable())
{
message = Language.Current.DiscordCommandTvNotificationRequestFutureSeasonAvailable;
}
else if (tvShow.AllSeasonsFullyRequested())
{
message = Language.Current.DiscordCommandTvNotificationRequestFutureSeasonRequested;
}
else
{
message = Language.Current.DiscordCommandTvNotificationRequestFutureSeasonMissing;
}
}
var requestButton = new DiscordButtonComponent(ButtonStyle.Primary, $"TNR/{_interactionContext.User.Id}/{tvShow.TheTvDbId}/{selectedSeason.GetType().Name.First()}/{selectedSeason.SeasonNumber}", Language.Current.DiscordCommandNotifyMe, false, new DiscordComponentEmoji(DiscordEmoji.FromUnicode("🔔")));
var embed = GenerateTvShowDetailsAsync(tvShow);
var builder = (await AddPreviousDropdownsAsync(tvShow, new DiscordWebhookBuilder().AddEmbed(embed))).AddComponents(requestButton).WithContent(message);
await _interactionContext.EditOriginalResponseAsync(builder);
}
public static DiscordButtonComponent SetEmoji(this DiscordButtonComponent button, DiscordComponentEmoji emoji)
{
#warning Ugly hack, needs builder method or better yet making the setter public like before
var property = button.GetType().GetProperty(nameof(button.Emoji));
property?.SetValue(button, emoji, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.SetProperty, null, null, null);
return(button);
}
public async Task DisplayRequestDeniedForSeasonAsync(TvShow tvShow, TvSeason selectedSeason)
{
var embed = GenerateTvShowDetailsAsync(tvShow);
var deniedButton = new DiscordButtonComponent(ButtonStyle.Danger, $"0/1/0", Language.Current.DiscordCommandRequestButtonDenied);
var builder = (await AddPreviousDropdownsAsync(tvShow, new DiscordWebhookBuilder().AddEmbed(embed))).AddComponents(deniedButton).WithContent(Language.Current.DiscordCommandTvRequestDenied);
await _interactionContext.EditOriginalResponseAsync(builder);
}
private async Task WithComponents(DiscordButtonComponent component)
{
var builder = new DiscordMessageBuilder()
.WithEmbed(_setupEmbed.Build())
.AddComponents(component);
_setupMessage = await _setupMessage.ModifyAsync(builder);
}
public async Task WarnSeasonAlreadyAvailableAsync(TvShow tvShow, TvSeason selectedSeason)
{
var embed = GenerateTvShowDetailsAsync(tvShow);
var requestButton = new DiscordButtonComponent(ButtonStyle.Primary, $"TTT/{_interactionContext.User.Id}/{tvShow.TheTvDbId}/999", Language.Current.DiscordCommandAvailableButton, true);
var builder = (await AddPreviousDropdownsAsync(tvShow, new DiscordWebhookBuilder().AddEmbed(embed))).WithContent(Language.Current.DiscordCommandTvRequestAlreadyAvailableSeason.ReplaceTokens(LanguageTokens.SeasonNumber, selectedSeason.SeasonNumber.ToString())).AddComponents(requestButton);
await _interactionContext.EditOriginalResponseAsync(builder);
}
public async Task WarnShowCannotBeRequestedAsync(TvShow tvShow)
{
var embed = GenerateTvShowDetailsAsync(tvShow);
var requestButton = new DiscordButtonComponent(ButtonStyle.Danger, $"TTT/{_interactionContext.User.Id}/{tvShow.TheTvDbId}/999", Language.Current.DiscordCommandRequestButton, true);
var builder = (await AddPreviousDropdownsAsync(tvShow, new DiscordWebhookBuilder().AddEmbed(embed))).WithContent(Language.Current.DiscordCommandTvRequestUnsupported).AddComponents(requestButton);
await _interactionContext.EditOriginalResponseAsync(builder);
}
public PaginationButtons(PaginationButtons other)
{
this.Stop = new(other.Stop);
this.Left = new(other.Left);
this.Right = new(other.Right);
this.SkipLeft = new(other.SkipLeft);
this.SkipRight = new(other.SkipRight);
}
public PaginationButtons()
{
this.SkipLeft = new(ButtonStyle.Secondary, "leftskip", null, false, new(DiscordEmoji.FromUnicode("⏮")));
this.Left = new(ButtonStyle.Secondary, "left", null, false, new(DiscordEmoji.FromUnicode("◀")));
this.Stop = new(ButtonStyle.Secondary, "stop", null, false, new(DiscordEmoji.FromUnicode("⏹")));
this.Right = new(ButtonStyle.Secondary, "right", null, false, new(DiscordEmoji.FromUnicode("▶")));
this.SkipRight = new(ButtonStyle.Secondary, "rightskip", null, false, new(DiscordEmoji.FromUnicode("⏭")));
}
public async Task DisplayTvShowDetailsForSeasonAsync(TvShowRequest request, TvShow tvShow, TvSeason season)
{
var message = season is AllTvSeasons
? Language.Current.DiscordCommandTvRequestConfirmAllSeasons
: season is FutureTvSeasons
? Language.Current.DiscordCommandTvRequestConfirmFutureSeasons
: Language.Current.DiscordCommandTvRequestConfirmSeason.ReplaceTokens(LanguageTokens.SeasonNumber, season.SeasonNumber.ToString());
var requestButton = new DiscordButtonComponent(ButtonStyle.Primary, $"TRC/{_interactionContext.User.Id}/{request.CategoryId}/{tvShow.TheTvDbId}/{season.SeasonNumber}", Language.Current.DiscordCommandRequestButton);
var embed = GenerateTvShowDetailsAsync(tvShow);
var builder = (await AddPreviousDropdownsAsync(tvShow, new DiscordWebhookBuilder().AddEmbed(embed))).AddComponents(requestButton).WithContent(message);
await _interactionContext.EditOriginalResponseAsync(builder);
}
public async Task DisplayRequestSuccessForSeasonAsync(TvShow tvShow, TvSeason requestedSeason)
{
var embed = GenerateTvShowDetailsAsync(tvShow);
var message = requestedSeason is AllTvSeasons
? Language.Current.DiscordCommandTvRequestSuccessAllSeasons.ReplaceTokens(tvShow, requestedSeason.SeasonNumber)
: requestedSeason is FutureTvSeasons
? Language.Current.DiscordCommandTvRequestSuccessFutureSeasons.ReplaceTokens(tvShow, requestedSeason.SeasonNumber)
: Language.Current.DiscordCommandTvRequestSuccessSeason.ReplaceTokens(tvShow, requestedSeason.SeasonNumber);
var successButton = new DiscordButtonComponent(ButtonStyle.Success, $"0/1/0", Language.Current.DiscordCommandRequestButtonSuccess);
var builder = (await AddPreviousDropdownsAsync(tvShow, new DiscordWebhookBuilder().AddEmbed(embed))).AddComponents(successButton).WithContent(message);
await _interactionContext.EditOriginalResponseAsync(builder);
}
public async Task Buttons(CommandContext ctx)
{
var myButton = new DiscordButtonComponent(ButtonStyle.Primary, "emoji_button", null, false, new DiscordComponentEmoji(944192261510561832));
var builder = new DiscordMessageBuilder()
.WithContent("This message has buttons! Pretty neat innit?")
.AddComponents(new DiscordComponent[]
{
new DiscordButtonComponent(ButtonStyle.Primary, "1_top", "Blurple!"),
new DiscordButtonComponent(ButtonStyle.Primary, "2_top", "Grey!"),
new DiscordButtonComponent(ButtonStyle.Danger, "4_top", "Red!"),
new DiscordLinkButtonComponent("https://some-super-cool.site", "Link!")
});
await ctx.Channel.SendMessageAsync(builder);
}
public async Task WarnShowHasEndedAsync(TvShow tvShow)
{
var embed = GenerateTvShowDetailsAsync(tvShow);
if (tvShow.AllSeasonsAvailable())
{
var requestButton = new DiscordButtonComponent(ButtonStyle.Primary, $"TTT/{_interactionContext.User.Id}/{tvShow.TheTvDbId}/999", Language.Current.DiscordCommandAvailableButton, true);
var builder = (await AddPreviousDropdownsAsync(tvShow, new DiscordWebhookBuilder().AddEmbed(embed))).WithContent(Language.Current.DiscordCommandTvRequestAlreadyAvailableSeries).AddComponents(requestButton);
await _interactionContext.EditOriginalResponseAsync(builder);
}
else
{
var requestButton = new DiscordButtonComponent(ButtonStyle.Primary, $"TTT/{_interactionContext.User.Id}/{tvShow.TheTvDbId}/999", Language.Current.DiscordCommandRequestedButton, true);
var builder = (await AddPreviousDropdownsAsync(tvShow, new DiscordWebhookBuilder().AddEmbed(embed))).AddComponents(requestButton).WithContent(Language.Current.DiscordCommandTvRequestAlreadyExistSeries);
await _interactionContext.EditOriginalResponseAsync(builder);
}
}
public async Task Select_Interactive_Test_2(CommandContext ctx)
{
var input = ctx.Client.GetInteractivity();
var builder = new DiscordMessageBuilder();
builder.WithContent("This is a test! Select is valid for 30 seconds.");
var opts = new[]
{
new DiscordSelectComponentOption("Label 1", "the first option", emoji: new DiscordComponentEmoji("⬜")),
new DiscordSelectComponentOption("Label 2", "the second option", emoji: new DiscordComponentEmoji("🟦")),
new DiscordSelectComponentOption("Label 3", "the third option", emoji: new DiscordComponentEmoji("⬛")),
};
var select = new DiscordSelectComponent("yert", "Dropdowns!", opts, false);
var btn1 = new DiscordButtonComponent(ButtonStyle.Primary, "no1", "Button 1!", true);
var btn2 = new DiscordButtonComponent(ButtonStyle.Secondary, "no2", "Button 2!", true);
var btn3 = new DiscordButtonComponent(ButtonStyle.Success, "no3", "Button 3!", true);
builder.AddComponents(btn1, btn2, btn3);
builder.AddComponents(select);
var msg = await builder.SendAsync(ctx.Channel);
wait:
var res = await input.WaitForSelectAsync(msg, "yert", TimeSpan.FromSeconds(30));
if (res.TimedOut)
{
await ctx.RespondAsync("Sorry but it timed out!");
}
else if (res.Result.Values.Length != 2)
{
goto wait; // I'm lazy. A while(true) or while (res?.Result.Values.Length != 2 ?? false) would be better. This duplicates messages.
}
else
{
await ctx.RespondAsync($"You selected {string.Join(", ", res.Result.Values)}");
}
}
public async Task DisplayMovieDetailsAsync(MovieRequest request, Movie movie)
{
var message = Language.Current.DiscordCommandMovieRequestConfirm;
if (DateTime.TryParse(movie.ReleaseDate, out var releaseDate))
{
if (releaseDate > DateTime.UtcNow)
{
message = Language.Current.DiscordCommandMovieNotReleased;
}
else
{
message = Language.Current.DiscordCommandMovieRequestConfirm;
}
}
var requestButton = new DiscordButtonComponent(ButtonStyle.Primary, $"MRC/{_interactionContext.User.Id}/{request.CategoryId}/{movie.TheMovieDbId}", Language.Current.DiscordCommandRequestButton);
var builder = (await AddPreviousDropdownsAsync(movie, new DiscordWebhookBuilder().AddEmbed(await GenerateMovieDetailsAsync(movie, _movieSearcher)))).AddComponents(requestButton).WithContent(message);
await _interactionContext.EditOriginalResponseAsync(builder);
}
public DiscordButtonWithCallback(DiscordClient client, DiscordButtonComponent button, Func <DiscordFollowupMessageBuilder> followup) : this(client, button)
{
_followup = followup;
}
private DiscordButtonWithCallback(DiscordClient client, DiscordButtonComponent button)
{
_client = client;
_button = button;
_client.ComponentInteractionCreated += HandleComponentInteractionCreated;
}
public DiscordButtonWithCallback(DiscordClient client, DiscordButtonComponent button, Func <DiscordInteractionResponseBuilder> response) : this(client, button)
{
_response = response;
}
public static DiscordButtonComponent SetEnabled(this DiscordButtonComponent button, bool isEnabled) => isEnabled?button.Enable() : button.Disable();
public static async Task CreateConfirmation(this CommandContext context, string message, Action onConfirm = null, Action onAbort = null)
{
var confirmButton = new DiscordButtonComponent(
ButtonStyle.Success,
"confirm_" + context.User.Id,
"Confirm"
);
var abortButton = new DiscordButtonComponent(
ButtonStyle.Danger,
"abort_" + context.User.Id,
"Abort"
);
var messageBuilder = new DiscordMessageBuilder()
.WithEmbed(
new DiscordEmbedBuilder()
.WithTitle("Confirm:")
.WithDescription(message)
.WithColor(DiscordColor.Red)
.Build()
)
.AddComponents(confirmButton, abortButton);
DiscordMessage botMessage = await context.RespondAsync(messageBuilder);
var interactivity = context.Client.GetInteractivity();
var buttonResult = await interactivity.WaitForButtonAsync(
botMessage,
context.User,
TimeSpan.FromMinutes(1)
);
await buttonResult.Result?.Interaction.CreateResponseAsync(InteractionResponseType.DeferredMessageUpdate);
messageBuilder = new DiscordMessageBuilder();
messageBuilder.AddEmbed(botMessage.Embeds[0]);
messageBuilder.ClearComponents();
if (!buttonResult.TimedOut)
{
if (buttonResult.Result.Id == confirmButton.CustomId)
{
onConfirm?.Invoke();
messageBuilder.AddComponents(new DiscordButtonComponent(
ButtonStyle.Success, "confirmed" + context.User.Id, "Confirm", true
));
}
else
{
onAbort?.Invoke();
messageBuilder.AddComponents(new DiscordButtonComponent(
ButtonStyle.Danger, "aborted" + context.User.Id, "Abort", true
));
}
}
else
{
await botMessage.CreateReactionAsync(DiscordEmoji.FromUnicode("⌛"));
}
await botMessage.ModifyAsync(messageBuilder);
}
public async Task RoleMenu(CommandContext ctx, string message, string emojis, [RemainingText] params DiscordRole[] roles)
{
var converter = (IArgumentConverter <DiscordEmoji>) new DiscordEmojiConverter();
var split = emojis.Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
var emojiArray = new DiscordEmoji[roles.Length];
if (split.Length < roles.Length)
{
throw new ArgumentOutOfRangeException(nameof(emojis), "You don't have enough emojis!");
}
if (roles.Length > 25)
{
throw new ArgumentOutOfRangeException(nameof(roles), "You can only have up to 25 roles per role menu!");
}
for (var i = 0; i < roles.Length; i++)
{
var e = await converter.ConvertAsync(split[i], ctx);
if (!e.HasValue)
{
throw new ArgumentException($"I couldn't parse {split[i]}");
}
emojiArray[i] = e.Value;
}
var unavailable = emojiArray.Where(e => !e.IsAvailable && e.Id != 0);
if (unavailable.Any())
{
throw new ArgumentException($"One or more emojis is from a server I'm not in!\nNames: {string.Join(", ", unavailable.Select(u => u.GetDiscordName()))}");
}
var buttons = new List <DiscordComponent>(5);
var chnk = roles.Zip(emojiArray).Chunk(5).OrderBy(l => l.Count).ToList();
var builder = new DiscordMessageBuilder()
.WithContent(message.Replace("\\n", "\n") + $"\n{string.Join('\n', chnk.SelectMany(c => c).Select(p => $"{p.Second} -> {p.First.Mention}"))}")
.WithAllowedMentions(Mentions.None);
foreach (var chunklist in chnk)
{
foreach (var pair in chunklist)
{
if (pair.First.Position >= ctx.Guild.CurrentMember.Hierarchy)
{
throw new InvalidOperationException("Cannot assign role higher or equal to my own role!");
}
if (pair.First.Position > ctx.Member.Hierarchy)
{
throw new InvalidOperationException("Cannot assign role higher than your own!");
}
var e = new DiscordComponentEmoji(pair.Second.Id);
var b = new DiscordButtonComponent(ButtonStyle.Success, $"{pair.First.Mention}", "", emoji: e);
buttons.Add(b);
}
builder.AddComponents(buttons.ToArray());
buttons.Clear();
}
await builder.SendAsync(ctx.Channel);
}
