Пример #1
0
        private async Task OnGuildMembersChunked(DiscordClient dClient, GuildMembersChunkEventArgs args)
        {
            if (args.Guild.Id != Guilds.SBG)
            {
                return;
            }

            IServiceScope scope = this.scopeFactory.CreateScope();
            BloonContext  db    = scope.ServiceProvider.GetRequiredService <BloonContext>();

            List <RoleMember> roleMembers = await db.RoleMembers
                                            .Where(r => args.Members.Select(m => m.Id).Contains(r.MemberId))
                                            .ToListAsync();

            db.RoleMembers.RemoveRange(roleMembers);

            foreach (DiscordMember member in args.Members)
            {
                IEnumerable <DiscordRole> roles = member.Roles.Where(r => ShouldPersist(args.Guild, r));

                if (!roles.Any() || member.IsBot)
                {
                    continue;
                }

                foreach (DiscordRole role in roles)
                {
                    RoleMember roleMember = roleMembers.Where(r => r.MemberId == member.Id && r.RoleId == role.Id)
                                            .FirstOrDefault();

                    if (roleMember != null)
                    {
                        db.Entry(roleMember).State = EntityState.Unchanged;
                    }
                    else
                    {
                        db.RoleMembers.Add(new RoleMember
                        {
                            MemberId = member.Id,
                            RoleId   = role.Id,
                        });
                    }
                }
            }

            await db.SaveChangesAsync();
        }
Пример #2
0
        private async Task OnGuildMemberUpdated(DiscordClient dClient, GuildMemberUpdateEventArgs args)
        {
            if (args.Guild.Id != Guilds.SBG || args.RolesBefore.Count == args.RolesAfter.Count || args.Member.IsBot)
            {
                return;
            }

            bool roleAssigned = args.RolesBefore.Count < args.RolesAfter.Count;
            IEnumerable <DiscordRole> modifiedRoles = roleAssigned
                ? args.RolesAfter.Except(args.RolesBefore)
                : args.RolesBefore.Except(args.RolesAfter);

            IServiceScope scope = this.scopeFactory.CreateScope();
            BloonContext  db    = scope.ServiceProvider.GetRequiredService <BloonContext>();

            foreach (DiscordRole role in modifiedRoles.Where(m => ShouldPersist(args.Guild, m)))
            {
                RoleMember roleMember = await db.RoleMembers.Where(r => r.MemberId == args.Member.Id && r.RoleId == role.Id)
                                        .FirstOrDefaultAsync();

                if (roleMember == null && roleAssigned)
                {
                    db.RoleMembers.Add(new RoleMember
                    {
                        MemberId = args.Member.Id,
                        RoleId   = role.Id,
                    });
                }
                else if (roleMember != null && !roleAssigned)
                {
                    db.RoleMembers.Remove(roleMember);
                }
            }

            await db.SaveChangesAsync();
        }