roles not working ? about aspnetcore.identity.ravendb HOT 9 CLOSED

              var newRole = new IdentityRole("Admin");
              var result = await roleman.CreateAsync(newRole);
              if (result.Succeeded)
              {
                  var user = new ApplicationUser();
                  user.UserName = "jos";
                  user.Email = "******";

                  string userPWD = "******";

                  var res= await userman.CreateAsync(user, userPWD);
                  if (res.Succeeded)
                  {
                      var added=await userman.AddToRoleAsync(user, "Admin");
                      await userman.UpdateAsync(user);
                  }

  public AccountController(
            UserManager<ApplicationUser> userManager,
            SignInManager<ApplicationUser> signInManager,
            IOptions<IdentityCookieOptions> identityCookieOptions,
            IEmailSender emailSender,
            ISmsSender smsSender,
            ILoggerFactory loggerFactory)
        {
            _userManager = userManager;
            _signInManager = signInManager;
            _externalCookieScheme = identityCookieOptions.Value.ExternalCookieAuthenticationScheme;
            _emailSender = emailSender;
            _smsSender = smsSender;
            _logger = loggerFactory.CreateLogger<AccountController>();
        }

        //
        // GET: /Account/Login
        [HttpGet]
        [AllowAnonymous]
        public async Task<IActionResult> Login(string returnUrl = null)
        {
            // Clear the existing external cookie to ensure a clean login process
            await HttpContext.Authentication.SignOutAsync(_externalCookieScheme);

            ViewData["ReturnUrl"] = returnUrl;
            return View();
        }

        //
        // POST: /Account/Login
        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            if (ModelState.IsValid)
            {
                // This doesn't count login failures towards account lockout
                // To enable password failures to trigger account lockout, set lockoutOnFailure: true
                var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);
                if (result.Succeeded)
                {
                    _logger.LogInformation(1, "User logged in.");
                    return RedirectToLocal(returnUrl);
                }
                if (result.RequiresTwoFactor)
                {
                    return RedirectToAction(nameof(SendCode), new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                }
                if (result.IsLockedOut)
                {
                    _logger.LogWarning(2, "User account locked out.");
                    return View("Lockout");
                }
                else
                {
                    ModelState.AddModelError(string.Empty, "Invalid login attempt.");
                    return View(model);
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

[HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Register(RegisterViewModel model, string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
                var result = await _userManager.CreateAsync(user, model.Password);
                if (result.Succeeded)
                {
                    // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
                    // Send an email with this link
                    //var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
                    //var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
                    //await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
                    //    $"Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
                    await _signInManager.SignInAsync(user, isPersistent: false);
                    _logger.LogInformation(3, "User created a new account with password.");
                    return RedirectToLocal(returnUrl);
                }
                AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using try3.Models;
using try3.Services;
using Maqduni.AspNetCore.Identity.RavenDb;
using Maqduni.Extensions.DependencyInjection; 
using Microsoft.AspNetCore.Identity;

namespace try3
{
    public class Startup
    {
        public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                .SetBasePath(env.ContentRootPath)
                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);

            if (env.IsDevelopment())
            {
                // For more details on using the user secret store see https://go.microsoft.com/fwlink/?LinkID=532709
                builder.AddUserSecrets<Startup>();
            }

            builder.AddEnvironmentVariables();
            Configuration = builder.Build();
        }

        public IConfigurationRoot Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            // Add framework services.


            services.AddMvc();
            services.AddRavenDbAsyncSession(Configuration.GetConnectionString("RavenDb"));

            services.AddIdentity<ApplicationUser, Maqduni.AspNetCore.Identity.RavenDb.IdentityRole>(
                options =>
                {
                    options.Password.RequireDigit = false;
                    options.Password.RequiredLength = 6;
                    options.Password.RequireNonAlphanumeric = false;
                    options.Password.RequireUppercase = true;
                    options.Password.RequireLowercase = true;

                    options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
                    options.Lockout.MaxFailedAccessAttempts = 5;

                    options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@";
                    options.User.RequireUniqueEmail = true;


                })
                .AddRavenDbStores()
                .AddDefaultTokenProviders();
            services.AddOptions();
            services.Configure<TicketSaleConfig>(Configuration.GetSection("TicketSale"));
            services.Configure<MultiSafePayConfig>(Configuration.GetSection("MultiSafePay"));
            // Add application services.
            services.AddTransient<IEmailSender, AuthMessageSender>();
            services.AddTransient<ISmsSender, AuthMessageSender>();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, RoleManager<IdentityRole> roleman, UserManager<ApplicationUser> userman)
        {
            loggerFactory.AddConsole(Configuration.GetSection("Logging"));
            loggerFactory.AddDebug();

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
                app.UseBrowserLink();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
            }

            app.UseStaticFiles();

            app.UseIdentity();
            // Add external authentication middleware below. To configure them please see https://go.microsoft.com/fwlink/?LinkID=532715
            Task.Run(async () =>
            {
                try
                {
                    bool roleexists = (await roleman.RoleExistsAsync("Admin"));
                    bool rolecreated = false;
                    if (!roleexists)
                    {
                        var newRole = new IdentityRole("Admin");

                       rolecreated= (await roleman.CreateAsync(newRole)).Succeeded;
                    }
                    if (roleexists||rolecreated)
                    {
                        var user = new ApplicationUser { UserName = "****", Email = "***" };

                        string userPWD = "****";
                        if((await userman.FindByEmailAsync(user.Email)) == null)
                        { var res = await userman.CreateAsync(user, userPWD);
                            if (res.Succeeded)
                            {
                                var added = await userman.AddToRoleAsync(user, "Admin");
                                //await userman.UpdateAsync(user);
                            }
                        }

                    }
                }
                catch (Exception ex)
                {

                }
            });

            app.UseMvc(routes =>
        {

            routes.MapRoute(name: "area_route",
                template: "{area:exists}/{controller}/{action}/{id?}",
                defaults: new { action = "Index" });
            routes.MapRoute(
                name: "default",
                template: "{controller=Home}/{action=Index}/{id?}");
        });
        }
    }
}

{
    "UserName": "[email protected]",
    "Email": "[email protected]",
    "EmailConfirmed": false,
    "PasswordHash": "AQAAAAEAACcQAAAAEI/tjQ2t/sy8jVDzwzFO06uWxv2SGin1J5rx+zfRauQ8dvoIUYl0Kulx/98nLKMsxg==",
    "SecurityStamp": "581cc3e6-136d-42ec-9d1a-1b93c5fd4838",
    "PhoneNumber": null,
    "PhoneNumberConfirmed": false,
    "TwoFactorEnabled": false,
    "LockoutEnd": null,
    "LockoutEnabled": true,
    "AccessFailedCount": 0,
    "Roles": [],
    "Claims": [],
    "Logins": []
}