ASP.NET

<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="First2023WebUserControl.ascx.cs" Inherits="First2023Control.UserControls.First2023WebUserControl" %>
<asp:Label ID="Label1" runat="server" Text="Hello Year 2023"></asp:Label>
<p>
     </p>
Category:<asp:DropDownList ID="ddlCategory" runat="server" AutoPostBack="True" OnSelectedIndexChanged="ddlCategory_SelectedIndexChanged">
</asp:DropDownList>
<p>
    Subcategory:
    <asp:DropDownList ID="ddlSubcategory" runat="server" AutoPostBack="True">
    </asp:DropDownList>
</p>
<p>
    <asp:Label ID="Label2" runat="server" Text="Label"></asp:Label>
</p>
<asp:Button ID="Button1" runat="server" OnClick="Button1_Click" Text="Button" />
<asp:Label ID="Label3" runat="server" Text="Label"></asp:Label>

dotnet.exe publish C:\..\Produce.csproj --configuration Release -r win-x64 --self-contained true --output C:\..\Produce5

MSBuild version 17.7.1+971bf70db for .NET
...
C:\Program Files\dotnet\sdk\7.0.400\Sdks\Microsoft.NET.Sdk.BlazorWebAssembly\targets\Microsoft.NET.Sdk.BlazorWebAssembly.6_0.targets(325,5)
error MSB4018: 
The "GenerateBlazorWebAssemblyBootJson" task failed unexpectedly. [C:\...\Parts.Production.Blazor.csproj]
System.IO.IOException: The process cannot access the file 'C:\..\Parts.Production.Blazor\obj\Release\net7.0\blazor.boot.json' because it is being used by another process. [C:\..\Parts.Production.Blazor.csproj]

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;
            }
        }
    }