using System;
using System.Configuration;
using System.Globalization;
using System.IO;
using System.Web;
using NLog;
using System.Net.Mail;


namespace ETS_Data
{
  public class utils
  {
    protected AppSettingsReader configAppSetReader;
    //public Logger lg = LogManager.GetCurrentClassLogger();

    #region area table adapters

    public DS_AnagraficaTableAdapters.UtentiTableAdapter taUtenti;
    public DS_AnagraficaTableAdapters.DirittiTableAdapter taDiritti;

    public DS_utilsTableAdapters.v_selFontiTableAdapter taSelFonti;
    public DS_utilsTableAdapters.v_selCommesseTableAdapter taSelCommesse;
    public DS_utilsTableAdapters.v_selFasiTableAdapter taSelFasi;
    public DS_utilsTableAdapters.v_selAutoriTableAdapter taSelAutori;
    public DS_utilsTableAdapters.v_tbDocs_selFontiTableAdapter taTDSelFonti;
    public DS_utilsTableAdapters.v_tbDocs_selCommesseTableAdapter taTDSelCommesse;
    public DS_utilsTableAdapters.v_tbDocs_selFasiTableAdapter taTDSelFasi;
    public DS_utilsTableAdapters.v_tbDocs_selOggettoTableAdapter taTDSelOggetti;
    public DS_utilsTableAdapters.v_tbDocs_selRedattoreTableAdapter taTDSelRedattore;
    public DS_utilsTableAdapters.stp_calcolaProtocolloTableAdapter taCalcProto;
    public DS_utilsTableAdapters.v_selEmailFornitoriTableAdapter taEmailForn;
    public DS_utilsTableAdapters.AnagSuggestTagsTableAdapter taAST;
    public DS_utilsTableAdapters.v_selFonti_explTableAdapter taVSFE;

    public DS_WebScipTableAdapters.tbDocumentiTableAdapter taDoc;
    public DS_WebScipTableAdapters.Tags2DocTableAdapter taTags2Doc;
    public DS_WebScipTableAdapters.tbMetaDataSetTableAdapter taTMD;
    public DS_WebScipTableAdapters.stp_userLoginRefreshDbTableAdapter taDBRefresh;


    /// <summary>
    /// init dei table adapters
    /// </summary>
    protected void initTA()
    {
      taUtenti = new DS_AnagraficaTableAdapters.UtentiTableAdapter();
      taDiritti = new DS_AnagraficaTableAdapters.DirittiTableAdapter();
      taSelFonti = new DS_utilsTableAdapters.v_selFontiTableAdapter();
      taSelCommesse = new DS_utilsTableAdapters.v_selCommesseTableAdapter();
      taSelFasi = new DS_utilsTableAdapters.v_selFasiTableAdapter();
      taSelAutori = new DS_utilsTableAdapters.v_selAutoriTableAdapter();
      taTDSelFonti = new DS_utilsTableAdapters.v_tbDocs_selFontiTableAdapter();
      taTDSelCommesse = new DS_utilsTableAdapters.v_tbDocs_selCommesseTableAdapter();
      taTDSelFasi = new DS_utilsTableAdapters.v_tbDocs_selFasiTableAdapter();
      taTDSelOggetti = new DS_utilsTableAdapters.v_tbDocs_selOggettoTableAdapter();
      taTDSelRedattore = new DS_utilsTableAdapters.v_tbDocs_selRedattoreTableAdapter();
      taCalcProto = new DS_utilsTableAdapters.stp_calcolaProtocolloTableAdapter();
      taEmailForn = new DS_utilsTableAdapters.v_selEmailFornitoriTableAdapter();
      taAST = new DS_utilsTableAdapters.AnagSuggestTagsTableAdapter();
      taVSFE = new DS_utilsTableAdapters.v_selFonti_explTableAdapter();
      taDoc = new DS_WebScipTableAdapters.tbDocumentiTableAdapter();
      taTags2Doc = new DS_WebScipTableAdapters.Tags2DocTableAdapter();
      taTMD = new DS_WebScipTableAdapters.tbMetaDataSetTableAdapter();
      taDBRefresh = new DS_WebScipTableAdapters.stp_userLoginRefreshDbTableAdapter();
    }
    /// <summary>
    /// effettua setup dei connection strings da web.config delal singola applicazione
    /// </summary>
    protected virtual void setupConnectionStringBase()
    {
      string connStringETS_WS = (string)configAppSetReader.GetValue("ETS_WSConnectionString", typeof(string));
      string connStringETS_WAnagrafica = (string)configAppSetReader.GetValue("ETS_AnagraficaConnectionString", typeof(string));
      // connections del db
      taUtenti.Connection.ConnectionString = connStringETS_WAnagrafica;
      taDiritti.Connection.ConnectionString = connStringETS_WAnagrafica;

      taSelFonti.Connection.ConnectionString = connStringETS_WS;
      taSelCommesse.Connection.ConnectionString = connStringETS_WS;
      taSelFasi.Connection.ConnectionString = connStringETS_WS;
      taSelAutori.Connection.ConnectionString = connStringETS_WS;
      taTDSelFonti.Connection.ConnectionString = connStringETS_WS;
      taTDSelCommesse.Connection.ConnectionString = connStringETS_WS;
      taTDSelFasi.Connection.ConnectionString = connStringETS_WS;
      taTDSelOggetti.Connection.ConnectionString = connStringETS_WS;
      taTDSelRedattore.Connection.ConnectionString = connStringETS_WS;
      taCalcProto.Connection.ConnectionString = connStringETS_WS;
      taEmailForn.Connection.ConnectionString = connStringETS_WS;
      taAST.Connection.ConnectionString = connStringETS_WS;
      taVSFE.Connection.ConnectionString = connStringETS_WS;
      taDoc.Connection.ConnectionString = connStringETS_WS;
      taTags2Doc.Connection.ConnectionString = connStringETS_WS;
      taTMD.Connection.ConnectionString = connStringETS_WS;
      taDBRefresh.Connection.ConnectionString = connStringETS_WS;
    }

    #endregion

    #region Inizializzazione

    protected utils()
    {
      configAppSetReader = new AppSettingsReader();
      initTA();
      setupConnectionStringBase();
    }

    /// <summary>
    /// oggetto static per fare chiamate sul magazzino
    /// </summary>
    public static utils obj = new utils();

    #endregion


