ASP.NET

public class CustomAuthenticationStateProvider : AuthenticationStateProvider
    {
        private readonly ProtectedSessionStorage _sessionStorage;
        private ClaimsPrincipal _anonymous = new ClaimsPrincipal(new ClaimsIdentity());
        public CustomAuthenticationStateProvider(ProtectedSessionStorage sessionStorage)
        {
            _sessionStorage = sessionStorage;
        }

        public override async Task<AuthenticationState> GetAuthenticationStateAsync()
        {
            try
            {
                var userSessionStorageResult = await _sessionStorage.GetAsync<UserSession>("UserSession");
                var userSession = userSessionStorageResult.Success ? userSessionStorageResult.Value : null;
                if (userSession == null)
                {
                    return await Task.FromResult(new AuthenticationState(_anonymous));
                }
                var claimsPrincipal = new ClaimsPrincipal(new ClaimsIdentity(new List<Claim> {
                new Claim(ClaimTypes.Name, userSession.Username),
                new Claim(ClaimTypes.Role, userSession.UserRole),
                new Claim(ClaimTypes.NameIdentifier, userSession.UserId.ToString())
            }, "Jwt"));

                return await Task.FromResult(new AuthenticationState(claimsPrincipal));
            }
            catch (Exception)
            {
                return await Task.FromResult(new AuthenticationState(_anonymous));
            }
        }

        public async Task UpdateAuthenticationState(UserSession userSession)
        {
            ClaimsPrincipal claimsPrincipal;

            if (userSession != null)
            {
                await _sessionStorage.SetAsync("UserSession", userSession);
                await _sessionStorage.SetAsync("Token", userSession.TokenText);
                claimsPrincipal = new ClaimsPrincipal(new ClaimsIdentity(new List<Claim>
                {
                    new Claim(ClaimTypes.Name, userSession.Username),
                    new Claim(ClaimTypes.Role, userSession.UserRole),
                    new Claim(ClaimTypes.NameIdentifier, userSession.UserId.ToString())
                }));
            }
            else
            {
                await _sessionStorage.DeleteAsync("UserSession");
                claimsPrincipal = _anonymous;
            }

            NotifyAuthenticationStateChanged(Task.FromResult(new AuthenticationState(claimsPrincipal)));
        }
    }

public class UserSession
{
    public int UserId { get; set; }
    public string Username { get; set; }
    public string UserRole { get; set; }
    public string Name { get; set; }
    public string TokenText { get; set; }
}

[Route("api/[controller]/[action]")]
    [ApiController]
    public class ApiLoginController : ControllerBase
    {
        private readonly SqliteContext _sqlServerContext;
        private readonly IConfiguration _configuration;
        private readonly IUserService _userService;

        public ApiLoginController(SqliteContext sqlServerContext, IConfiguration configuration, IUserService userService)
        {
            _sqlServerContext = sqlServerContext;
            _configuration = configuration;
            _userService = userService;
        }

        [HttpPost]
        public async Task<IActionResult> LoginSystem([FromBody] UserLoginVM loginModel)
        {
            var user = await _sqlServerContext.Users.Include(x => x.RoleRefNavigation)
                .FirstOrDefaultAsync(x => x.Username == loginModel.Username && x.IsActive);
            if (user == null)
            {
                return BadRequest("Invalid credentials.");
            }

            if (!MatchPasswordHash(loginModel.Password, user.Password, user.SaltPassword))
            {
                return BadRequest("Invalid credentials.");
            }
            if (!user.IsActive)
            {
                return StatusCode(403, "User is not active.");
            }
            if (user.IsLocked)
            {
                DateTime setDate = (DateTime)user.LockUntil;
                DateTime current = DateTime.Now;
                if (setDate > current)
                {
                    return StatusCode(403, "User is restricted.");
                }
                await _userService.UnsetUserLimits(user.UserId);
            }

            user.RoleRefNavigation = await _sqlServerContext.Roles.FirstOrDefaultAsync(x => x.RoleId == user.RoleRef);
            string token = CreateToken(user);

            var data = new
            {
                tokenText = token,
                username = user.Username,
                userId = user.UserId.ToString(),
                name = user.Name,
                role = user.RoleRefNavigation.User_Role
            };

            await _userService.RegisterLoginTime(user.UserId);

            return Ok(data);
        }

        private string CreateToken(User user)
        {
            List<Claim> claims = new List<Claim>()
            {
                new Claim(ClaimTypes.NameIdentifier, user.Username),
                new Claim(ClaimTypes.Role, user.RoleRefNavigation.User_Role),
                new Claim(type: "UserId", value: user.UserId.ToString())
            };

            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration.GetSection("Jwt:Key").Value!));
            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
            var token = new JwtSecurityToken(
                claims: claims,
                issuer: _configuration["Jwt:Issuer"],
                audience: _configuration["Jwt:Issuer"],
                expires: DateTime.Now.AddHours(8),
                signingCredentials: creds
                );

            var jwt = new JwtSecurityTokenHandler().WriteToken(token);

            return jwt;
        }

        private bool MatchPasswordHash(string passwordText, byte[] password, byte[] passwordKey)
        {
            using (var hmac = new HMACSHA512(passwordKey))
            {
                var passwordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(passwordText));

                for (int i = 0; i < passwordHash.Length; i++)
                {
                    if (passwordHash[i] != password[i])
                    {
                        return false;
                    }
                }
                return true;
            }
        }
    }

Public Sub GetExcel(ByVal dt As DataTable)
    Dim fileName As String = "file" & DateTime.Now.ToString("MMddyyyy") & ".xls"
    Response.AddHeader("content-disposition", "attachment;filename=" & fileName)
    Response.ContentType = "application/vnd.ms-excel"
    Dim stringWriter As StringWriter = New StringWriter()
    Dim htmlWrite As HtmlTextWriter = New HtmlTextWriter(stringWriter)
    Dim dtExportExcel As DataGrid = New DataGrid()
    dtExportExcel.DataSource = dt
    dtExportExcel.DataBind()
    dtExportExcel.RenderControl(htmlWrite)
    Dim sb As System.Text.StringBuilder = New System.Text.StringBuilder()
    sb.Append("<html xmlns:v=""urn:schemas-microsoft-com:vml"" xmlns:o=""urn:schemas-microsoft-com:office:office"" xmlns:x=""urn:schemas-microsoft-com:office:xlExcel8"" xmlns=""http://www.w3.org/TR/REC-html40""> <head><style> table { mso-number-format:'0'; } </style></head> <body></html>")
    sb.Append(stringWriter & "</body></html>")
    Response.Write(sb.ToString())
    Response.[End]()
End Sub

sb.Append(stringWriter & "</body></html>")