MoonPro.net/MP-SITE/DettaglioMacchina.aspx.cs

using MapoDb;
using SteamWare;
using System;
using System.Collections.Generic;
using System.Web.UI;

namespace MP_SITE
{
    public partial class DettaglioMacchina : BasePage
    {
        #region Protected Fields

        protected intervalloDate _intervalloAnalisi;
        protected resoconti _resoconti;
        protected int deltaPlot = 24;
        protected int durataMin;
        protected string idxMacchina;
        protected long standardZoom = 3;

        #endregion Protected Fields

        #region Protected Properties

        protected bool graphDataRefresh
        {
            get
            {
                return memLayer.ML.BoolSessionObj("graphDataRefresh");
            }
            set
            {
                memLayer.ML.setSessionVal("graphDataRefresh", value);
            }
        }

        protected intervalloDate intervalloAnalisi
        {
            get
            {
                return _intervalloAnalisi;
            }
            set
            {
                // controllo che la data di fine non sia posteriore ad adesso...
                if (value.fine > DateTime.Now)
                {
                    DateTime adesso = DateTime.Now;
                    // verifico durata periodo x approssimare
                    double durata = value.fine.Subtract(value.inizio).TotalHours;
                    // arrotondo i minuti secondo durata timespan...
                    int round = 1;
                    if (durata > 2 && durata <= 6)
                    {
                        round = 2;
                    }
                    else if (durata <= 6)
                    {
                        round = 3;
                    }
                    else if (durata <= 12)
                    {
                        round = 4;
                    }
                    else if (durata <= 24)
                    {
                        round = 5;
                    }
                    else if (durata <= 48)
                    {
                        round = 10;
                    }
                    else if (durata <= 96)
                    {
                        round = 20;
                    }
                    else if (durata <= 168)
                    {
                        round = 30;
                    }
                    else
                    {
                        round = 60;
                    }
                    int minuti = (adesso.Minute / round) * round;
                    value.fine = new DateTime(adesso.Year, adesso.Month, adesso.Day, adesso.Hour, minuti, 0);
                }
                _intervalloAnalisi = value;
            }
        }

        #endregion Protected Properties

        #region Protected Methods

        protected void chkHideSpenta_CheckedChanged(object sender, EventArgs e)
        {
            // in base a quello ridisegno la torta...
            graphDataRefresh = true;
            impostaGrafici();
            //setTorta();
            up_grafici.Update();
        }

        protected void impostaGrafici()
        {
            if (graphDataRefresh)
            {
                try
                {
                    setTorta();
                    if (memLayer.ML.CRB("showSeqStati"))
                    {
                        setSequencer();
                    }
                    else
                    {
                        Mod_sequencerStati1.Visible = false;
                    }
                    if (memLayer.ML.CRB("showSeqTC"))
                    {
                        setTC();
                    }
                    else
                    {
                        mod_sequencerTempiCiclo1.Visible = false;
                    }
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog(string.Format("Errore nella renderizzazione dettaglio macchina: intervallo analisi da {0} a {1}, macchina {2}{3}{4}", intervalloAnalisi.inizio, intervalloAnalisi.fine, idxMacchina, Environment.NewLine, exc));
                }
                graphDataRefresh = false;
                up_grafici.Update();
            }
        }

        /// <summary>
        /// caricamento pagina
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Page_Load(object sender, EventArgs e)
        {
            // al primo caricamento imposto il refresh obbligatorio
            if (!Page.IsPostBack)
            {
                chkHideSpenta.DataBind();
                graphDataRefresh = true;
                // controllo se devo ricaricare i valori in cache redis...
                string rKey = DataLayer.mHash($"VETO:ReloadTabInCache");
                var vetoRefresh = memLayer.ML.getRSV(rKey);
                if(string.IsNullOrEmpty(vetoRefresh))
                {
                    // metto veto
                    int ttlReload = memLayer.ML.CRI("SITE_ForceReloadCache");
                    memLayer.ML.setRSV(rKey, $"Veto Reload TabInCache until: {DateTime.Now.AddSeconds(ttlReload): HH:mm:ss}", ttlReload);
                    // chiamo refresh tab in cache...
                    refreshTabInCache();
                }
            }
            Mod_periodoAnalisi1.eh_doUpdate += new EventHandler(Mod_periodoAnalisi1_eh_doUpdate);
            Mod_listaStatiEventi1.eh_doUpdate += new EventHandler(Mod_listaStatiEventi1_eh_doUpdate);
            Mod_sequencerStati1.eh_richiestaZoom += new EventHandler(Mod_sequencerStati1_eh_richiestaZoom);
            mod_sequencerTempiCiclo1.eh_richiestaZoom += new EventHandler(mod_sequencerTempiCiclo1_eh_richiestaZoom);
            _resoconti = new resoconti();
            idxMacchina = memLayer.ML.QSS("IdxMacchina");
            intervalloAnalisi = (intervalloDate)memLayer.ML.objSessionObj("_intervallo");
            durataMin = memLayer.ML.IntSessionObj("_durataMin");
            // chiamo routine disegno
            impostaGrafici();
        }

