Beispiel #1
0
    public async Task PlayAsync(string searchQuery)
    {
        // Join if not playing.
        if (_lavaNode.HasPlayer(Context.Guild) is false)
        {
            await TryJoinAsync();
        }

        var player = _lavaNode.GetPlayer(Context.Guild);

        if (Context.User is IVoiceState user && user.VoiceChannel != player.VoiceChannel)
        {
            await RespondAsync("You must be in the same voice channel.");

            return;
        }

        await DeferAsync();

        // Play from url or search YouTube.
        var search = Uri.IsWellFormedUriString(searchQuery, UriKind.Absolute)
            ? await _lavaNode.SearchAsync(SearchType.Direct, searchQuery)
            : await _lavaNode.SearchYouTubeAsync(searchQuery);

        if (search.Status is SearchStatus.NoMatches or SearchStatus.LoadFailed)
        {
            await RespondAsync($"No matches found for query `{searchQuery.Truncate(100, "...")}`");

            return;
        }

        // Generate select menu for search results.
        var selectMenu = new SelectMenuBuilder()
                         .WithPlaceholder("Select a track")
                         .WithCustomId($"tracks:{Context.Interaction.Id}")
                         .WithMinValues(1)
                         .WithMaxValues(1);

        foreach (var track in search.Tracks.Take(10))
        {
            selectMenu.AddOption(
                track.Title,
                track.Url,
                track.Duration.ToString("c"),
                new Emoji("▶️"));
        }

        var components = new ComponentBuilder().WithSelectMenu(selectMenu);
        await Context.Interaction.ModifyOriginalResponseAsync(properties =>
        {
            properties.Content    = "Choose a track from the menu to play";
            properties.Components = components.Build();
        });
    }
        public async Task Unsubscribe()
        {
            //Ensure subscriptions are enabled:
            if (!_subscriptions.ModuleEnabled)
            {
                await RespondAsync("Subscriptions module is currently disabled.", ephemeral : true);

                return;
            }

            //Buy more time to process:
            await DeferAsync(false);

            // Get Accounts:
            var subs = await _subscriptions.GuildSubscriptionsAsync(Context.Guild.Id);

            // Create Dropdown with channels:
            var menuBuilder = new SelectMenuBuilder()
                              .WithCustomId("unsubscribe")
                              .WithPlaceholder("Select accounts to remove.")
                              .WithMinValues(0);

            // Get IG account:
            InstagramProcessor instagram = new InstagramProcessor(InstagramProcessor.AccountFinder.GetIGAccount());

            // Add users to dropdown:
            foreach (FollowedIGUser user in subs)
            {
                foreach (RespondChannel chan in user.SubscribedChannels)
                {
                    // Get username:
                    string username = await instagram.GetIGUsername(user.InstagramID);

                    if (username == null)
                    {
                        username = "******";
                    }

                    string channelName = Context.Guild.GetChannel(ulong.Parse(chan.ChannelID))?.Name;
                    // Channel null check:
                    if (channelName is null)
                    {
                        channelName = "Unknown Channel";
                    }

                    // Add account option to menu:
                    SelectMenuOptionBuilder optBuilder = new SelectMenuOptionBuilder()
                                                         .WithLabel(username)
                                                         .WithValue(user.InstagramID + "-" + chan.ChannelID)
                                                         .WithDescription(username + " in channel " + channelName);
                    menuBuilder.AddOption(optBuilder);
                }
            }

            // Check for subs:
            if (subs.Length < 1)
            {
                await FollowupAsync("No accounts subscribed.");

                return;
            }

            // Make embed:
            var embed = new EmbedBuilder();

            embed.Title       = "Unsubscribe";
            embed.Description = "Select accounts that you would like to unsubscribe from in the dropdown below.";
            embed.WithColor(new Color(131, 58, 180));

            // Set max count:
            menuBuilder.WithMaxValues(menuBuilder.Options.Count);
            // Component Builder:
            var builder = new ComponentBuilder()
                          .WithSelectMenu(menuBuilder)
                          .WithButton("Delete Message", $"delete-message-{Context.User.Id}", style: ButtonStyle.Danger);

            // Send message
            await FollowupAsync(embed : embed.Build(), components : builder.Build());
        }
