Пример #1
0
        public async Task <ulong> RequestRuleEphemeral(ContextMenuContext ctx)
        {
            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);

            var message = await ctx.FollowUpAsync(new DiscordFollowupMessageBuilder()
                                                  .AddComponents(selectMenu)
                                                  .WithContent("­")
                                                  .AsEphemeral(true));

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

            Rule = RuleService.rules.Single(x => x.RuleNum.ToString() == reaction.Result.Values.First());
            await reaction.Result.Interaction.CreateResponseAsync(InteractionResponseType.DeferredMessageUpdate);

            return(message.Id);
        }
Пример #2
0
        public async Task UserInfoFromMessageCommand(ContextMenuContext ctx)
        {
            DiscordGuild guild = await ctx.Client.GetGuildAsync(Guilds.SBG);

            DiscordMember member = await guild.GetMemberAsync(ctx.TargetMessage.Author.Id);

            Permissions memberPerms = member.PermissionsIn(guild.GetChannel(ctx.Channel.Id));

            DiscordEmbedBuilder userDetails = new DiscordEmbedBuilder
            {
                Footer = new DiscordEmbedBuilder.EmbedFooter
                {
                    Text = $"ID: {member.Id} | isBot: {(member.IsBot ? "✔" : "✘")}",
                },
                Color     = new DiscordColor(95, 95, 95),
                Timestamp = DateTime.UtcNow,
                Thumbnail = new DiscordEmbedBuilder.EmbedThumbnail
                {
                    Url = member.AvatarUrl,
                },
                Title = $"**User Details for {ctx.Channel.Name}**",
            };

            userDetails.WithDescription(this.BuildUserDetails(member));

            userDetails.AddField("Guild Permissions", this.BuildPermissions(memberPerms, ctx));

            await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AddEmbed(userDetails.Build()).AsEphemeral(true));
        }
Пример #3
0
        private string BuildUserEventsAsync(ulong discordId, ContextMenuContext ctx)
        {
            List <UserEvent> userEvents = this.userEventService.QueryEventReportAsync(discordId);

            StringBuilder discordUserEvents = new StringBuilder();

            foreach (UserEvent events in userEvents)
            {
                if (events.Event == Event.Joined)
                {
                    discordUserEvents.Append($"{DiscordEmoji.FromGuildEmote(ctx.Client, Variables.Emojis.EventEmojis.Join)} Joined - {events.Timestamp.ToString("ddd, MMM d, yyyy", CultureInfo.CurrentCulture)}\n");
                }

                if (events.Event == Event.Left)
                {
                    discordUserEvents.Append($"{DiscordEmoji.FromGuildEmote(ctx.Client, Variables.Emojis.EventEmojis.Leave)} Left - {events.Timestamp.ToString("ddd, MMM d, yyyy", CultureInfo.CurrentCulture)}\n");
                }

                if (events.Event == Event.Banned)
                {
                    discordUserEvents.Append($"{DiscordEmoji.FromGuildEmote(ctx.Client, Variables.Emojis.EventEmojis.Banned)} Banned - {events.Timestamp.ToString("ddd, MMM d, yyyy", CultureInfo.CurrentCulture)}\n");
                }

                if (events.Event == Event.Unbanned)
                {
                    discordUserEvents.Append($"{DiscordEmoji.FromGuildEmote(ctx.Client, Variables.Emojis.EventEmojis.Edited)} Unbanned - {events.Timestamp.ToString("ddd, MMM d, yyyy", CultureInfo.CurrentCulture)}\n");
                }
            }

            return(discordUserEvents.ToString());
        }
Пример #4
0
        public async Task UserInfoFromUserMenu(ContextMenuContext ctx)
        {
            DiscordGuild guild = await ctx.Client.GetGuildAsync(Guilds.SBG);

            DiscordMember member = await guild.GetMemberAsync(ctx.TargetMember.Id);

            DiscordEmbedBuilder userDetails = new DiscordEmbedBuilder
            {
                Footer = new DiscordEmbedBuilder.EmbedFooter
                {
                    Text = $"ID: {member.Id} | isBot: {(member.IsBot ? "✔" : "✘")}",
                },
                Color     = new DiscordColor(95, 95, 95),
                Timestamp = DateTime.UtcNow,
                Thumbnail = new DiscordEmbedBuilder.EmbedThumbnail
                {
                    Url = member.AvatarUrl,
                },
                Title = "**User Details**",
            };

            userDetails.WithDescription(this.BuildUserDetails(member));
            string userEvents = this.BuildUserEventsAsync(ctx.TargetMember.Id, ctx);

            if (!string.IsNullOrEmpty(userEvents))
            {
                userDetails.AddField("User Server Events", userEvents);
            }

            await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AddEmbed(userDetails.Build()).AsEphemeral(true));
        }