    #region gestione email & log...
    /// <summary>
    /// classe di gestione delle email
    /// </summary>
    public class gestEmail
    {
      protected Logger lg = LogManager.GetCurrentClassLogger();
      /// <summary>
      /// stringa del nome DNS o dell'ip del server SMTP
      /// </summary>
      protected string _smtpCli;
      /// <summary>
      /// stringa username x server SMTP
      /// </summary>
      protected string _username;
      /// <summary>
      /// stringa pwd x server SMTP
      /// </summary>
      protected string _password;
      /// <summary>
      /// metodo static per la gestione delle email
      /// </summary>
      /// <param name="smtpCli"></param>
      public gestEmail(string smtpCli)
      {
        lg.Info("[Modulo gestEmail]: avviato con  parametro smtp {0}", smtpCli);
        _smtpCli = smtpCli;
        _username = "";
        _password = "";
      }
      /// <summary>
      /// metodo static per la gestione delle email
      /// </summary>
      /// <param name="smtpCli"></param>
      /// <param name="user"></param>
      /// <param name="pwd"></param>
      public gestEmail(string smtpCli, string user, string pwd)
      {
        lg.Info("[Modulo gestEmail]: avviato con  parametro smtp {0} ed utente {1}", smtpCli, user);
        _smtpCli = smtpCli;
        _username = user;
        _password = pwd;
      }
      /// <summary>
      /// metodo static per la gestione delle email
      /// </summary>
      /// <param name="smtpCli"></param>
      /// <param name="logDir"></param>
      public gestEmail(string smtpCli, string logDir)
      {
        lg.Info("[Modulo gestEmail]: avviato con  parametro smtp {0} e logdir {1}", smtpCli, logDir);
        _smtpCli = smtpCli;
        _username = "";
        _password = "";
      }
      /// <summary>
      /// procedura invio email
      /// </summary>
      /// <param name="_mailFrom">email mittente</param>
      /// <param name="_mailTo">email destinatario</param>
      /// <param name="_oggetto">oggetto dell'email</param>
      /// <param name="_corpo">corpo del messaggio</param>
      public bool mandaEmailNoLog(string _mailFrom, string _mailTo, string _oggetto, string _corpo)
      {
        //manda email...
        MailMessage messaggio = new MailMessage(_mailFrom, _mailTo, _oggetto, _corpo);
        messaggio.IsBodyHtml = true;
        SmtpClient _smtpClient = new SmtpClient(_smtpCli);
        // se ci sono credenziali utente...
        if (_username != "")
        {
          _smtpClient.Credentials = new System.Net.NetworkCredential(_username, _password);
          _smtpClient.EnableSsl = utils.obj.confReadBool("_enableSSL");
        }
        try
        {
          _smtpClient.Send(messaggio);
          return true;
        }
        catch (SmtpException esmtp)
        {
          Console.WriteLine("{0}", esmtp.Message);
          Console.WriteLine("Here is the full error message output");
          Console.Write("{0}", esmtp.ToString());
          lg.ErrorException(string.Format("{0}\r\n full error message\r\n", esmtp.Message), esmtp);
          return false;
        }
      }
      /// <summary>
      /// procedura invio email + scrittura in log!
      /// </summary>
      /// <param name="_mailFrom">email mittente</param>
      /// <param name="_mailTo">email destinatario</param>
      /// <param name="_oggetto">oggetto dell'email</param>
      /// <param name="_corpo">corpo del messaggio</param>
      public bool mandaEmail(string _mailFrom, string _mailTo, string _oggetto, string _corpo)
      {
        bool fatto = false;
        //manda email...
        try
        {
          fatto = mandaEmailNoLog(_mailFrom, _mailTo, _oggetto, _corpo);
          lg.Info("Email inviata: oggetto: {0}, corpo: {1}", _oggetto, _corpo);
        }
        catch (Exception exc)
        {
          lg.ErrorException(string.Format("ERRORE! Email NON INVIATA!oggetto: {0} corpo: {1} eccezione: ", _oggetto, _corpo), exc);
        }
        return fatto;
      }
      /// <summary>
      /// metodo singleton gestione email...
      /// </summary>
      public static gestEmail ge = new gestEmail(utils.obj.confReadString("_smtpCli"));
      /// <summary>
      /// metodo singleton gestione email CON AUTH utente...
      /// </summary>
      public static gestEmail geAuth = new gestEmail(utils.obj.confReadString("_smtpCli"), utils.obj.confReadString("_emailUser"), utils.obj.confReadString("_emailPwd"));
    }

    #endregion

    #region area user (wrapper su user_std)

    /// <summary>
    /// WRAPPER utente correntemente connesso (Formato dominio\username)
    /// </summary>
    public string currUserAD
    {
      get
      {
        return user_std.UtSn.currUserAD;
      }
    }
    /// <summary>
    /// WRAPPER utente correntemente connesso per utilizzo FileSystem (Formato dominio.username)
    /// </summary>
    public string currUser_FS
    {
      get
      {
        return user_std.UtSn.currUser_FS;
      }
    }
    /// <summary>
    /// WRAPPER utente correntemente connesso (Formato Cognome nome)
    /// </summary>
    public string currUserCognomeNome
    {
      get
      {
        return user_std.UtSn.currUserCognomeNome;
      }
    }
    /// <summary>
    /// WRAPPER utente correntemente connesso (Formato Nome Cognome)
    /// </summary>
    public string currUserNomeCognome
    {
      get
      {
        return user_std.UtSn.currUserNomeCognome;
      }
    }
    /// <summary>
    /// WRAPPER EMAIL utente correntemente connesso
    /// </summary>
    public string currUserEmail
    {
      get
      {
        return user_std.UtSn.currUserEmail;
      }
    }
    /// <summary>
    /// WRAPPER UserId (AD) utente correntemente connesso
    /// </summary>
    public string currUserId
    {
      get
      {
        return user_std.UtSn.currUserId;
      }
    }
    /// <summary>
    /// WRAPPER calcola se l'utente abbia il diritto x la funzione indicata
    /// </summary>
    /// <param name="utenteAD">username formato AD</param>
    /// <param name="codModulo">codice modulo</param>
    /// <param name="codFunzione">codice funzione</param>
    /// <returns></returns>
    public bool userHasRight(string utenteAD, string codModulo, string codFunzione)
    {
      return user_std.UtSn.userHasRight(utenteAD, codModulo, codFunzione);
    }

    #endregion

    #region area Session

    /// <summary>
    /// carica dalla sessione un dato di tipo object generico
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public object objSessionObj(string nomeVar)
    {
      if (HttpContext.Current.Session[nomeVar] != null)
      {
        return HttpContext.Current.Session[nomeVar];
      }
      else
      {
        return "";
      }
    }

