Exemple #1
0
        public async Task <bool> PreExecutionChecks()
        {
            if (Member.Id == 192037157416730625)
            {
                await WarnChannel.SendMessageAsync("You cant warn Lathrix!");

                return(false);
            }
            if (await Guild.GetMemberAsync(Member.Id) == null)
            {
                await WarnChannel.SendMessageAsync($"User {Member.DisplayName} is not on this server anymore, you can't warn them!");

                return(false);
            }
            if (Mod.Roles.Contains(Guild.GetRole(748646909354311751)))
            {
                DiscordEmbedBuilder discordEmbed = new DiscordEmbedBuilder
                {
                    Color  = Mod.Color,
                    Title  = $"Trial Plague {Member.Nickname} just used a moderation command",
                    Footer = new DiscordEmbedBuilder.EmbedFooter
                    {
                        IconUrl = Member.AvatarUrl,
                        Text    = $"{Mod.Username}#{Mod.Discriminator} ({Mod.Id})"
                    }
                };
                await Guild.GetChannel(722905404354592900).SendMessageAsync(discordEmbed.Build());
            }
            return(true);
        }
Exemple #2
0
        public async Task RequestPoints()
        {
            DiscordMessageBuilder discordMessage = new DiscordMessageBuilder
            {
                Content = $"For this rule you can reduce the users chances by {Rule.MinPoints} - {Rule.MaxPoints}"
            };

            for (int i = 0; i < 3; i++)
            {
                List <DiscordButtonComponent> buttons = new List <DiscordButtonComponent>();
                for (int index = i * 5; index < (i * 5) + 5; index++)
                {
                    buttons.Add(new DiscordButtonComponent
                                (
                                    ButtonStyle.Primary,
                                    (index + 1).ToString(),
                                    (index + 1).ToString(),
                                    (index + 1) < Rule.MinPoints || (index + 1) > Rule.MaxPoints)
                                );
                }
                discordMessage.AddComponents(buttons);
            }
            DiscordMessage pointsMessage = await WarnChannel.SendMessageAsync(discordMessage);

            var interactpointsMessage = await Interactivity.WaitForButtonAsync(pointsMessage, Mod, TimeSpan.FromMinutes(2));

            PointsDeducted = int.Parse(interactpointsMessage.Result.Id);
            await pointsMessage.DeleteAsync();
        }
Exemple #3
0
        public async Task RequestRule(ContextMenuContext ctx = null)
        {
            List <DiscordSelectComponentOption> options = new List <DiscordSelectComponentOption>();

            foreach (var item in RuleService.rules)
            {
                if (item.RuleNum == 0)
                {
                    options.Add(new DiscordSelectComponentOption(
                                    $"OTHER",
                                    item.RuleNum.ToString()));
                    continue;
                }
                var option = new DiscordSelectComponentOption(
                    $"Rule {item.RuleNum}: {item.ShortDesc}",
                    item.RuleNum.ToString(),
                    item.RuleText.Length > 99 ? item.RuleText[..95] + "..." : item.RuleText);
                options.Add(option);
            }
            DiscordSelectComponent selectMenu = new DiscordSelectComponent("warnSelect", "Select a Rule!", options);

            DiscordMessageBuilder messageBuilder = new DiscordMessageBuilder()
                                                   .AddComponents(selectMenu)
                                                   .WithContent("­");
            DiscordMessage message = await WarnChannel.SendMessageAsync(messageBuilder);

            if (!(ctx is null))
            {
                await ctx.FollowUpAsync(new DiscordFollowupMessageBuilder
                {
                    Content = message.JumpLink.ToString()
                });
            }

            var reaction = await Interactivity.WaitForSelectAsync(message, Mod, "warnSelect", TimeSpan.FromMinutes(2));

            Rule = RuleService.rules.Single(x => x.RuleNum.ToString() == reaction.Result.Values.First());
            await message.DeleteAsync();
        }