Пример #5
0
        private string BuildPermissions(Permissions permissions, ContextMenuContext ctx)
        {
            string perms = $"**Add Reactions**: {(permissions.HasPermission(Permissions.AddReactions) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Administrator: {(permissions.HasPermission(Permissions.Administrator) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Attach Files**: {(permissions.HasPermission(Permissions.AttachFiles) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Ban Members: {(permissions.HasPermission(Permissions.BanMembers) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Change Nickname**: {(permissions.HasPermission(Permissions.ChangeNickname) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Connect: {(permissions.HasPermission(Permissions.UseVoice) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Create II: {(permissions.HasPermission(Permissions.CreateInstantInvite) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Embed Links**: {(permissions.HasPermission(Permissions.EmbedLinks) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Kick Members: {(permissions.HasPermission(Permissions.KickMembers) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Manage Channels**: {(permissions.HasPermission(Permissions.ManageChannels) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Manage Emojis: {(permissions.HasPermission(Permissions.ManageEmojis) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Manage Guild**: {(permissions.HasPermission(Permissions.ManageGuild) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Manage Messages: {(permissions.HasPermission(Permissions.ManageMessages) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Manage Nicknames**: {(permissions.HasPermission(Permissions.ManageNicknames) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Manage Roles: {(permissions.HasPermission(Permissions.ManageRoles) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Manage Webhooks**: {(permissions.HasPermission(Permissions.ManageWebhooks) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Mention Everyone: {(permissions.HasPermission(Permissions.MentionEveryone) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Move Members**: {(permissions.HasPermission(Permissions.MoveMembers) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Mute Members: {(permissions.HasPermission(Permissions.MuteMembers) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Read Message History**: {(permissions.HasPermission(Permissions.ReadMessageHistory) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Read Messages: {(permissions.HasPermission(Permissions.AccessChannels) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Send Messages**: {(permissions.HasPermission(Permissions.SendMessages) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Send TTS Messages: {(permissions.HasPermission(Permissions.SendTtsMessages) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Speak**: {(permissions.HasPermission(Permissions.Speak) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"Use External Emojis: {(permissions.HasPermission(Permissions.UseExternalEmojis) ? DiscordEmoji.FromName(ctx.Client, ":white_check_mark:") : DiscordEmoji.FromName(ctx.Client, ":x:"))}\n"
                           + $"**Use VAD**: {(permissions.HasPermission(Permissions.UseVoiceDetection) ? "✔" : "✘")}\n";

            return(perms);
        }
Пример #6
0
        public async Task ContextAvatar(ContextMenuContext ctx)
        {
            string avatarUrl = "";

            try
            {
                avatarUrl = await Helpers.UserOrMemberAvatarURL(ctx.TargetUser, ctx.Guild);
            }
            catch (ArgumentException e)
            {
                await ctx.RespondAsync($"{Program.cfgjson.Emoji.Xmark} {e.Message}", ephemeral : true);

                return;
            }

            DiscordEmbedBuilder embed = new DiscordEmbedBuilder()
                                        .WithColor(new DiscordColor(0xC63B68))
                                        .WithTimestamp(DateTime.UtcNow)
                                        .WithFooter(
                $"Called by {ctx.User.Username}#{ctx.User.Discriminator} ({ctx.User.Id})",
                ctx.User.AvatarUrl
                )
                                        .WithImageUrl(avatarUrl)
                                        .WithAuthor(
                $"Avatar for {ctx.TargetUser.Username} (Click to open in browser)",
                avatarUrl
                );

            await ctx.RespondAsync(null, embed, ephemeral : true);
        }
