Exemple #1
0
        public void HandleChildReaction(TicketChild child, SocketReaction reaction, Discord.Rest.RestUserMessage message)
        {
            var user = reaction.User.Value as SocketGuildUser;

            if (child.State == TicketState.Locked && reaction.UserId == child.UserId)
            {
                if (!user.GuildPermissions.Administrator && !user.Roles.Any(g => TicketManager.GetGuild(child.ParentGuildId).PermittedRoles.Contains(g.Id)))
                {
                    message.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
                    return;
                }
            }

            if (message.Id == child.MainMessageId)
            {
                switch (child.State)
                {
                case TicketState.Open:
                    TicketManager.ChangeChildState(TicketState.Locked, DiscordClient, user, child);
                    break;

                case TicketState.Locked:
                    TicketManager.ChangeChildState(TicketState.Open, DiscordClient, user, child);
                    break;
                }
            }

            else
            {
                switch (reaction.Emote.Name)
                {
                case "⛔":
                    TicketManager.DeleteChild(DiscordClient, child);
                    break;

                case "📑":
                    TicketManager.DeleteChildWithTranscript(DiscordClient, child);
                    break;

                case "🔓":
                    TicketManager.ChangeChildState(TicketState.Open, DiscordClient, user, child);
                    break;
                }
            }
        }
Exemple #2
0
        public void HandleSetupMessage(GuildEngine guildE, SetupMessage setupMessage, SocketReaction reaction, Discord.Rest.RestUserMessage message)
        {
            var user   = reaction.User.Value as SocketGuildUser;
            var ticket = GetTicket(guildE.Id, setupMessage.TicketId);

            if (ticket == null)
            {
                return;
            }

            message.RemoveReactionAsync(reaction.Emote, user);

            if (ticket.ActiveChildChannels.Values.Any(x => x.UserId == user.Id))
            {
                return;
            }

            TicketManager.CreateNewChild(DiscordClient, user, ticket);
        }