    /// <summary>
    /// carica dalla sessione un dato di tipo boolean (se vuoto false)
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public bool BoolSessionObj(string nomeVar)
    {
      if (HttpContext.Current.Session[nomeVar] != null)
      {
        return (bool)HttpContext.Current.Session[nomeVar];
      }
      else
      {
        return false;
      }
    }

    /// <summary>
    /// carica dalla sessione un dato di tipo string
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public string StringSessionObj(string nomeVar)
    {
      if (HttpContext.Current.Session[nomeVar] != null)
      {
        return HttpContext.Current.Session[nomeVar].ToString();
      }
      else
      {
        return "";
      }
    }

    /// <summary>
    /// carica dalla sessione un dato di tipo long
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public long LongSessionObj(string nomeVar)
    {
      if (HttpContext.Current.Session[nomeVar] != null)
      {
        return (long)Convert.ToInt32(HttpContext.Current.Session[nomeVar].ToString());
      }
      else
      {
        return 0;
      }
    }

    /// <summary>
    /// carica dalla sessione un dato di tipo int
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public int IntSessionObj(string nomeVar)
    {
      if (HttpContext.Current.Session[nomeVar] != null)
      {
        return (int)Convert.ToInt32(HttpContext.Current.Session[nomeVar].ToString());
      }
      else
      {
        return -1;
      }
    }

    /// <summary>
    /// inserisce in session un valore
    /// </summary>
    /// <param name="nome"></param>
    /// <param name="valore"></param>
    public bool setSessionVal(string nome, object valore)
    {
      bool _done = false;
      try
      {
        HttpContext.Current.Session[nome] = valore;
        _done = true;
      }
      catch
      { }
      return _done;
    }

    /// <summary>
    /// svuota una variabile dalla session
    /// </summary>
    /// <param name="nome"></param>
    public bool emptySessionVal(string nome)
    {
      bool _done = false;
      try
      {
        HttpContext.Current.Session.Remove(nome);
        _done = true;
      }
      catch
      { }
      return _done;
    }
    /// <summary>
    /// restituisce true se è presente in session l'oggetto richiesto
    /// </summary>
    /// <param name="nomeVar"></param>
    /// <returns></returns>
    public bool isInSessionObject(string nomeVar)
    {
      bool answ = false;
      bool stringAnsw = false;
      // cerco di fare cast a stringa...
      try
      {
        stringAnsw = (string)HttpContext.Current.Session[nomeVar].ToString() != "";
      }
      catch
      { }
      // infine condizione doppia...
      try
      {
        answ = (HttpContext.Current.Session[nomeVar] != null && stringAnsw);
      }
      catch
      { }
      return answ;
    }

    #endregion


    //#region cache

    ///// <summary>
    ///// carica dalla Cache un dato di tipo object generico
    ///// </summary>
    ///// <param name="nomeVar"></param>
    ///// <returns></returns>
    //public object objCacheObj(string nomeVar)
    //{
    //  if (HttpContext.Current.Cache[nomeVar] != null)
    //  {
    //    return HttpContext.Current.Cache[nomeVar];
    //  }
    //  else
    //  {
    //    return "";
    //  }
    //}

    ///// <summary>
    ///// carica dalla Cachee un dato di tipo boolean (se vuoto false)
    ///// </summary>
    ///// <param name="nomeVar"></param>
    ///// <returns></returns>
    //public bool BoolCacheObj(string nomeVar)
    //{
    //  if (HttpContext.Current.Cache[nomeVar] != null)
    //  {
    //    return (bool)HttpContext.Current.Cache[nomeVar];
    //  }
    //  else
    //  {
    //    return false;
    //  }
    //}

    ///// <summary>
    ///// carica dalla Cachee un dato di tipo string
    ///// </summary>
    ///// <param name="nomeVar"></param>
    ///// <returns></returns>
    //public string StringCacheObj(string nomeVar)
    //{
    //  if (HttpContext.Current.Cache[nomeVar] != null)
    //  {
    //    return HttpContext.Current.Cache[nomeVar].ToString();
    //  }
    //  else
    //  {
    //    return "";
    //  }
    //}

    ///// <summary>
    ///// inserisce in Cache un valore
    ///// </summary>
    ///// <param name="nome">nome della variabile</param>
    ///// <param name="valore">valore</param>
    //public bool setCacheVal(string nome, object valore)
    //{
    //  bool _done = false;
    //  try
    //  {
    //    HttpContext.Current.Cache[nome] = valore;
    //    _done = true;
    //  }
    //  catch
    //  { }
    //  return _done;
    //}
    ///// <summary>
    ///// inserisce in Cache un valore e su richiesta regitra tra le tab in cache da svuotare on update..
    ///// </summary>
    ///// <param name="nome">nome della variabile</param>
    ///// <param name="valore">valore</param>
    ///// <param name="setInTabInCache">da registrare come tabella da svuotare on update</param>
    ///// <returns></returns>
    //public bool setCacheVal(string nome, object valore, bool setInTabInCache)
    //{
    //  bool _done = setCacheVal(nome, valore);
    //  if (setInTabInCache)
    //  {
    //    addTabInCache(nome);
    //  }
    //  return _done;
    //}
    ///// <summary>
    ///// svuota una variabile dalla Cache
    ///// </summary>
    ///// <param name="nome"></param>
    //public bool emptyCacheVal(string nome)
    //{
    //  bool _done = false;
    //  try
    //  {
    //    HttpContext.Current.Cache.Remove(nome);
    //    _done = true;
    //  }
    //  catch
    //  { }
    //  return _done;
    //}

