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

using SteamWare;
using System;
using System.Web.UI;

namespace MoonPro
{
  public partial class DettaglioMacchina : UserPage
  {
    protected resoconti _resoconti;
    protected string idxMacchina;
    protected intervalloDate _intervalloAnalisi;
    protected intervalloDate intervalloAnalisi
    {
      get
      {
        return _intervalloAnalisi;
      }
      set
      {
        // controllo che la data di fine non sia posteriore ad adesso...
        if (value.fine > DateTime.Now)
        {
          value.fine = DateTime.Now;
        }
        _intervalloAnalisi = value;
      }
    }
    protected int durataMin;
    protected long standardZoom = 3;
    protected bool graphDataRefresh
    {
      get
      {
        return memLayer.ML.BoolSessionObj("graphDataRefresh");
      }
      set
      {
        memLayer.ML.setSessionVal("graphDataRefresh", value);
      }
    }
    /// <summary>
    /// effettua traduzione del lemma
    /// </summary>
    /// <param name="lemma"></param>
    /// <returns></returns>
    public string traduci(string lemma)
    {
      return user_std.UtSn.Traduci(lemma);
    }
    /// <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)
      {
        graphDataRefresh = true;
      }
      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)Session["_intervallo"];
      durataMin = (int)Session["_durataMin"];
      // chiamo routine disegno
      impostaGrafici();
    }

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

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

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

    void Mod_listaStatiEventi1_eh_doUpdate(object sender, EventArgs e)
    {
      impostaGrafici();
    }

    void Mod_periodoAnalisi1_eh_doUpdate(object sender, EventArgs e)
    {
      graphDataRefresh = true;
      intervalloAnalisi = (intervalloDate)Session["_intervallo"];
      impostaGrafici();
      Mod_listaStatiEventi1.aggiornamento();
    }

    protected void impostaGrafici()
    {
      try
      {
        setTorta();
        if (memLayer.ML.confReadBool("showSeqStati"))
        {
          setSequencer();
        }
        else
        {
          Mod_sequencerStati1.Visible = false;
        }
        if (memLayer.ML.confReadBool("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));
      }
      if (graphDataRefresh)
      {
        graphDataRefresh = false;
        up_grafici.Update();
      }
    }

    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}", Environment.NewLine, exc));
        datiTC = new objTempiCiclo();
      }
      // procedo SE ho dati...
      if (datiOk)
      {
        mod_sequencerTempiCiclo1.larghezza = memLayer.ML.IntSessionObj("WindowWidth") - 2;
        mod_sequencerTempiCiclo1.plotReversed = true;
        mod_sequencerTempiCiclo1.graphHeight = 100;
        mod_sequencerTempiCiclo1.numSplit = 600;
        mod_sequencerTempiCiclo1.grafico = datiTC;
        mod_sequencerTempiCiclo1.doUpdate();
      }
    }

    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}", Environment.NewLine, exc));
        datiSeq = new objSequencer();
      }
      // procedo SE ho dati...
      if (datiOk)
      {
        Mod_sequencerStati1.larghezza = memLayer.ML.IntSessionObj("WindowWidth") - 2;
        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);
    }

    protected void chkHideSpenta_CheckedChanged(object sender, EventArgs e)
    {
      // in base a quello ridisegno la torta...
      setTorta();
    }
  }
}