TourIAm/TIAMSharedUI/Pages/Login.razor.cs

using Microsoft.AspNetCore.Components;
using System.IdentityModel.Tokens.Jwt;
using System.Text.Json;
using AyCode.Core.Helpers;
using TIAMWebApp.Shared.Application.Models.ClientSide;
using TIAMWebApp.Shared.Application.Models;
using TIAMWebApp.Shared.Application.Interfaces;
using Microsoft.JSInterop;
using AyCode.Interfaces.StorageHandlers;
using TIAMSharedUI.Resources;
using Microsoft.Extensions.Localization;
using AyCode.Services.Loggers;
using Microsoft.AspNetCore.Components.Authorization;
using TIAM.Core.Consts;
using TIAM.Entities.Users;
using TIAM.Models;
using TIAM.Services;
using TIAMWebApp.Shared.Application.Services;
using TIAMSharedUI.Shared.Components.BaseComponents;

namespace TIAMSharedUI.Pages
{
    public partial class Login : BasePageComponent
    {
        [Inject] private AdminSignalRClient _adminSignalRClient { get; set; }
        [Inject] private SiteViewModel _siteViewModel { get; set; }

        [Inject]
        public NavigationManager navManager { get; set; }
        [Inject]
        public IUserDataService userDataService { get; set; }
        [Inject]
        public IAcLogWriterClientBase BrowserConsoleLogWriter { get; set; }
        [Inject]
        public IJSRuntime jsRuntime { get; set; }
        [Inject]
        public ISecureStorageHandler secureStorageHandler { get; set; }               

        [Inject]
        public AuthenticationStateProvider AuthStateProvider { get; set; }

        //fill loginmodel with fake but valid data

        //LoginModel loginModel = new();

        //[Display(Name = "LoginTitleText", ResourceType = typeof(MyResources))]
        public string TitleText { get; set; } = "dda,mnd,amn,a";
        private int _currentStep = 1;
        bool _loggedIn = false;
        private string messageClass = "";
        private string resultMessage = "";

        private void GoToNextStep()
        {
            _currentStep++;
        }

        private void GoToPreviousStep()
        {
            _currentStep--;
        }