    ///// <summary>
    ///// restituisce true se è presente in cache l'oggetto richiesto
    ///// </summary>
    ///// <param name="nomeVar"></param>
    ///// <returns></returns>
    //public bool isInCacheObject(string nomeVar)
    //{
    //  bool answ = false;
    //  bool stringAnsw = false;
    //  // cerco di fare cast a stringa...
    //  try
    //  {
    //    stringAnsw = (string)HttpContext.Current.Cache[nomeVar].ToString() != "";
    //  }
    //  catch
    //  { }
    //  // infine condizione doppia...
    //  try
    //  {
    //    answ = (HttpContext.Current.Cache[nomeVar] != null && stringAnsw);
    //  }
    //  catch
    //  { }
    //  return answ;
    //}
    ///// <summary>
    ///// elenco dictionary delle tab in cache da aggiornare con update svuotando da cache...
    ///// </summary>
    //public Dictionary<string, string> tabelleInCache
    //{
    //  get
    //  {
    //    try
    //    {
    //      return (Dictionary<string, string>)objCacheObj("tabelleInCache");
    //    }
    //    catch
    //    {
    //      return new Dictionary<string, string>();
    //    }
    //  }
    //  set
    //  {
    //    setCacheVal("tabelleInCache", value);
    //  }
    //}
    ///// <summary>
    ///// aggiunge la stringa corrente nel dictionary delle tabelle messe in cache e da aggiornare su comando update
    ///// </summary>
    ///// <param name="nuovaTab"></param>
    //public void addTabInCache(string nuovaTab)
    //{
    //  // provo ad aggiungere nuova tab  in elenco...
    //  Dictionary<string, string> _tabelleInCache = tabelleInCache;
    //  try
    //  {
    //    _tabelleInCache.Add(nuovaTab, nuovaTab);
    //    tabelleInCache = _tabelleInCache;
    //  }
    //  catch
    //  { }
    //}

    ///// <summary>
    ///// elenco dictionary dei valori in session da NON aggiornare con update...
    ///// </summary>
    //public Dictionary<string, string> valSess2SurvUpd
    //{
    //  get
    //  {
    //    try
    //    {
    //      return (Dictionary<string, string>)objSessionObj("valoriInSession2Survive");
    //    }
    //    catch
    //    {
    //      return new Dictionary<string, string>();
    //    }
    //  }
    //  set
    //  {
    //    setSessionVal("valoriInSession2Survive", value);
    //  }
    //}
    ///// <summary>
    ///// aggiunge la stringa corrente nel dictionary delle tabelle messe in session che vanno preservate da comando update (es: oggetto selezionato...)
    ///// </summary>
    ///// <param name="nomePar"></param>
    ///// <param name="valore"></param>
    //public void addValInSession(string nomePar, string valore)
    //{
    //  // provo ad aggiungere nuova tab  in elenco...
    //  Dictionary<string, string> _valoriInSession2Survive = valSess2SurvUpd;
    //  // verifico se fare update o insert...
    //  if (_valoriInSession2Survive.ContainsKey(nomePar))
    //  {
    //    // update, rimuovo vecchio valore...
    //    try
    //    {
    //      _valoriInSession2Survive.Remove(nomePar);
    //    }
    //    catch
    //    { }
    //  }
    //  // insert
    //  try
    //  {
    //    _valoriInSession2Survive.Add(nomePar, valore);
    //    valSess2SurvUpd = _valoriInSession2Survive;
    //  }
    //  catch
    //  { }
    //}
    ///// <summary>
    ///// forza lo svuotamento delle tabelle indicate come in cache...
    ///// </summary>
    //public void flushRegisteredCache()
    //{
    //  // elimino tutte le tab nella pos tabInCache...
    //  foreach (KeyValuePair<string, string> kvp in tabelleInCache)
    //  {
    //    HttpContext.Current.Cache.Remove(kvp.Value);
    //  }
    //  HttpContext.Current.Cache.Remove("tabelleInCache");
    //}

    //#endregion


    //#region gestione valori in RedisCache

