protected override ValueTask HandleRequirementAsync(AuthorizationHandlerContext context, AdminRequirement requirement, DiscordMember member)
 {
     if (DiscordClientProvider.HasAdminRole(member))
     {
         context.Succeed(requirement);
     }
     return(default);
        protected override async ValueTask HandleRequirementAsync(AuthorizationHandlerContext context, CharacterOwnerRequirement requirement, DiscordMember member)
        {
            if (requirement.AllowAdmin && DiscordClientProvider.HasAdminRole(member))
            {
                context.Succeed(requirement);
                return;
            }

            long?characterId = context.Resource switch
            {
                long id => id,
                CharacterDto character => character.Id,
                _ => null
            };

            if (characterId.HasValue)
            {
                var discordId         = (long)member.Id;
                var characterIdString = characterId.Value.ToString();

                if (context.User.HasClaim(AppClaimTypes.Character, characterIdString) ||
                    await _context.UserClaims.AsNoTracking().CountAsync(claim => claim.UserId == discordId && claim.ClaimType == AppClaimTypes.Character && claim.ClaimValue == characterIdString) > 0)
                {
                    context.Succeed(requirement);
                }
            }
        }
    }
    protected override async ValueTask HandleRequirementAsync(AuthorizationHandlerContext context, CharacterOwnerRequirement requirement, DiscordMember member)
    {
        if (requirement.AllowAdmin && DiscordClientProvider.HasAdminRole(member))
        {
            context.Succeed(requirement);
            return;
        }

        long characterId;
        long discordId = (long)member.Id;

        switch (context.Resource)
        {
        case long l:
            characterId = l;
            break;

        case CharacterDto dto:
            characterId = dto.Id;
            break;

        case Character character:
            if (character.OwnerId == discordId)
            {
                context.Succeed(requirement);
            }
            return;

        default:
            return;
        }

        if (await _context.Characters.AsNoTracking().CountAsync(c => c.Id == characterId && c.OwnerId == discordId) > 0)
        {
            context.Succeed(requirement);
        }
    }
        protected override async ValueTask HandleRequirementAsync(AuthorizationHandlerContext context, TeamLeaderRequirement requirement, DiscordMember member)
        {
            if (requirement.AllowAdmin && DiscordClientProvider.HasAdminRole(member))
            {
                context.Succeed(requirement);
                return;
            }

            if ((requirement.AllowRaidLeader && DiscordClientProvider.HasRaidLeaderRole(member)) ||
                (requirement.AllowLootMaster && DiscordClientProvider.HasLootMasterRole(member)) ||
                (requirement.AllowRecruiter && DiscordClientProvider.HasRecruiterRole(member)))
            {
                long?teamId = context.Resource switch
                {
                    long id => id,
                    TeamDto team => team.Id,
                    _ => null
                };

                if (teamId.HasValue)
                {
                    var discordId    = (long)member.Id;
                    var teamIdString = teamId.Value.ToString();

                    if (context.User.HasClaim(AppClaimTypes.RaidLeader, teamIdString) ||
                        await _context.UserClaims.AsNoTracking().CountAsync(claim => claim.UserId == discordId && claim.ClaimType == AppClaimTypes.RaidLeader && claim.ClaimValue == teamIdString) > 0)
                    {
                        context.Succeed(requirement);
                    }
                }
                else
                {
                    context.Succeed(requirement);
                }
            }
        }
    }
    protected override async ValueTask HandleRequirementAsync(AuthorizationHandlerContext context, TeamLeaderRequirement requirement, DiscordMember member)
    {
        if (requirement.AllowAdmin && DiscordClientProvider.HasAdminRole(member))
        {
            context.Succeed(requirement);
            return;
        }

        if ((requirement.AllowRaidLeader && DiscordClientProvider.HasRaidLeaderRole(member)) ||
            (requirement.AllowLootMaster && DiscordClientProvider.HasLootMasterRole(member)) ||
            (requirement.AllowRecruiter && DiscordClientProvider.HasRecruiterRole(member)))
        {
            long?teamId = context.Resource switch
            {
                long id => id,
                TeamDto team => team.Id,
                RaidTeam team => team.Id,
                _ => null
            };

            if (teamId.HasValue)
            {
                var discordId = (long)member.Id;

                if (await _context.RaidTeamLeaders.AsNoTracking().CountAsync(rtl => rtl.UserId == discordId && rtl.RaidTeamId == teamId) > 0)
                {
                    context.Succeed(requirement);
                }
            }
            else
            {
                context.Succeed(requirement);
            }
        }
    }
}