kreta/KretaWeb/Security/ClaimsPrincipalExtensions.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using Kreta.Framework.Security;

namespace Kreta.Web.Security
{
    public static class ClaimsPrincipalExtensions
    {
        /// <summary>
        /// Checks whether a given claim exists
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="predicate">The search predicate.</param>
        /// <returns>true/false</returns>
        public static bool ClaimExists(this ClaimsPrincipal principal, Predicate<Claim> predicate)
        {
            foreach (var identity in principal.Identities)
            {
                if (identity.ClaimExists(predicate))
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Checks whether a given claim exists
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <returns>true/false</returns>
        public static bool ClaimExists(this ClaimsPrincipal principal, string claimType)
        {
            return principal.ClaimExists(c => c.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase));
        }

        /// <summary>
        /// Checks whether a given claim exists.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <param name="value">The value.</param>
        /// <returns>true/false</returns>
        public static bool ClaimExists(this ClaimsPrincipal principal, string claimType, string[] value)
        {
            var result = false;
            foreach (var item in value)
            {
                if (principal.ClaimExists(c => c.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase) && c.Value.Equals(item, StringComparison.OrdinalIgnoreCase)))
                {
                    result = true;
                    break;
                }
            }
            return result;

        }

        /// <summary>
        /// Checks whether a given claim exists.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <param name="value">The value.</param>
        /// <param name="issuer">The issuer.</param>
        /// <returns>true/false</returns>
        public static bool ClaimExists(this ClaimsPrincipal principal, string claimType, string[] value, string issuer)
        {
            var result = false;
            foreach (var item in value)
            {
                if (principal.ClaimExists(c =>
                    c.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase) &&
                    c.Value.Equals(item, StringComparison.OrdinalIgnoreCase) &&
                    c.Issuer.Equals(issuer, StringComparison.OrdinalIgnoreCase)))
                {
                    result = true;
                    break;
                }
            }
            return result;
        }

        /// <summary>
        /// Demands a specific claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="predicate">The search predicate.</param>
        public static void DemandClaim(this ClaimsPrincipal principal, Predicate<Claim> predicate)
        {
            foreach (Claim claim in principal.FindClaims(predicate))
            {
                return;
            }

            throw new SecurityException();
        }