    ///// <summary>
    ///// Connessione lazy a redis...
    ///// </summary>
    //private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
    //{
    //  return ConnectionMultiplexer.Connect("127.0.0.1,abortConnect=false,ssl=false");
    //});
    ///// <summary>
    ///// Oggetto statico connessione redis
    ///// </summary>
    //public static ConnectionMultiplexer connRedis
    //{
    //  get
    //  {
    //    return lazyConnection.Value;
    //  }
    //}
    ///// <summary>
    ///// Restituisce una chiave salvata in RedisCache
    ///// </summary>
    ///// <param name="chiave"></param>
    ///// <returns></returns>
    //public string getRSV(string chiave)
    //{
    //  string answ = "";
    //  try
    //  {
    //    IDatabase cache = connRedis.GetDatabase();
    //    answ = cache.StringGet(chiave);
    //  }
    //  catch (Exception exc)
    //  {
    //    logger.lg.scriviLog(string.Format("Errore in getRSV:{0}{1}", Environment.NewLine, exc));
    //  }
    //  return answ;
    //}
    ///// <summary>
    ///// Salva una chiave in RedisCache
    ///// </summary>
    ///// <param name="chiave"></param>
    ///// <param name="valore"></param>
    ///// <returns></returns>
    //public bool setRSV(string chiave, string valore)
    //{
    //  bool answ = false;
    //  try
    //  {
    //    IDatabase cache = connRedis.GetDatabase();
    //    cache.StringSet(chiave, valore);
    //    answ = true;
    //  }
    //  catch (Exception exc)
    //  {
    //    logger.lg.scriviLog(string.Format("Errore in setRSV:{0}{1}", Environment.NewLine, exc));
    //  }
    //  return answ;
    //}
    ///// <summary>
    ///// Incrementa un contatore in Redis
    ///// </summary>
    ///// <param name="chiave"></param>
    ///// <returns></returns>
    //public long setRCntI(string chiave)
    //{
    //  long answ = 0;
    //  try
    //  {
    //    IDatabase cache = connRedis.GetDatabase();
    //    answ = cache.StringIncrement(chiave, 1);
    //  }
    //  catch (Exception exc)
    //  {
    //    logger.lg.scriviLog(string.Format("Errore in setRCI:{0}{1}", Environment.NewLine, exc));
    //  }
    //  return answ;
    //}
    ///// <summary>
    ///// Decrementa un contatore in Redis
    ///// </summary>
    ///// <param name="chiave"></param>
    ///// <returns></returns>
    //public long setRCntD(string chiave)
    //{
    //  long answ = 0;
    //  try
    //  {
    //    IDatabase cache = connRedis.GetDatabase();
    //    answ = cache.StringDecrement(chiave, 1);
    //  }
    //  catch (Exception exc)
    //  {
    //    logger.lg.scriviLog(string.Format("Errore in setRCD:{0}{1}", Environment.NewLine, exc));
    //  }
    //  return answ;
    //}
    ///// <summary>
    ///// Restituisce una chiave COUNTER in RedisCache
    ///// </summary>
    ///// <param name="chiave"></param>
    ///// <returns></returns>
    //public int getRCnt(string chiave)
    //{
    //  int answInt = 0;
    //  string answ = "";
    //  try
    //  {
    //    IDatabase cache = connRedis.GetDatabase();
    //    answ = cache.StringGet(chiave);
    //    answInt = Convert.ToInt32(answ);
    //  }
    //  catch (Exception exc)
    //  {
    //    logger.lg.scriviLog(string.Format("Errore in getRSV:{0}{1}", Environment.NewLine, exc));
    //  }
    //  return answInt;
    //}
    ///// <summary>
    ///// Resetta (elimina) un contatore in Redis
    ///// </summary>
    ///// <param name="chiave"></param>
    ///// <returns></returns>
    //public bool resetRCnt(string chiave)
    //{
    //  bool answ = false;
    //  try
    //  {
    //    IDatabase cache = connRedis.GetDatabase();
    //    answ = cache.KeyDelete(chiave);
    //  }
    //  catch (Exception exc)
    //  {
    //    logger.lg.scriviLog(string.Format("Errore in resetRCnt:{0}{1}", Environment.NewLine, exc));
    //  }
    //  return answ;
    //}
    ///// <summary>
    ///// Restituisce un set KVP (Key Value Pair) salvati in RedisCache
    ///// </summary>
    ///// <param name="chiavi"></param>
    ///// <returns></returns>
    //public RedisValue[] getRKeys(RedisKey[] chiavi)
    //{
    //  RedisValue[] answ = null;
    //  try
    //  {
    //    IDatabase cache = connRedis.GetDatabase();
    //    answ = cache.StringGet(chiavi);
    //  }
    //  catch (Exception exc)
    //  {
    //    logger.lg.scriviLog(string.Format("Errore in getRKeys:{0}{1}", Environment.NewLine, exc));
    //  }
    //  return answ;
    //}
    ///// <summary>
    ///// Salva  un set KVP (Key Value Pair) in RedisCache
    ///// </summary>
    ///// <param name="valori">Set KVP chiave-valore da salvare</param>
    ///// <returns></returns>
    //public bool setRKeys(KeyValuePair<RedisKey, RedisValue>[] valori)
    //{
    //  bool answ = false;
    //  try
    //  {
    //    IDatabase cache = connRedis.GetDatabase();
    //    cache.StringSet(valori);
    //    answ = true;
    //  }
    //  catch (Exception exc)
    //  {
    //    logger.lg.scriviLog(string.Format("Errore in setRKeys:{0}{1}", Environment.NewLine, exc));
    //  }
    //  return answ;
    //}
    ///// <summary>
    ///// Verifica se ci siano valori nella hash indicata...
    ///// </summary>
    ///// <param name="key"></param>
    ///// <returns></returns>
    //public bool redHashPresent(RedisKey key)
    //{
    //  bool answ = false;
    //  // cerco se ci sia valore in redis...
    //  IDatabase cache = connRedis.GetDatabase();
    //  try
    //  {
    //    answ = cache.HashGetAll(key).Length > 0;
    //  }
    //  catch
    //  { }
    //  return answ;
    //}
    ///// <summary>
    ///// Recupera tutti i valori dalla hash
    ///// </summary>
    ///// <param name="hashKey"></param>
    ///// <returns></returns>
    //public KeyValuePair<string, string>[] redGetHash(string hashKey)
    //{
    //  KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[1];
    //  // cerco se ci sia valore in redis...
    //  IDatabase cache = connRedis.GetDatabase();
    //  try
    //  {
    //    RedisKey chiave = hashKey;
    //    HashEntry[] valori = cache.HashGetAll(chiave);
    //    answ = new KeyValuePair<string, string>[valori.Length];
    //    int i = 0;
    //    foreach (HashEntry item in valori)
    //    {
    //      answ[i] = new KeyValuePair<string, string>(item.Name, item.Value);
    //      i++;
    //    }
    //  }
    //  catch
    //  { }
    //  return answ;
    //}
    ///// <summary>
    ///// Salvataggio di una hash di valori
    ///// </summary> 
    ///// <param name="hashKey"></param>
    ///// <param name="hashFields"></param>
    ///// <returns></returns>
    //public bool redSaveHash(string hashKey, KeyValuePair<string, string>[] hashFields)
    //{
    //  bool answ = false;
    //  // cerco se ci sia valore in redis...
    //  IDatabase cache = connRedis.GetDatabase();
    //  try
    //  {
    //    RedisKey chiave = hashKey;
    //    HashEntry[] valori = new HashEntry[hashFields.Length];
    //    int i = 0;
    //    foreach (KeyValuePair<string, string> kvp in hashFields)
    //    {
    //      valori[i] = new HashEntry(kvp.Key, kvp.Value);
    //      i++;
    //    }
    //    cache.HashSet(chiave, valori);
    //    answ = true;
    //  }
    //  catch
    //  { }
    //  return answ;
    //}
    ///// <summary>
    ///// Elimina una key (hash, string)
    ///// </summary>
    ///// <param name="key"></param>
    ///// <returns></returns>
    //public bool redDelKey(string key)
    //{
    //  bool answ = false;
    //  // cerco se ci sia valore in redis...
    //  IDatabase cache = connRedis.GetDatabase();
    //  try
    //  {
    //    RedisKey chiave = key;
    //    cache.KeyDelete(chiave);
    //    answ = true;
    //  }
    //  catch
    //  { }
    //  return answ;
    //}
    ///// <summary>
    ///// Flush completo cache redis
    ///// </summary>
    ///// <param name="keyPattern">** = tutti</param>
    ///// <returns></returns>
    //public bool redFlushKey(string keyPattern)
    //{
    //  bool answ = false;
    //  // cerco se ci sia valore in redis...
    //  IDatabase cache = connRedis.GetDatabase();
    //  // se vuoto = ALL...
    //  keyPattern = keyPattern == "" ? "**" : keyPattern;
    //  try
    //  {
    //    foreach (var ep in connRedis.GetEndPoints())
    //    {
    //      var server = connRedis.GetServer(ep);
    //      foreach (var key in server.Keys(pattern: keyPattern))
    //      {
    //        cache.KeyDelete(key);
    //      }
    //    }
    //    answ = true;
    //  }
    //  catch (Exception exc)
    //  {
    //    logger.lg.scriviLog(string.Format("{0}", exc), tipoLog.EXCEPTION);
    //  }
    //  return answ;
    //}
    ///// <summary>
    ///// Restituisce numero record in Redis DB
    ///// </summary>
    //public long numRecRedis
    //{
    //  get
    //  {
    //    long answ = 0;
    //    try
    //    {
    //      foreach (var ep in connRedis.GetEndPoints())
    //      {
    //        var server = connRedis.GetServer(ep);
    //        answ += server.DatabaseSize();
    //      }
    //    }
    //    catch
    //    { }
    //    return answ;
    //  }
    //}


    //#endregion

