Example #1
0
        private async Task MergeRolesCommand(IRole role1, IRole role2)
        {
            try
            {
                string      output = "";
                SocketGuild server;
                IEnumerable <IGuildUser> users;
                List <ulong>             usersToMerge  = new List <ulong>();
                List <IRole>             roleToMergeTo = new List <IRole>();
                IGuildUser curUser;

                RoleTranslations roleTranslations = new RoleTranslations();

                roleTranslations.translateFrom = role2.Name;
                roleTranslations.translateTo   = role1.Name;

                roleTranslations.insert();

                server = this.Context.Guild as SocketGuild;
                roleToMergeTo.Add(role1);


                users = await this.Context.Guild.GetUsersAsync();

                // Get users from Role 2 that aren't in Role 1
                for (int i = 0; i < users.Count(); i++)
                {
                    curUser = users.ElementAt(i);

                    if (curUser.RoleIds.Contains(role2.Id) && !curUser.RoleIds.Contains(role1.Id))
                    {
                        usersToMerge.Add(curUser.Id);
                    }
                }
                // Add users to Role 1
                if (usersToMerge.Count > 0)
                {
                    await this.RoleAddUsers(server, usersToMerge, roleToMergeTo);
                }
                // Delete Role 2
                await this.RoleDelete(server, role2);

                output = string.Format("Roles {0} and {1} merged", role1.Name, role2.Name);
                await ReplyAsync(output);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
Example #2
0
        private async static Task <bool> HandleTimer(DiscordSocketClient client)
        {
            try
            {
                IReadOnlyCollection <SocketGuild> guilds;

                guilds = client.Guilds;

                foreach (SocketGuild curGuild in guilds)
                {
                    IReadOnlyCollection <SocketGuildUser> users;
                    users = curGuild.Users;
                    foreach (SocketGuildUser curUser in users)
                    {
                        if (curUser.Activity.Type == Discord.ActivityType.Playing && !curUser.IsBot)
                        {
                            IRole  gameRole;
                            string gameName;
                            IReadOnlyCollection <SocketRole>  userRoles;
                            CoOpBot.Modules.Admin.RolesModule roleModule = new Modules.Admin.RolesModule();
                            Boolean          userHasRole = false;
                            List <IRole>     roleList    = new List <IRole>();
                            List <ulong>     userList    = new List <ulong>();
                            RoleTranslations rt          = new RoleTranslations();

                            gameName = curUser.Activity.Name;

                            rt = rt.find(gameName) as RoleTranslations;

                            if (rt != null)
                            {
                                gameName = rt.translateTo;
                            }

                            gameRole = roleModule.FindRoleFromName(gameName, curGuild);

                            if (gameRole == null)
                            {
                                return(true);

                                //await roleModule.RoleCreate(curGuild, gameName);

                                //gameRole = roleModule.FindRoleFromName(gameName, curGuild);
                            }

                            userRoles = curUser.Roles;

                            foreach (SocketRole curRole in userRoles)
                            {
                                if (curRole.Name == gameRole.Name)
                                {
                                    userHasRole = true;
                                    break;
                                }
                            }

                            if (!userHasRole)
                            {
                                roleList.Add(gameRole);
                                userList.Add(curUser.Id);
                                await roleModule.RoleAddUsers(curGuild, userList, roleList);
                            }
                        }
                    }
                }
            }
            catch (OperationCanceledException) { }
            catch (Exception ex)
            {
                Console.WriteLine(ex.InnerException);
                return(true);
            }

            return(true);
        }