using System;
using System.Configuration;
using System.Globalization;
using System.IO;
using System.Web;
using NLog;
using System.Net.Mail;
using System.Collections.Generic;
using StackExchange.Redis;
using System.Data;
using Newtonsoft.Json;

namespace ETS_Data
{
    /// <summary>
    /// definisce un intervalo di 2 date
    /// </summary>
    public struct intervalloDate
    {
        #region Public Fields

        /// <summary>
        /// data fine
        /// </summary>
        public DateTime fine;

        /// <summary>
        /// data inizio
        /// </summary>
        public DateTime inizio;

        #endregion Public Fields

        #region Public Properties

        /// <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);
            }
        }

        #endregion Public Properties
    }

    /// <summary>
    /// Helper methods e funzioni x gestione conversione dataset tipizzati e non
    /// </summary>
    /// <typeparam name="T">A strongly type DataTable.
    /// A DataTable of type T will be returned from the DataSet.
    /// </typeparam>
    public static class DataSetAdapter<T>
      where T : DataTable, new()
    {
        #region Public Methods

        /// <summary>
        /// Convert the first DataTable from a DataSet to a
        /// strongly-typed data table.
        /// </summary>
        public static T convert(DataSet dataSet)
        {
            if (dataSet == null)
                return null;
            if (dataSet.Tables.Count == 0)
                return null;
            DataTable dataTable = dataSet.Tables[0];
            return convert(dataTable);
        }

        /// <summary>
        /// Convert an ordinary DataTable to a strongly-typed
        /// data table.
        /// </summary>
        public static T convert(DataTable dataTable)
        {
            if (dataTable == null)
                return null;
            T stronglyTyped = new T();
            // add data from the regular DataTable to the
            // strongly typed DataTable.
            stronglyTyped.Merge(dataTable, true, MissingSchemaAction.Ignore);
            return stronglyTyped;
        }

        #endregion Public Methods
    }

    /// <summary>
    /// Struttura allocazione risorse / commessa
    /// </summary>
    public class allocRis
    {
        #region Public Constructors

        /// <summary>
        /// Inizializzazione oggetto
        /// </summary>
        /// <param name="commessa"></param>
        /// <param name="risorsa"></param>
        /// <param name="allocazione"></param>
        public allocRis(string commessa, string risorsa, int allocazione)
        {
            this.commessa = commessa;
            this.risorsa = risorsa;
            this.allocazione = allocazione;
        }

        #endregion Public Constructors

        #region Public Properties

        /// <summary>
        /// allocazione risorsa/commessa
        /// </summary>
        public int allocazione { get; set; }

        /// <summary>
        /// codice commessa
        /// </summary>
        public string commessa { get; set; }

        /// <summary>
        /// codice risorsa
        /// </summary>
        public string risorsa { get; set; }

        #endregion Public Properties
    }

    /// <summary>
    /// classe di funzioni inerenti le date
    /// </summary>
    public class datario
    {
        #region Public Fields

        /// <summary>
        /// oggetto singleton
        /// </summary>
        public static datario mngr = new datario();

        #endregion Public Fields

        #region Public Constructors

        /// <summary>
        /// inizializzazione empty
        /// </summary>
        public datario()
        {
        }

        #endregion Public Constructors

        #region Public Methods

        /// <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);
        }

        /// <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 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>
        /// 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 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>
        /// 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 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>
        /// 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>
        /// 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>
        /// 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>
        /// 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 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;
        }

        #endregion Public Methods
    }

    public class oreWeek
    {
        #region Public Constructors

        /// <summary>
        /// inizializzazione empty
        /// </summary>
        public oreWeek()
        {
        }

        #endregion Public Constructors

        #region Public Methods

        /// <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
                    {
                        answ += "X";
                    }
                }
            }
            return answ;
        }

        #endregion Public Methods
    }

    public class utils
    {
        #region Private Fields

        /// <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");
        });

        #endregion Private Fields

        #region Protected Fields

        protected AppSettingsReader configAppSetReader;

        #endregion Protected Fields

        #region Public Fields

        public static Logger lg = LogManager.GetCurrentClassLogger();

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

        public DS_utilsTableAdapters.AnagSuggestTagsTableAdapter taAST;
        public DS_utilsTableAdapters.stp_calcolaProtocolloTableAdapter taCalcProto;
        public DS_WebScipTableAdapters.stp_userLoginRefreshDbTableAdapter taDBRefresh;
        public DS_AnagraficaTableAdapters.DirittiTableAdapter taDiritti;
        public DS_WebScipTableAdapters.tbDocumentiTableAdapter taDoc;
        public DS_utilsTableAdapters.v_selEmailFornitoriTableAdapter taEmailForn;
        public DS_utilsTableAdapters.v_selAutoriTableAdapter taSelAutori;
        public DS_utilsTableAdapters.v_selCommesseTableAdapter taSelCommesse;
        public DS_utilsTableAdapters.v_selFasiTableAdapter taSelFasi;
        public DS_utilsTableAdapters.v_selFontiTableAdapter taSelFonti;
        public DS_WebScipTableAdapters.Tags2DocTableAdapter taTags2Doc;
        public DS_utilsTableAdapters.v_tbDocs_selCommesseTableAdapter taTDSelCommesse;
        public DS_utilsTableAdapters.v_tbDocs_selFasiTableAdapter taTDSelFasi;
        public DS_utilsTableAdapters.v_tbDocs_selFontiTableAdapter taTDSelFonti;
        public DS_utilsTableAdapters.v_tbDocs_selOggettoTableAdapter taTDSelOggetti;
        public DS_utilsTableAdapters.v_tbDocs_selRedattoreTableAdapter taTDSelRedattore;
        public DS_WebScipTableAdapters.tbMetaDataSetTableAdapter taTMD;
        public DS_AnagraficaTableAdapters.UtentiTableAdapter taUtenti;
        public DS_utilsTableAdapters.v_selFonti_explTableAdapter taVSFE;

        #endregion Public Fields

        #region Protected Constructors

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

        #endregion Protected Constructors

        #region Public Properties

        /// <summary>
        /// Oggetto statico connessione redis
        /// </summary>
        public static ConnectionMultiplexer connRedis
        {
            get
            {
                return lazyConnection.Value;
            }
        }

        /// <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);
            }
        }

        public static int pageSizeConf
        {
            get
            {
                return obj.confReadInt("pageSize");
            }
        }

        /// <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 dominio\username)
        /// </summary>
        public string currUserAD
        {
            get
            {
                return user_std.UtSn.currUserAD;
            }
        }

        /// <summary>
        /// WRAPPER utente correntemente connesso (Formato Cognome nome)
        /// </summary>
        public string currUserCognomeNome
        {
            get
            {
                return user_std.UtSn.currUserCognomeNome;
            }
        }

        /// <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 utente correntemente connesso (Formato Nome Cognome)
        /// </summary>
        public string currUserNomeCognome
        {
            get
            {
                return user_std.UtSn.currUserNomeCognome;
            }
        }

        /// <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 ProjectManager
        /// </summary>
        /// <returns></returns>
        public bool isPM
        {
            get
            {
                return user_std.UtSn.userHasRight("PM");
            }
        }

        /// <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 PowerUser
        /// </summary>
        /// <returns></returns>
        public bool isPowerUser
        {
            get
            {
                return user_std.UtSn.userHasRight("PowerUser");
            }
        }

        /// <summary>
        /// risponde alla domanda se l'utente sia User
        /// </summary>
        /// <returns></returns>
        public bool isUser
        {
            get
            {
                return user_std.UtSn.userHasRight("User");
            }
        }

        /// <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;
            }
        }

        /// <summary>
        /// Verifica se si debba serializzare ogni valore complesso (tabelle/righe) in sessione (per impiego di sessioni avanzate come Redis)
        /// </summary>
        public bool serializeSession
        {
            get
            {
                return confReadBool("serializeSession");
            }
        }

        /// <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>
        /// 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);
            }
        }

        #endregion Public Properties

        #region Protected Methods

        /// <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 Protected Methods

        #region Public Methods

        /// <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;
        }

        /// <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>
        /// 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>
        /// 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 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>
        /// 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 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;
        }

        /// <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>
        /// carica dalla sessione un dato di tipo DataSet NON Tipizzato
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public DataSet dsSessionObj(string nomeVar)
        {
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                string valSer = obj.StringSessionObj(nomeVar);
                DataSet dataSet = JsonConvert.DeserializeObject<DataSet>(valSer);
                return dataSet;
            }
            else
            {
                return null;
            }
        }

        /// <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>
        /// 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>
        /// 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");
        }

        /// <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)
            {
                utils.lg.Error(string.Format("Errore in getRSV:{0}{1}", Environment.NewLine, exc));
            }
            return answInt;
        }

        /// <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)
            {
                utils.lg.Error(string.Format("Errore in getRKeys:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }

        /// <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)
            {
                utils.lg.Error(string.Format("Errore in getRSV:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }

        /// <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>
        /// 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;
        }

        /// <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>
        /// 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
            {
                if (HttpContext.Current.Session != null && HttpContext.Current.Session[nomeVar] != null)
                {
                    stringAnsw = !string.IsNullOrEmpty($"{HttpContext.Current.Session[nomeVar]}");
                    //stringAnsw = (string)HttpContext.Current.Session[nomeVar].ToString() != "";
                }
            }
            catch
            { }
            // infine condizione doppia...
            try
            {
                answ = (HttpContext.Current.Session[nomeVar] != null && stringAnsw);
            }
            catch
            { }
            return answ;
        }

        /// <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 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 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>
        /// 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;
        }

        /// <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 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>
        /// 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)
            {
                utils.lg.Error(string.Format("{0}", exc));
            }
            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>
        /// Nome della variabile HASH da utilizzare dato CodModulo  + keyName richiesto...
        /// </summary>
        public string redHash(string keyName)
        {
            string answ = keyName;
            try
            {
                answ = $"{confReadString("CodModulo")}:{keyName}".Replace("\\", "_").Replace(" ", "_");
            }
            catch
            { }
            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>
        /// 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>
        /// 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)
            {
                utils.lg.Error(string.Format("Errore in resetRCnt:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }

        /// <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>
        /// 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)
            {
                utils.lg.Error(string.Format("Errore in setRCD:{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)
            {
                utils.lg.Error(string.Format("Errore in setRCI:{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)
            {
                utils.lg.Error(string.Format("Errore in setRKeys:{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)
            {
                utils.lg.Error(string.Format("Errore in setRSV:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }

        /// <summary>
        /// Salva una chiave in RedisCache
        /// </summary>
        /// <param name="chiave"></param>
        /// <param name="valore"></param>
        /// <param name="TTL_sec">in secondi</param>
        /// <returns></returns>
        public bool setRSV(string chiave, string valore, int TTL_sec)
        {
            bool answ = false;
            try
            {
                TimeSpan expT = new TimeSpan(0, 0, TTL_sec);
                // salvo con expiry...
                IDatabase cache = connRedis.GetDatabase();
                cache.StringSet(chiave, valore, expT);
                answ = true;
            }
            catch (Exception exc)
            {
                utils.lg.Error($"Errore in setRSV | chiave: {chiave} | valore: {valore} | TTL: {TTL_sec}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <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>
        /// 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>
        /// 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>
        /// 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 Public Methods

        #region Public Classes

        /// <summary>
        /// classe di gestione delle email
        /// </summary>
        public class gestEmail
        {
            #region Protected Fields

            /// <summary>
            /// stringa pwd x server SMTP
            /// </summary>
            protected string _password;

            /// <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;

            protected Logger lg = LogManager.GetCurrentClassLogger();

            #endregion Protected Fields

            #region Public Fields

            /// <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 Public Fields

            #region Public Constructors

            /// <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 = "";
            }

            #endregion Public Constructors

            #region Public Methods

            /// <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.Error($"ERRORE! Email NON INVIATA!oggetto: {_oggetto} corpo: {_corpo} eccezione:{Environment.NewLine}{exc}");
                }
                return fatto;
            }

            /// <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.Error($"{esmtp.Message}{Environment.NewLine}full error message:{Environment.NewLine}{esmtp}");
                    return false;
                }
            }

            #endregion Public Methods
        }

        #endregion Public Classes
    }
}