egwcapp/EgwControlCenter.App/Components/Compo/ApplicationCheck.razor.cs

using EgwControlCenter.Core;
using EgwControlCenter.Core.DTO;
using Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;
using System.Diagnostics;

namespace EgwControlCenter.App.Components.Compo
{
    public partial class ApplicationCheck : IDisposable
    {
        #region Public Properties

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

        #endregion Public Properties

        #region Public Methods

        private string ComputerName
        {
            get => Environment.MachineName;
        }
        private string UserName
        {
            get => Environment.UserName;
        }
        private string DomainName
        {
            get => Environment.UserDomainName;
        }

        public void Dispose()
        {
            ACService.EA_StatusUpdated -= ACService_EA_StatusUpdated;
            ACService.EA_RemoteCalling -= ACService_EA_RemoteCalling;
        }

        #endregion Public Methods

        #region Protected Properties

        [Inject]
        protected AppControlService ACService { get; set; } = null!;

        [Inject]
        protected IJSRuntime JSRuntime { get; set; } = null!;

        protected bool RemoteCallActive { get; set; } = false;

        protected bool ShowOnlyUpdate
        {
            get => showOnlyUpdate;
            set
            {
                showOnlyUpdate = value;
                currPage = 1;
                ForceReload();
            }
        }

        protected string UpdateCss
        {
            get => isUpdating ? "btn-outline-success disabled" : "btn-success";
        }

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Esegue step x update app
        /// </summary>
        /// <param name="ReqApp"></param>
        protected async void DoUpdate(VersStatusDTO ReqApp)
        {
            if (!await JSRuntime.InvokeAsync<bool>("confirm", $"{ReqApp.CodApp} | Sicuro di voler procedere con l'aggiornamento? Verrà eseguito un backup della configurazione e dell'applicativo prima di installare il nuovo, ma l'eventuale ripristino dovrà essere condotto manualmente."))
                return;

            isUpdating = true;
            await InvokeAsync(StateHasChanged);
            await Task.Delay(50);
            // verifico il TIPO di oggetto gestito x la procedura di update...
            switch (ReqApp.ApplicationType)
            {
                case CoreEnum.AppType.None:
                    break;

                case CoreEnum.AppType.Cli:
                    break;

                case CoreEnum.AppType.EgwACC:
                    // sollevo richiesta riavvio!
                    ACService.RaiseRestartReq();
                    break;

                case CoreEnum.AppType.Machine:
                    break;

                case CoreEnum.AppType.WebApp:
                    break;

                case CoreEnum.AppType.WinApp:
                    await ExecWinAppUpdate(ReqApp);
                    break;

                default:
                    break;
            }
            isUpdating = false;
            await InvokeAsync(StateHasChanged);
            // check finale
            await ACService.DoFullCheckAsync(true);
            await ACService.DoTaskCheckAsync(true);
            ForceReload();
            await InvokeAsync(StateHasChanged);
        }

        /// <summary>
        /// Esecuzione step update x WinApp (tipicamente IOB-WIN-*)
        /// </summary>
        /// <param name="ReqApp"></param>
        /// <returns></returns>
        private async Task ExecWinAppUpdate(VersStatusDTO ReqApp)
        {
            // esegue update delle app Iob-*
            Stopwatch sw = new Stopwatch();
            sw.Start();
            UpdateMsg = "Backup Config";
            currVal = 0;
            nextVal = 60;
            await InvokeAsync(StateHasChanged);
            await ACService.IobWinUpdateStep(ReqApp, 1);
            currStats.RecordExeData("Step01_Backup", sw.Elapsed);
            sw.Restart();

            UpdateMsg = "Download update";
            currVal = 60;
            nextVal = 90;
            await InvokeAsync(StateHasChanged);
            await ACService.IobWinUpdateStep(ReqApp, 2);
            currStats.RecordExeData("Step02_Download", sw.Elapsed);
            sw.Restart();

            UpdateMsg = "Unzip software";
            currVal = 90;
            nextVal = 96;
            await InvokeAsync(StateHasChanged);
            await ACService.IobWinUpdateStep(ReqApp, 3);
            currStats.RecordExeData("Step03_UnZip", sw.Elapsed);
            sw.Restart();

            UpdateMsg = "Config Restore";
            currVal = 96;
            nextVal = 100;
            await InvokeAsync(StateHasChanged);
            await ACService.IobWinUpdateStep(ReqApp, 4);
            currStats.RecordExeData("Step04_Restore", sw.Elapsed);
            currStats.SaveToDisk();
            UpdateMsg = "Completed!";
            currVal = 100;
            ACService.ReportStatusUpd();
            await InvokeAsync(StateHasChanged);
        }

        protected async Task ForceCheck()
        {
            isLoading = true;
            ListRecords = new List<VersStatusDTO>();
            await ACService.DoFullCheckAsync(true);
            await ACService.DoTaskCheckAsync(true);
            isLoading = false;
        }

        protected override void OnInitialized()
        {
            ACService.EA_StatusUpdated += ACService_EA_StatusUpdated;
            ACService.EA_RemoteCalling += ACService_EA_RemoteCalling;
            currStats = new TaskRunStats(ACService.DataDir, "Stats.json");
        }

      

        protected override void OnParametersSet()
        {
            ForceReload();
        }

        protected void SetNumRec(int newNum)
        {
            numRecord = newNum;
            currPage = 1;
            ForceReload();
        }

        protected void SetPage(int newNum)
        {
            currPage = newNum;
            ForceReload();
        }

        protected async void ToggleSetup()
        {
            await EC_GotoSetup.InvokeAsync(true);
        }

        #endregion Protected Methods

        #region Private Fields

        private int currVal = 100;

        private int expTotalTimeMSec = 12000;

        private int maxVal = 100;

        private int nextVal = 100;

        private string UpdateMsg = "Updating...";

        #endregion Private Fields

        #region Private Properties

        private int currPage { get; set; } = 1;

        private List<VersStatusDTO> CurrRecords
        {
            get => ACService.ListAppStatus;
        }

        /// <summary>
        /// Oggetto gestione statistiche
        /// </summary>
        private TaskRunStats currStats { get; set; } = new TaskRunStats();

        private int expTimeMSec
        {
            get => expTotalTimeMSec * (nextVal - currVal) / 100;
        }

        private bool isLoading { get; set; } = false;
        private bool isUpdating { get; set; } = false;

        private List<VersStatusDTO>? ListRecords { get; set; } = null;

        private int numRecord { get; set; } = 5;

        private List<VersStatusDTO>? SearchRecords { get; set; } = null;

        private bool showOnlyUpdate { get; set; } = true;

        private int totalCount { get; set; } = 0;

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Gestione evento chiamata verso server
        /// </summary>
        private async void ACService_EA_RemoteCalling()
        {
            RemoteCallActive = ACService.CloudCallActive;
            await InvokeAsync(StateHasChanged);
        }

        private void ACService_EA_StatusUpdated()
        {
            ForceReload();
        }

        private void ForceReload()
        {
            isLoading = true;
            SearchRecords = CurrRecords
                            .Where(x => x.HasUpdate || !ShowOnlyUpdate)
                            .ToList();
            totalCount = SearchRecords.Count;
            ListRecords = SearchRecords
                            .Skip(numRecord * (currPage - 1))
                            .Take(numRecord)
                            .ToList();
            isLoading = false;
        }

        #endregion Private Methods
    }
}