Implementacja ról w ASP.Net Core z React

Chodzi mi o to, że wiadomo jak robi się autoryzację w ASP.NET Core MVC. Natomiast usiłuję wyguglać jak to się robi w przypadku tworzenia projektu "asp.net core z biblioteką react" czyli takim jakby klientem reactowym wewnątrz projektu asp.net core. Jest sporo o tym jak to się robi w przypadku web api, ale nie mogę się doszukać jak robi się w przypadku Reacta wewnątrz projektu.

Chyba nie powinno być dużych różnic, w końcu React i backend będą się komunikować po jakimś HTTP API, prawda?

Mimo wszystko do komunikacji będziesz wykorzystywać API. Mam stronę postawioną na asp net core MVC oraz API dla mobile (traktuję to jako api dla reacta)

builder.Services.AddAuthentication().AddJwtBearer(options =>
{
    options.SaveToken = true;
    options.RequireHttpsMetadata = false;
    options.TokenValidationParameters = new TokenValidationParameters()
    {
        ValidateIssuer = false,
        ValidateAudience = false,
        ValidAudience = builder.Configuration["JWT:ValidAudience"],
        ValidIssuer = builder.Configuration["JWT:ValidIssuer"],
        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["JWT:Secret"]))
    };
});

Do logowania:

[HttpPost]
[Route("Login")]
public async Task<IActionResult> Login([FromBody] LoginInput input)
{
    var user = await _userManager.FindByEmailAsync(input.Login);
    if (user != null && await _userManager.CheckPasswordAsync(user, input.Password))
    {
        var userRoles = await _userManager.GetRolesAsync(user);

        var authClaims = new List<Claim>
        {
            new Claim(ClaimTypes.NameIdentifier, user.Id),
            new Claim(ClaimTypes.Name, user.UserName),
            new Claim(ClaimTypes.Email, user.Email),
            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
        };

        foreach (var userRole in userRoles)
        {
            authClaims.Add(new Claim(ClaimTypes.Role, userRole));
        }

        var authSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["JWT:Secret"]));

        DateTime expiryTime = DateTime.Now.AddHours(12);
        var token = new JwtSecurityToken(
            expires: DateTime.Now.AddHours(3),
            claims: authClaims,
            signingCredentials: new SigningCredentials(authSigningKey, SecurityAlgorithms.HmacSha256)
            );

        return Ok(JsonConvert.SerializeObject(new LoginResult()
        {
            Token = new JwtSecurityTokenHandler().WriteToken(token),
            ValidTo = token.ValidTo
        }));
    }
    return Unauthorized();
}

I przykład z akcją wymagającą autoryzacji:

[Route("api/v1/Users")]
[ApiController]
[Authorize(AuthenticationSchemes = "Bearer", Roles = "User")]
public class ApiUsersController : ControllerBase
{
    private readonly ILogger<ApiUsersController> _logger;
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly RoleManager<IdentityRole> _roleManager;
    private readonly SignInManager<ApplicationUser> _signInManager;
    private readonly IUserStore<ApplicationUser> _userStore;
    private readonly ApplicationDbContext _applicationDbContext;
    private readonly IConfiguration _configuration;
    private readonly IApplicationUserService _applicationUserService;

    public ApiUsersController(
        ILogger<ApiUsersController> logger,
        RoleManager<IdentityRole> roleManager,
        UserManager<ApplicationUser> userManager,
        ApplicationDbContext applicationDbContext,
        IUserStore<ApplicationUser> userStore,
        SignInManager<ApplicationUser> signInManager,
        IConfiguration configuration,
        IApplicationUserService applicationUserService)
    {
        _logger = logger;
        _roleManager = roleManager;
        _userManager = userManager;
        _applicationDbContext = applicationDbContext;
        _userStore = userStore;
        _signInManager = signInManager;
        _configuration = configuration;
        _applicationUserService = applicationUserService;
    }

    [HttpGet]
    [Route("Current")]
    public async Task<IActionResult> Current()
    {
        var user = await _userManager.GetUserAsync(User);
        var userDto = await _applicationUserService.FindById(user.Id);
        return Ok(JsonConvert.SerializeObject(userDto));
    }

A tak w nawiasie (sprawdzałem ten template z vs'a à propos reacta i net core'a. Nie brnij w to :D )