Exemple #1
0
            public async Task Unload(string role)
            {
                RoleSetting       roleSetting = Methods.Data.GetRoleSetting(role);
                SocketTextChannel channel     = Constants.IGuilds.Jordan(Context).Channels.Where(x => x.Id == Methods.Data.GetChnlId("role-selection")).FirstOrDefault() as SocketTextChannel;
                IUserMessage      msg         = channel.GetMessageAsync(roleSetting.id).Result as IUserMessage;
                Embed             embed       = msg.Embeds.FirstOrDefault() as Embed;

                if (embed.Fields.FirstOrDefault().Name == $"There are no {roleSetting.group.ToLower()} roles available at the moment.")
                {
                    //Message is empty
                    await ReplyAsync(":x: Role is not loaded.");
                }

                string rolename = Constants.IGuilds.Jordan(Context).Roles.Where(x => x.Id == roleSetting.roleid).FirstOrDefault().Name;

                foreach (EmbedField field in embed.Fields)
                {
                    if (field.Name == rolename)
                    {
                        //Role is loaded
                        EmbedBuilder embedBuilder = new EmbedBuilder();
                        embedBuilder.WithTitle(embed.Title);
                        embedBuilder.WithColor(embed.Color.Value);
                        if (embed.Fields.Count() == 1)
                        {
                            embedBuilder.AddField($"There are no {roleSetting.group.ToLower()} roles available at the moment.", "Check back later for another event.");
                        }
                        else
                        {
                            foreach (EmbedField field_ in embed.Fields)
                            {
                                if (field_.Name != rolename)
                                {
                                    embedBuilder.AddField(field_.Name, field_.Value);
                                }
                            }
                        }
                        if (embed.Footer != null)
                        {
                            embedBuilder.WithFooter(embed.Footer.Value.Text);
                        }

                        await msg.ModifyAsync(x => x.Embed = embedBuilder.Build());
                        await ReplyAsync(":white_check_mark: Role unloaded.");

                        IEmote emote = new Emoji("");
                        emote = new Emoji(Methods.Data.GetRoleSetting(role).emoji);
                        await msg.RemoveReactionAsync(emote, Context.Client.CurrentUser);

                        return;
                    }
                }
            }
        public async Task Roles_ReactionAdded(Cacheable <IUserMessage, ulong> cacheable, ISocketMessageChannel channel, SocketReaction reaction)
        {
            if (channel is IDMChannel)
            {
                return;
            }

            SocketGuildUser user = Constants.IGuilds.Jordan(_client).GetUser(reaction.UserId);

            SocketTextChannel channel_ = channel as SocketTextChannel;
            SocketGuild       guild    = channel_.Guild;

            if (channel_.Id == Data.GetChnlId("role-selection") && !user.IsBot)
            {
                RoleSetting role = new RoleSetting();
                role = Data.GetEmojiRoleSetting(reaction.Emote.Name);

                IMessage     msg  = channel_.GetMessageAsync(role.id).Result;
                IUserMessage msg_ = msg as IUserMessage;
                await msg_.RemoveReactionAsync(reaction.Emote, user);

                foreach (SocketRole role_ in user.Roles)
                {
                    if (role_.Id == role.roleid)
                    {
                        //User has the role
                        //=> remove the role
                        await user.RemoveRoleAsync(role_);

                        IDMChannel dm_ = await user.GetOrCreateDMChannelAsync();

                        await dm_.SendMessageAsync($"You have been removed from the {role_.Name} role.");

                        return;
                    }
                }
                //User does not have the role
                //=> add the role
                SocketRole role__ = guild.Roles.Where(x => x.Id == role.roleid).FirstOrDefault();
                await user.AddRoleAsync(role__);

                IDMChannel dm = await user.GetOrCreateDMChannelAsync();

                await dm.SendMessageAsync($"You have been added to the {role__.Name} role.");
            }
        }
Exemple #3
0
            public async Task Load(string role)
            {
                RoleSetting       roleSetting  = Methods.Data.GetRoleSetting(role);
                SocketTextChannel channel      = Constants.IGuilds.Jordan(Context).Channels.Where(x => x.Id == Methods.Data.GetChnlId("role-selection")).FirstOrDefault() as SocketTextChannel;
                IUserMessage      msg          = channel.GetMessageAsync(roleSetting.id).Result as IUserMessage;
                Embed             embed        = msg.Embeds.FirstOrDefault() as Embed;
                EmbedBuilder      embedBuilder = embed.ToEmbedBuilder();

                if (embed.Fields.FirstOrDefault().Name == $"There are no {roleSetting.group.ToLower()} roles available at the moment.")
                {
                    //Message is empty
                    EmbedBuilder emptybuilder = new EmbedBuilder();
                    embedBuilder.Fields = emptybuilder.Fields;
                }

                string rolename = Constants.IGuilds.Jordan(Context).Roles.Where(x => x.Id == roleSetting.roleid).FirstOrDefault().Name;

                foreach (EmbedField field in embed.Fields)
                {
                    if (field.Name == rolename)
                    {
                        //Role is loaded
                        await ReplyAsync(":x: Role already loaded.");

                        return;
                    }
                }
                embedBuilder.AddField(rolename, $"React with {roleSetting.emote} for this role!");
                await msg.ModifyAsync(x => x.Embed = embedBuilder.Build());

                await ReplyAsync(":white_check_mark: Loaded.");

                Emoji emote = new Emoji("");

                emote = new Emoji(Methods.Data.GetRoleSetting(role).emoji);
                await msg.AddReactionAsync(emote);
            }
Exemple #4
0
        public static RoleSetting GetRoleSetting(string role)
        {
            string ans         = Environment.GetEnvironmentVariable("SystemType");
            string XmlLocation = Environment.GetEnvironmentVariable("SettingsLocation").Replace("config.yml", "RoleMessages.xml");

            /*switch (ans)
             * {
             *  default:
             *      break;
             *  case "win":
             *      XmlLocation = Assembly.GetEntryAssembly().Location.Replace(@"bin\Debug\netcoreapp3.0\rJordanBot.dll", @"Data\RoleMessages.xml");
             *      break;
             *  case "aws":
             *      XmlLocation = Path.Combine("Data", "RoleMessages.xml");
             *      break;
             * }*/

            if (!File.Exists(XmlLocation))
            {
                return(null);
            }

            FileStream  Stream = new FileStream(XmlLocation, FileMode.Open, FileAccess.Read);
            XmlDocument Doc    = new XmlDocument();

            Doc.Load(Stream);
            Stream.Dispose();

            RoleSetting roleSetting = new RoleSetting();
            ulong       id          = 0;

            foreach (XmlNode typenode in Doc.DocumentElement)
            {
                foreach (XmlNode rolenode in typenode)
                {
                    if (rolenode.Name == "id")
                    {
                        id = ulong.Parse(rolenode.InnerText);
                    }
                    if (rolenode.Name == role)
                    {
                        roleSetting.id = id;
                        foreach (XmlNode inrolenode in rolenode)
                        {
                            switch (inrolenode.Name)
                            {
                            case "roleid":
                                roleSetting.roleid = ulong.Parse(inrolenode.InnerText);
                                break;

                            case "emote":
                                roleSetting.emote = inrolenode.InnerText;
                                break;

                            case "emoji":
                                roleSetting.emoji = inrolenode.InnerText;
                                break;
                            }
                        }

                        roleSetting.group = typenode.Name;
                    }
                }
            }

            return(roleSetting);
        }