Пример #7
0
        /* H A N D L E  C O N T E X T  O P E N I N G */

        /*----------------------------------------------------------------------------
        *       %%Function: HandleContextOpening
        *       %%Qualified: AzLog.AzLogWindow.HandleContextOpening
        *       %%Contact: rlittle
        *
        *   This is going to get executed every time they go to open a context menu.
        *   We want to know *where* they are invoking from, so we do some clever
        *   hacker in HeaderSup.ColumnHeaderFromContextOpening(...) -- it figures out
        *   (based on the client rects of the column header items) where they are
        *   clicking and which column header is appropriate.
        *
        *   NOTE: IF it locates a ColumnHeader and returns it to you, then
        *   ColumnHeaderFromContextOpeneing CANCELS the context menu operation
        *   from here from happening and assumes you are going to invoke the context
        *   menu yourself (which is why we conly call m_ctxmHeader.Show() when
        *   we get a columnheader back - this allows us to show our ContextMenu
        *   for our Header columns instead of the context menu for the rest of the
        *   listview)
        *
        *   ALSO NOTE that we squirrel away the matched columnheader into the first
        *   menu item in the context menu -- in our case, that's the
        *   "Remove this column" menu item, so it follows that it needs to know
        *   what "this" column is.  (Other routings may choose to look here for this
        *   information, so let's make sure to clear the Tag in times when we aren't
        *   matched...)
        *  ----------------------------------------------------------------------------*/
        private void HandleContextOpening(object sender, CancelEventArgs e)
        {
            if (m_hs == null)
            {
                m_hs = new HeaderSupp();
            }

            ColumnHeader ch = m_hs.ColumnHeaderFromContextOpening(m_lvLog, sender, e);

            if (ch != null)
            {
                m_ctxmHeader.Tag           = ch;
                m_ctxmHeader.Items[0].Text = "Remove column " + ch.Text;
                m_ctxmHeader.Show(Control.MousePosition);
            }
            else
            {
                // we aren't in the column headers. now customize our context menu
                Point        ptLocal = m_lvLog.PointToClient(Cursor.Position);
                ListViewItem lvi     = m_lvLog.GetItemAt(ptLocal.X, ptLocal.Y);
                AzLogEntry   azle    = (AzLogEntry)lvi.Tag;

                ch = TCore.ListViewSupp.HeaderSupp.ColumnFromPoint(m_lvLog, ptLocal.X);
                AzLogViewSettings.AzLogViewColumn azlvc = m_azlvs.AzlvcFromName((string)ch.Tag);
                ContextMenuContext cmc = new ContextMenuContext();
                cmc.azle = azle;
                cmc.lc   = azlvc.DataColumn;
                m_ctxmListViewLog.Items[0].Tag  = cmc;
                m_ctxmListViewLog.Items[0].Text = String.Format("Filter to this {0}", ch.Text);
                m_ctxmListViewLog.Items[1].Tag  = cmc;
                m_ctxmListViewLog.Items[1].Text = String.Format("Filter out this {0}", ch.Text);
                m_ctxmListViewLog.Items[2].Tag  = cmc;
                m_ctxmListViewLog.Items[2].Text = String.Format("Color this {0}", ch.Text);
            }
        }
Пример #8
0
		internal ContextMenuEventArgs(ContextMenuContext context, nsIContextMenuInfo contextMenuInfo)
		{
			m_Context = context;
			m_DomEvent = DomEvent.Create(contextMenuInfo.MouseEvent);
			m_DomNode = DomNode.Create(contextMenuInfo.TargetNode);
			String associaledLink = XpcomStringHelper.Get(contextMenuInfo.GetAssociatedLink);
			Uri.TryCreate(associaledLink, UriKind.RelativeOrAbsolute, out m_AssociatedLink);
		}
