using System;
using System.Collections.Generic;
using System.Data;
using System.IO;

namespace SteamWare
{
  /// <summary>
  /// Base class for every user control in the application, containing some common
  /// behaviour and utility methods.
  /// It is not meant to be be used directly.
  /// </summary>
  public class ApplicationUserControl : System.Web.UI.UserControl
  {
    /// <summary>
    /// tipo id controllo con classi di base comune da cui derivare gli *.asmx
    /// </summary>
    public ApplicationUserControl()
    { }
    /*
         * Definizioni generali:
         * SteamWare:	codice scritto manualmente da SteamWare
         * webForm:	codice autogenerato da VisualStudio
         * =c= :	codice costante (non serve modifica)
         * <c> :	codice variabile (va modificato x ogni controllo / pagina)
         * 
         * Notazione
         * _ :		se posto all'inizio del nome indica una variabile/oggetto caricato in memoria da input pagina e/o session
         * MAIUS :	le procedure / metodi con prima lettera in MAIUSCOLO indicano codice COSTANTE
         * minus :	le procedure / metodi con prima lettera in minuscolo indicano codice variabile da verificare/modificare
    */


    /// <summary>
    /// imposto il tipo di anagrafica del controlloS
    /// </summary>
    public tipoAnagrafica TipoAnagControllo
    {
      get
      {
        return _tipoAnagrafica;
      }
      set
      {
        _tipoAnagrafica = value;
      }
    }

    #region dati utente e sessione =c=

    /// <summary>
    /// nome della pagina correntemente caricata
    /// </summary>
    public string _paginaCorrente;
    /// <summary>
    /// memorizza la pagina precedente (ovvero la corrente ma non da page-object ma in session...
    /// </summary>
    public string _paginaPrecedente;
    /// <summary>
    /// stringa con CDC in (...) dei cdc abilitati (da permesso gerarchicamente a discendere...)
    /// </summary>
    protected string _AuthCdC;
    /// <summary>
    /// stringa con elenco CDC abilitati (da permesso gerarchicamente a discendere...)
    /// </summary>
    protected string _CdCUser;

    #endregion

    #region tabelle dati

    /// <summary>
    /// tabella diritti
    /// </summary>
    protected DataLayer_AnagGen.DIRITTIDataTable _Diritti;
    /// <summary>
    /// tabella di tutti i cdc
    /// </summary>
    protected DataLayer_AnagGen.CDCDataTable _allCdC;

    #endregion

    #region altri dati

    /// <summary>
    /// tipo di anagrafica usata
    /// </summary>
    protected tipoAnagrafica _tipoAnagrafica = tipoAnagrafica.Standard;
    /// <summary>
    /// importo il tipo di vista del modulo
    /// </summary>
    protected tipoVistaMod _vistaModulo = tipoVistaMod.editing;

    /// <summary>
    /// elenco testuale csv dei cdc accessibili all'utente (x filtri tipo IN(...))
    /// </summary>
    protected string _elencoCdC;
    /// <summary>
    /// numero di righe standard x i datagrid
    /// </summary>
    protected int _righeDataGrid;
    /// <summary>
    /// numero di righe standard x i datagrid di anagrafica
    /// </summary>
    protected int _righeDataGridAnagr;
    /// <summary>
    /// numero di righe standard x i datagrid lunghi
    /// </summary>
    protected int _righeDataGridLong;
    /// <summary>
    /// numero di righe standard x i datagrid medi
    /// </summary>
    protected int _righeDataGridMed;
    /// <summary>
    /// numero di righe standard x i datagrid su mezza pagina
    /// </summary>
    protected int _righeDataGridShort;
    /// <summary>
    /// numero di righe standard x i selettori popup
    /// </summary>
    protected int _righeSelettore;
    /// <summary>
    /// indirizzo email dell'admin applicativo cui vanno le email in caso di anomalie...
    /// </summary>
    protected string _adminEmail;
    /// <summary>
    /// indirizzo email dell'applicativo da cui partono le email in caso di anomalie...
    /// </summary>
    protected string _fromEmail;
    /// <summary>
    /// indirizzo server SMTP
    /// </summary>
    protected string _smtpCli;
    /// <summary>
    /// elenco delle pagine "safe" ovvero da non autorizzare - da web.config
    /// </summary>
    protected string _safePages;
    /// <summary>
    /// elenco delle pagine "common" ovvero da autorizzare ma senza bisogno diritti in anagrafica - da web.config
    /// </summary>
    protected string _commonPages;
    /// <summary>
    /// valore che determina se � possibile forzare impersonificazioen utente...
    /// </summary>
    protected bool _allowForceUser;
    /// <summary>
    /// livello di log (1-->5)
    /// </summary>
    protected int _logLevel;
    /// <summary>
    /// dir di logging
    /// </summary>
    protected string _logBaseDir;

    #endregion

    #region flusso creazione pagina =c=

    /// <summary>
    /// MAIN: esecuzione al caricamento del modulo delle routines di controllo utente e creazione pagina
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected virtual void Page_Load(object sender, System.EventArgs e)
    {
      // carico i dati...
      LoadUserData();
      SetUpByUserRight();
      loadSessionData();
      PredisponiDati();
      bindControlli();
    }

    /// <summary>
    /// predisposizione dati x pagina da cache/database a seconda della disponibilit� in cache o refresh (B.1.4)
    /// </summary>
    protected void PredisponiDati()
    {
      if (!datiDisponibili())
      {
        resetUpdate();
        forza_Update();
      }
      else
      {
        caricaDati();
      }
    }

    /// <summary>
    /// popola gli oggetti e le labels... (B.1.6)
    /// </summary>
    protected virtual void bindControlli()
    {
      // IsPostBack � TRUE se utilizzo javascript ovvero confermo cancellazioni o modifico i controlli...
      if (!IsPostBack)
      {
        DisegnaPagina();
      }
    }

