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

using global::Microsoft.AspNetCore.Components;
using MP.Data.DbModels;
using MP.Data.Services;
using NLog;

namespace MP_TAB3.Components
{
    public partial class ProdConfirm : IDisposable
    {
        #region Public Properties

        /// <summary>
        /// registrato nuovo valore
        /// </summary>
        [Parameter]
        public EventCallback<bool> E_inserting { get; set; }

        [Parameter]
        public EventCallback<string> E_MachSel { get; set; }

        /// <summary>
        /// registrato nuovo valore
        /// </summary>
        [Parameter]
        public EventCallback<bool> E_reset { get; set; }

        /// <summary>
        /// Post update restituisco nuova lista dati
        /// </summary>
        [Parameter]
        public EventCallback<List<MappaStatoExplModel>> E_Updated { get; set; }

        [Parameter]
        public MappaStatoExplModel? RecMSE
        {
            get => currRecMSE;
            set
            {
                // salvo SOLO SE non sono in conferma
                if (!confProdActive)
                {
                    currRecMSE = value;
                }
            }
        }

        #endregion Public Properties

        #region Public Methods

        public void Dispose()
        {
            datiProdAct = null;
            confTimer.Elapsed -= ConfTimer_Elapsed;
            confTimer.Close();
        }

        #endregion Public Methods

        #region Protected Properties

        protected string ConfBg
        {
            get => confProdActive ? "bg-dark text-success border border-success" : "bg-success text-light";
        }

        protected string ConfCssWidth
        {
            get => enableMagPrint ? "col-6" : "col-12";
        }

        protected string ConfTitle
        {
            get => confProdActive ? "Nascondi conferma" : "Mostra conferma";
        }

        protected string ConfTitleIcon
        {
            get => confProdActive ? "fa-chevron-up" : "fa-chevron-down";
        }

        /// <summary>
        /// Dati produzione rilevati
        /// </summary>
        protected StatoProdModel? datiProdAct { get; set; } = null;

        protected DateTime dtFine { get; set; } = DateTime.Today.AddMonths(-1);
        protected DateTime dtInizio { get; set; } = DateTime.Today.AddMonths(-2);

        /// <summary>
        /// Restituisce il codice IdxMacchina dell'altra tavola (se multi) altrimenti la stessa macchina...
        /// </summary>
        protected string idxMaccAltraTav
        {
            get
            {
                string answ = "";
                try
                {
                    // verifico se SIA una tavola (ha char "#")
                    int iSharp = IdxMaccSel.IndexOf('#');
                    if (iSharp > 0)
                    {
                        // ora verifico SE ALTRA TAVOLA ha ODL...
                        string nomeTav = IdxMaccSel.Substring(iSharp);
                        string altraTav = nomeTav.Substring(0, nomeTav.Length - 1);
                        altraTav += nomeTav.EndsWith("1") ? "2" : "1";
                        // sistemo nome
                        answ = IdxMaccSel.Replace(nomeTav, altraTav);
                    }
                }
                catch
                { }
                return answ;
            }
        }

        protected int lblCicliRilavorati
        {
            get => numPzRilav2Rec;
        }

        protected int lblPz2RecBuoni
        {
            get => numPzConfermati - numPzLasciati;
        }

        protected int lblPz2RecScarto
        {
            get => numPzScarto2Rec - numPzRilav2Rec;
        }

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

        protected int numPz2Rec { get; set; } = 0;
        protected int numPzBuoniConf { get; set; } = 0;

        /// <summary>
        /// Numero pezzi confermati (buoni - scarto)
        /// </summary>
        protected int numPzConfermati
        {
            get
            {
                return numPzProdotti2Rec - numPzScarto2Rec;
            }
        }

        protected int numPzLasciati
        {
            get => numPzLasc;
            set
            {
                if (value <= numPzConfermati)
                {
                    numPzLasc = value;
                }
            }
        }

        protected int numPzProdotti { get; set; } = 0;
        protected int numPzProdotti2Rec { get; set; } = 0;
        protected int numPzRilav2Rec { get; set; } = 0;
        protected int numPzRilavConf { get; set; } = 0;
        protected int numPzScaConf { get; set; } = 0;
        protected int numPzScarto2Rec { get; set; } = 0;