Пример #9
0
        /* F I L T E R  T O  C O N T E X T */

        /*----------------------------------------------------------------------------
        *       %%Function: CreateFilterToContext
        *       %%Qualified: AzLog.AzLogWindow.CreateFilterToContext
        *       %%Contact: rlittle
        *
        *   Grabt he ContextMenuContext that we stashed away when the context menu
        *   was popping up and then make a filter for that.
        *
        *   (we can't evaluate the context here because the mousemove that happened
        *   to select the context menu item will screw up the context of *where* they
        *   were when they right clicked for the context menu.
        *  ----------------------------------------------------------------------------*/
        private void CreateFilterToContext(object sender, EventArgs e)
        {
            ContextMenuContext cmc = (ContextMenuContext)((ToolStripMenuItem)sender).Tag;

            m_azlv.Filter.Add(new AzLogFilter.AzLogFilterCondition(AzLogFilter.AzLogFilterValue.ValueType.String, AzLogFilter.AzLogFilterValue.DataSource.Column, cmc.lc, AzLogFilter.AzLogFilterCondition.CmpOp.Eq, cmc.azle.GetColumn(cmc.lc)));
            m_azlv.Filter.Add(AzLogFilter.AzLogFilterOperation.OperationType.And);
            m_azlv.RebuildView();
        }
Пример #10
0
 public async Task DumpCommand(ContextMenuContext ctx)
 {
     await using var outStream = new MemoryStream(Encoding.UTF8.GetBytes(ctx.TargetMessage.Content))
                 {
                     Position = 0
                 };
     await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
                                   new DiscordInteractionResponseBuilder().AddFile("message.txt", outStream));
 }
Пример #11
0
 internal ShowControlContextMenuEventArgs(
     DockControl dockControl,
     System.Drawing.Point position,
     ContextMenuContext context)
     : base(dockControl)
 {
     this.x13d4cb8d1bd20347 = position;
     this.x0f7b23d1c393aed9 = context;
 }
Пример #12
0
        public override async Task <bool> BeforeContextMenuExecutionAsync(ContextMenuContext ctx)
        {
            Ctx = ctx;
            // for now
            var res = await new RequireServerAdminOrOwnerSlashAttribute().ExecuteChecksAsync(ctx);

            if (!res)
            {
                throw new Exception("Checks failed");
            }
            return(await base.BeforeContextMenuExecutionAsync(ctx));
        }
Пример #13
0
        /*----------------------------------------------------------------------------
        *       %%Function: CreateColorContext
        *       %%Qualified: AzLog.AzLogWindow.CreateColorContext
        *
        *   we're going to get called for the color item, so the parent of this item
        *   should have our tag
        *  ----------------------------------------------------------------------------*/
        private void CreateColorContext(object sender, EventArgs e)
        {
            ToolStripMenuItem subMenuItem = (ToolStripMenuItem)sender;
            ToolStripMenuItem menuItem    = colorThisToolStripMenuItem;

            ContextMenuContext cmc = (ContextMenuContext)(menuItem).Tag;

            AzLogFilter filter = new AzLogFilter();

            filter.Add(new AzLogFilter.AzLogFilterCondition(AzLogFilter.AzLogFilterValue.ValueType.String, AzLogFilter.AzLogFilterValue.DataSource.Column, cmc.lc, AzLogFilter.AzLogFilterCondition.CmpOp.Eq, cmc.azle.GetColumn(cmc.lc)));
            m_azlv.AddColorFilter(filter, subMenuItem.BackColor, subMenuItem.ForeColor);
            m_azlv.RebuildView();
        }
Пример #14
0
        public override async Task <bool> ExecuteChecksAsync(ContextMenuContext ctx)
        {
            // SBG
            if (ctx.Guild.Id == 103933666417217536)
            {
                return(await Task.FromResult(ctx.Member?.Roles?.Any(r => r.Id == SBGRoles.Mod) ?? false));
            }

            if (ctx.Guild.Id == 196820438398140417)
            {
                return(await Task.FromResult(true));
            }

            return(await Task.FromResult(false));
        }