    /// <summary>
    /// disegna la pagina: prima i controlli poi il datagrid
    /// </summary>
    protected void DisegnaPagina()
    {
      sistemaControlli();
      aggiungiLink();
      aggiornaControlliDataGL();
      traduciObj();
    }
    /// <summary>
    /// aggiunge i link x i selettori
    /// </summary>
    protected virtual void aggiungiLink()
    {
    }

    /// <summary>
    /// sistema i vari controlli della pagina
    /// </summary>
    protected virtual void sistemaControlli()
    { }
    /// <summary>
    /// aggiorna eventuali datalist e datagrid
    /// </summary>
    protected virtual void aggiornaControlliDataGL()
    {
    }

    /// <summary>
    /// sistema tutte le labels traducendo i lemmi nella lingua utente ed in inglese
    /// </summary>
    protected virtual void traduciObj()
    { }



    #endregion

    #region utility =c=

    /// <summary>
    /// calcola come percentuale la radio dividendo/divisore
    /// </summary>
    /// <param name="dividendo"></param>
    /// <param name="divisore"></param>
    /// <returns></returns>
    public string percentuale(object dividendo, object divisore)
    {
      string answ = "";
      double _dividendo = Convert.ToDouble(dividendo);
      double _divisore = Convert.ToDouble(divisore);
      try
      {
        answ = string.Format("{0:p}", _dividendo / _divisore);
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// limita una stringa al numero max di caratteri imposto
    /// </summary>
    /// <param name="original"></param>
    /// <param name="maxChar"></param>
    /// <returns></returns>
    public string limitString(string original, int maxChar)
    {
      string outString = original;
      if (outString.Length > maxChar)
      {
        outString = string.Format("{0}...", original.Substring(0, maxChar - 3));
      }
      return outString;
    }

    /// <summary>
    /// Reads data from a stream until the end is reached. The
    /// data is returned as a byte array. An IOException is
    /// thrown if any of the underlying IO calls fail.
    /// </summary>
    /// <param name="stream">The stream to read data from</param>
    /// <param name="initialLength">The initial buffer length</param>
    public static byte[] ReadFully(Stream stream, int initialLength)
    {
      // If we've been passed an unhelpful initial length, just
      // use 32K.
      if (initialLength < 1)
      {
        initialLength = 32768;
      }

      byte[] buffer = new byte[initialLength];
      int read = 0;

      int chunk;
      while ((chunk = stream.Read(buffer, read, buffer.Length - read)) > 0)
      {
        read += chunk;

        // If we've reached the end of our buffer, check to see if there's
        // any more information
        if (read == buffer.Length)
        {
          int nextByte = stream.ReadByte();

          // End of stream? If so, we're done
          if (nextByte == -1)
          {
            return buffer;
          }

          // Nope. Resize the buffer, put in the byte we've just
          // read, and continue
          byte[] newBuffer = new byte[buffer.Length * 2];
          Array.Copy(buffer, newBuffer, buffer.Length);
          newBuffer[read] = (byte)nextByte;
          buffer = newBuffer;
          read++;
        }
      }
      // Buffer is now too big. Shrink it.
      byte[] ret = new byte[read];
      Array.Copy(buffer, ret, read);
      return ret;
    }


    /// <summary>
    /// converte una data in formato aaaammgg in stringa gg/mm/aaaa
    /// </summary>
    /// <param name="val"></param>
    /// <returns></returns>
    public string data2string(object val)
    {
      string dataFormattata = "";
      try
      {
        string data = val.ToString();
        dataFormattata = data.Substring(6, 2) + "/" + data.Substring(4, 2) + "/" + data.Substring(0, 4);
      }
      catch
      {
      }
      return dataFormattata;
    }
    /// <summary>
    /// converte una data in formato aaaammgg in stringa aaaa-mm-gg
    /// </summary>
    /// <param name="val"></param>
    /// <returns></returns>
    public string data2IsoString(object val)
    {
      string dataFormattata = "";
      try
      {
        string data = val.ToString();
        dataFormattata = data.Substring(0, 4) + "-" + data.Substring(4, 2) + "-" + data.Substring(6, 2);
      }
      catch
      {
      }
      return dataFormattata;
    }/// <summary>
     /// converte una stringa in formato gg/mm/aaaa in stringa(intero data) in formato aaaammgg
     /// </summary>
     /// <param name="val"></param>
     /// <returns></returns>
    public string string2data(object val)
    {
      DateTime data = Convert.ToDateTime(val);
      return (data.Year).ToString() + (data.Month).ToString().PadLeft(2, '0') + (data.Day).ToString().PadLeft(2, '0');
    }
    /// <summary>
    /// converte una datetime in un intero tipo yyyymmddhhmmss
    /// </summary>
    /// <param name="_data"></param>
    /// <returns></returns>
    public long datetime2int(DateTime _data)
    {
      long valore_data = 0;
      long valore_time = 0;
      long valore = 0;
      valore_data = (_data).Year * 10000 + (_data).Month * 100 + (_data).Day;
      valore_time = (_data).Hour * 10000 + (_data).Minute * 100 + (_data).Second;
      valore = valore_data * 1000000 + valore_time;
      return valore;
    }
    /// <summary>
    /// formatta la data in formato dateTime in una data formato italiano come stringa gg/mm/aaaa
    /// </summary>
    /// <param name="dataRichiesta"></param>
    /// <returns></returns>
    public string dataItaliana(DateTime dataRichiesta)
    {
      string dataFormattata;
      dataFormattata = dataRichiesta.Day.ToString().PadLeft(2, '0') + "/" + dataRichiesta.Month.ToString().PadLeft(2, '0') + "/" + dataRichiesta.Year.ToString();
      return dataFormattata;
    }



    /// <summary>
    /// invia un alert jscript con messaggio indicato...
    /// </summary>
    /// <param name="_messaggio">messaggio dell'alert da mandare</param>
    public void mandaAlert(string _messaggio)
    {
      string comando = "<script language='JavaScript'>";
      comando += "alert('" + _messaggio + "')";
      comando += "</script>";
      Response.Write(comando);
    }
    /// <summary>
    /// scrive immediatamente sulla pagina web il messaggio di avanzamento...
    /// </summary>
    /// <param name="_messaggio"></param>
    public void scriviAvanzamento(string _messaggio)
    {
      Response.Write(_messaggio);
      Response.Flush();
    }

    /// <summary>
    /// restituisce una scringa formattata in testa e coda x essere un corretto comando javascript
    /// </summary>
    /// <param name="comando"></param>
    /// <returns></returns>
    public string jscriptFormat(string comando)
    {
      return "<script language='JavaScript'>" + comando + "</script>";
    }

    #endregion

    #region gestione email & log...

    /// <summary>
    /// invio email senza log
    /// </summary>
    /// <param name="_mailFrom"></param>
    /// <param name="_mailTo"></param>
    /// <param name="_oggetto"></param>
    /// <param name="_corpo"></param>
    /// <returns></returns>
    protected bool mandaEmailNoLog(string _mailFrom, string _mailTo, string _oggetto, string _corpo)
    {
      bool answ = false;
      try
      {
        answ = SteamWare.gestEmail.ge.mandaEmailNoLog(_mailFrom, _mailTo, _oggetto, _corpo);
      }
      catch { }
      return answ;
    }
    /// <summary>
    /// invio email con log
    /// </summary>
    /// <param name="_mailFrom"></param>
    /// <param name="_mailTo"></param>
    /// <param name="_oggetto"></param>
    /// <param name="_corpo"></param>
    /// <returns></returns>
    protected bool mandaEmail(string _mailFrom, string _mailTo, string _oggetto, string _corpo)
    {
      return SteamWare.gestEmail.ge.mandaEmailNoLog(_mailFrom, _mailTo, _oggetto, _corpo);
    }

    #endregion

    #region gestione dati

    /// <summary>
    /// caricamento dati applicazione da sessione (B.1.3)
    /// </summary>
    protected virtual void loadSessionData()
    {
    }
    /// <summary>
    /// setup datamanagers...
    /// </summary>
    protected virtual void setupUserDataMan()
    {
    }
    /// <summary>
    /// reset update del modulo corrente
    /// </summary>
    protected virtual void resetUpdate()
    { }
    /// <summary>
    /// (ri)carica i dataset del modulo 
    /// </summary>
    protected virtual void forza_Update()
    { }
    /// <summary>
    /// verifica se tutti i dataset richiesti sono disponibili i cache
    /// </summary>
    /// <returns></returns>
    protected virtual bool datiDisponibili()
    {
      return true;
    }
    /// <summary>
    /// salva nella cache i dataset caricati
    /// </summary>
    protected virtual void salvaDati()
    { }
    /// <summary>
    /// carica dalla cache i dataset necessari
    /// </summary>
    protected virtual void caricaDati()
    { }


    #endregion

    #region lettura dataset standard

    /// <summary>
    /// legge i valori standard x dataset e parametri
    /// </summary>
    protected void StandardDataLoad()
    {
      try
      {
        loadAuthCdC();
      }
      catch
      { }
    }
    /// <summary>
    /// leggi i parametri di configurazione standard dell'applicativo
    /// </summary>
    protected void loadDefaultsWebConfig()
    {
      _righeDataGrid = memLayer.ML.CRI("_righeDataGrid");
      _righeDataGridAnagr = memLayer.ML.CRI("_righeDataGridAnagr");
      _righeDataGridLong = memLayer.ML.CRI("_righeDataGridLong");
      _righeDataGridMed = memLayer.ML.CRI("_righeDataGridMed");
      _righeDataGridShort = memLayer.ML.CRI("_righeDataGridShort");
      _adminEmail = memLayer.ML.CRS("_adminEmail");
      _fromEmail = memLayer.ML.CRS("_fromEmail");
      _smtpCli = memLayer.ML.CRS("_smtpCli");
      _logLevel = memLayer.ML.CRI("_logLevel");
      _safePages = memLayer.ML.CRS("_safePages");
      _commonPages = memLayer.ML.CRS("_commonPages");
    }
    /// <summary>
    /// genera la stringa dei cdc autorizzati dell'utente
    /// </summary>
    protected void loadAuthCdC()
    {
      if (!memLayer.ML.isInSessionObject("_AuthCdC"))
      {
        _CdCUser = elencoCdC;
        memLayer.ML.setSessionVal("_CdCUser", _CdCUser);
        _AuthCdC = string.Format(" COD_CDC IN ({0})", _CdCUser);
        memLayer.ML.setSessionVal("_AuthCdC", _AuthCdC);
      }
      else
      {
        _AuthCdC = memLayer.ML.StringSessionObj("_AuthCdC");
      }
    }

    /// <summary>
    /// legge il dataset dei CdC
    /// </summary>
    protected void loadAllCdC()
    {
      if (!memLayer.ML.isInCacheObject("_allCdC"))
      {
        _allCdC = DataWrap.DW.taCdc.GetData();
        //Cache["_allCdC"] = _allCdC;
        memLayer.ML.setCacheVal("_allCdC", _allCdC, true);
      }
      else
      {
        _allCdC = (DataLayer_AnagGen.CDCDataTable)Cache["_allCdC"];
      }
    }

    #endregion

    #region autenticazione / autorizzazione =c=

    /// <summary>
    /// caricamento dati user da sessione (B.1.1)
    /// </summary>
    protected void LoadUserData()
    {
      _paginaPrecedente = memLayer.ML.StringSessionObj("_paginaPrecedente");
      setupUserDataMan();
      loadDefaultsWebConfig();
      if (user_std.UtSn.utente != "")
      {
        StandardDataLoad();
      }
    }

    /// <summary>
    /// verifica che l'utente abbia almeno un permesso per la pagina corrente altrimenti redirect ad unauthorized
    /// </summary>
    protected virtual void SetUpByUserRight()
    {
      PagCorrente();
      // verifica la pagina NON sia di quelle "libere"
      if (_safePages.IndexOf(_paginaCorrente) == -1)
      {
        // verifica l'utente sia autorizzato (in session...)
        if (!user_std.UtSn.isAuth)
        {
          if (_paginaCorrente != "" && _paginaCorrente != "login.aspx")
          {
            Session["nextPage"] = _paginaCorrente;
          }

          Response.Redirect("login.aspx");
        }
        // verifica i permessi dell'utente per almeno vedere la pagina corrente SSE non � una common page...
        if (!user_std.UtSn.isPageEnabled(_paginaCorrente) && _commonPages.IndexOf(_paginaCorrente) == -1)
        {
          logger.lg.scriviLog(string.Format("Errore in SetUpByUserRight: utente {0} non autorizzato per la pagina {1}", user_std.UtSn.utente, _paginaCorrente), tipoLog.STARTUP);
          Response.Redirect("~/unauthorized.aspx");
        }

      }
    }

    /// <summary>
    /// salva in variabile pagina il nome della pagina corrente
    /// </summary>
    protected virtual void PagCorrente()
    {
      Uri MyUrl = Request.Url;
      string delimStr = "/";
      char[] delimiter = delimStr.ToCharArray();
      string[] finalUrl = MyUrl.LocalPath.ToString().Split(delimiter);
      int n = finalUrl.Length;
      _paginaCorrente = finalUrl[n - 1].ToString();
      // tolgo .aspx!
      _paginaCorrente = _paginaCorrente.Replace(".aspx", "");
      if (string.IsNullOrEmpty(_paginaPrecedente) || _paginaPrecedente == null)
      {
        _paginaPrecedente = _paginaCorrente;
        memLayer.ML.setSessionVal("_paginaPrecedente", _paginaPrecedente);
      }
      if (_paginaCorrente != _paginaPrecedente)
      {
        // in questo caso tolgo i vari filtering e gli indici...
        memLayer.ML.emptySessionVal("_indexFilt");
        memLayer.ML.emptySessionVal("valoreCercato");
        _paginaPrecedente = _paginaCorrente;
        memLayer.ML.setSessionVal("_paginaPrecedente", _paginaPrecedente);
      }
    }

    /// <summary>
    /// selezione delle posizioni cdc autorizzate come stringa di filtraggio su POSIZIONE LIKE, se non ce ne fossero redirige su unauthorized.aspx
    /// </summary>
    /// <returns></returns>
    protected string filtroPosizioneCdC()
    {
      string Filtraggio;
      Filtraggio = " (";
      DataLayer_AnagGen.CDCDataTable tblCdc = DataWrap.DW.taCdc.GetTopCdC(user_std.UtSn.utente, user_std.UtSn.dominio, user_std.UtSn.modulo);
      if (tblCdc.Rows.Count == 0 && _safePages.IndexOf(_paginaCorrente) == -1)
      {
        logger.lg.scriviLog(string.Format("Errore in filtroPosizioneCdC: utente {0} non autorizzato per la pagina {1}", user_std.UtSn.utente, _paginaCorrente), tipoLog.STARTUP);
        Response.Redirect("~/unauthorized.aspx");
      }
      foreach (DataLayer_AnagGen.CDCRow riga in tblCdc)
      {
        // aggiongo solo se non � contenuta la posizione...
        if (Filtraggio.IndexOf(riga.POSIZIONE) == -1)
        {
          // controllo se posizione termina col punto...
          if (riga.POSIZIONE.EndsWith("."))
          {
            Filtraggio += String.Format("(POSIZIONE LIKE '{0}%') OR ", riga.POSIZIONE);
          }
          else
          {
            Filtraggio += String.Format("(POSIZIONE LIKE '{0}.%') OR ", riga.POSIZIONE);
          }
        }
      }
      int lungFiltr = Filtraggio.Length;
      Filtraggio = Filtraggio.Remove(lungFiltr - 3, 3);
      Filtraggio += ") ";
      return Filtraggio;
    }

    /// <summary>
    /// risponde alla domanda se l'utente abbia permesso tipo writable (S) nel permessi2funzione
    /// </summary>
    /// <returns></returns>
    public bool isWritable()
    {
      bool answ = false;
      if (_paginaCorrente == null)
      {
        PagCorrente();
      }
      answ = user_std.UtSn.isPageWriteEnabled(_paginaCorrente);
      return answ;
    }

    #endregion

    #region funzioni x sorting & filtering =c=

    /// <summary>
    /// verifica la condizione booleana e formatta di conseguenza la stringa di filtraggio da accodare al filtro x CdC autorizzati
    /// </summary>
    /// <param name="_condizione">condizione</param>
    /// <param name="_tipoEqual">tipo di eguaglianza</param>
    /// <param name="_nomeParam">nome parametro</param>
    /// <param name="_valParam">valore parametro</param>
    /// <returns></returns>
    protected string condFilter(bool _condizione, string _tipoEqual, string _nomeParam, string _valParam)
    {
      string outFilter = "";
      if (_condizione && _valParam != "")
      {
        if (_tipoEqual == "=")
        {
          outFilter = " AND (" + _nomeParam.Replace("'", "''") + " = '" + _valParam.Replace("'", "''") + "')";
        }
        else if (_tipoEqual == "IN")
        {
          outFilter = String.Format(" AND ({0} IN ({1}))", _nomeParam.Replace("'", "''"), _valParam.Replace("'", "''"));
        }

        else
        {
          outFilter = " AND (" + _nomeParam.Replace("'", "''") + " LIKE '%" + _valParam.Replace("'", "''") + "%')";
        }
      }
      return outFilter;
    }
    /// <summary>
    /// crea la stringa di filtraggio x data secondo modalit� tipo inizio/fine/durante...
    /// </summary>
    /// <returns></returns>
    protected string dataFilter(bool _condizione, string _tipoPeriodo, string _nomeFrom, string _dataFrom, string _nomeTo, string _dataTo)
    {
      string outFilter = "";
      if (_condizione)
      {
        // carica i valori dalle textbox... se non ci sono li imposta a:
        // start	=	01/01/1900
        // end		=	01/01/2200
        try
        {
          _dataFrom = _dataFrom.Replace(".", "/");
          if (string.IsNullOrEmpty(_dataFrom))
          {
            _dataFrom = "01/01/1900";
          }
        }
        catch
        {
          _dataFrom = "01/01/1900";
        }
        try
        {
          _dataTo = _dataTo.Replace(".", "/");
          if (string.IsNullOrEmpty(_dataTo))
          {
            _dataTo = "01/01/2200";
          }
        }
        catch
        {
          _dataTo = "01/01/2200";
        }
        switch (_tipoPeriodo)
        {
          case "1":
            // filtro su inizio
            outFilter += " AND (" + _nomeFrom + " >= '" + _dataFrom + "' AND " + _nomeFrom + " <= '" + _dataTo + "') ";
            break;
          case "2":
            // filtro su scadenza
            outFilter += " AND (" + _nomeTo + " >= '" + _dataFrom + "' AND " + _nomeTo + " <= '" + _dataTo + "') ";
            break;
          case "3":
            // filtro su "in corso"
            outFilter += " AND NOT (" + _nomeFrom + " > '" + _dataTo + "' OR " + _nomeTo + " < '" + _dataFrom + "') ";
            break;
        }
      }
      return outFilter;
    }

    /// <summary>
    /// crea la stringa di filtraggio x data secondo modalit� tipo minoreUguale / uguale / maggioreUguale...
    /// </summary>
    /// <returns></returns>
    protected string dataFilter(bool _condizione, string _tipoPeriodo, string _nome, string _data)
    {
      string outFilter = "";
      if (_condizione)
      {
        // carica i valori dalle textbox... se non ci sono li imposta a:
        // start	=	01/01/1900
        // end		=	01/01/2200
        try
        {
          _data = _data.Replace(".", "/");
          if (string.IsNullOrEmpty(_data))
          {
            _data = "01/01/1900";
          }
        }
        catch
        {
          _data = "01/01/1900";
        }
        switch (_tipoPeriodo)
        {
          case "<=":
            // filtro su inizio
            outFilter += " AND (" + _nome + " <= '" + _data + "') ";
            break;
          case "=":
            // filtro su scadenza
            outFilter += " AND (" + _nome + " = '" + _data + "') ";
            break;
          case ">=":
            // filtro su "in corso"
            outFilter += " AND (" + _nome + " >= '" + _data + "') ";
            break;
        }
      }
      return outFilter;
    }
    /// <summary>
    /// verifica la condizione booleana e formatta di conseguenza la stringa di filtraggio tipo LIKE x i campi inseriti separati da # SE valParam !=""
    /// </summary>
    /// <param name="_elencoCampi"></param>
    /// <param name="_valParam"></param>
    /// <returns></returns>
    protected string likeFilter(string _elencoCampi, string _valParam)
    {
      string outFilter = "";
      if (_valParam != "")
      {
        outFilter = " AND ( ";
        string comandoCompleto = _elencoCampi;
        string[] comando = comandoCompleto.Split('#');
        int numCampi = comando.GetLength(0);
        for (int i = 1; i <= numCampi; i++)
        {
          outFilter += "(" + comando[i - 1] + " LIKE '%" + _valParam + "%')";
          outFilter += " OR ";
        }
        outFilter = outFilter.Remove(outFilter.Length - 3, 3);
        outFilter += " ) ";
      }
      return outFilter;
    }

    /// <summary>
    /// variabile salvata in view state x la stringa di sorting - dg 2
    /// </summary>
    protected string SortField2
    {
      //registra nella viewState la stringa di sorting 
      //(nome campo + scritta desc o nulla che equivale ad ascending...)
      //si pu� impropriamente usare x + controlli... al max serve 1 click in +...
      get
      {
        object o = ViewState["SortField2"];
        if (o == null)
        {
          return String.Empty;
        }
        return (string)o;
      }

      set
      {
        if (value == SortField2)
        {
          // same as current sort file, toggle sort direction
          SortAscending = !SortAscending;
        }
        ViewState["SortField2"] = value;
      }
    }

    /// <summary>
    /// variabile salvata in view state x la stringa di sorting - dg 2
    /// </summary>
    protected string SortField
    {
      //registra nella viewState la stringa di sorting 
      //(nome campo + scritta desc o nulla che equivale ad ascending...)
      //si pu� impropriamente usare x + controlli... al max serve 1 click in +...
      get
      {
        object o = ViewState["SortField"];
        if (o == null)
        {
          return String.Empty;
        }
        return (string)o;
      }

      set
      {
        if (value == SortField)
        {
          // same as current sort file, toggle sort direction
          SortAscending = !SortAscending;
        }
        ViewState["SortField"] = value;
      }
    }
    /// <summary>
    /// legge e scrive in viewState la stringa di filtraggio...
    /// </summary>
    protected string FiltString
    {
      get
      {
        object o = ViewState["FiltString"];
        if (o == null)
        {
          return String.Empty;
        }
        return (string)o;
      }

      set
      {
        ViewState["FiltString"] = value;
      }
    }
    /// <summary>
    /// variabile salvata in viewstate x la direzione del sorting
    /// </summary>
    protected bool SortAscending
    {
      //memorizza l'ultima direzione di sort x poterla invertire
      get
      {
        object o = ViewState["SortAscending"];
        if (o == null)
        {
          return true;
        }
        return (bool)o;
      }

      set
      {
        ViewState["SortAscending"] = value;
      }
    }
    /// <summary>
    /// genera la stringa filtro x i cdc autorizzati x l'user
    /// </summary>
    /// <returns></returns>
    protected string elencoCdC
    {
      get
      {
        // messo qui caricamento dei cdc...
        loadAllCdC();
        //filtro sui CdC -- ATTENZIONE!!! possibile stack overflow se si supera un filtro con oltre 5000 char di posizioni... loop! vedi 647 mantis
        string filtroCompleto = filtroPosizioneCdC();
        string filtroCorrente = "";
        string Filtraggio;
        //dall'elenco dei CdC compone filtro x tabella corrente...
        Filtraggio = "";
        // setta a 0 il cdc precedente... poi inserisce il cdc SE E SOLO SE � diverso dal precedente: � distinct!!!
        string _cdcPrec = "000";
        string _cdcCurr = "";
        int currPos = 0;
        int filtLenght = filtroCompleto.Length;
        int currLenght = 0;
        // workaround: separo la ricerca in + tranches, andando a prendere solo (circa) 2000 char alla volta...
        if (filtroCompleto.Length < 2000)
        {
          // uso il filtro completo...
          Filtraggio = recuperaCdC_daFiltro(filtroCompleto, ref Filtraggio, ref _cdcPrec, ref _cdcCurr);
        }
        else
        {
          while (currPos < filtLenght)
          {
            // se non trova significa che siamo all'ultimo "tratto" da meno di 1900 char...
            if (filtLenght - currPos < 2100)
            {
              currLenght = filtLenght - currPos;
            }
            else
            {
              // cerco l'i-esima occorrenza di "(POSIZIONE LIKE" dopo circa 2000 dalla currPos...
              currLenght = filtroCompleto.IndexOf("(POSIZIONE", currPos + 1900) - currPos;
            }
            filtroCorrente = filtroCompleto.Substring(currPos, currLenght);
            // se termina con "OR " tolgo...
            if (filtroCorrente.EndsWith("OR "))
            {
              filtroCorrente = filtroCorrente.Remove(currLenght - 3, 3);
            }
            Filtraggio = recuperaCdC_daFiltro(filtroCorrente, ref Filtraggio, ref _cdcPrec, ref _cdcCurr);
            // sposto la posizione corrente...
            currPos = currPos + currLenght;
          }
        }
        return Filtraggio;
      }
    }
    /// <summary>
    /// esegue la ricerca dei cdc nelle posizioni indicate dal filtro e restituisce elenco distinct degli stessi
    /// </summary>
    /// <param name="filtroCorrente">filtro con cui cercare i cdc (del tipo " (POSIZIONE LIKE 'T.1.2.3%') OR ... " </param>
    /// <param name="Filtraggio">stringa di filtraggio ricostruita per l'elenco dei cdc fino a quel momento trovati</param>
    /// <param name="_cdcPrec">ultimo cdc trovato</param>
    /// <param name="_cdcCurr">cdc corrente</param>
    /// <returns></returns>
    private string recuperaCdC_daFiltro(string filtroCorrente, ref string Filtraggio, ref string _cdcPrec, ref string _cdcCurr)
    {
      // esegue ciclo ricerca
      DataView dv = new DataView(_allCdC, filtroCorrente, "COD_CDC", DataViewRowState.CurrentRows);
      foreach (DataRowView rowView in dv)
      {
        _cdcCurr = rowView.Row[0].ToString();
        if (_cdcCurr != _cdcPrec && (Filtraggio.IndexOf(_cdcCurr) < 0)) // aggiunta verifica non ci siano duplicati visto che si fa in + tranches la ricerca cdc...
        {
          Filtraggio += "'" + _cdcCurr + "' , ";
        }
        _cdcPrec = _cdcCurr;
      }
      int lungFiltr = Filtraggio.Length;
      if (Filtraggio.EndsWith("' , "))
      {
        Filtraggio = Filtraggio.Remove(lungFiltr - 3, 3);
      }
      return Filtraggio;
    }


    #endregion

    #region funzioni di conversione da Id dati anagrafici

    /// <summary>
    /// restituisce il cdc dell'utente data la sua matricola
    /// </summary>
    /// <param name="val"></param>
    /// <returns></returns>
    public string cdcUtente(object val)
    {
      DataLayer_AnagGen.UTENTERow riga = DataWrap.DW.taUtente.getByMatricola(val.ToString())[0];
      return riga.COD_CDC;
    }


    /// <summary>
    /// restituisce l'utente AS dall'utente win
    /// </summary>
    /// <param name="utenteWin"></param>
    /// <returns></returns>
    public string siglaDaUserWin(string utenteWin)
    {
      string sigla = "__";
      try
      {
        DataLayer_AnagGen.UTENTERow riga = DataWrap.DW.taUtente.getByUserName(utenteWin)[0];
        sigla = riga.SIGLA;
      }
      catch
      { }
      return sigla;
    }

    /// <summary>
    /// restituisce la descr del CdC
    /// </summary>
    /// <param name="val"></param>
    /// <returns></returns>
    public string descrCdcDaId(object val)
    {
      // cambio sena obj completo in cache
      string label = "-";
      try
      {
        label = (DataWrap.DW.taCdc.getByCdc(val.ToString())[0]).DESCRIZIONE;
      }
      catch
      { }
      return label;
    }



    #endregion

    #region funzioni di concatenamento stringhe x comandi hyperlink & help

    /// <summary>
    /// invia la stringa jscript di conferma pre-cancellazione
    /// </summary>
    /// <returns></returns>
    public string confermaCancellazione()
    {
      return string.Format("return confirm(\"{0}\");", user_std.UtSn.Traduci("confermaDel"));
    }
    /// <summary>
    /// restituisce la stringa del path corretto per l'immagine richiesta nel formato "~/images/{0}{1}"
    /// </summary>
    /// <param name="_tipo">verr� usato x posizione {0}, tipo "view"</param>
    /// <param name="_dimensione">verr� usato x posizione {1}, tipo "_s.png"</param>
    /// <returns></returns>
    public string imgPath(tipoImg _tipo, dimImg _dimensione)
    {
      return imgPath(_tipo, _dimensione, tipoFileImg.png);
    }

    /// <summary>
    /// restituisce la stringa del path corretto per l'immagine richiesta nel formato "~/images/{0}{1}"
    /// </summary>
    /// <param name="_tipo">verr� usato x posizione {0}, tipo "view"</param>
    /// <param name="_dimensione">verr� usato x posizione {1}, tipo "_s.png"</param>
    /// <param name="_tipoFile">tipo del file richiesto..."</param>
    /// <returns></returns>
    public string imgPath(tipoImg _tipo, dimImg _dimensione, tipoFileImg _tipoFile)
    {
      string _imgName = "unknown";
      string _imgDim = "_s";
      string _imgType = "png";
      switch (_tipo)
      {
        case tipoImg.annulla:
          _imgName = "cancel";
          break;
        case tipoImg.approva:
          _imgName = "approva";
          break;
        case tipoImg.barcode:
          _imgName = "barcode_white";
          break;
        case tipoImg.barcodeArancio:
          _imgName = "barcode_orange";
          break;
        case tipoImg.clona:
          _imgName = "clonaObj";
          break;
        case tipoImg.conferma:
          _imgName = "apply";
          break;
        case tipoImg.elimina:
          _imgName = "elimina";
          break;
        case tipoImg.modifica:
          _imgName = "edit";
          break;
        case tipoImg.notepad:
          _imgName = "notepad";
          break;
        case tipoImg.notepadPdf:
          _imgName = "notepadPdf";
          break;
        case tipoImg.nuovo:
          _imgName = "new";
          break;
        case tipoImg.seleziona:
          _imgName = "view";
          break;
        case tipoImg.semaforoGiallo:
          _imgName = "semaGiallo";
          break;
        case tipoImg.semaforoRosso:
          _imgName = "semaRosso";
          break;
        case tipoImg.semaforoVerde:
          _imgName = "semaVerde";
          break;
        case tipoImg.stampa:
          _imgName = "print";
          break;
        default:
          break;
      }
      switch (_dimensione)
      {
        case dimImg.small:
          _imgDim = "_s";
          break;
        case dimImg.medium:
          _imgDim = "_m";
          break;
        case dimImg.large:
          _imgDim = "_l";
          break;
        default:
          break;
      }
      switch (_tipoFile)
      {
        case tipoFileImg.gif:
          _imgType = "gif";
          break;
        case tipoFileImg.jpg:
          _imgType = "jpg";
          break;
        case tipoFileImg.png:
          _imgType = "png";
          break;
        default:
          break;
      }
      return string.Format("~/images/{0}{1}.{2}", _imgName, _imgDim, _imgType);
    }

    #endregion

    #region funzioni dummy x traduzione

    /// <summary>
    /// effettua traduzione del lemma
    /// </summary>
    /// <param name="lemma"></param>
    /// <returns></returns>
    public string traduci(string lemma)
    {
      return user_std.UtSn.Traduci(lemma);
    }
    /// <summary>
    /// effettua traduzione in inglese del lemma
    /// </summary>
    /// <param name="lemma"></param>
    /// <returns></returns>
    public string traduciEn(string lemma)
    {
      return user_std.UtSn.TraduciEn(lemma);
    }

    #endregion

    #region gestione visibilit� da tipo modulo

    /// <summary>
    /// definisce visibilit�
    /// </summary>
    /// <param name="cosa"></param>
    /// <returns></returns>
    public bool isVisible(object cosa)
    {
      bool visibile;
      switch (cosa.ToString())
      {
        case "Select":
          visibile = (_vistaModulo == tipoVistaMod.selezione);
          break;
        case "Edit":
          visibile = (_vistaModulo == tipoVistaMod.editing);
          break;
        case "Delete":
          visibile = (_vistaModulo == tipoVistaMod.editing);
          break;
        default:
          visibile = false;
          break;
      }
      return visibile;
    }
    /// <summary>
    /// tipo di vista del modulo
    /// </summary>
    public tipoVistaMod vistaModulo
    {
      get
      {
        return _vistaModulo;
      }
      set
      {
        _vistaModulo = value;
      }
    }

    #endregion

    #region gestione eventi e logging

    /// <summary>
    /// effettua la registrazione degli eventi
    /// </summary>
    public void registraEventi()
    {
      // controllo: loggin SOLO se la scheda ha logging abilitato nella riga del db...
      bool logEn = memLayer.ML.BoolSessionObj("logEn");
      memLayer.ML.emptySessionVal("logEn");
      if (logEn)
      {
        // leggo e svuoto info x logging
        string ev2log = memLayer.ML.StringSessionObj("ev2log");
        memLayer.ML.emptySessionVal("ev2log");
        string valOrig = memLayer.ML.StringSessionObj("valOrig");
        memLayer.ML.emptySessionVal("valOrig");
        string valNew = memLayer.ML.StringSessionObj("valNew");
        memLayer.ML.emptySessionVal("valNew");
        string filtEv = memLayer.ML.StringSessionObj("filtEv");
        memLayer.ML.emptySessionVal("filtEv");
        // solo se almeno uno dei due valori orig e new sono diversi da zero...)
        if (valNew != "" || valOrig != "")
        {
          insEvento(ev2log, valOrig, valNew, filtEv);
        }
      }
    }
    /// <summary>
    /// effettua l'inserimento vero e proprio dell'evento letto dai valori in session x l'utente corrente...
    /// </summary>
    /// <param name="ev2log">evento da loggare</param>
    /// <param name="valOrig">valori originali</param>
    /// <param name="valNew">nuovi valori</param>
    /// <param name="filtEv">filtro associato</param>
    public virtual void insEvento(string ev2log, string valOrig, string valNew, string filtEv)
    {
      // effettuo logging evento
      log2note.l2n.insEvento(user_std.UtSn.utente, _paginaCorrente, valOrig, valNew, ev2log, filtEv);
    }
    /// <summary>
    /// salva in sessione i valori indicati
    /// </summary>
    /// <param name="oldVal">dictionary dei valori vecchi</param>
    /// <param name="newVal">dictionary dei valori nuovi</param>
    /// <param name="logEnabled">bool su abilitazione al log dell'oggetto</param>
    /// <param name="ev2log">descrizione evento da loggare</param>
    /// <param name="filtroEv">filtro associato all'evento</param>
    /// <returns>restituisce il numero di elementi contenuti, -1 significa nessuna differenza...</returns>
    public static int setLogValueToSession(Dictionary<string, string> oldVal, Dictionary<string, string> newVal, bool logEnabled, string ev2log, string filtroEv)
    {
      int answ = -1;
      // salvo i valori x logging
      confrontoValori.obj.paramOld = oldVal;
      confrontoValori.obj.paramNew = newVal;
      // faccio generare il diff...
      confrontoValori.obj.doDiff();
      // logging modifica
      memLayer.ML.setSessionVal("ev2log", ev2log);
      memLayer.ML.setSessionVal("logEn", logEnabled);
      memLayer.ML.setSessionVal("filtEv", filtroEv);
      memLayer.ML.setSessionVal("valOrig", confrontoValori.obj.valOld);
      memLayer.ML.setSessionVal("valNew", confrontoValori.obj.valNew);
      // se ci sono differenze allora restituisco posizione della prima differenza, cercando <BR> nella stringa...
      try
      {
        if (confrontoValori.obj.valNew != "")
        {
          string[] righe = confrontoValori.obj.valNew.Split('<');
          answ = righe.Length;
        }
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// salva in sessione i valori per un oggetto che sta x essere eliminato
    /// </summary>
    /// <param name="oldVal">dictionary dei valori vecchi</param>
    /// <param name="logEnabled">bool su abilitazione al log dell'oggetto</param>
    /// <param name="ev2log">descrizione evento da loggare</param>
    /// <param name="filtroEv">filtro associato all'evento</param>
    /// <returns>restituisce il numero di elementi contenuti, -1 significa nessuna differenza...</returns>
    public static int setLogValueToSession4del(Dictionary<string, string> oldVal, bool logEnabled, string ev2log, string filtroEv)
    {
      int answ = -1;
      // salvo i valori x logging
      confrontoValori.obj.paramOld = oldVal;
      // faccio generare il diff...
      confrontoValori.obj.calcOldVal();
      // logging modifica
      memLayer.ML.setSessionVal("ev2log", ev2log);
      memLayer.ML.setSessionVal("logEn", logEnabled);
      memLayer.ML.setSessionVal("filtEv", filtroEv);
      memLayer.ML.setSessionVal("valOrig", confrontoValori.obj.valOld);
      memLayer.ML.setSessionVal("valNew", "-");
      // se ci sono differenze allora restituisco posizione della prima differenza, cercando <BR> nella stringa...
      try
      {
        string[] righe = confrontoValori.obj.valNew.Split('<');
        answ = righe.Length;
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// wrapper per log con salvataggio dell'IP del chiamante
    /// </summary>
    /// <param name="_testoPre"></param>
    /// <returns></returns>
    public bool httpLog(string _testoPre)
    {
      bool answ = false;
      string postazione_IP = "";
      try
      {
        postazione_IP = string.Format(" | {0} | ", Request.UserHostName);
      }
      catch
      { }
      logger.lg.scriviLog(postazione_IP + _testoPre);
      return answ;
    }
    /// <summary>
    /// wrapper per log con salvataggio dell'IP del chiamante
    /// </summary>
    /// <param name="testoLog">The testo log.</param>
    /// <param name="tipo">The tipo.</param>
    /// <returns></returns>
    public bool httpLog(string testoLog, tipoLog tipo)
    {
      bool answ = false;
      string postazione_IP = "";
      try
      {
        postazione_IP = string.Format(" | {0} | ", Request.UserHostName);
      }
      catch
      { }
      logger.lg.scriviLog(postazione_IP + testoLog, tipo);
      return answ;
    }

    /// <summary>
    /// event handler generico
    /// </summary>
    public event EventHandler eh_ucev;
    /// <summary>
    /// sollevo evento selezione
    /// </summary>
    protected void raiseEvent(ucEvType evType)
    {
      // sollevo evento nuovo valore...
      if (eh_ucev != null)
      {
        ucEvent evento = new ucEvent(evType);
        eh_ucev(this, evento);
      }
    }

    #endregion

  }
}