        /// <summary>
        /// Verifica ODL OK (ovvero caricato x macchina...)
        /// </summary>
        protected bool odlOk
        {
            get
            {
                bool answ = false;
                if (RecMSE != null)
                {
                    answ = (RecMSE.IdxOdl > 0);
                    if (isMulti && (RecMSE != null && IdxMaccSel != RecMSE?.IdxMacchina))
                    {
                        int idxOdlSel = 0;
                        try
                        {
                            var pUpd = Task.Run(async () =>
                            {
                                var tabOdlSel = await TabDServ.OdlCurrByMacc(IdxMaccSel, true);
                                idxOdlSel = tabOdlSel.IdxOdl;
                            });
                            pUpd.Wait();
                            answ = idxOdlSel > 0;
                        }
                        catch (Exception exc)
                        {
                            Log.Error($"Errore Durante recupero idxOdlSel {Environment.NewLine}{exc}");
                        }
                    }
                    else
                    {
                        answ = (RecMSE != null && RecMSE.IdxOdl > 0);
                    }
                }
                return answ;
            }
        }

        [Inject]
        protected StatusData SDService { get; set; } = null!;

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

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

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Aggiorno valori produzione alla data richiesta...
        /// </summary>
        /// <param name="newDate"></param>
        protected async Task DoUpdate()
        {
            isProcessing = true;
            await Task.Delay(1);
            datiProdAct = await TabDServ.StatoProdMacchinaAsync(IdxMaccSel, dtReqUpdate);
            // aggiorno visualizzazione...
            numPzProdotti = datiProdAct.PzTotODL;
            numPz2Rec = datiProdAct.Pz2RecTot;
            numPzBuoniConf = datiProdAct.PzConfBuoni;
            numPzRilavConf = datiProdAct.PzConfRilav;
            numPzScaConf = datiProdAct.PzConfScarto - datiProdAct.PzConfRilav;
            numPzProdotti2Rec = datiProdAct.Pz2RecTot;
            numPzRilav2Rec = datiProdAct.Pz2RecRilav;
            numPzScarto2Rec = datiProdAct.Pz2RecScarto;
            dtInizio = RecMSE?.DataInizioOdl ?? DateTime.Today.AddMonths(-2);
            dtFine = dtReqUpdate;
            isProcessing = false;
            await Task.Delay(1);
        }

        protected override void OnInitialized()
        {
            enablePzProdLasciati = SMServ.GetConfBool("enablePzProdLasciati");
            chkPzBuoniNeg = SMServ.GetConfBool("TAB_ChkConfPz");
            confRett = SMServ.GetConfBool("confRett");
            enableMagPrint = SMServ.GetConfBool("enableMagPrint");
            modoConfProd = SMServ.GetConfInt("modoConfProd");
            tOutConfProd = SMServ.GetConfInt("TAB_TimeOutConfProd");
            // petto periodo a 100ms x controllare scadenze
            confTimer = new System.Timers.Timer(100);
            //confTimer = new System.Timers.Timer(tOutConfProd);
            confTimer.Elapsed += ConfTimer_Elapsed;
        }

        protected override async Task OnParametersSetAsync()
        {
            lblOut = "";
            if (RecMSE != null && (string.IsNullOrEmpty(IdxMaccSel) || !RecMSE.MostlyEquals(lastRecMSE)))
            {
                await TabDServ.FlushCache("StatoProd");
                if (!confProdActive)
                {
                    numPzLasciati = 0;
                }
                if (!confDone)
                {
                    // verifico se la macchina sia configurata tra le MSFD...
                    if (SMServ.DictMacchMulti.ContainsKey(RecMSE.IdxMacchina))
                    {
                        isMulti = SMServ.DictMacchMulti[RecMSE.IdxMacchina] == 1;
                    }
                    IdxMaccSel = RecMSE.IdxMacchina;
                    if (isMulti)
                    {
                        var idxMSel = MsgServ.UserPrefGet(IdxMaccSel);
                        if (!string.IsNullOrEmpty(idxMSel))
                        {
                            IdxMaccSel = idxMSel;
                        }
                    }
                }
                // salvo lastRec...
                lastRecMSE = RecMSE;
                dtReqUpdate = DateTime.Now.AddMilliseconds(100);
                await DoUpdate();
            }
        }