Пример #15
0
        public async Task WarnMessage(ContextMenuContext ctx)
        {
            await ctx.DeferAsync(true);

            if (!ctx.Member.Permissions.HasFlag(Permissions.KickMembers))
            {
                await ctx.FollowUpAsync(new DiscordFollowupMessageBuilder().WithContent("No you dumbass!"));

                return;
            }

            WarnBuilder warnBuilder = new WarnBuilder(
                ctx.Client,
                ctx.Guild.GetChannel(764251867135475713),
                ctx.Guild,
                ctx.Member,
                await ctx.Guild.GetMemberAsync(ctx.TargetMessage.Author.Id),
                ctx.TargetMessage);

            if (!await warnBuilder.PreExecutionChecks())
            {
                return;
            }
            var id = await warnBuilder.RequestRuleEphemeral(ctx);

            var interaction = await warnBuilder.RequestPointsEphemeral(ctx, id);

            await warnBuilder.RequestReasonEphemeral(ctx, interaction);

            if (!await warnBuilder.WriteToDatabase())
            {
                return;
            }
            if (!await warnBuilder.WriteAuditToDb())
            {
                return;
            }
            await warnBuilder.ReadRemainingPoints();

            await warnBuilder.SendWarnMessage();

            await warnBuilder.LogMessage();

            await warnBuilder.SendPunishMessageEphemeral(ctx, id);
        }
Пример #16
0
        public async Task SetMessageContextMenuAsync(ContextMenuContext ctx)
        {
            string   message = ctx.TargetMessage.Content;
            GuildBan?ban;

            if ((ban = await this._ban.GetBanAsync(ctx.Guild.Id)) is not null ||
                (ban = await this._ban.GetBanAsync(ctx.Guild.OwnerId)) is not null)
            {
                await RespondError($"Your server is banned due to: {ban.Reason}\n\n" +
                                   $"Contact a staff member on the [support server](https://discord.gg/3SCTnhCMam) to learn more.");

                await ctx.Guild.LeaveAsync();

                return;
            }

            if (string.IsNullOrWhiteSpace(message))
            {
                await RespondError("The partner message can not be null or white space!");

                return;
            }

            IReadOnlyList <string>?links = message.GetUrls();

            foreach (string?l in links)
            {
                message = message.Remove(message.IndexOf(l), l.Length);
            }

            int drank = await this._donor.GetDonorRankAsync(ctx.Guild.OwnerId);

            (Partner?, string)res = await this._partners.UpdateOrAddPartnerAsync(ctx.Guild.Id, () => {
                PartnerUpdater dat = new()
                {
                    Message   = message,
                    GuildIcon = ctx.Guild.IconUrl,
                    GuildName = ctx.Guild.Name,
                    UserCount = ctx.Guild.MemberCount,
                    OwnerId   = ctx.Guild.OwnerId,
                    DonorRank = drank
                };

                return(dat);
            });
Пример #17
0
        public async Task <DiscordInteraction> RequestPointsEphemeral(ContextMenuContext ctx, ulong messageID)
        {
            DiscordWebhookBuilder webhook = new DiscordWebhookBuilder
            {
                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)
                                );
                }
                webhook.AddComponents(buttons);
            }
            DiscordMessage pointsMessage = await ctx.EditFollowupAsync(messageID, webhook);

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

            PointsDeducted = int.Parse(interactpointsMessage.Result.Id);

            foreach (var item in webhook.Components)
            {
                foreach (DiscordButtonComponent button in item.Components)
                {
                    button.Disable();
                }
            }

            await ctx.EditFollowupAsync(messageID, webhook);

            return(interactpointsMessage.Result.Interaction);
        }
Пример #18
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();
        }
Пример #19
0
 public async Task ContextHug(ContextMenuContext ctx)
 {
     await ctx.RespondAsync($"{Program.cfgjson.Emoji.BlobHug} {ctx.TargetUser.Mention} was given a tight hug by {ctx.User.Mention}!");
 }
Пример #20
0
 public async Task ContextPat(ContextMenuContext ctx)
 {
     await ctx.RespondAsync($"{Program.cfgjson.Emoji.BlobPats} {ctx.TargetUser.Mention} was given a big headpat by {ctx.User.Mention}!");
 }
Пример #21
0
 internal ShowControlContextMenuEventArgs(DockControl dockControl, Point position, ContextMenuContext context) : base(dockControl)
 {
     Position = position;
     Context = context;
 }