        private async void SubmitLogin()
        {
            _currentStep = 1;
            BrowserConsoleLogWriter.Info("Login started: " + "Email: " + _loginModel.Email + ", Password: " + _loginModel.Password);
            var response = await userDataService.AuthenticateUser(_loginModel);
            //var response = await UserDataservice.TestUserApi(30);
            BrowserConsoleLogWriter.Info("Login started");
            BrowserConsoleLogWriter.Info(response);

            if (!string.IsNullOrEmpty(response))
            {
                //get token and save to local storage
                //parse to Mainresponse from json string


                //var Mainresponse = JsonSerializer.Deserialize<MainResponse>(response);
                var mainResponse = JsonSerializer.Deserialize<MainResponse>(response, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

                if (mainResponse != null)
                {

                    if (!mainResponse.IsSuccess)
                    {
                        //await App.Current.MainPage.DisplayAlert("Error", "Invalid credentials", "Ok");
                        //display error message via jsinterop
                        BrowserConsoleLogWriter.Info("Invalid credentials");
                        messageClass = "text-danger";
                        resultMessage = "Invalid credentials";
                        await InvokeAsync(StateHasChanged);
                        //navManager.NavigateTo("login");
                    }
                    else
                    {
                        string authResponseJson = JsonSerializer.Serialize(mainResponse.Content);

                        var authResponse = JsonSerializer.Deserialize<AuthenticationResponse>(authResponseJson, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

                        string accessToken = authResponse.AccessToken;

                        var token = ProcessToken(accessToken);

                        string userId = token.Claims.First(claim => claim.Type == JwtRegisteredClaimNames.NameId).Value;
                        string email = token.Claims.First(claim => claim.Type == JwtRegisteredClaimNames.Email).Value;

                        var myId = Guid.Parse(userId);
                        //userDataService.User.Email = _email;

                        var userBasicDetails = new UserBasicDetails(userId, email, authResponse.AccessToken, authResponse.RefreshToken);

                        string userBasicDetailsJson = JsonSerializer.Serialize(userBasicDetails);


                        //save to local storage
                        await secureStorageHandler.SaveToSecureStorageAsync(nameof(Setting.UserBasicDetails), userBasicDetailsJson);

                        await AuthStateProvider.GetAuthenticationStateAsync();


                        //await App.Current.MainPage.DisplayAlert("Success", "Successful login", "Ok");
                        //display success message via jsinterop
                        BrowserConsoleLogWriter.Info("Successful login");
                        var user = await userDataService.IsLoggedInAsync(myId);

                        _adminSignalRClient.GetByIdAsync<SiteViewModel>(SignalRTags.GetSiteViewModelByUserId, signalResponseMessage =>
                        {
                            _siteViewModel.Initialize(signalResponseMessage.ResponseData!);
                            BrowserConsoleLogWriter.Debug($"UnreadMessages: {_siteViewModel.UnreadMessages.Count}");

                            return Task.CompletedTask;
                        }, user.UserId).Forget();
                        messageClass = "text-success";
                        resultMessage = "Successful login";
                        SaveToSessionInfo(user).Forget();

                        navManager.NavigateTo("/");
                    }

                }

            }
            else
            {
                //api error
                //await App.Current.MainPage.DisplayAlert("Error", "An error occured while trying to login", "Ok");
                //display error message via jsinterop
                BrowserConsoleLogWriter.Info("An error occured while trying to login");
                navManager.NavigateTo("login");
            }

        }

        protected override void OnInitialized()
        {
                        
            base.OnInitialized();
            if(_sessionService.IsAuthenticated)
            {
                navManager.NavigateTo("index");
            }
            
        }

        public JwtSecurityToken ProcessToken(string accessToken)
        {
            var handler = new JwtSecurityTokenHandler();
            var token = handler.ReadJwtToken(accessToken) as JwtSecurityToken;
            return token;
        }
        /// <summary>
        /// This method stores the user data in the session service so we know during navigation that the user is logged in.
        /// </summary>
        /// <param name="user"></param>
        protected async Task SaveToSessionInfo(UserSessionModel user)
        {
            _sessionService.User = user;
            _sessionService.IsAuthenticated = true;
            _sessionService.HasCompany = user.UserModelDto.UserProductMappings.Count > 0;
            _sessionService.IsDriver = await 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;
                }
            }            
            BrowserConsoleLogWriter.Debug($"Saved to session: IsAuthenticated: {_sessionService.IsAuthenticated}, HasCompany: {_sessionService.HasCompany}, IsDriver: {_sessionService.IsDriver}, IsDevAdmin: {_sessionService.IsDevAdmin}, IsSysAdmin: {_sessionService.IsSysAdmin}");
        }

        public async Task<bool> CheckIfDriver(List<UserProductMapping> Permissions)
        {
            bool _isDriver = false;

            foreach (UserProductMapping Permission in Permissions)
            {
                //var permissionToCheck = await ServiceProviderDataService.GetUserProductMappingByIdAsync(Permission.Id);
                BrowserConsoleLogWriter.Debug($"calling IsPowerOf with values: {Permission.Id}, {Permission.Permissions}, {1}");
                var driverPermissionResult = IsBitSet(Permission.Permissions, 1);
                if (driverPermissionResult)
                {
                    _isDriver = true;
                    _sessionService.DriverPersmissionId = Permission.Id;
                }
            }
            return _isDriver;
        }

        public bool IsBitSet(int number, int power)
        {
            BrowserConsoleLogWriter.Debug($"called IsBitSet with values: {number}, {power}");

            int powerOfTwo = 1 << power; // Calculate 2^power

            BrowserConsoleLogWriter.Debug($"powerOfTwo: {powerOfTwo}, {power}");

            bool result = (number & powerOfTwo) != 0; // Check if the bit at position `power` is set
            return result;
        }
    }
}