mapo-core/MP-TAB3/Components/CmpTop.razor.cs

using Microsoft.AspNetCore.Components;
using MP.Data.DbModels;
using MP.Data.DTO;
using MP.Data.Services;
using MP_TAB3.Pages;
using Newtonsoft.Json;
using NLog;
using System.Diagnostics;

namespace MP_TAB3.Components
{
    public partial class CmpTop
    {
        #region Public Properties

        [Parameter]
        public List<LinkMenuModel> CurrMenuItems { get; set; } = new List<LinkMenuModel>();

        [Parameter]
        public EventCallback<bool> EA_ReloadMStor { get; set; }

        [Parameter]
        public EventCallback<bool> EA_UserIsOk { get; set; }

        [Parameter]
        public int TypeScadLogin { get; set; } = -1;

        #endregion Public Properties

        #region Protected Fields

        protected string ResetClass = "btn-primary";

        #endregion Protected Fields

        #region Protected Properties

        protected string CurrMacc { get; set; } = null!;
        protected string CurrOprTknLS { get; set; } = null!;

        protected string CurrOprTknRedis { get; set; } = null!;

        protected bool HideMenu
        {
            get => NavMan.Uri.Contains("reg-new-device");
        }

        protected string LastOpenedPage { get; set; } = null!;

        [Inject]
        protected ListSelectDataSrv MDataService { get; set; } = null!;

        [Inject]
        protected MessageService MsgServ { get; set; } = null!;

        [Inject]
        protected SharedMemService MStor { get; set; } = null!;

        [Inject]
        protected NavigationManager NavMan { get; set; } = null!;

        [Inject]
        protected SharedMemService SMServ { get; set; } = null!;

        [Inject]
        protected TabDataService TDService { get; set; } = null!;

        #endregion Protected Properties

        #region Protected Methods

        protected async Task backToSM()
        {
            if (!NavMan.Uri.Contains("reg-new-device"))
            {
                await MsgServ.IdxMaccSet("");
                NavMan.NavigateTo("status-map", false);
            }
        }

        private bool IsReloading = false;

        private string CssReload
        {
            get => IsReloading ? "bg-primary bg-gradient" : "";
        }

        protected async Task ForceReload()
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            Log.Info("Start ForceReload");
            IsReloading = true;
            ResetClass = "btn-warning";
            MsgServ.IsReloading = true;
            await InvokeAsync(StateHasChanged);
            var currToken = await MsgServ.GetCurrOperDtoLSAsync();
            var lastOpr = await MsgServ.GetLastMatrOprAsync();
            var devGuid = await MsgServ.GetCurrDevGuidLSAsync();
            // reset cache varie
            await MsgServ.ClearLocalStor();
            await MsgServ.ClearSessionStor();
            await MDataService.FlushCache();
            await TDService.FlushCache();
            // salvo di nuovo opr + GUID
            await MsgServ.SetCurrDevGuidLSAsync(devGuid);
            await MsgServ.SetLastMatrOprAsync(lastOpr);
            await MsgServ.SetCurrOperDtoLSAsync(currToken);
            // richiesta reload MStor
            await EA_ReloadMStor.InvokeAsync(true);
            // calcolo tempo esecuzione
            sw.Stop();
            int delta = 150 - (int)sw.ElapsedMilliseconds;
            delta = delta > 0 ? delta : 10;
            await Task.Delay(delta);
            ResetClass = "btn-primary";
            MsgServ.IsReloading = false;
            IsReloading = false;
            Log.Info($"ForceReload completed in {sw.Elapsed.TotalMilliseconds}ms");
            // ricarica pagina!
            NavMan.NavigateTo("status-map", true);
        }

        protected override async Task OnInitializedAsync()
        {
            await Task.Delay(1);
            var CurrDevGuid = await MsgServ.GetCurrDevGuidLSAsync();

            if (CurrDevGuid == Guid.Empty)
            {
                CurrDevGuid = Guid.NewGuid();
                await MsgServ.SetCurrDevGuidLSAsync(CurrDevGuid);
            }

            LastOpenedPage = await MsgServ.LastOpenedPageGet();
            CurrMacc = await MsgServ.IdxMaccGet();

            CurrOprTknLS = await MsgServ.GetCurrOperDtoLSAsync();
            var currOprTokLsDeco = Uri.UnescapeDataString(CurrOprTknLS);
            if (!string.IsNullOrEmpty(CurrOprTknLS))
            {
                var decryptedData = MsgServ.DecryptData(CurrOprTknLS);
                if (!string.IsNullOrEmpty(decryptedData))
                {
                    var oprObj = JsonConvert.DeserializeObject<userTknDTO>(decryptedData);
                    if (oprObj != null)
                    {
                        MsgServ.RigaOper = oprObj.currOpr;
                    }
                }
            }

            CurrOprTknRedis = await TDService.OperatoreGetRedis(MatrOpr, CurrDevGuid);

            if (string.IsNullOrEmpty(CurrOprTknRedis))
            {
                if (!NavMan.Uri.Contains("reg-new-device"))
                {
                    NavMan.NavigateTo("reg-new-device", true);
                }
            }
            else if (!string.IsNullOrEmpty(CurrOprTknRedis) && CurrOprTknRedis == CurrOprTknLS)
            {
                await RefreshScadLogIn(currOprTokLsDeco);
                await EA_UserIsOk.InvokeAsync(true);
            }
        }

        protected async Task RefreshScadLogIn(string decodValue)
        {
            bool done = false;
            // solo se non � logout!!!
            if (!NavMan.Uri.Contains("logout"))
            {
                if (listT2H == null || listT2H.Count == 0)
                {
                    listT2H = CurrMenuItems.Where(x => x.TipoLink == "T2H").ToList();
                }
                if (TypeScadLogin <= 0 || TypeScadLogin == 2)
                {
                    done = await MsgServ.DoLogIn(decodValue, false);
                }
                else
                {
                    done = await MsgServ.DoLogIn(decodValue, true);
                }
                if (done && !string.IsNullOrEmpty(LastOpenedPage))
                {
                    // se � nelle pagine "T2H" lascio proseguire...
                    if (listT2H != null && listT2H.Find(x => x.NavigateUrl == LastOpenedPage) != null)
                    {
                        NavMan.NavigateTo(LastOpenedPage);
                    }
                    else if (!string.IsNullOrEmpty(CurrMacc))
                    {
                        var machMse = await MsgServ.GetMachineMse(CurrMacc);
                        if (machMse == null)
                        {
                            await MsgServ.IdxMaccSet("");
                            NavMan.NavigateTo("status-map");
                        }
                        else
                        {
                            NavMan.NavigateTo(LastOpenedPage);
                        }
                    }
                    else
                    {
                        NavMan.NavigateTo("status-map");
                    }
                }
            }
        }

        #endregion Protected Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();
        private List<LinkMenuModel> listT2H = new List<LinkMenuModel>();

        #endregion Private Fields

        #region Private Properties

        private int MatrOpr
        {
            get => MsgServ.MatrOpr;
        }

        private string UserName
        {
            get => MsgServ.CognomeNome;
        }

        #endregion Private Properties
    }
}