Пример #22
0
        /* H A N D L E  C O N T E X T  O P E N I N G */
        /*----------------------------------------------------------------------------
            %%Function: HandleContextOpening
            %%Qualified: AzLog.AzLogWindow.HandleContextOpening
            %%Contact: rlittle

            This is going to get executed every time they go to open a context menu.
            We want to know *where* they are invoking from, so we do some clever
            hacker in HeaderSup.ColumnHeaderFromContextOpening(...) -- it figures out
            (based on the client rects of the column header items) where they are
            clicking and which column header is appropriate.

            NOTE: IF it locates a ColumnHeader and returns it to you, then
            ColumnHeaderFromContextOpeneing CANCELS the context menu operation
            from here from happening and assumes you are going to invoke the context
            menu yourself (which is why we conly call m_ctxmHeader.Show() when
            we get a columnheader back - this allows us to show our ContextMenu
            for our Header columns instead of the context menu for the rest of the
            listview)

            ALSO NOTE that we squirrel away the matched columnheader into the first
            menu item in the context menu -- in our case, that's the
            "Remove this column" menu item, so it follows that it needs to know
            what "this" column is.  (Other routings may choose to look here for this
            information, so let's make sure to clear the Tag in times when we aren't
            matched...)
        ----------------------------------------------------------------------------*/
        private void HandleContextOpening(object sender, CancelEventArgs e)
        {
            if (m_hs == null)
                m_hs = new HeaderSupp();

            ColumnHeader ch = m_hs.ColumnHeaderFromContextOpening(m_lvLog, sender, e);

            if (ch != null)
                {
                m_ctxmHeader.Tag = ch;
                m_ctxmHeader.Items[0].Text = "Remove column " + ch.Text;
                m_ctxmHeader.Show(Control.MousePosition);
                }
            else
                {
                // we aren't in the collumn headers. now customize our context menu
                Point ptLocal = m_lvLog.PointToClient(Cursor.Position);
                ListViewItem lvi = m_lvLog.GetItemAt(ptLocal.X, ptLocal.Y);
                AzLogEntry azle = (AzLogEntry) lvi.Tag;

                ch = TCore.ListViewSupp.HeaderSupp.ColumnFromPoint(m_lvLog, ptLocal.X);
                AzLogViewSettings.AzLogViewColumn azlvc = m_azlvs.AzlvcFromName((string)ch.Tag);
                ContextMenuContext cmc = new ContextMenuContext();
                cmc.azle = azle;
                cmc.lc = azlvc.DataColumn;
                m_ctxmListViewLog.Items[0].Tag = cmc;
                m_ctxmListViewLog.Items[0].Text = String.Format("Filter to this {0}", ch.Text);
                }
        }
Пример #23
0
        public override List <MacroCommandDescriptor> GetMenuEntries(List <ObjectProxy> aSelectedObjects, ContextMenuContext aContext)
        {
            var result = new List <MacroCommandDescriptor>();

            ExportManager = ExportManager ?? new ExportManager(Session);

            result.Add(new MacroCommandDescriptor()
            {
                CaptionLid = "Transfer to Unity",
                Execute    = ConfigureTemplate
            });

            var flow         = Session.RunQuery("SELECT * FROM Flow WHERE ObjectType=FlowFragment");
            var entitiesRoot = Session.GetSystemFolder(SystemFolderNames.Entities);

            var t = Session.GetSystemFolder(SystemFolderNames.Assets);

            foreach (var obj in flow.Rows)
            {
                var list = obj.GetChildren();
            }

            switch (aContext)
            {
            case ContextMenuContext.Global:
                // entries for the "global" commands of the ribbon menu are requested
                return(result);

            default:
                // normal context menu when working in the content area, navigator, search
                return(result);
            }
        }
Пример #24
0
        public override List <MacroCommandDescriptor> GetMenuEntries(List <ObjectProxy> aSelectedObjects, ContextMenuContext aContext)
        {
            var result = new List <MacroCommandDescriptor>();

            switch (aContext)
            {
            case ContextMenuContext.Global:
                // entries for the "global" commands of the ribbon menu are requested
                return(result);

            default:
                // normal context menu when working in the content area, navigator, search
                return(result);
            }
        }
Пример #25
0
 public Task UserMenu(ContextMenuContext ctx)
 {
     return(WhoIsTask(ctx, ctx.TargetMember));
 }
 public Task LookupContextAsync(ContextMenuContext ctx) => LookupAsync(ctx, ctx.TargetUser);
