Unable to actually get "Admin" authorization to work using JWT about authorization HOT 3 CLOSED

public class GraphQLMiddleware
    {
        private readonly RequestDelegate _next;

        public GraphQLMiddleware(
            RequestDelegate next)
        {
            _next = next;
        }

        public async Task Invoke(HttpContext context, UserManager<User> userManager)
        {
            var result = await context.AuthenticateAsync("Bearer");
            ClaimsPrincipal principal = null;
            if (result.Succeeded)
            {
                principal = result.Principal;
            }
            
            if (!IsGraphQLRequest(context))
            {
                await _next(context);
                return;
            }

            if (principal != null)
            {
                await ExecuteAsync(context, principal, userManager);
            }
            else
            {
                await _next(context);
            }
            
        }

        private bool IsGraphQLRequest(HttpContext context)
        {
            return context.Request.Path.StartsWithSegments("/graphql")
                && string.Equals(context.Request.Method, "POST", StringComparison.OrdinalIgnoreCase);
        }

        private async Task ExecuteAsync(HttpContext context, ClaimsPrincipal principal, UserManager<User> userManager)
        {
            var claims = (from c in principal.Claims select c).ToList();
            string name = claims.SingleOrDefault(c => c.Type == "sub")?.Value;
            
            User user = await userManager.FindByEmailAsync(name);

            if (user != null)
            {
                bool inRole = await userManager.IsInRoleAsync(user, "Admin");
                if (inRole)
                {
                    // add the claim....
                    Claim c = new Claim("role", "Admin");
                    var claimsIndentity = principal.Identity as ClaimsIdentity;
                    if (claimsIndentity != null)
                    {
                        claimsIndentity.AddClaim(c);
                    }
                }
            }

            await _next(context);
        }
    }

public class Startup
{
    public virtual void ConfigureServices(IServiceCollection services)
    {
        ...
        services.AddGraphQLAuth(_ =>
        {
            _.AddPolicy("AdminPolicy", p => p.RequireClaim("Role", "Admin"));
        });
        services.AddScoped<IDependencyResolver>(x => new FuncDependencyResolver(x.GetRequiredService));
        services.AddScoped<MySchema>();
        services
            .AddGraphQL(options => { options.ExposeExceptions = true; })
            .AddGraphTypes(ServiceLifetime.Scoped);
        ...
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, IServiceProvider serviceProvider)
    {
        ...
        app.UseMiddleware<MapRolesForGraphQLMiddleware>();
        app.UseGraphQL<MySchema>();
        ...
    }
}

public static class GraphQLAuthExtensions
{
    public static void AddGraphQLAuth(this IServiceCollection services, Action<AuthorizationSettings> configure)
    {
        services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
        services.AddSingleton<IAuthorizationEvaluator, AuthorizationEvaluator>();
        services.AddTransient<IValidationRule, AuthorizationValidationRule>();

        services.AddTransient<IUserContextBuilder>(s => new UserContextBuilder<GraphQLUserContext>(context =>
        {
            var userContext = new GraphQLUserContext
            {
                User = context.User
            };
                
            return Task.FromResult(userContext);
        }));

        services.AddSingleton(s =>
        {
            var authSettings = new AuthorizationSettings();
            configure(authSettings);
            return authSettings;
        });
    }
}

public class GraphQLUserContext : IProvideClaimsPrincipal
{
    public ClaimsPrincipal User { get; set; }
}

public class MapRolesForGraphQLMiddleware
{
    private readonly RequestDelegate _next;

    public MapRolesForGraphQLMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        var metadata = context.User.Claims.SingleOrDefault(x => x.Type.Equals("metadata"));

        if (metadata != null)
        {
            var roleContainer = JsonConvert.DeserializeObject<RoleContainer>(metadata.Value);
            (context.User.Identity as ClaimsIdentity).AddClaim(new Claim("Role", string.Join(", ", roleContainer.Roles)));
        }
        
        await _next(context);
    }
}

public class RoleContainer
{
    public String[] Roles { get; set; }
}