ASP.NET Web API своя авторизация

//по дефолту - пустые (если необходимо добавить что-то, то добавляются поля и миграции соответсвенно), все поля дергаются из базового класса. простейшие классы, их можно даже в счет не брать.
 
public class ApplicationUser : IdentityUser
    {
    }
public class ApplicationRole : IdentityRole
    {
    }

//здесь тоже все по дефолту, но нужно связать систему с нужно БД (что делается в одну строчку)
public class ApplicationRoleManager : RoleManager<ApplicationRole>
    {
        public ApplicationRoleManager(RoleStore<ApplicationRole> store)
            : base(store)
        { }
        public static ApplicationRoleManager Create(IdentityFactoryOptions<ApplicationRoleManager> options, IOwinContext context)
        {
            //связываем систему с базой данных
            return new ApplicationRoleManager(new
                    RoleStore<ApplicationRole>(context.Get<DBEntities>()));
        }
    }

    //здесь тоже все по дефолту, но нужно связать систему с нужно БД (что делается в одну строчку)
    public class ApplicationUserManager : UserManager<ApplicationUser>
    {
        public ApplicationUserManager(IUserStore<ApplicationUser> store)
            : base(store)
        {
        }
 
        public static ApplicationUserManager Create(IdentityFactoryOptions<ApplicationUserManager> options, IOwinContext context)
        {
            //связываем систему с базой данных
            var manager = new ApplicationUserManager(new UserStore<ApplicationUser>(context.Get<DBEntities>()));
            // Настройка логики проверки имен пользователей
            manager.UserValidator = new UserValidator<ApplicationUser>(manager)
            {
                AllowOnlyAlphanumericUserNames = false,
                RequireUniqueEmail = true
            };
 
            // Настройка логики проверки паролей
            manager.PasswordValidator = new PasswordValidator
            {
                RequiredLength = 6,
                RequireNonLetterOrDigit = false,
                RequireDigit = false,
                RequireLowercase = false,
                RequireUppercase = false,
            };
 
            return manager;
        }
    }

app.CreatePerOwinContext<ApplicationRoleManager>(ApplicationRoleManager.Create);
app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);

        public async Task<IdentityResult> CreateAsync(RegisterModel model)
        {
            try
            {
                ApplicationUser user = Mapper.Map<ApplicationUser>(model);
                var result = await Database.ApplicationUserManager.CreateAsync(user, model.Password);
                return result;
            }
            catch (Exception e)
            {
                return new IdentityResult(new [] {"Database error"});
            }
        }

app.UseIdentity();

services.AddIdentity<User, IdentityRole>(options =>
{
    options.User = new UserOptions
    {
        RequireUniqueEmail = true,
        //AllowedUserNameCharacters = "допустимые символы"
    };
 
    options.Password = new PasswordOptions
        {
            RequireDigit = true,
            RequireNonAlphanumeric = false,
            RequireUppercase = false,
            RequireLowercase = true,
            RequiredLength = 5,
        };
    })
    .AddEntityFrameworkStores<ApplicationContext>();
 
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(cfg =>
    {
        cfg.RequireHttpsMetadata = false;
        cfg.SaveToken = true;
 
        cfg.TokenValidationParameters = new TokenValidationParameters()
        {
            //ValidateIssuerSigningKey = true,
            //ValidateIssuer = true,
            ValidateLifetime = true,
 
            ValidIssuer = "",
            ValidAudience = "",
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("KEYKEYKEY!"))
        };
    });

// POST api/auth/login
[HttpPost("login")]
public async Task<IActionResult> Login([FromBody]LoginViewModel model)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }
 
    var user = await _userManager.FindByNameAsync(model.Email);
    if (user == null ||
        !await _userManager.CheckPasswordAsync(user, model.Password))
    {
        return Unauthorized();
    }
 
    var claims = await GetValidClaims(user);
 
    var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("KEYKEYKEY"));
    var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
 
    var expires_in = 10 * 60;
 
    var token = new JwtSecurityToken("УДАЛИЛ",
        "УДАЛИЛ",
        claims,
        expires: DateTime.Now.AddSeconds(expires_in),
        signingCredentials: creds);
 
    return Ok(new
    {
        id = user.Id,
        user_name = user.UserName,
        auth_token = new JwtSecurityTokenHandler().WriteToken(token),
        expires_in = expires_in
    });
}
 
private async Task<List<Claim>> GetValidClaims(User user)
{
    IdentityOptions options = new IdentityOptions();
    var claims = new List<Claim>
    {
        new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
        new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
        new Claim(options.ClaimsIdentity.UserIdClaimType, user.Id.ToString()),
        new Claim(options.ClaimsIdentity.UserNameClaimType, user.UserName)
    };
 
    var userClaims = await _userManager.GetClaimsAsync(user);
    var userRoles = await _userManager.GetRolesAsync(user);
    claims.AddRange(userClaims);
    foreach (var userRole in userRoles)
    {
        claims.Add(new Claim(ClaimTypes.Role, userRole));
        var role = await _roleManager.FindByNameAsync(userRole);
        if (role != null)
        {
            var roleClaims = await _roleManager.GetClaimsAsync(role);
            foreach (Claim roleClaim in roleClaims)
            {
                claims.Add(roleClaim);
            }
        }
    }
 
    return claims;
}

[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme, Roles = "admin")]