Пример #27
0
        public static MenuFlyout GetTrackMenu(IAudio track, ContextMenuContext context)
        {
            var menu = new MenuFlyout();

            if (context != ContextMenuContext.NowPlaying && context != ContextMenuContext.Player)
            {
                menu.Items?.Add(new MenuFlyoutItem()
                {
                    Text = Resources.GetStringByKey("ContextMenu_Play"), Command = ViewModelLocator.Main.PlaySingleTrackCommand, CommandParameter = track
                });

                menu.Items?.Add(new MenuFlyoutItem()
                {
                    Text = Resources.GetStringByKey("ContextMenu_AddToNowPlaying"), Command = ViewModelLocator.Main.AddTrackToNowPlayingCommand, CommandParameter = track
                });
                menu.Items?.Add(new MenuFlyoutItem()
                {
                    Text = Resources.GetStringByKey("ContextMenu_PlayNext"), Command = ViewModelLocator.Main.PlayTrackNextCommand, CommandParameter = track
                });

                menu.Items?.Add(new MenuFlyoutSeparator());
            }

            if (context != ContextMenuContext.NowPlaying)
            {
                if (track is AudioVk)
                {
                    var vkAudio = (AudioVk)track;
                    if (vkAudio.IsAddedByCurrentUser)
                    {
                        if (context != ContextMenuContext.Player)
                        {
                            menu.Items?.Add(new MenuFlyoutItem()
                            {
                                Text = Resources.GetStringByKey("ContextMenu_Edit"), Command = ViewModelLocator.Main.EditTrackCommand, CommandParameter = track
                            });
                        }
                        menu.Items?.Add(new MenuFlyoutItem()
                        {
                            Text = Resources.GetStringByKey("ContextMenu_Remove"), Command = ViewModelLocator.Main.RemoveTrackFromMyMusicCommand, CommandParameter = track
                        });
                        menu.Items?.Add(new MenuFlyoutItem()
                        {
                            Text = Resources.GetStringByKey("ContextMenu_AddToPlaylist"), Command = ViewModelLocator.Main.AddTrackToPlaylistCommand, CommandParameter = track
                        });
                    }
                    else
                    {
                        menu.Items?.Add(new MenuFlyoutItem()
                        {
                            Text = Resources.GetStringByKey("ContextMenu_AddToMyMusic"), Command = ViewModelLocator.Main.AddTrackToMyMusicCommand, CommandParameter = track
                        });
                    }
                }
            }
            else
            {
                if (context != ContextMenuContext.Player)
                {
                    menu.Items?.Add(new MenuFlyoutItem()
                    {
                        Text = Resources.GetStringByKey("ContextMenu_RemoveFromNowPlaying"), Command = ViewModelLocator.Main.RemoveTrackFromNowPlayingCommand, CommandParameter = track
                    });
                }
            }

            if (track is AudioVk)
            {
                menu.Items?.Add(new MenuFlyoutItem()
                {
                    Text = Resources.GetStringByKey("ContextMenu_Lyrics"), Command = ViewModelLocator.Main.ShowTrackLyricsCommand, CommandParameter = track, IsEnabled = ((AudioVk)track).LyricsId != 0
                });
            }

            if (!(menu.Items?.LastOrDefault() is MenuFlyoutSeparator))
            {
                menu.Items?.Add(new MenuFlyoutSeparator());
            }

            menu.Items?.Add(new MenuFlyoutItem()
            {
                Text = Resources.GetStringByKey("ContextMenu_FindMore"), Command = ViewModelLocator.Main.FindMoreForTrackCommand, CommandParameter = track
            });
            menu.Items?.Add(new MenuFlyoutItem()
            {
                Text = Resources.GetStringByKey("ContextMenu_CopyTitle"), Command = ViewModelLocator.Main.CopyTrackTitleCommand, CommandParameter = track
            });

            return(menu);
        }
Пример #28
0
		internal ContextMenuEventArgs(ContextMenuContext context, nsIDOMEvent domEvent, nsIDOMNode domNode)
		{
			m_Context = context;
			m_DomEvent = DomEvent.Create(domEvent);
			m_DomNode = DomNode.Create(domNode);
		}