gehgassi_backend/gehGassi.Web/Auth/UserExtensions.cs

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

namespace gehGassi.Web.Auth
{
    /// <summary>
    /// Erweiterungen für ClaimsPrincipal
    /// </summary>
    public static class UserExtensions
    {
        #region Customer

        /// <summary>
        /// Gibt die Id des zugeordneten Kunden zurück
        /// </summary>
        /// <param name="user">ClaimsPrincipal</param>
        /// <returns>Id des Kunden oder null wenn nicht zugeordnet</returns>
        public static long? CustomerId(this ClaimsPrincipal user)
        {
            var selectedCustomerClaim = user?.Claims.SingleOrDefault(x => x.Type == ClaimConstants.SelectedCustomerIdClaimType);
            if (selectedCustomerClaim != null && !string.IsNullOrWhiteSpace(selectedCustomerClaim.Value))
            {
                return long.Parse(selectedCustomerClaim.Value);
            }

            var customerClaim = user?.Claims.SingleOrDefault(x => x.Type == ClaimConstants.CustomerIdClaimType);
            if (customerClaim != null && !string.IsNullOrWhiteSpace(customerClaim.Value))
            {
                return long.Parse(customerClaim.Value);
            }
            return null;
        }

        /// <summary>
        /// Gibt die UniqueId des zugeordneten Kunden zurück
        /// </summary>
        /// <param name="user">ClaimsPrincipal</param>
        /// <returns>Id des Kunden oder null wenn nicht zugeordnet</returns>
        public static Guid? CustomerUniqueId(this ClaimsPrincipal user)
        {
            var selectedCustomerClaim = user?.Claims.SingleOrDefault(x => x.Type == ClaimConstants.SelectedCustomerUniqueIdClaimType);
            if (selectedCustomerClaim != null && !string.IsNullOrWhiteSpace(selectedCustomerClaim.Value))
            {
                return Guid.Parse(selectedCustomerClaim.Value);
            }

            var customerClaim = user?.Claims.SingleOrDefault(x => x.Type == ClaimConstants.CustomerUniqueIdClaimType);
            if (customerClaim != null && !string.IsNullOrWhiteSpace(customerClaim.Value))
            {
                return Guid.Parse(customerClaim.Value);
            }
            return null;
        }

        /// <summary>
        /// Gibt den Namen des zugeordneten Kunden zurück
        /// </summary>
        /// <param name="user">ClaimsPrincipal</param>
        /// <returns>Name des Kunden</returns>
        public static string CustomerName(this ClaimsPrincipal user)
        {
            var selectedCustomerClaim = user?.Claims.SingleOrDefault(x => x.Type == ClaimConstants.SelectedCustomerNameClaimType);
            if (selectedCustomerClaim != null && !string.IsNullOrWhiteSpace(selectedCustomerClaim.Value))
            {
                return selectedCustomerClaim.Value;
            }

            var customerClaim = user?.Claims.SingleOrDefault(x => x.Type == ClaimConstants.CustomerNameClaimType);
            if (customerClaim != null && !string.IsNullOrWhiteSpace(customerClaim.Value))
            {
                return customerClaim.Value;
            }
            return string.Empty;
        }

        #endregion

        #region App-User

        /// <summary>
        /// Gibt die Id des zugeordneten App-Users zurück
        /// </summary>
        /// <param name="user">ClaimsPrincipal</param>
        /// <returns>Id des App-Users oder null wenn nicht zugeordnet</returns>
        public static string AppUserId(this ClaimsPrincipal user)
        {
            var selectedAppUserClaim = user?.Claims.SingleOrDefault(x => x.Type == ClaimConstants.SelectedAppUserIdClaimType);
            if (selectedAppUserClaim != null && !string.IsNullOrWhiteSpace(selectedAppUserClaim.Value))
            {
                return selectedAppUserClaim.Value;
            }

            var appUserClaim = user?.Claims.SingleOrDefault(x => x.Type == ClaimConstants.AppUserIdClaimType);
            if (appUserClaim != null && !string.IsNullOrWhiteSpace(appUserClaim.Value))
            {
                return appUserClaim.Value;
            }
            return null;
        }

        /// <summary>
        /// Gibt den Namen des zugeordneten App-Users zurück
        /// </summary>
        /// <param name="user">ClaimsPrincipal</param>
        /// <returns>Name des App-Users</returns>
        public static string AppUserName(this ClaimsPrincipal user)
        {
            var selectedAppUserClaim = user?.Claims.SingleOrDefault(x => x.Type == ClaimConstants.SelectedAppUserNameClaimType);
            if (selectedAppUserClaim != null && !string.IsNullOrWhiteSpace(selectedAppUserClaim.Value))
            {
                return selectedAppUserClaim.Value;
            }

            var appUserClaim = user?.Claims.SingleOrDefault(x => x.Type == ClaimConstants.AppUserNameClaimType);
            if (appUserClaim != null && !string.IsNullOrWhiteSpace(appUserClaim.Value))
            {
                return appUserClaim.Value;
            }
            return string.Empty;
        }

        #endregion

        /// <summary>
        /// Gibt die Rollen eines Benutzers zurück
        /// </summary>
        /// <param name="user">ClaimsPrincipal</param>
        /// <returns>Rollen des Benutzers</returns>
        public static List<string> Roles(this ClaimsPrincipal user)
        {
            var rolesList = new List<string>();

            var roleClaims = user?.Claims.Where(x => x.Type == ClaimTypes.Role).ToList();

            if (roleClaims != null && roleClaims.Any())
            {
                rolesList.AddRange(from roleClaim in roleClaims where !string.IsNullOrWhiteSpace(roleClaim.Value) select roleClaim.Value);
            }

            return rolesList;
        }

        /// <summary>
        /// Fügt einen Claim zu einem Benutzer hinzu oder aktualisiert diesen, wenn er existiert
        /// </summary>
        /// <param name="currentPrincipal">ClaimsPrincipal</param>
        /// <param name="key">Key des claims</param>
        /// <param name="value">Zu setzender Wert</param>
        public static void AddUpdateClaim(this ClaimsPrincipal currentPrincipal, string key, string value)
        {
            var identity = currentPrincipal.Identity as ClaimsIdentity;
            if (identity == null)
                return;

            // check for existing claim and remove it
            var existingClaim = identity.FindFirst(key);
            if (existingClaim != null)
                identity.RemoveClaim(existingClaim);

            // add new claim
            identity.AddClaim(new Claim(key, value ?? ""));
        }

        /// <summary>
        /// Fügt einen Claim zu einem Benutzer hinzu oder aktualisiert diesen, wenn er existiert
        /// </summary>
        /// <param name="identity">ClaimsIdentity</param>
        /// <param name="key">Key des claims</param>
        /// <param name="value">Zu setzender Wert</param>
        public static void AddUpdateClaim(this ClaimsIdentity identity, string key, string value)
        {
            // check for existing claim and remove it
            var existingClaim = identity.FindFirst(key);
            if (existingClaim != null)
                identity.RemoveClaim(existingClaim);

            // add new claim
            identity.AddClaim(new Claim(key, value ?? ""));
        }
    }
}