Exemple #3
0
        public override async Task OnExecuteFromDiscord(SocketGuild guild, SocketUser user, SocketTextChannel channel, SocketMessage messageobject, string fullmessage, string arguments_string, List <string> arguments)
        {
            int           page  = 0;
            List <string> pages = new List <string>();

            Emoji em1 = new Emoji("\u23EE");
            Emoji em2 = new Emoji("\u23ED");

            String             currentPage = "```A list of known command categories:";
            List <CmdCategory> categories  = new List <CmdCategory>();

            foreach (CmdCategory cat in Bot.GetBot().CmdCategories)
            {
                if (arguments.Count != 0)
                {
                    if (cat.name.ToLower() != arguments[0].ToLower())
                    {
                        continue;
                    }
                }
                if (!categories.Contains(cat))
                {
                    categories.Add(cat);
                }
            }
            foreach (CmdCategory cat in Bot.GetBot().CmdCategories)
            {
                if (arguments.Count != 0)
                {
                    if (!cat.name.ToLower().StartsWith(arguments[0].ToLower()))
                    {
                        continue;
                    }
                }
                if (!categories.Contains(cat))
                {
                    categories.Add(cat);
                }
            }
            foreach (CmdCategory cat in Bot.GetBot().CmdCategories)
            {
                if (arguments.Count != 0)
                {
                    if (!cat.name.ToLower().Contains(arguments[0].ToLower()))
                    {
                        continue;
                    }
                }
                if (!categories.Contains(cat))
                {
                    categories.Add(cat);
                }
            }
            foreach (CmdCategory cat in Bot.GetBot().CmdCategories)
            {
                if (arguments.Count != 0)
                {
                    if (!cat.description.ToLower().StartsWith(arguments[0].ToLower()))
                    {
                        continue;
                    }
                }
                if (!categories.Contains(cat))
                {
                    categories.Add(cat);
                }
            }
            foreach (CmdCategory cat in Bot.GetBot().CmdCategories)
            {
                if (arguments.Count != 0)
                {
                    if (!cat.description.ToLower().Contains(arguments[0].ToLower()))
                    {
                        continue;
                    }
                }
                if (!categories.Contains(cat))
                {
                    categories.Add(cat);
                }
            }

            foreach (CmdCategory cat in categories)
            {
                if (currentPage.Length + 3 >= 2000)
                {
                    currentPage += "```";
                    pages.Add(currentPage);
                    currentPage = "```A list of known command categories (page " + pages.Count + "):";
                }
                currentPage += ("\n - " + cat.name + " - " + cat.description);
            }
            if (currentPage.Length != ("```A list of known command categories (page " + pages.Count + "):").Length)
            {
                currentPage += "```";
                pages.Add(currentPage);
            }

            Discord.Rest.RestUserMessage message = await channel.SendMessageAsync(pages[page]);

            Func <Cacheable <IUserMessage, ulong>, ISocketMessageChannel, SocketReaction, Task> handler = new Func <Cacheable <IUserMessage, ulong>, ISocketMessageChannel, SocketReaction, Task>((arg1, arg2, arg3) =>
            {
                if (arg3.MessageId == message.Id && arg3.Channel.Id == message.Channel.Id)
                {
                    if (arg3.Emote.Name == em1.Name)
                    {
                        bool changed = false;
                        var v        = message.GetReactionUsersAsync(em1, int.MaxValue).GetAsyncEnumerator();
                        while (true)
                        {
                            if (v.Current != null)
                            {
                                foreach (IUser usr in v.Current)
                                {
                                    if (!usr.Id.Equals(Bot.GetBot().client.CurrentUser.Id))
                                    {
                                        message.RemoveReactionAsync(em1, usr).GetAwaiter().GetResult();
                                        changed = true;
                                    }
                                }
                            }
                            if (!v.MoveNextAsync().GetAwaiter().GetResult())
                            {
                                break;
                            }
                        }
                        if (changed)
                        {
                            page--;

                            var oldmsg = message;
                            message    = channel.SendMessageAsync(pages[page]).GetAwaiter().GetResult();
                            oldmsg.DeleteAsync().GetAwaiter().GetResult();

                            if (page != 0)
                            {
                                message.AddReactionAsync(em1).GetAwaiter().GetResult();
                            }
                            if (page != pages.Count - 1)
                            {
                                message.AddReactionAsync(em2).GetAwaiter().GetResult();
                            }
                        }
                    }
                    if (arg3.Emote.Name == em2.Name)
                    {
                        bool changed = false;
                        var v        = message.GetReactionUsersAsync(em2, int.MaxValue).GetAsyncEnumerator();
                        while (true)
                        {
                            if (v.Current != null)
                            {
                                foreach (IUser usr in v.Current)
                                {
                                    if (!usr.Id.Equals(Bot.GetBot().client.CurrentUser.Id))
                                    {
                                        message.RemoveReactionAsync(em1, usr).GetAwaiter().GetResult();
                                        changed = true;
                                    }
                                }
                            }
                            if (!v.MoveNextAsync().GetAwaiter().GetResult())
                            {
                                break;
                            }
                        }
                        if (changed)
                        {
                            page++;

                            var oldmsg = message;
                            message    = channel.SendMessageAsync(pages[page]).GetAwaiter().GetResult();
                            oldmsg.DeleteAsync().GetAwaiter().GetResult();

                            if (page != 0)
                            {
                                message.AddReactionAsync(em1).GetAwaiter().GetResult();
                            }
                            if (page != pages.Count - 1)
                            {
                                message.AddReactionAsync(em2).GetAwaiter().GetResult();
                            }
                        }
                    }
                }
                return(null);
            });

            Bot.GetBot().client.ReactionAdded += handler;
            Bot.GetBot().client.MessageDeleted += (arg11, arg22) =>
            {
                if (arg11.Id == message.Id)
                {
                    Bot.GetBot().client.ReactionAdded -= handler;
                }
                return(null);
            };

            if (pages.Count != 1)
            {
                if (page != pages.Count)
                {
                    await message.AddReactionAsync(em2);
                }
            }
        }