        protected async Task SalvaConfPz()
        {
            isProcessing = true;
            await Task.Delay(10);
            // effettua conferma con conf da DB del tipo (giorni / turni / periodo
            bool fatto = effettuaConfermaProd();
            await TabDServ.FlushCache("StatoProd");
            await TabDServ.FlushCache("ODL");
            await TabDServ.FlushCache("ElConfProd");
            // refresh tabella dati tablet...
            await TabDServ.RicalcMse(IdxMaccSel, 0);
            // rileggo e salvo..
            var ListMSE = await SDService.MseGetAll(true);
            if (ListMSE != null)
            {
                // salvo in LocalStorage...
                await MsgServ.SaveMse(ListMSE);
                // aggiorno MSE attuale
                RecMSE = ListMSE.Find(x => x.IdxMacchina == IdxMaccSel);
            }
            // mostro output
            lblOut = $"Confermata produzione {numPzConfermati - numPzLasciati} pezzi (+{numPzLasciati} pz lasciati, +{numPzScarto2Rec} pz scarto) |{dtReqUpdate:HH:mm:ss} | {dtReqUpdate:ddd yyyy.MM.dd}";
            // salvo ultimi valori conferma...
            lastPzBuoni = numPzConfermati - numPzLasciati;
            lastPzRilav = numPzRilav2Rec;
            lastPzScarto = numPzScarto2Rec;
            lastConfProd = DateTime.Now;
            // cambio button conferma...
            confProdActive = false;
            numPzLasciati = 0;
            dtReqUpdate = DateTime.Now;
            // azzero cache pezzi conf
            SDService.MachNumPzSet(IdxMaccSel, -1);
            await DoUpdate();
            await RefreshData();
            // imposto visualizzazione conferma effettuata
            showConfirmResult = true;
            // imposto timeout display + avvio timer x nascondere...
            scadConfPezzi = dtReqUpdate.AddMilliseconds(tOutConfProd);
            confTimer.Start();
            TabDServ.NotifyDataInvalidated(IdxMaccSel);
            isProcessing = false;
        }

        protected void setConfirmBtn(bool newVal)
        {
            showConfirm = newVal;
        }

        protected async Task SetMacc(string selIdxMacc)
        {
            isProcessing = true;
            await Task.Delay(1);
            IdxMaccSel = selIdxMacc;
            await DoUpdate();
            isProcessing = false;
            await Task.Delay(1);
            await E_MachSel.InvokeAsync(selIdxMacc);
        }

        /// <summary>
        /// Cambio stato visibilit� pannello e testo button
        /// </summary>
        protected async Task ToggleConfProd()
        {
            confProdActive = !confProdActive;
            if (confProdActive)
            {
                // svuoto cache conf prod sicurezza
                await TabDServ.FlushCache("StatoProd");
                numPzLasc = 0;
            }
            dtReqUpdate = DateTime.Now;
            await DoUpdate();
        }

        #endregion Protected Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();

        private bool chkPzBuoniNeg = false;

        private bool confDone = false;

        private bool confRett = false;

        /// <summary>
        /// Timer 3 sec x mostrare conferma
        /// </summary>
        private System.Timers.Timer confTimer = new System.Timers.Timer(3000);

        private bool enableMagPrint = false;

        private bool enablePzProdLasciati = false;

        private bool isMulti = false;

        private bool isSlave = false;

        private DateTime lastConfProd = DateTime.Now;

        private int lastPzBuoni = 0;

        private int lastPzRilav = 0;

        private int lastPzScarto = 0;

        private string lblOut = "";

        private int modoConfProd = 0;

        private DateTime scadConfPezzi = DateTime.Today;
        private bool showConfirmResult = false;
        private int tOutConfProd = 2000;

        #endregion Private Fields

        #region Private Properties

        private bool confProdActive { get; set; } = false;

        private MappaStatoExplModel? currRecMSE { get; set; } = null;

        private DateTime dtReqUpdate { get; set; } = DateTime.Now;

        private string IdxMaccSel { get; set; } = "";

        private bool isProcessing { get; set; } = false;

        private MappaStatoExplModel? lastRecMSE { get; set; } = null;

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

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

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

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Timer visualizzazione esito conferma pezzi: deve nascondere...
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ConfTimer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
        {
            DateTime adesso = DateTime.Now;
            // controllo se sia ascaduto il periodo di display
            if (adesso > scadConfPezzi)
            {
                confTimer.Stop();
                showConfirmResult = false;
                // resetto
                lastPzBuoni = 0;
                lastPzRilav = 0;
                lastPzScarto = 0;
            }
        }

        /// <summary>
        /// Registra conferma produzione in modalita nuova (con rettifica pezzi lasciati) o legacy
        /// (con anticipo periodo)
        /// </summary>
        private bool effettuaConfermaProd()
        {
            bool fatto = false;
            if (confRett)
            {
                // confermo al netto dei pezzi lasciati...
                fatto = TabDServ.ConfermaProdMacchinaFull(IdxMaccSel, modoConfProd, numPzConfermati - numPzLasciati, numPzLasciati, numPzScarto2Rec, dtReqUpdate, MatrOpr);
            }
            else
            {
                fatto = TabDServ.ConfermaProdMacchina(IdxMaccSel, modoConfProd, numPzConfermati, numPzScarto2Rec, dtReqUpdate, MatrOpr);
            }
            return fatto;
        }

        private async Task RefreshData()
        {
            List<MappaStatoExplModel> ListMSE = await SDService.MseGetAll(true);
            await MsgServ.SaveMse(ListMSE);
            await E_Updated.InvokeAsync(ListMSE);
        }

        #endregion Private Methods
    }
}