        private void refreshTabInCache()
        {
#if false
            // salvo i dati attuali...
            string cod_cdc = SteamWare.memLayer.ML.StringSessionObj("valRicercaCdC");
            string lingua = user_std.UtSn.lingua;
            string USER_NAME = SteamWare.memLayer.ML.StringSessionObj("USER_NAME");
            string DOMINIO = SteamWare.memLayer.ML.StringSessionObj("DOMINIO");
            bool isForceUser = user_std.UtSn.isForcedUser;
            // salvo i valori delle tab in session...
            Dictionary<string, string> sessionParam = SteamWare.memLayer.ML.valSess2SurvUpd;

            // svuoto session e cache per rileggere i dati da Db
            Session.RemoveAll(); 
#endif

            SteamWare.memLayer.ML.flushRegisteredCache();

#if false
            // rimemorizzo
            SteamWare.memLayer.ML.setSessionVal("valRicercaCdC", cod_cdc);
            user_std.UtSn.startUpUtente(DOMINIO, USER_NAME);
            user_std.UtSn.lingua = lingua;
            user_std.UtSn.isForcedUser = isForceUser;
            DataWrap.DW.resetVocabolario();

            // risalvo in session i valori...
            foreach (KeyValuePair<string, string> kvp in sessionParam)
            {
                SteamWare.memLayer.ML.setSessionVal(kvp.Key, kvp.Value, true);
            } 
#endif
        }

        protected void setSequencer()
        {
            // procedo SOLO SE ho dei dati...
            bool datiOk = false;
            objSequencer datiSeq;
            try
            {
                datiSeq = _resoconti.sequenzaDati(idxMacchina, intervalloAnalisi);
                datiOk = (datiSeq.serieDati != null);
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog(string.Format("Errore in recupero seq DATI {0}{1}{2}", idxMacchina, Environment.NewLine, exc));
                datiSeq = new objSequencer();
            }
            // procedo SE ho dati...
            if (datiOk)
            {
                Mod_sequencerStati1.larghezza = memLayer.ML.IntSessionObj("WindowWidth") - deltaPlot;
                Mod_sequencerStati1.graphHeight = 100;
                Mod_sequencerStati1.numSplit = 1000;
                Mod_sequencerStati1.datiSequencer = datiSeq;
                Mod_sequencerStati1.doUpdate();
            }
        }

        protected void setTorta()
        {
            Mod_grafico2.graficoTorta = new pieChart();
            Mod_grafico2.graficoTorta.serie = _resoconti.tortaStati(idxMacchina, intervalloAnalisi, durataMin, chkHideSpenta.Checked);
        }

        #endregion Protected Methods

        #region Private Methods

        private void Mod_listaStatiEventi1_eh_doUpdate(object sender, EventArgs e)
        {
            graphDataRefresh = false;
            impostaGrafici();
        }

        private void Mod_periodoAnalisi1_eh_doUpdate(object sender, EventArgs e)
        {
            graphDataRefresh = true;
            intervalloAnalisi = (intervalloDate)memLayer.ML.objSessionObj("_intervallo");
            impostaGrafici();
            Mod_listaStatiEventi1.aggiornamento();
        }

        private void Mod_sequencerStati1_eh_richiestaZoom(object sender, EventArgs e)
        {
            updateDaZoom();
        }

        private void mod_sequencerTempiCiclo1_eh_richiestaZoom(object sender, EventArgs e)
        {
            updateDaZoom();
        }

        private void setTC()
        {
            // procedo SOLO SE ho dei dati...
            bool datiOk = false;
            objTempiCiclo datiTC;
            try
            {
                datiTC = _resoconti.tempiCiclo(idxMacchina, intervalloAnalisi, 0);
                datiOk = (datiTC.serieDati != null);
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog(string.Format("Errore in recupero seq TC {0}{1}{2}", idxMacchina, Environment.NewLine, exc));
                datiTC = new objTempiCiclo();
            }
            // procedo SE ho dati...
            if (datiOk)
            {
                mod_sequencerTempiCiclo1.larghezza = memLayer.ML.IntSessionObj("WindowWidth") - deltaPlot;
                mod_sequencerTempiCiclo1.plotReversed = true;
                mod_sequencerTempiCiclo1.graphHeight = 100;
                mod_sequencerTempiCiclo1.numSplit = 600;
                mod_sequencerTempiCiclo1.grafico = datiTC;
                mod_sequencerTempiCiclo1.doUpdate();
            }
        }

        private void updateDaZoom()
        {
            graphDataRefresh = true;
            // chiamo procedura zoom in controllo periodo
            Mod_periodoAnalisi1.dateZoom();
        }

        #endregion Private Methods
    }
}