Beispiel #3
0
        public async Task <CommandResponse> Process(IDiscordBotContext context)
        {
            if (context.Interaction is SocketSlashCommand slashCommand)
            {
                var settings = SettingsConfig.GetSettings(context.GuildChannel.Guild.Id);

                if (settings.SelfRoles.Count > 0)
                {
                    var roles     = context.GuildChannel.Guild.Roles.OrderByDescending(r => r.Position).Where(r => settings.SelfRoles.ContainsKey(r.Id));
                    var roleCount = roles.Count();
                    if (roleCount > SlashCommandBuilder.MaxOptionsCount)
                    {
                        await slashCommand.RespondAsync($"Too many roles to display in a menu. Complain to management. Max is {SlashCommandBuilder.MaxOptionsCount}.", ephemeral : true);
                    }
                    else if (roleCount > 0)
                    {
                        var menuBuilder = new SelectMenuBuilder()
                                          .WithPlaceholder("Select a role")
                                          .WithCustomId("role")
                                          .WithMinValues(0)
                                          .WithMaxValues(roleCount);

                        foreach (var role in roles)
                        {
                            menuBuilder.AddOption(role.Name, role.Id.ToString(), null, string.IsNullOrEmpty(role.Emoji.Name) ? null : role.Emoji);
                        }

                        if (roleCount == 1)
                        {
                            menuBuilder.AddOption("[clear role]", "clear");
                        }

                        var component = new ComponentBuilder().WithSelectMenu(menuBuilder).Build();
                        await slashCommand.RespondAsync("choose a role", components : component, ephemeral : true);
                    }
                }
                else
                {
                    await slashCommand.RespondAsync("No roles are self assignable", ephemeral : true);
                }

                return(new CommandResponse {
                    IsHandled = true
                });
            }

            if (context.Message.Channel is SocketGuildChannel guildChannel)
            {
                var settings = SettingsConfig.GetSettings(guildChannel.Guild.Id.ToString());
                var roles    = guildChannel.Guild.Roles.OrderByDescending(r => r.Position).Where(r => settings.SelfRoles.ContainsKey(r.Id)).Select(r => $"``{r.Name.Replace("`", @"\`")}``");

                var multiText = new List <string>();
                var sb        = new StringBuilder();
                sb.Append("The following roles are available to self-assign: ");

                foreach (var role in roles)
                {
                    if (sb.Length + role.Length + 2 < DiscordConfig.MaxMessageSize)
                    {
                        sb.Append($"{role}, ");
                    }
                    else
                    {
                        multiText.Add(sb.ToString());
                        sb.Clear();
                        sb.Append($"{role}, ");
                    }
                }

                multiText.Add(sb.ToString());

                return(new CommandResponse {
                    MultiText = multiText
                });
            }

            return(new CommandResponse {
                Text = "role command does not work in private channels"
            });
        }
Beispiel #4
0
        private async Task ActivityMessageReceivedAsync(IMessage message)
        {
            var command = message.Content.ToLower();

            switch (command)
            {
            case "!швидка активність":
            {
                var builder = new EmbedBuilder()
                              .WithColor(new Color(0xFFFFFF))
                              .WithDescription("Швидко зберіться у активність на найближчий час");

                var menuBuilder = new SelectMenuBuilder()
                                  .WithPlaceholder("Оберіть активність")
                                  .WithCustomId("QuickActivitySelector")
                                  .WithMinValues(1).WithMaxValues(1)
                                  .WithOptions(Activity.QuickActivityTypes.Select(x =>
                                                                                  new SelectMenuOptionBuilder
                    {
                        Label = Translation.ActivityNames[x][0],
                        Value = $"QuickActivity_{x}",
                        Emote = Emote.Parse(CommonData.DiscordEmoji.Emoji.GetActivityEmoji(x))
                    }).ToList());

                var component = new ComponentBuilder()
                                .WithSelectMenu(menuBuilder);

                await message.Channel.SendMessageAsync(embed : builder.Build(), components : component.Build());

                await ServiceCommandsManager.DeleteMessageAsync(message);
            }
            break;

            case "!швидкий рейд":
            {
                var builder = new EmbedBuilder()
                              .WithColor(new Color(0xFFFFFF))
                              .WithDescription("Швидко зберіть рейд на найближчий час");

                var menuBuilder = new SelectMenuBuilder()
                                  .WithPlaceholder("Оберіть рейд")
                                  .WithCustomId("QuickActivitySelector")
                                  .WithMinValues(1).WithMaxValues(1)
                                  .WithOptions(Activity.ActivityRaidTypes.Select(x =>
                                                                                 new SelectMenuOptionBuilder
                    {
                        Label = Translation.ActivityRaidTypes[x],
                        Value = $"QuickRaid_{x}",
                        Emote = Emote.Parse(CommonData.DiscordEmoji.Emoji.GetActivityRaidEmoji(x))
                    }).ToList());

                var component = new ComponentBuilder()
                                .WithSelectMenu(menuBuilder);

                await message.Channel.SendMessageAsync(embed : builder.Build(), components : component.Build());

                await ServiceCommandsManager.DeleteMessageAsync(message);
            }
            break;

            case "!допомога":
            {
                var helpEmbeds = new BotCommands.SlashCommands.OrganizeActivity().HelpEmbeds;

                await message.Channel.SendMessageAsync(embeds : helpEmbeds);
            }
            break;

            case "!скасувати":
            {
                var msgId = message?.Reference?.MessageId.Value;
                if (msgId is not null)
                {
                    await _activityManager.DisableActivityAsync(msgId.Value, message.Author.Id);

                    await ServiceCommandsManager.DeleteMessageAsync(message);
                }
            }
            break;

            case string c
                when c.StartsWith("!передати"):
            {
                var msgId = message?.Reference?.MessageId.Value;
                if (msgId is not null && message.MentionedUserIds.Count == 2)
                {
                    var receiverID = message.MentionedUserIds.Last();
                    await _activityManager.UserTransferPlaceAsync(msgId.Value, message.Author.Id, receiverID);

                    await ServiceCommandsManager.DeleteMessageAsync(message);
                }
            }
            break;

            case string c
                when c.StartsWith("!перенести "):
            {
                var msgId = message?.Reference?.MessageId.Value;
                if (msgId is not null)
                {
                    try
                    {
                        var date = DateTime.ParseExact(command.Replace("!перенести ", string.Empty), "d.M-H:m", CultureInfo.CurrentCulture);
                        if (date < DateTime.Now)
                        {
                            date = date.AddYears(1);
                        }

                        await _activityManager.RescheduleActivityAsync(msgId.Value, message.Author.Id, date.ToUniversalTime());

                        await ServiceCommandsManager.DeleteMessageAsync(message);
                    }
                    catch { }
                }
            }
            break;

            case string c
                when c.StartsWith("!зарезервувати"):
            {
                var msgId = message?.Reference?.MessageId.Value;
                if (msgId is not null)
                {
                    await _activityManager.UsersSubscribeAsync(msgId.Value, message.Author.Id, message.MentionedUserIds.Skip(1));

                    await ServiceCommandsManager.DeleteMessageAsync(message);
                }
            }
            break;

            case string c
                when c.StartsWith("!виключити"):
            {
                var msgId = message?.Reference?.MessageId.Value;
                if (msgId is not null)
                {
                    await _activityManager.UsersUnSubscribeAsync(msgId.Value, message.Author.Id, message.MentionedUserIds.Skip(1));

                    await ServiceCommandsManager.DeleteMessageAsync(message);
                }
            }
            break;

            case string c
                when c.StartsWith("!змінити "):
            {
                var msgId = message?.Reference?.MessageId.Value;
                if (msgId is null)
                {
                    return;
                }

                try
                {
                    var action = message.Content[9..];
Beispiel #5
0
        private async Task ActivitySelectMenuExecutedAsync(SocketMessageComponent component)
        {
            switch (component.Data.CustomId)
            {
            case "QuickActivitySelector":
            {
                var builder = new EmbedBuilder()
                              .WithColor(new Color(0xFFFFFF))
                              .WithDescription("Оберіть зручний час");

                var menuBuilder = new SelectMenuBuilder()
                                  .WithPlaceholder("Оберіть час")
                                  .WithCustomId(string.Join(',', component.Data.Values))
                                  .WithMinValues(1).WithMaxValues(1);

                var startDate = DateTime.Now;
                var endDate   = startDate.AddHours(12);
                var tmpDate   = startDate.AddMinutes(30);

                while (tmpDate < endDate)
                {
                    menuBuilder = menuBuilder.AddOption(tmpDate.ToString("dd.MM HH:mm"), tmpDate.ToString("dd.MM_HH:mm"));
                    tmpDate     = tmpDate.AddMinutes(30);
                }

                var componentBuilder = new ComponentBuilder()
                                       .WithSelectMenu(menuBuilder);

                await component.RespondAsync(embed : builder.Build(), components : componentBuilder.Build(), ephemeral : true);
            }
            break;

            case string c
                when c.StartsWith("QuickActivity_"):
            {
                var raid = new ActivityContainer()
                {
                    ChannelID    = component.Channel.Id,
                    ActivityType = Enum.Parse <BungieSharper.Entities.Destiny.HistoricalStats.Definitions.DestinyActivityModeType>(c.Split('_')[1]),
                    PlannedDate  = DateTime.ParseExact(string.Join(',', component.Data.Values), "dd.MM_HH:mm", CultureInfo.CurrentCulture),
                    ActivityName = null,
                    Description  = null,
                    Users        = new ulong[] { component.User.Id }
                };

                await component.DeferAsync();

                await InitActivityAsync(raid);
            }
            break;

            case string c
                when c.StartsWith("QuickRaid_"):
            {
                var raid = new ActivityContainer()
                {
                    ChannelID    = component.Channel.Id,
                    ActivityType = BungieSharper.Entities.Destiny.HistoricalStats.Definitions.DestinyActivityModeType.Raid,
                    PlannedDate  = DateTime.ParseExact(string.Join(',', component.Data.Values), "dd.MM_HH:mm", CultureInfo.CurrentCulture),
                    ActivityName = c.Split('_')[1],
                    Description  = null,
                    Users        = new ulong[] { component.User.Id }
                };

                await component.DeferAsync();

                await InitActivityAsync(raid);
            }
            break;

            default: break;
            }
        }