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

using global::Microsoft.AspNetCore.Components;
using MP.Data.DatabaseModels;
using MP.Data.Services;

namespace MP_TAB3.Components
{
    public partial class ProdConfirm
    {
        #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<MappaStatoExpl>> E_Updated { get; set; }

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

        #endregion Public Properties

        #region Protected Properties

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

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

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

        /// <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);

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

        protected int lblPz2RecScarto
        {
            get => numPzScarto2Rec;
        }

        [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 numPzScaConf { get; set; } = 0;

        protected int numPzScarto2Rec { get; set; } = 0;

        /// <summary>
        /// Verifica ODL OK (ovvero caricato x macchina...)
        /// </summary>
        protected bool odlOk
        {
            get => (RecMSE != null && RecMSE.IdxOdl > 0);
        }

        [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.StatoProdMacchina(IdxMaccSel, dtReqUpdate);
            // aggiorno visualizzazione...
            numPzProdotti = datiProdAct.PzTotODL;
            numPz2Rec = datiProdAct.Pz2RecTot;
            numPzScaConf = datiProdAct.PzConfScarto;
            numPzBuoniConf = datiProdAct.PzConfBuoni;
            numPzProdotti2Rec = datiProdAct.Pz2RecTot;
            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");
        }

        protected override async Task OnParametersSetAsync()
        {
            lblOut = "";
            if (RecMSE != null && string.IsNullOrEmpty(IdxMaccSel))
            {
                if (!confProdActive)
                {
                    numPzLasciati = 0;
                }
                // verifico SE fosse doppia...
                bool isMulti = false;
                // 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;
                    }
                }
                await DoUpdate();
            }
        }

        protected async Task SalvaConfPz()
        {
            isProcessing = true;
            // effettua conferma con conf da DB del tipo (giorni / turni / periodo
            bool fatto = effettuaConfermaProd();
            await TabDServ.FlushCache("StatoProd");
            // 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}";
            // cambio button conferma...
            confProdActive = false;
            numPzLasciati = 0;
            dtReqUpdate = DateTime.Now;
            // azzero cache pezzi conf
            SDService.MachNumPzSet(IdxMaccSel, -1);
            await DoUpdate();
            await Task.Delay(1);
            await RefreshData();
            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)
            {
                numPzLasc = 0;
            }
            dtReqUpdate = DateTime.Now;
            await DoUpdate();
            StateHasChanged();
        }

        #endregion Protected Methods

        #region Private Fields

        private bool chkPzBuoniNeg = false;
        private bool confRett = false;
        private bool enableMagPrint = false;
        private bool enablePzProdLasciati = false;
        private string lblOut = "";
        private int modoConfProd = 0;

        #endregion Private Fields

        #region Private Properties

        private bool confProdActive { get; set; } = false;
        private MappaStatoExpl? currRecMSE { get; set; } = null;
        private DateTime dtReqUpdate { get; set; } = DateTime.Now;

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

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

        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>
        /// Registra conferma produzione in modalit� 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<MappaStatoExpl> ListMSE = await SDService.MseGetAll(true);
            await MsgServ.SaveMse(ListMSE);
            await E_Updated.InvokeAsync(ListMSE);
        }

        #endregion Private Methods
    }
}