    #region gestione file config

    /// <summary>
    /// legge dalla config un valore bool
    /// </summary>
    /// <param name="nomeParam"></param>
    /// <returns></returns>
    public bool confReadBool(string nomeParam)
    {
      bool answ = false;
      try
      {
        answ = (bool)configAppSetReader.GetValue(nomeParam, typeof(bool));
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// legge dalla config un valore string
    /// </summary>
    /// <param name="nomeParam"></param>
    /// <returns></returns>
    public string confReadString(string nomeParam)
    {
      string answ = "";
      try
      {
        answ = (string)configAppSetReader.GetValue(nomeParam, typeof(string));
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// legge dalla config un valore int
    /// </summary>
    /// <param name="nomeParam"></param>
    /// <returns></returns>
    public int confReadInt(string nomeParam)
    {
      int answ = -1;
      try
      {
        answ = (int)configAppSetReader.GetValue(nomeParam, typeof(int));
      }
      catch
      { }
      return answ;
    }

    #endregion


    #region querystring

    /// <summary>
    /// recupera valore querystring STRING
    /// </summary>
    /// <param name="nome"></param>
    /// <returns>valore string</returns>
    public string QSS(string nome)
    {
      string answ = "";
      try
      {
        answ = HttpContext.Current.Request.QueryString[nome].ToString().Trim();
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// recupera valore querystring INT
    /// </summary>
    /// <param name="nome"></param>
    /// <returns>valore INT</returns>
    public int QSI(string nome)
    {
      int answ = 0;
      try
      {
        answ = Convert.ToInt32(HttpContext.Current.Request.QueryString[nome]);
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// recupera valore querystring BOOL
    /// </summary>
    /// <param name="nome"></param>
    /// <returns>valore string</returns>
    public bool QSB(string nome)
    {
      bool answ = false;
      try
      {
        answ = Convert.ToBoolean(HttpContext.Current.Request.QueryString[nome]);
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// recupera valore querystring DATE
    /// </summary>
    /// <param name="nome"></param>
    /// <returns>valore DATE</returns>
    public DateTime QSD(string nome)
    {
      DateTime answ = DateTime.Now;
      try
      {
        answ = Convert.ToDateTime(HttpContext.Current.Request.QueryString[nome]);
      }
      catch
      { }
      return answ;
    }

    #endregion

    #region area varie

    /// <summary>
    /// ripulisce la stringa da eventuali caratteri non ammessi quali
    ///  [ .,;\/]
    ///  e OPZIONALMENTE toglie " " (spazi) sostituendoli con "_" (underscore)
    /// </summary>
    /// <param name="originalName">stringa originale</param>
    /// <param name="keepSpaces">definisce se mantenere (true) o togliere (false) gli spazi (eventualmente sostituendo con underscore "_")</param>
    /// <returns></returns>
    public static string cleanPathName(string originalName, bool keepSpaces)
    {
      string answ = originalName.Trim().Replace("&", "e").Replace(".", "").Replace(",", "").Replace(";", "").Replace(":", "").Replace("/", "-").Replace(@"\", "-").Replace(@"'", "_").Replace("\"", "_").Replace("#", "_").Replace("?", "_").Replace("*", "_").Replace(" ", "_").Replace("__", "_").Replace("__", "_").Replace("__", "_").Replace("__", "_"); ;
      if (keepSpaces)
      {
        answ = originalName.Trim().Replace("&", "e").Replace(".", "").Replace(",", "").Replace(";", "").Replace(":", "").Replace("/", "-").Replace(@"\", "-").Replace(@"'", "_").Replace("\"", "_").Replace("#", "_").Replace("?", "_").Replace("*", "_").Replace("  ", " ").Replace("  ", " ").Replace("  ", " ").Replace("  ", " ").Replace("__", "_").Replace("__", "_").Replace("__", "_").Replace("__", "_");
      }
      return answ;
    }
    /// <summary>
    /// ripulisce la stringa da eventuali caratteri non ammessi quali
    ///  [ .,;\/]
    ///  e toglie " " (spazi) sostituendoli con "_" (underscore)
    /// </summary>
    /// <param name="originalName">stringa originale</param>
    /// <returns></returns>
    public static string cleanPathName(string originalName)
    {
      return cleanPathName(originalName, false);
    }
    /// <summary>
    /// restituisce, in caso di null o stringa vuota, il carattere "*"
    /// </summary>
    /// <param name="original"></param>
    /// <returns></returns>
    public static string emptyToStar(string original)
    {
      string answ = original;
      if ((original == null) || (original == ""))
      {
        answ = "*";
      }
      return answ;
    }
    /// <summary>
    /// Effettua shring di una stringa ricudendola in lunghezza (tiene inizio/fine + eventuale ".." centrale se lungh superiore a indicata)
    /// </summary>
    /// <param name="originalString">stringa originale</param>
    /// <param name="maxLenght">lungh max desiderata</param>
    /// <returns></returns>
    public static string shrinkString(string originalString, int maxLenght)
    {
      string answ = originalString;
      if (answ.Length > maxLenght)
      {
        string sep = utils.obj.confReadString("separatoreTrim");
        int numChar = (maxLenght - sep.Length) / 2;
        answ = string.Format("{0}{1}{2}", answ.Substring(0, numChar), sep, answ.Substring(answ.Length - (maxLenght - 3 - numChar)));
      }
      return answ;
    }
    /// <summary>
    /// trimma una stringa per il num max di caratteri richiesti togliendo dal centro (tiene inizio/fine...)
    /// </summary>
    /// <param name="stringaIn"></param>
    /// <param name="maxNum"></param>
    /// <param name="ignoreRight">num caratteri da ignorare a dx</param>
    /// <returns></returns>
    public static string shrinkString(string stringaIn, int maxNum, int ignoreRight)
    {
      // elimino caratteri a dx.. se posso
      string answ = stringaIn;
      if (ignoreRight < stringaIn.Length)
      {
        answ = answ.Substring(0, stringaIn.Length - ignoreRight);
      }
      // effetuo shrink!
      answ = shrinkString(answ, maxNum);
      return answ;
    }

    /// <summary>
    /// trimma una stringa per il num max di caratteri richiesti
    /// </summary>
    /// <param name="stringaIn"></param>
    /// <returns></returns>
    public static string trimChar(object stringaIn, object maxChar)
    {
      string answ = "";
      int maxNum = 0;
      try
      {
        answ = stringaIn.ToString();
        maxNum = Convert.ToInt32(maxChar);
      }
      catch
      { }
      if (maxNum < answ.Length)
      {
        answ = answ.Substring(0, maxNum) + "...";
      }
      return answ;
    }
    public static int pageSizeConf
    {
      get
      {
        return obj.confReadInt("pageSize");
      }
    }
    /// <summary>
    /// dim pagina desiderata
    /// </summary>
    public static int pageSize
    {
      get
      {
        int answ = 0;
        try
        {
          answ = utils.obj.IntSessionObj("pageSize");
        }
        catch
        { }
        if (answ <= 0)
        {
          answ = 20;
        }
        return answ;
      }
      set
      {
        utils.obj.setSessionVal("pageSize", value);
      }
    }
    #endregion

    #region gestione ruoli utente...

    /// <summary>
    /// risponde alla domanda se l'utente sia PowerUser
    /// </summary>
    /// <returns></returns>
    public bool isPowerUser
    {
      get
      {
        return user_std.UtSn.userHasRight("PowerUser");
      }
    }
    /// <summary>
    /// risponde alla domanda se l'utente sia PowerReader
    /// </summary>
    /// <returns></returns>
    public bool isPowerReader
    {
      get
      {
        return user_std.UtSn.userHasRight("PowerReader");
      }
    }
    /// <summary>
    /// risponde alla domanda se l'utente sia ProjectManager
    /// </summary>
    /// <returns></returns>
    public bool isPM
    {
      get
      {
        return user_std.UtSn.userHasRight("PM");
      }
    }
    /// <summary>
    /// risponde alla domanda se l'utente sia CapoCommessa
    /// </summary>
    /// <returns></returns>
    public bool isCC
    {
      get
      {
        return user_std.UtSn.userHasRight("CC");
      }
    }
    /// <summary>
    /// risponde alla domanda se l'utente sia User
    /// </summary>
    /// <returns></returns>
    public bool isUser
    {
      get
      {
        return user_std.UtSn.userHasRight("User");
      }
    }
    /// <summary>
    /// risponde alla domanda se l'utente sia CC della commessa indicata dalla fase
    /// </summary>
    /// <param name="idxFase"></param>
    /// <returns></returns>
    public bool isCurrentCC(int idxFase)
    {
      bool answ = false;
      string CapoCommessa = "";
      try
      {
        CapoCommessa = DataProxy_ProjEts.DP.taDC.GetData(idxFase)[0].CapoCommessa;
      }
      catch
      { }
      if (user_std.UtSn.NomeCognome == CapoCommessa || user_std.UtSn.CognomeNome == CapoCommessa)
      {
        answ = true;
      }
      return answ;
    }

    #endregion

  }
  /// <summary>
  /// definisce un intervalo di 2 date
  /// </summary>
  public struct intervalloDate
  {
    /// <summary>
    /// data inizio
    /// </summary>
    public DateTime inizio;
    /// <summary>
    /// data fine
    /// </summary>
    public DateTime fine;
    /// <summary>
    /// indica se sia valido il dato, ovvero inizio e fine > 0 e FINE >= INIZIO
    /// </summary>
    public bool isValid
    {
      get
      {
        bool cond1 = false;
        bool cond2 = false;
        bool cond3 = false;
        try
        {
          cond1 = inizio > Convert.ToDateTime("01/01/0001");
        }
        catch
        { }
        try
        {
          cond2 = fine > Convert.ToDateTime("01/01/0001");
        }
        catch
        { }
        try
        {
          cond3 = (fine.Subtract(inizio).TotalHours > 0);
        }
        catch
        { }
        return (cond1 && cond2 && cond3);
      }
    }
  }

  public class oreWeek
  {
    /// <summary>
    /// inizializzazione empty
    /// </summary>
    public oreWeek()
    {
    }
    /// <summary>
    /// effettua una somma di ore dallo schema ore LMMGV facendo somma giorno per giorno
    /// </summary>
    /// <param name="addendo1">string LMMGV (se <> 5 char errore)</param>
    /// <param name="addendo2">string LMMGV (se <> 5 char errore)</param>
    /// <returns>Restituisce:
    /// - somma giornaliera LMMGV
    /// - "X" se nel singolo giorno > maxOre
    /// - "?????" se secondo addendo nn di 5 char
    /// - "#" se non può convertire un singolo char</returns>
    public static string addOre(string addendo1, string addendo2, int MaxOre)
    {
      string answ = "";
      int summa = 0;
      // procedo SOLO se le 2 stringhe sono 5 char
      if (addendo1.Length != 5 || addendo2.Length != 5)
      {
        answ = "?????";
      }
      else
      {
        // faccio somma 1 char alla volta e controllo lungh max
        for (int i = 0; i < 5; i++)
        {
          try
          {
            // se già ho carattere "X" confermo "X"...
            if (addendo1.Substring(i, 1) == "X" || addendo1.Substring(i, 1) == "X")
            {
              answ += "X";
            }
            else
            {
              summa = Convert.ToInt16(addendo1.Substring(i, 1)) + Convert.ToInt16(addendo2.Substring(i, 1));
              if (summa > MaxOre)
              {
                answ += "X";
              }
              else
              {
                answ += summa.ToString();
              }
            }
          }
          catch (Exception exc)
          {
            answ += "X";
          }
        }
      }
      return answ;
    }
  }

  /// <summary>
  /// classe di funzioni inerenti le date
  /// </summary>
  public class datario
  {
    /// <summary>
    /// inizializzazione empty
    /// </summary>
    public datario()
    {
    }
    /// <summary>
    /// costruisce un oggetto intervallo date
    /// </summary>
    /// <param name="inizio"></param>
    /// <param name="fine"></param>
    /// <returns></returns>
    public intervalloDate setIntervallo(DateTime inizio, DateTime fine)
    {
      intervalloDate periodo = new intervalloDate();
      periodo.inizio = inizio;
      periodo.fine = fine;
      return periodo;
    }
    /// <summary>
    /// effettua l'operazione di intersezione tra 2 intervali di date restituendo ulteriore intervallo: NB se sono intervali disgiunti restituisce 9/9/9999 x inizio e fine
    /// </summary>
    /// <param name="interv1"></param>
    /// <param name="interv2"></param>
    /// <returns></returns>
    public intervalloDate intersecaIntervalli(intervalloDate interv1, intervalloDate interv2)
    {
      intervalloDate interv3;
      // verifico non siano disgiunti...
      if (interv1.fine < interv2.inizio || interv2.fine < interv1.inizio)
      {
        interv3.inizio = Convert.ToDateTime("9/9/9999");
        interv3.fine = Convert.ToDateTime("9/9/9999");
      }
      else
      {
        interv3 = interv1;
        if (interv2.inizio > interv1.inizio)
        {
          interv3.inizio = interv2.inizio;
        }
        if (interv2.fine < interv1.fine)
        {
          interv3.fine = interv2.fine;
        }
      }
      return interv3;
    }
    /// <summary>
    /// oggetto mese precedente alla dataLilmite
    /// </summary>
    /// <param name="dataLimite"></param>
    public intervalloDate mesePrecedente(DateTime dataLimite)
    {
      intervalloDate interv = new intervalloDate();
      interv.inizio = dataLimite.AddMonths(-1).AddDays(-(dataLimite.Day - 1)).Subtract(dataLimite.TimeOfDay);
      interv.fine = dataLimite.AddDays(-(dataLimite.Day - 1)).Subtract(dataLimite.TimeOfDay);
      return interv;
    }
    /// <summary>
    /// oggetto mese corrente fino alla dataLilmite
    /// </summary>
    /// <param name="dataLimite"></param>
    public intervalloDate meseCorrente(DateTime dataLimite)
    {
      intervalloDate interv = new intervalloDate();
      interv.inizio = dataLimite.AddDays(-(dataLimite.Day - 1)).Subtract(dataLimite.TimeOfDay);
      interv.fine = dataLimite.Subtract(dataLimite.TimeOfDay);
      return interv;
    }
    /// <summary>
    /// confronta le date e restituisce true se le date sono nello stesso mese
    /// </summary>
    /// <param name="data1"></param>
    /// <param name="data2"></param>
    /// <returns></returns>
    public bool stessoMese(DateTime data1, DateTime data2)
    {
      bool stessoMese = false;
      if ((data1.Year == data2.Year) && (data1.Month == data2.Month))
      {
        stessoMese = true;
      }
      return stessoMese;
    }
    /// <summary>
    /// restituisce l'intervallo del giorno completo che comprende la data indicata
    /// </summary>
    /// <param name="data"></param>
    /// <returns></returns>
    public intervalloDate giornata(DateTime data)
    {
      intervalloDate interv = new intervalloDate();
      interv.inizio = data.Subtract(data.TimeOfDay);
      interv.fine = interv.inizio.AddDays(1);
      return interv;
    }
    /// <summary>
    /// restituisce l'intervallo di N giorni fino alla data indicata
    /// </summary>
    /// <param name="data"></param>
    /// <param name="numGiorniPrima"></param>
    /// <returns></returns>
    public intervalloDate ultimiGiorni(DateTime data, int numGiorniPrima)
    {
      intervalloDate interv = new intervalloDate();
      interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
      interv.inizio = interv.fine.AddDays(-numGiorniPrima);
      return interv;
    }
    /// <summary>
    /// restituisce l'intervallo della settimana corrente per la data indicata
    /// </summary>
    /// <param name="data"></param>
    /// <returns></returns>
    public intervalloDate questaSett(DateTime data)
    {
      intervalloDate interv = new intervalloDate();
      interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
      DayOfWeek giorno = data.DayOfWeek;
      int numGG = 0;
      switch (giorno)
      {
        case DayOfWeek.Monday:
          numGG = 1;
          break;
        case DayOfWeek.Tuesday:
          numGG = 2;
          break;
        case DayOfWeek.Wednesday:
          numGG = 3;
          break;
        case DayOfWeek.Thursday:
          numGG = 4;
          break;
        case DayOfWeek.Friday:
          numGG = 5;
          break;
        case DayOfWeek.Saturday:
          numGG = 6;
          break;
        case DayOfWeek.Sunday:
          numGG = 7;
          break;
        default:
          break;
      }
      interv.inizio = interv.fine.AddDays(-numGG);
      return interv;
    }
    /// <summary>
    /// restituisce l'intervallo del mese corrente per la data indicata (dal giorno 1 all'indomani delal data indicata)
    /// </summary>
    /// <param name="data"></param>
    /// <returns></returns>
    public intervalloDate questoMese(DateTime data)
    {
      intervalloDate interv = new intervalloDate();
      interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
      interv.inizio = interv.fine.AddDays(-data.Day);
      return interv;
    }
    /// <summary>
    /// restituisce l'intervallo del mese che comprende la data indicata (dal primo all'ultimo giorno)
    /// </summary>
    /// <param name="data"></param>
    /// <returns></returns>
    public intervalloDate estremiMese(DateTime data)
    {
      intervalloDate interv = new intervalloDate();
      interv.inizio = data.AddDays(-(data.Day - 1)).Subtract(data.TimeOfDay);
      interv.fine = interv.inizio.AddMonths(1);
      return interv;
    }
    /// <summary>
    /// restituisce l'intervallo dell'anno corrente per la data indicata
    /// </summary>
    /// <param name="data"></param>
    /// <returns></returns>
    public intervalloDate estremiAnno(DateTime data)
    {
      intervalloDate interv = new intervalloDate();
      interv.inizio = data.AddDays(-(data.Day - 1)).AddMonths(-(data.Month - 1)).Subtract(data.TimeOfDay);
      interv.fine = interv.inizio.AddMonths(12);
      return interv;
    }
    /// <summary>
    /// oggetto singleton
    /// </summary>
    public static datario mngr = new datario();
    /// <summary>
    /// calcola week number secondo ISO 8601
    /// </summary>
    /// <param name="date"></param>
    /// <returns></returns>
    public static int WeekOfYearISO8601(DateTime date)
    {
      var day = (int)CultureInfo.CurrentCulture.Calendar.GetDayOfWeek(date);
      return CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(date.AddDays(4 - (day == 0 ? 7 : day)), CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
    }
    /// <summary>
    /// restituisce la prima data della settimana richiesta
    /// </summary>
    /// <param name="year"></param>
    /// <param name="weekOfYear"></param>
    /// <returns></returns>
    public static DateTime FirstDateOfWeekISO8601(int year, int weekOfYear)
    {
      DateTime jan1 = new DateTime(year, 1, 1);
      int daysOffset = DayOfWeek.Thursday - jan1.DayOfWeek;

      DateTime firstThursday = jan1.AddDays(daysOffset);
      var cal = CultureInfo.CurrentCulture.Calendar;
      int firstWeek = cal.GetWeekOfYear(firstThursday, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);

      var weekNum = weekOfYear;
      if (firstWeek <= 1)
      {
        weekNum -= 1;
      }
      var result = firstThursday.AddDays(weekNum * 7);
      return result.AddDays(-3);
    }
  }
}