TourIAm/TIAMSharedUI/Pages/AppLaunchComponent.razor

@* @page "/"; *@
@using Microsoft.AspNetCore.Components.Authorization
@using TIAM.Core.Consts
@using TIAM.Entities.Users
@using TIAMWebApp.Shared.Application.Interfaces
@using TIAMWebApp.Shared.Application.Models
@using TIAMWebApp.Shared.Application.Utility
@using Newtonsoft.Json
@using System.IdentityModel.Tokens.Jwt
@using TIAMWebApp.Shared.Application.Models.ClientSide
@using AyCode.Interfaces.StorageHandlers;
@using System.Globalization;
@using AyCode.Core.Enums
@using AyCode.Core.Loggers
@using AyCode.Services.Loggers
@using TIAM.Core.Loggers
@inject NavigationManager NavManager
@inject IJSRuntime JSRuntime
@inject IEnumerable<IAcLogWriterClientBase> LogWriters
@inject IUserDataService UserDataService
@inject ISecureStorageHandler SecureStorageHandler
@inject ISessionService sessionService;
@inject HttpClient http;
@inject IComponentUpdateService ComponentUpdateService
@inject AuthenticationStateProvider AuthStateProvider

@{
    if (string.IsNullOrWhiteSpace(TrackingId))
    {
        TrackingId = "";
        // <p>Loading...</p>
    }
    else
    {
        <p>Loading with trackingId: @TrackingId</p>
    }
}


@code {

    [Parameter]
    public string TrackingId { get; set; }

    string userDetailsStr;
    string locale;
    ILogger _logger;

    protected override async Task OnInitializedAsync()
    {
        _logger = new LoggerClient<AppLaunchComponent>(LogWriters.ToArray());

        var (_userDetailStr, _locale) = await GetLocalSettings();

        userDetailsStr = _userDetailStr;

        if(_locale != null)
        {            
            locale = _locale;
            Culture = new CultureInfo(locale);
            _logger.Info("Locale from settings: " + locale);
        }
        else
        {
            _logger.Info("Default locale:" + Culture.Name);
        }

        //_logger = new _logger(JSRuntime);
        //wait for 5 seconds
        //await Task.Delay(1000);                      

        if (!string.IsNullOrWhiteSpace(userDetailsStr))
        {
            _logger.Info(userDetailsStr);
            var userBasicDetail = JsonConvert.DeserializeObject<UserBasicDetails>(userDetailsStr);

            var handler = new JwtSecurityTokenHandler();
            var jsontoken = handler.ReadToken(userBasicDetail?.AccessToken) as JwtSecurityToken;

            if(userBasicDetail!= null)
                Setting.UserBasicDetails = userBasicDetail;

            if (jsontoken?.ValidTo < DateTime.UtcNow)
            {
                _logger.Info("Token needs to be refreshed");
                bool isTokenRefreshed = await UserDataService.RefreshToken();

                if (isTokenRefreshed)
                {
                    await AuthStateProvider.GetAuthenticationStateAsync();
                    _logger.Info("Token refreshed");

                }
                else
                {
                    _logger.Info("Couldn't refresh token");
                    SignOut();
                    //NavManager.NavigateTo("/");
                    return;
                }

            }
            else
            {
                _logger.Info("Valid token found");
                await AuthStateProvider.GetAuthenticationStateAsync();
            }

            string _userId = jsontoken.Claims.First(claim => claim.Type == JwtRegisteredClaimNames.NameId).Value;
            string _email = jsontoken.Claims.First(claim => claim.Type == JwtRegisteredClaimNames.Email).Value;
            var user = await UserDataService.IsLoggedInAsync(Guid.Parse(_userId));
            SaveToSessionInfo(user);            
            _logger.Info($"Saved user in db is: {user.DisplayName}, setting autenthicated state");
            
            //NavManager.NavigateTo("/");
        }
        else
        {
            _logger.Info("No token stored yet");
            //NavManager.NavigateTo("/");
        }
        ComponentUpdateService.CallRequestRefresh();

    }

    protected void SaveToSessionInfo(UserSessionModel user)
    {
        sessionService.User = user;
        sessionService.IsAuthenticated = true;
        sessionService.HasCompany = user.UserModelDto.UserProductMappings.Count > 0;
        sessionService.IsDriver = CheckIfDriver(user.UserModelDto.UserProductMappings);
        if (user.UserModelDto.Id == TiamConstClient.DevAdminIds[0] || user.UserModelDto.Id == TiamConstClient.DevAdminIds[1])
        {
            sessionService.IsDevAdmin = true;
        }
        foreach (var guid in TiamConstClient.SysAdmins)
        {
            if (user.UserModelDto.Id == guid)
            {
                sessionService.IsSysAdmin = true;
            }
        }
        _logger.Debug($"Saved to session: IsAuthenticated: {sessionService.IsAuthenticated}, HasCompany: {sessionService.HasCompany}, IsDriver: {sessionService.IsDriver}, IsDevAdmin: {sessionService.IsDevAdmin}, IsSysAdmin: {sessionService.IsSysAdmin}");
    }

    public bool CheckIfDriver(List<UserProductMapping> Permissions)
    {
        bool _isDriver = false;
        foreach (UserProductMapping Permission in Permissions)
        {
            if (IsPowerOfTwoInSum(2, Permission.Permissions))
            {
                _isDriver = true;
                sessionService.DriverPersmissionId = Permission.Id;
            }
        }
        return _isDriver;
    }

    public static bool IsPowerOfTwoInSum(int number, int power)
    {
        int powerOfTwo = 1 << power; // Calculate 2^power
        return (number & powerOfTwo) != 0; // Check if the bit at position `power` is set
    }

    public async Task<(string, string)> GetLocalSettings()
    {
        string userDetailsStr = await SecureStorageHandler.GetFromSecureStorageAsync(nameof(Setting.UserBasicDetails));
        string locale = await SecureStorageHandler.GetFromSecureStorageAsync(nameof(Setting.Locale));
        return (userDetailsStr, locale);
    }

    private void SignOut()
    {
        var userBasicDetail = JsonConvert.DeserializeObject<UserBasicDetails>(userDetailsStr);

        UserDataService.Logout(userBasicDetail.RefreshToken);
        AuthStateProvider.GetAuthenticationStateAsync();
        SecureStorageHandler.ClearAllSecureStorageAsync();
        sessionService.User = null;
        sessionService.IsAuthenticated = false;
    }

    CultureInfo Culture
    {
        get => CultureInfo.CurrentCulture;
        set
        {
            if (CultureInfo.CurrentCulture != value)
            {
                Thread.CurrentThread.CurrentCulture = value;
                Thread.CurrentThread.CurrentUICulture = value;
                CultureInfo.DefaultThreadCurrentCulture = value;
                CultureInfo.DefaultThreadCurrentUICulture = value;                
            }
        }
    }


}