GetAuthenticationStateAsync Question about policybasedauthwithblazor HOT 9 CLOSED

    public class AuthStateProvider : AuthenticationStateProvider
    {
        private const string tokenKey = "authToken";

        internal readonly IStorage storage;

        public AuthStateProvider(IStorage storage)
        {
            this.storage = storage ?? throw new ArgumentNullException(nameof(storage));
        }

        public override async Task<AuthenticationState> GetAuthenticationStateAsync()
        {
            var savedToken = await this.storage.GetItem<string>(tokenKey);
            return string.IsNullOrWhiteSpace(savedToken) ? await CreateAnomymousState() : await CreateAuthenticatedState(savedToken);
        }

        public async Task MarkUserAsAuthenticated(string token)
        {
            await this.storage.SetItem(tokenKey, token);
            base.NotifyAuthenticationStateChanged(CreateAuthenticatedState(token));
        }

        public async Task MarkUserAsLoggedOut()
        {
            await this.storage.RemoveItem(tokenKey);
            base.NotifyAuthenticationStateChanged(CreateAnomymousState());
        }

        private static async Task<AuthenticationState> CreateAuthenticatedState(string token)
        {
            var authenticatedUser = new ClaimsPrincipal(new ClaimsIdentity(ParseClaimsFromJwt(token), "jwt"));
            return await Task.FromResult(new AuthenticationState(authenticatedUser));
        }

        private static async Task<AuthenticationState> CreateAnomymousState()
        {
            var anonymousUser = new ClaimsPrincipal(new ClaimsIdentity());
            return await Task.FromResult(new AuthenticationState(anonymousUser));
        }

        private static IEnumerable<Claim> ParseClaimsFromJwt(string jwt)
        {
            var result = new List<Claim>();

            var payload = ParseBase64WithoutPadding(jwt.Split('.')[1]);
            var claims = JsonConvert.DeserializeObject<Dictionary<string, object>>(payload);

            claims.TryGetValue(ClaimTypes.Role, out var roles);

            if (roles != null)
            {
                if (roles.ToString().Trim().StartsWith("["))
                {
                    var parsedRoles = JsonConvert.DeserializeObject<string[]>(roles.ToString());

                    result.AddRange(parsedRoles.Select(parsedRole => new Claim(ClaimTypes.Role, parsedRole)));
                }
                else
                {
                    result.Add(new Claim(ClaimTypes.Role, roles.ToString()));
                }

                claims.Remove(ClaimTypes.Role);
            }

            result.AddRange(claims.Select(e => new Claim(e.Key, e.Value.ToString())));

            return result;
        }

        private static string ParseBase64WithoutPadding(string base64)
        {
            switch (base64.Length % 4)
            {
                case 2: base64 += "=="; break;
                case 3: base64 += "="; break;
            }

            return BitConverter.ToString(Convert.FromBase64String(base64));
        }
    }