mapo-core/MP-TAB-SERV/Components/ProdConfirm.razor.cs

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

namespace MP_TAB_SERV.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; }

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

        [Parameter]
        public MappaStatoExpl? RecMSE { get; set; } = null;

        #endregion Public Properties

        #region Protected Properties

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

        protected string ConfTitle
        {
            get => showInnov ? "Nascondi conferma" : "Mostra conferma";
        }
        protected string ConfCssWidth
        {
            get => enableMagPrint ? "col-6" : "col-12";
        }

        /// <summary>
        /// Dati produzioen 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 lblPzBuo2Rec { get; set; } = 0;
        protected int lblPz2RecScarto
        {
            get => numPzScarto2Rec;
        }

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

        [Inject]
        protected MessageService MServ { 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;

        [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 async Task OnInitializedAsync()
        {
            lblOut = "";
            numPzLasciati = 0;
            if (RecMSE != null)
            {
                IdxMaccSel = RecMSE.IdxMacchina;
                enablePzProdLasciati = SMServ.GetConfBool("enablePzProdLasciati");
                chkPzBuoniNeg = SMServ.GetConfBool("TAB_ChkConfPz");
                confRett = SMServ.GetConfBool("confRett");
                enableMagPrint = SMServ.GetConfBool("enableMagPrint");
                modoConfProd = SMServ.GetConfInt("modoConfProd");
                await DoUpdate();
            }
        }

        protected async Task SalvaConfPz()
        {
            isProcessing = true;
            await Task.Delay(1);
            // effettua conferma con conf da DB del tipo (giorni / turni / periodo
            bool fatto = effettuaConfermaProd();
            // refresh tabella dati tablet...
            await TabDServ.RicalcMse(IdxMaccSel, 0);
            // rileggo e salvo..
            var ListMSE = await MDataService.MseGetAll(true);
            if (ListMSE != null)
            {
                // salvo in LocalStorage...
                await MServ.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...
            showInnov = false;
            // sollevo evento!
            //dtReqUpdate = DateTime.Now;
            numPzLasciati = 0;
            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()
        {
            showInnov = !showInnov;
            dtReqUpdate = DateTime.Now;
            await DoUpdate();
            StateHasChanged();
        }

        #endregion Protected Methods

        #region Private Fields

        private bool confRett = false;

        private bool enablePzProdLasciati = false;
        private bool enableMagPrint = false;
        private bool chkPzBuoniNeg = false;

        private string lblOut = "";

        private int modoConfProd = 0;

        #endregion Private Fields

        #region Private Properties

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

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

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

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

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

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

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

        #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 MDataService.MseGetAll(true);
            await MServ.SaveMse(ListMSE);
            await E_Updated.InvokeAsync(ListMSE);
        }

        #endregion Private Methods

#if false

        /// <summary>
        /// restituisce css disabled SE odl NON OK...
        /// </summary>
        public string cssBtnConf
        {
            get
            {
                return odlOk ? "" : "disabled";
            }
        }

        /// <summary>
        /// Data-Ora ultimo update valori produzione
        /// </summary>
        public DateTime dtReqUpdate
        {
            get
            {
                DateTime answ = DateTime.Now;
                DateTime.TryParse(hfDtReqUpdate.Value, out answ);
                return answ;
            }
            set
            {
                hfDtReqUpdate.Value = $"{value}";
            }
        }

        protected DateTime dtFine
        {
            set
            {
                lblFine.Text = value.ToString();
            }
        }

        /// <summary>
        /// Numero pezzi PRODOTTI da ultima conferma
        /// </summary>
        protected DateTime dtInizio
        {
            set
            {
                lblInizio.Text = value.ToString();
            }
        }

        /// <summary>
        /// Numero pezzi PRODOTTI da ultima conferma
        /// </summary>
        protected int numPz2Rec
        {
            set
            {
                lblPz2RecTot.Text = value.ToString();
            }
        }

        /// <summary>
        /// Numero pezzi BUONI già confermati
        /// </summary>
        protected int numPzBuoniConf
        {
            set
            {
                lblPzConfBuoni.Text = value.ToString();
            }
        }

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

        /// <summary>
        /// Numero pezzi da LASCIARE non dichiarati
        /// </summary>
        protected int numPzLasciati
        {
            set
            {
                txtNumLasciati.Text = value.ToString();
            }
            get
            {
                int answ = 0;
                try
                {
                    answ = Convert.ToInt32(txtNumLasciati.Text);
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// Numero pezzi PRODOTTI GLOBALI
        /// </summary>
        protected int numPzProdotti
        {
            set
            {
                lblPzTotODL.Text = value.ToString();
            }
        }

        /// <summary>
        /// Numero pezzi PRODOTTI da registrare
        /// </summary>
        /// da ultima conferma
        protected int numPzProdotti2Rec
        {
            set
            {
                txtNumPezzi.Text = value.ToString();
            }
            get
            {
                int answ = 0;
                try
                {
                    answ = Convert.ToInt32(txtNumPezzi.Text);
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// Numero pezzi SCARTO già confermati
        /// </summary>
        protected int numPzScaConf
        {
            set
            {
                lblPzConfScarto.Text = value.ToString();
            }
        }

        /// <summary>
        /// Numero pezzi SCARTATI da registrare
        /// </summary>
        protected int numPzScarto2Rec
        {
            set
            {
                lblPz2RecScarto.Text = value.ToString();
                memLayer.ML.setSessionVal("lblPz2RecScarto", value);
            }
            get
            {
                int answ = 0;
                try
                {
                    answ = memLayer.ML.IntSessionObj("lblPz2RecScarto");
                }
                catch
                { }
                return answ;
            }
        }

        protected void ddlSubMacc_DataBound(object sender, EventArgs e)
        {
            // se ho in memoria un valore LO REIMPOSTO...
            if (!string.IsNullOrEmpty(subMaccSel))
            {
                // se è una SUB machcina (contiene "#")
                if (subMaccSel.Contains("#"))
                {
                    // provo a preselezionare...
                    try
                    {
                        ddlSubMacc.SelectedValue = subMaccSel;
                    }
                    catch
                    { }
                }
                // altrimenti salvo!
                else
                {
                    subMaccSel = ddlSubMacc.SelectedValue;
                }
            }
        }

        protected void ddlSubMacc_SelectedIndexChanged(object sender, EventArgs e)
        {
            subMaccSel = ddlSubMacc.SelectedValue;
            // salvo ODL
            DataLayerObj.taMSE.getByIdxMaccAndSub(idxMacchinaSel, subMaccSel);
            //altri controlli
            checkAll();
        }

        /// <summary>
        /// salvo produzione
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void lbtSalva_Click(object sender, EventArgs e)
        {
            // effettua conferma con conf da DB del tipo (giorni / turni / periodo
            bool fatto = effettuaConfermaProd();
            // refresh tabella dati tablet...
            DataLayerObj.taMSE.forceRecalc(0, idxMacchinaSel);
            // mostro output
            lblOut.Text = string.Format("Confermata la produzione per {0} pezzi! (+{1} pz scarto) alle {2:yyyy-MM-dd HH:mm:ss}", numPzConfermati, numPzScarto2Rec, dtReqUpdate);
            // cambio button conferma...
            switchBtnConferma(!txtNumPezzi.Enabled);
            // sollevo evento!
            if (eh_newVal != null)
            {
                eh_newVal(this, new EventArgs());
            }
            dtReqUpdate = DateTime.Now;
            doUpdate();
        }

        /// <summary>
        /// caricamento pagina
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                checkAll();
                if (isMulti)
                {
                    // sollevo evento!
                    if (eh_reset != null)
                    {
                        eh_reset(this, new EventArgs());
                    }
                }
            }
        }

        /// <summary>
        /// Update pz lasciati --&gt; aggiorno!
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void txtNumLasciati_TextChanged(object sender, EventArgs e)
        {
            lblOut.Text = "";
            updatePzBuoni();
        }

        /// <summary>
        /// update post modifica pz buoni
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void txtNumPezzi_TextChanged(object sender, EventArgs e)
        {
            lblOut.Text = "";
            updatePzBuoni();
        }

        /// <summary>
        /// ODL correntemente sulla macchina
        /// - cerca in Redis (TTL 5 sec)
        /// - altrimenti recupera da DB...
        /// </summary>
        protected void updateOdl()
        {
            // userò ODL del turno
            int answ = 0;
            // cerco da redis...
            int.TryParse(DataLayerObj.currODL(idxMacchinaSel, true), out answ);
            // salvo!
            idxOdl = answ;
        }

        private void checkAll()
        {
            updateOdl();
            checkConfig();
            fixSelMacc();
            checkOdl();
            lblOut.Text = "";
            switchBtnConferma(false);
            lbtShowConfProd.Visible = odlOk;
            lblConfProd.Visible = !odlOk;
        }

        /// <summary>
        /// verifica config x modalità permesse
        /// </summary>
        private void checkConfig()
        {
            // verifico SE sia permesso gestire i "Pezzi lasciati" in macchina...
            lblNumLasciati.Visible = enablePzProdLasciati;
            txtNumLasciati.Visible = enablePzProdLasciati;
            lblEmptyNumLasciati.Visible = !enablePzProdLasciati;
        }

        /// <summary>
        /// Verifica se abbia un ODL ATTIVO
        /// </summary>
        private void checkOdl()
        {
            lbtShowConfProd.Visible = odlOk;
            lblConfProd.Visible = !odlOk;
            lblMancaODL.Visible = !odlOk;
        }

        /// <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 = DataLayerObj.confermaProdMacchinaFull(idxMacchinaSel, memLayer.ML.CRI("modoConfProd"), numPzConfermati - numPzLasciati, numPzLasciati, numPzScarto2Rec, dtReqUpdate);
            }
            else
            {
                fatto = DataLayerObj.confermaProdMacchina(idxMacchinaSel, memLayer.ML.CRI("modoConfProd"), numPzConfermati, numPzScarto2Rec, dtReqUpdate);
            }
            return fatto;
        }

        /// <summary>
        /// Se la machcina è MULTI --&gt; mostro selettore
        /// </summary>
        private void fixSelMacc()
        {
            divSelMacc.Visible = isMulti;
            if (isMulti)
            {
                try
                {
                    // salvo selezione submacc
                    ddlSubMacc.DataBind();
                    subMaccSel = ddlSubMacc.SelectedValue;
                }
                catch
                { }
            }
            updateOdl();
        }

        /// <summary>
        /// Reset parametri x calcolo pezzi (no pezzi lasciati, dataora attuale...)
        /// </summary>
        private void resetParam()
        {
            dtReqUpdate = DateTime.Now;
            numPzLasciati = 0;
        }

        /// <summary>
        /// determina comportamento btn conferma
        /// </summary>
        private void switchBtnConferma(bool showConf)
        {
            // aggiorno valori rilevati
            resetParam();
            doUpdate();
            divInnovazioni.Visible = showConf;
            if (showConf)
            {
                try
                {
                    updatePzBuoni();
                    // sollevo evento!
                    if (eh_inserting != null)
                    {
                        eh_inserting(this, new EventArgs());
                    }
                }
                catch
                {
                    txtNumPezzi.Text = "0";
                    logger.lg.scriviLog(string.Format("Errore recupero pezzi da confermare per la macchina {0}", idxMacchinaSel), tipoLog.ERROR);
                }
            }
            if (showConf)
            {
                lblShowConfProd.Text = "Nascondi Conferma";
            }
            else
            {
                lblShowConfProd.Text = "Mostra Conferma";
                // sollevo evento!
                if (eh_reset != null)
                {
                    eh_reset(this, new EventArgs());
                }
            }
        }

        /// <summary>
        /// aggiorna visualizzazione pz buoni /prodotti - scarti)
        /// </summary>
        private void updatePzBuoni()
        {
            if (confRett)
            {
                // cambio le qta di pezzi confermati...
                lblPz2RecBuoni.Text = (numPzConfermati - numPzLasciati).ToString();
            }
            else
            {
                // se ho dei pezzi lasciati RICALCOLO la data...
                if (numPzLasciati > 0)
                {
                    // calcolo la data..
                    DS_ProdTempi.TempiCicloRilevatiDataTable tab = DataLayerObj.taTempiCicloRilevati.getLastPzByMaccQta(idxMacchinaSel, DateTime.Now, numPzLasciati);
                    if (tab.Rows.Count > 0)
                    {
                        dtReqUpdate = tab[0].DataOraRif.AddSeconds(1);
                    }
                    // aggiorno
                    doUpdate();
                }
                lblPz2RecBuoni.Text = numPzConfermati.ToString();
            }
            // aggiorno la data calcolo + pezzi buoni...
            lblDtRec.Text = dtReqUpdate.ToString();
        }

#endif
    }
}