        /// <summary>
        /// Demands a specific claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        public static void DemandClaim(this ClaimsPrincipal principal, string claimType)
        {
            try
            {
                principal.DemandClaim(claim =>
                    claim.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase));
            }
            catch (SecurityException)
            {
                throw new SecurityException();
            }
        }

        /// <summary>
        /// Demands a specific claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <param name="value">The value.</param>
        public static void DemandClaim(this ClaimsPrincipal principal, string claimType, string value)
        {
            try
            {
                principal.DemandClaim(claim =>
                    claim.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase) &&
                    claim.Value.Equals(value, StringComparison.OrdinalIgnoreCase));
            }
            catch (SecurityException)
            {
                throw new SecurityException();
            }
        }

        /// <summary>
        /// Demands a specific claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <param name="value">The value.</param>
        /// <param name="issuer">The issuer.</param>
        public static void DemandClaim(this ClaimsPrincipal principal, string claimType, string value, string issuer)
        {
            try
            {
                principal.DemandClaim(claim =>
                    claim.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase) &&
                    claim.Value.Equals(value, StringComparison.OrdinalIgnoreCase) &&
                    claim.Issuer.Equals(issuer, StringComparison.OrdinalIgnoreCase));
            }
            catch (SecurityException)
            {
                throw new SecurityException();
            }
        }

        /// <summary>
        /// Denies a specific claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="predicate">The search predicate.</param>
        public static void DenyClaim(this ClaimsPrincipal principal, Predicate<Claim> predicate)
        {
            foreach (Claim claim in principal.FindClaims(predicate))
            {
                throw new SecurityException();
            }
        }

        /// <summary>
        /// Denies a specific claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        public static void DenyClaim(this ClaimsPrincipal principal, string claimType)
        {
            try
            {
                principal.DenyClaim(claim =>
                    claim.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase));
            }
            catch (SecurityException)
            {
                throw new SecurityException();
            }
        }

        /// <summary>
        /// Denies a specific claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <param name="value">The value.</param>
        public static void DenyClaim(this ClaimsPrincipal principal, string claimType, string value)
        {
            try
            {
                principal.DenyClaim(claim =>
                    claim.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase) &&
                    claim.Value.Equals(value, StringComparison.OrdinalIgnoreCase));
            }
            catch (SecurityException)
            {
                throw new SecurityException();
            }
        }

        /// <summary>
        /// Denies a specific claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <param name="value">The value.</param>
        /// <param name="issuer">The issuer.</param>
        public static void DenyClaim(this ClaimsPrincipal principal, string claimType, string value, string issuer)
        {
            try
            {
                principal.DenyClaim(claim =>
                    claim.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase) &&
                    claim.Value.Equals(value, StringComparison.OrdinalIgnoreCase) &&
                    claim.Issuer.Equals(issuer, StringComparison.OrdinalIgnoreCase));
            }
            catch (SecurityException)
            {
                throw new SecurityException();
            }
        }

        /// <summary>
        /// Finds all instances of the specified claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="predicate">A search predicate.</param>
        /// <returns>A list of claims that match the search criteria.</returns>
        public static IEnumerable<Claim> FindClaims(this ClaimsPrincipal principal, Predicate<Claim> predicate)
        {
            foreach (ClaimsIdentity identity in principal.Identities)
            {
                foreach (Claim claim in identity.FindClaims(predicate))
                {
                    yield return claim;
                }
            }
        }

        /// <summary>
        /// Finds all instances of the specified claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <returns>A list of claims that match the search criteria.</returns>
        public static IEnumerable<Claim> FindClaims(this ClaimsPrincipal principal, string claimType)
        {
            return principal.FindClaims(c =>
                c.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase));
        }

        /// <summary>
        /// Finds all instances of the specified claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <param name="issuer">The issuer.</param>
        /// <returns>A list of claims that match the search criteria.</returns>
        public static IEnumerable<Claim> FindClaims(this ClaimsPrincipal principal, string claimType, string issuer)
        {
            return principal.FindClaims(c =>
                c.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase) &&
                c.Issuer.Equals(issuer, StringComparison.OrdinalIgnoreCase));
        }

        /// <summary>
        /// Finds all instances of the specified claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <param name="issuer">The issuer.</param>
        /// <param name="value">The value.</param>
        /// <returns>A list of claims that match the search criteria.</returns>
        public static IEnumerable<Claim> FindClaims(this ClaimsPrincipal principal, string claimType, string issuer, string value)
        {
            return principal.FindClaims(c =>
                c.Type.Equals(claimType, StringComparison.OrdinalIgnoreCase) &&
                c.Value.Equals(value, StringComparison.OrdinalIgnoreCase) &&
                c.Issuer.Equals(issuer, StringComparison.OrdinalIgnoreCase));
        }

        /// <summary>
        /// Finds all instances of the specified claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claim">The claim.</param>
        /// <returns>A list of claims that match the search criteria.</returns>
        public static IEnumerable<Claim> FindClaims(this ClaimsPrincipal principal, Claim claim)
        {
            return principal.FindClaims(c =>
                c.Type.Equals(claim.Type, StringComparison.OrdinalIgnoreCase) &&
                c.Value.Equals(claim.Value, StringComparison.OrdinalIgnoreCase) &&
                c.Issuer.Equals(claim.Issuer, StringComparison.OrdinalIgnoreCase));
        }

        /// <summary>
        /// Retrieves the value of a claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <returns>The value</returns>
        public static string GetClaimValue(this ClaimsPrincipal principal, string claimType)
        {
            string value = null;
            foreach (var identity in principal.Identities)
            {
                if (identity.TryGetClaimValue(claimType, out value))
                {
                    return value;
                }
            }

            throw new ClaimNotFoundException(claimType);
        }

        /// <summary>
        /// Retrieves the value of a claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <param name="issuer">The issuer.</param>
        /// <returns>The value</returns>
        public static string GetClaimValue(this ClaimsPrincipal principal, string claimType, string issuer)
        {
            string value = null;
            foreach (var identity in principal.Identities)
            {
                if (identity.TryGetClaimValue(claimType, issuer, out value))
                {
                    return value;
                }
            }

            throw new ClaimNotFoundException(claimType);
        }

        /// <summary>
        /// Tries to retrieve the value of a claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <param name="claimValue">The claim value.</param>
        /// <returns>The value</returns>
        public static bool TryGetClaimValue(this ClaimsPrincipal principal, string claimType, out string claimValue)
        {
            claimValue = null;
            Claim claim = principal.FindClaims(claimType).FirstOrDefault();

            if (claim != null)
            {
                claimValue = claim.Value;
                return true;
            }

            return false;
        }

        /// <summary>
        /// Tries to retrieve the value of a claim.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimType">Type of the claim.</param>
        /// <param name="issuer">The issuer.</param>
        /// <param name="claimValue">The claim value.</param>
        /// <returns>The value</returns>
        public static bool TryGetClaimValue(this ClaimsPrincipal principal, string claimType, string issuer, out string claimValue)
        {
            claimValue = null;
            Claim claim = principal.FindClaims(claimType, issuer).FirstOrDefault();

            if (claim != null)
            {
                claimValue = claim.Value;
                return true;
            }

            return false;
        }

        /// <summary>
        /// Retrieves the first identity of an ClaimsPrincipal.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <returns>The first IClaimsIdentity</returns>
        public static ClaimsIdentity First(this ClaimsPrincipal principal)
        {
            return principal.Identities.ElementAt(0);
        }
    }

}