diff --git a/SteamWareLib/utils.cs b/SteamWareLib/utils.cs
index 7da8c65..13fe020 100644
--- a/SteamWareLib/utils.cs
+++ b/SteamWareLib/utils.cs
@@ -15,55 +15,261 @@ using System.Text;
 
 namespace SteamWare
 {
-    #region gestione date
-
-    /// <summary>
-    /// struttura che definisce i parametri di un turno di lavoro
-    /// </summary>
-    public struct turnoLavoro
+    namespace StringSplitter
     {
         /// <summary>
-        /// Gets or sets the cod turno.
+        /// Tipo di comparazione, Binary == CaseSensitive, Text = insensitive
         /// </summary>
-        /// <value>
-        /// The cod turno.
-        /// </value>
-        public string codTurno { get; set; }
+        public enum ComparisonMethod
+        {
+            /// <summary>
+            /// tipo controllo : binario
+            /// </summary>
+            Binary = 0,
+
+            /// <summary>
+            /// tipo controllo : text
+            /// </summary>
+            Text = 1
+        }
+
         /// <summary>
-        /// Gets or sets the inizio.
+        /// Funzione di splitting compatibile con multi-character e multi-line
         /// </summary>
-        /// <value>
-        /// The inizio.
-        /// </value>
-        public DateTime inizio { get; set; }
-        /// <summary>
-        /// Gets or sets the fine.
-        /// </summary>
-        /// <value>
-        /// The fine.
-        /// </value>
-        public DateTime fine { get; set; }
-        /// <summary>
-        /// Gets or sets the periodo.
-        /// </summary>
-        /// <value>
-        /// The periodo.
-        /// </value>
-        public intervalloDate periodo { get; set; }
-        /// <summary>
-        /// Gets or sets the durata minuti.
-        /// </summary>
-        /// <value>
-        /// The durata minuti.
-        /// </value>
-        public int durataMinuti { get; set; }
-        /// <summary>
-        /// Gets or sets the t number.
-        /// </summary>
-        /// <value>
-        /// The t number.
-        /// </value>
-        public int TNum { get; set; }
+        public class CSplitter
+        {
+            #region Private Fields
+
+            /// <summary>
+            /// Delimiter con cui splittare
+            /// </summary>
+            private static string m_Delimiter;
+
+            /// <summary>
+            /// stringa da splittare
+            /// </summary>
+            private static string m_Expression;
+
+            #endregion Private Fields
+
+            #region Public Constructors
+
+            /// <summary>
+            /// Costruttore dello Splitter
+            /// </summary>
+            public CSplitter()
+            {
+                // non fa nulla all'inizializzazione
+            }
+
+            #endregion Public Constructors
+
+            #region Private Methods
+
+            /// <summary>
+            /// comparatore case sensitive
+            /// </summary>
+            /// <param name="StringIndex"></param>
+            /// <param name="DelimiterIndex"></param>
+            /// <returns></returns>
+            private static bool isValidDelimiterBinary(int StringIndex, int DelimiterIndex)
+            {
+                if (DelimiterIndex == m_Delimiter.Length)
+                {
+                    return true;
+                }
+
+                if (StringIndex == m_Expression.Length)
+                {
+                    return false;
+                }
+                //If the current character of the expression matches
+                //the current character of the Delimiter,
+                //then go to next character
+                if (m_Expression[StringIndex] ==
+                    m_Delimiter[DelimiterIndex])
+                {
+                    return isValidDelimiterBinary(StringIndex + 1,
+                        DelimiterIndex + 1);
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            /// <summary>
+            /// comparatore case insensitive
+            /// </summary>
+            /// <param name="StringIndex"></param>
+            /// <param name="DelimiterIndex"></param>
+            /// <returns></returns>
+            private static bool isValidDelimiterText(int StringIndex, int DelimiterIndex)
+            {
+                if (DelimiterIndex == m_Delimiter.Length)
+                {
+                    return true;
+                }
+
+                if (StringIndex == m_Expression.Length)
+                {
+                    return false;
+                }
+                //If the current character of the expression
+                //matches the current character of the Delimiter,
+                //then go to next character
+                if (Char.ToLower(m_Expression[StringIndex])
+                    == Char.ToLower(m_Delimiter[DelimiterIndex]))
+                {
+                    return isValidDelimiterText(StringIndex + 1,
+                        DelimiterIndex + 1);
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            #endregion Private Methods
+
+            #region Public Methods
+
+            /// <summary>
+            /// parte principale dello splitter
+            /// </summary>
+            /// <param name="Expression">stringa da splittare</param>
+            /// <param name="Delimiter">delimitatore ricercato</param>
+            /// <param name="SingleSeparator">true=il delimiter � un blocco unico, false=qualsiasi oggetto del delimiter fa split (come split base)</param>
+            /// <param name="Count"></param>
+            /// <param name="Compare">0 -> Binary=CaseSensitive, 1 -> Text=case insensitive</param>
+            /// <returns></returns>
+            public static string[] Split(string Expression, string Delimiter, bool SingleSeparator, int Count, ComparisonMethod Compare)
+            {
+                //Update Private Members
+                m_Expression = Expression;
+                m_Delimiter = Delimiter;
+
+                //Array to hold Splitted Tokens
+                System.Collections.ArrayList Tokens =
+                    new System.Collections.ArrayList();
+                //If not using single separator,
+                //then use the regular split function
+                if (!SingleSeparator)
+                {
+                    if (Count >= 0)
+                    {
+                        return Expression.Split(Delimiter.ToCharArray(), Count);
+                    }
+                    else
+                    {
+                        return Expression.Split(Delimiter.ToCharArray());
+                    }
+                }
+
+                //Check if count = 0 then return an empty array
+                if (Count == 0)
+                {
+                    return new string[0];
+                }
+                else
+                    //Check if Count = 1 then return the whole expression
+                    if (Count == 1)
+                {
+                    return new string[] { Expression };
+                }
+                else
+                {
+                    Count--;
+                }
+
+                // Indexer to loop over the string with
+                int i;
+                //The Start index of the current
+                //token in the expression
+                int iStart = 0;
+
+                if (Compare == ComparisonMethod.Binary)
+                {
+                    for (i = 0; i < Expression.Length; i++)
+                    {
+                        if (isValidDelimiterBinary(i, 0))
+                        {
+                            //Assign New Token
+                            Tokens.Add(Expression.Substring(iStart,
+                                i - iStart));
+                            //Update Index
+                            i += Delimiter.Length - 1;
+                            //Update Current Token Start index
+                            iStart = i + 1;
+                            //If we reached the tokens limit , then exit For
+                            if (Tokens.Count == Count && Count >= 0)
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    for (i = 0; i < Expression.Length; i++)
+                    {
+                        if (isValidDelimiterText(i, 0))
+                        {
+                            //Assign New Token
+                            Tokens.Add(Expression.Substring(iStart,
+                                i - iStart));
+                            //Update Index
+                            i += Delimiter.Length - 1;
+                            //Update Current Token Start index
+                            iStart = i + 1;
+                            //If we reached the tokens limit , then exit For
+                            if (Tokens.Count == Count && Count >= 0)
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+                string LastToken = "";
+                //If there is still data & have not been added
+                if (iStart < Expression.Length)
+                {
+                    LastToken = Expression.Substring(iStart,
+                        Expression.Length - iStart);
+                    if (LastToken == Delimiter)
+                    {
+                        Tokens.Add(null);
+                    }
+                    else
+                    {
+                        Tokens.Add(LastToken);
+                    }
+                }
+                else
+                    //If there is no elements in the tokens array,
+                    //then pass the whole string as the one element
+                    if (Tokens.Count == 0)
+                {
+                    Tokens.Add(Expression);
+                }
+                //Return Splitted Tokens
+                return (string[])
+                    Tokens.ToArray(Type.GetType("System.String"));
+            }
+
+            /// <summary>
+            /// elimina dal nome file il tipo (desinenza)
+            /// </summary>
+            /// <param name="nomeCompleto"></param>
+            /// <returns></returns>
+            public string nomeFileNoExt(string nomeCompleto)
+            {
+                string[] valori = Split(nomeCompleto, ".", true, 0, ComparisonMethod.Text);
+                return valori[valori.Length - 2];
+            }
+
+            #endregion Public Methods
+        }
     }
 
     /// <summary>
@@ -72,14 +278,22 @@ namespace SteamWare
     [Serializable]
     public struct intervalloDate
     {
-        /// <summary>
-        /// data inizio
-        /// </summary>
-        public DateTime inizio;
+        #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>
@@ -111,279 +325,243 @@ namespace SteamWare
                 return (cond1 && cond2 && cond3);
             }
         }
+
+        #endregion Public Properties
     }
+
     /// <summary>
     /// struttura orario ordinarie/strordinarie
     /// </summary>
     public struct orarioSvolto
     {
+        #region Public Fields
+
         /// <summary>
         /// ore ordinarie
         /// </summary>
         public double ordinarie;
+
         /// <summary>
         /// ore straordinarie
         /// </summary>
         public double straordinarie;
+
+        #endregion Public Fields
     }
+
+    /// <summary>
+    /// struttura che definisce i parametri di un turno di lavoro
+    /// </summary>
+    public struct turnoLavoro
+    {
+        #region Public Properties
+
+        /// <summary>
+        /// Gets or sets the cod turno.
+        /// </summary>
+        /// <value>
+        /// The cod turno.
+        /// </value>
+        public string codTurno { get; set; }
+
+        /// <summary>
+        /// Gets or sets the durata minuti.
+        /// </summary>
+        /// <value>
+        /// The durata minuti.
+        /// </value>
+        public int durataMinuti { get; set; }
+
+        /// <summary>
+        /// Gets or sets the fine.
+        /// </summary>
+        /// <value>
+        /// The fine.
+        /// </value>
+        public DateTime fine { get; set; }
+
+        /// <summary>
+        /// Gets or sets the inizio.
+        /// </summary>
+        /// <value>
+        /// The inizio.
+        /// </value>
+        public DateTime inizio { get; set; }
+
+        /// <summary>
+        /// Gets or sets the periodo.
+        /// </summary>
+        /// <value>
+        /// The periodo.
+        /// </value>
+        public intervalloDate periodo { get; set; }
+
+        /// <summary>
+        /// Gets or sets the t number.
+        /// </summary>
+        /// <value>
+        /// The t number.
+        /// </value>
+        public int TNum { get; set; }
+
+        #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>
+    /// fornisce dati di base per l'utente
+    /// </summary>
+    public class anagrData
+    {
+        #region Public Methods
+
+        /// <summary>
+        /// fornisce cognome e nome utente formattati a partire dall'username e dalla tabella UTENTE
+        /// </summary>
+        /// <param name="username"></param>
+        /// <returns></returns>
+        public string datiUtenteDaUsername(string username)
+        {
+            string answ = "";
+            DataLayer_AnagGenTableAdapters.UTENTETableAdapter taUtente = new SteamWare.DataLayer_AnagGenTableAdapters.UTENTETableAdapter();
+            try
+            {
+                DataLayer_AnagGen.UTENTERow _rigaUt = taUtente.GetData().FindByUSER_NAME(username);
+                answ = String.Format("{0} {1}", _rigaUt.COGNOME, _rigaUt.NOME);
+            }
+            catch
+            { }
+            return answ;
+        }
+
+        /// <summary>
+        /// restituisce la riga completa dall'username richiesto
+        /// </summary>
+        /// <param name="username"></param>
+        /// <returns></returns>
+        public DataLayer_AnagGen.UTENTERow rigaUtenteDaUsername(string username)
+        {
+            DataLayer_AnagGenTableAdapters.UTENTETableAdapter taUtente = new SteamWare.DataLayer_AnagGenTableAdapters.UTENTETableAdapter();
+            try
+            {
+                return taUtente.GetData().FindByUSER_NAME(username);
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        #endregion Public Methods
+    }
+
     /// <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()
         {
         }
-        /// <summary>
-        /// calcola il turno di riferimento data una data di riferimento
-        /// </summary>
-        /// <param name="dataOraRif">The data ora rif.</param>
-        /// <param name="shiftTurno">The shift turno.</param>
-        /// <param name="durataTurno">The durata turno.</param>
-        /// <returns></returns>
-        public turnoLavoro getTurnoByDateTime(DateTime dataOraRif, int shiftTurno, int durataTurno)
-        {
-            // inizio con shift alla data-ora corrente..
-            dataOraRif = dataOraRif.AddHours(-shiftTurno);
-            // continuo calcolo
-            TimeSpan oraRif = dataOraRif.TimeOfDay;
-            DateTime dataRif = dataOraRif.Add(-oraRif);
-            // calcolo!
-            turnoLavoro answ = new turnoLavoro();
-            answ.durataMinuti = 60 * durataTurno;
-            answ.TNum = Convert.ToInt32(Math.Floor(Convert.ToDouble(dataOraRif.Hour) / durataTurno)) + 1;
-            answ.inizio = dataRif.AddHours(shiftTurno + (answ.TNum - 1) * durataTurno);
-            answ.fine = answ.inizio.AddHours(durataTurno);
-            intervalloDate periodo = setIntervallo(answ.inizio, answ.fine);
-            answ.periodo = periodo;
-            return answ;
-        }
-        /// <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 di N MESI fino alla data indicata
-        /// </summary>
-        /// <param name="data"></param>
-        /// <param name="numMesiPrima"></param>
-        /// <returns></returns>
-        public intervalloDate ultimiMesi(DateTime data, int numMesiPrima)
-        {
-            intervalloDate interv = new intervalloDate();
-            interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
-            interv.inizio = interv.fine.AddMonths(-numMesiPrima);
-            return interv;
-        }
-        /// <summary>
-        /// restituisce l'intervallo di N giorni dalla data indicata in avanti
-        /// </summary>
-        /// <param name="data"></param>
-        /// <param name="numGiorniSucc"></param>
-        /// <returns></returns>
-        public intervalloDate prossimiGiorni(DateTime data, int numGiorniSucc)
-        {
-            intervalloDate interv = new intervalloDate();
-            interv.inizio = data.Subtract(data.TimeOfDay);
-            interv.fine = interv.inizio.AddDays(numGiorniSucc);
-            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 della 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 dell'anno corrente per la data indicata (dal giorno 1 all'indomani della data indicata)
-        /// </summary>
-        /// <param name="data"></param>
-        /// <returns></returns>
-        public intervalloDate questoAnno(DateTime data)
-        {
-            intervalloDate interv = new intervalloDate();
-            interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
-            interv.inizio = data.AddDays(-(data.Day - 1)).AddMonths(-(data.Month - 1)).Subtract(data.TimeOfDay);
-            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();
 
+        #endregion Public Constructors
+
+        #region Public Enums
+
+        /// <summary>
+        /// Tipo di periodo selezione date
+        /// </summary>
+        public enum periodo
+        {
+            /// <summary>
+            /// non definito
+            /// </summary>
+            nd,
+
+            /// <summary>
+            /// Solo periodo passato (+ presente)
+            /// </summary>
+            past,
+
+            /// <summary>
+            /// Solo periodo futuro (+ presente)
+            /// </summary>
+            future,
+
+            /// <summary>
+            /// tutto
+            /// </summary>
+            all
+        }
+
+        #endregion Public Enums
+
+        #region Public Methods
 
         /// <summary>
         /// converte in datetime un valore formattato con una culture generica ed un formato generico
@@ -420,6 +598,7 @@ namespace SteamWare
 
             return answ;
         }
+
         /// <summary>
         /// converte in datetime un valore formattato con una culture generica ed un formato generico
         /// </summary>
@@ -431,96 +610,415 @@ namespace SteamWare
         {
             return convDate(dataOra, formato, culture, false);
         }
+
         /// <summary>
-        /// Tipo di periodo selezione date
+        /// restituisce l'intervallo dell'anno corrente per la data indicata
         /// </summary>
-        public enum periodo
+        /// <param name="data"></param>
+        /// <returns></returns>
+        public intervalloDate estremiAnno(DateTime data)
         {
-            /// <summary>
-            /// non definito
-            /// </summary>
-            nd,
-            /// <summary>
-            /// Solo periodo passato (+ presente)
-            /// </summary>
-            past,
-            /// <summary>
-            /// Solo periodo futuro (+ presente)
-            /// </summary>
-            future,
-            /// <summary>
-            /// tutto
-            /// </summary>
-            all
+            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>
+        /// calcola il turno di riferimento data una data di riferimento
+        /// </summary>
+        /// <param name="dataOraRif">The data ora rif.</param>
+        /// <param name="shiftTurno">The shift turno.</param>
+        /// <param name="durataTurno">The durata turno.</param>
+        /// <returns></returns>
+        public turnoLavoro getTurnoByDateTime(DateTime dataOraRif, int shiftTurno, int durataTurno)
+        {
+            // inizio con shift alla data-ora corrente..
+            dataOraRif = dataOraRif.AddHours(-shiftTurno);
+            // continuo calcolo
+            TimeSpan oraRif = dataOraRif.TimeOfDay;
+            DateTime dataRif = dataOraRif.Add(-oraRif);
+            // calcolo!
+            turnoLavoro answ = new turnoLavoro();
+            answ.durataMinuti = 60 * durataTurno;
+            answ.TNum = Convert.ToInt32(Math.Floor(Convert.ToDouble(dataOraRif.Hour) / durataTurno)) + 1;
+            answ.inizio = dataRif.AddHours(shiftTurno + (answ.TNum - 1) * durataTurno);
+            answ.fine = answ.inizio.AddHours(durataTurno);
+            intervalloDate periodo = setIntervallo(answ.inizio, answ.fine);
+            answ.periodo = periodo;
+            return answ;
+        }
+
+        /// <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 di N giorni dalla data indicata in avanti
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="numGiorniSucc"></param>
+        /// <returns></returns>
+        public intervalloDate prossimiGiorni(DateTime data, int numGiorniSucc)
+        {
+            intervalloDate interv = new intervalloDate();
+            interv.inizio = data.Subtract(data.TimeOfDay);
+            interv.fine = interv.inizio.AddDays(numGiorniSucc);
+            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 dell'anno corrente per la data indicata (dal giorno 1 all'indomani della data indicata)
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        public intervalloDate questoAnno(DateTime data)
+        {
+            intervalloDate interv = new intervalloDate();
+            interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
+            interv.inizio = data.AddDays(-(data.Day - 1)).AddMonths(-(data.Month - 1)).Subtract(data.TimeOfDay);
+            return interv;
+        }
+
+        /// <summary>
+        /// restituisce l'intervallo del mese corrente per la data indicata (dal giorno 1 all'indomani della 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;
+        }
+
+        /// <summary>
+        /// restituisce l'intervallo di N MESI fino alla data indicata
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="numMesiPrima"></param>
+        /// <returns></returns>
+        public intervalloDate ultimiMesi(DateTime data, int numMesiPrima)
+        {
+            intervalloDate interv = new intervalloDate();
+            interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
+            interv.inizio = interv.fine.AddMonths(-numMesiPrima);
+            return interv;
+        }
+
+        #endregion Public Methods
     }
+
     /// <summary>
-    /// Helper methods e funzioni x gestione conversione dataset tipizzati e non
+    /// utility x dns e naming
     /// </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()
+    public class dnsUtils
     {
+        #region Public Methods
+
         /// <summary>
-        /// Convert the first DataTable from a DataSet to a
-        /// strongly-typed data table.
+        /// calcola il nome del computer dato l'IP
         /// </summary>
-        public static T convert(DataSet dataSet)
+        /// <param name="IP"></param>
+        /// <returns></returns>
+        public static string DetermineCompName(string IP)
         {
-            if (dataSet == null)
-            {
-                return null;
-            }
-
-            if (dataSet.Tables.Count == 0)
-            {
-                return null;
-            }
-
-            DataTable dataTable = dataSet.Tables[0];
-            return convert(dataTable);
+            IPAddress myIP = IPAddress.Parse(IP);
+            IPHostEntry GetIPHost = Dns.GetHostEntry(myIP);
+            List<string> compName = GetIPHost.HostName.ToString().Split('.').ToList();
+            return compName.First();
         }
+
         /// <summary>
-        /// Convert an ordinary DataTable to a strongly-typed
-        /// data table.
+        /// fornisce mac address dato nome/IP
         /// </summary>
-        public static T convert(DataTable dataTable)
+        /// <param name="sName"></param>
+        /// <returns></returns>
+        public static string GetMacAddress(string sName)
         {
-            if (dataTable == null)
+            string s = string.Empty;
+            System.Net.IPHostEntry Tempaddr = null;
+            Tempaddr = Dns.GetHostEntry(sName);
+            System.Net.IPAddress[] TempAd = Tempaddr.AddressList;
+            string[] Ipaddr = new string[3];
+            foreach (IPAddress TempA in TempAd)
             {
-                return null;
+                Ipaddr[1] = TempA.ToString();
+                byte[] ab = new byte[6];
+                int len = ab.Length;
+                int r = SendARP(BitConverter.ToInt32(TempA.GetAddressBytes(), 0), 0, ab, ref len);
+                string sMAC = BitConverter.ToString(ab, 0, 6);
+                Ipaddr[2] = sMAC;
+                s = sMAC;
+            }
+            return s;
+        }
+
+        /// <summary>
+        /// Metodo x restituire nome dato IP tramite Reverse Lookup
+        /// </summary>
+        /// <param name="ip"></param>
+        /// <returns></returns>
+        public static string ReverseLookup(string ip)
+        {
+            if (string.IsNullOrEmpty(ip))
+            {
+                return ip;
             }
 
-            T stronglyTyped = new T();
-            // add data from the regular DataTable to the
-            // strongly typed DataTable.
-            stronglyTyped.Merge(dataTable, true, MissingSchemaAction.Ignore);
-            return stronglyTyped;
+            try
+            {
+                return Dns.GetHostEntry(ip).HostName; //.Select(entry => entry.HostName).FirstOrDefault() ?? ip;
+            }
+            catch (SocketException) { return ip; }
         }
+
+        /// <summary>
+        /// manda pacchetto ARP
+        /// </summary>
+        /// <param name="DestIP"></param>
+        /// <param name="SrcIP"></param>
+        /// <param name="pMacAddr"></param>
+        /// <param name="PhyAddrLen"></param>
+        /// <returns></returns>
+        [DllImport("iphlpapi.dll", ExactSpelling = true)]
+        public static extern int SendARP(int DestIP, int SrcIP, [Out] byte[] pMacAddr, ref int PhyAddrLen);
+
+        /// <summary>
+        /// scarica una pagina da URL e fornisce testo string
+        /// </summary>
+        /// <param name="URL">Indirizzo pagina (completo)</param>
+        /// <param name="user">username (se necessario)</param>
+        /// <param name="passwd">password (se necessaria)</param>
+        /// <returns></returns>
+        public static string wgetPage(string URL, string user, string passwd)
+        {
+            string page = "";
+            try
+            {
+                using (var client = new WebClient())
+                {
+                    client.Credentials = new NetworkCredential(user, passwd);
+                    page = client.DownloadString(URL);
+                }
+            }
+            catch
+            { }
+            return page;
+        }
+
+        #endregion Public Methods
     }
 
-    #endregion
-
-    #region gestione email & log...
     /// <summary>
     /// classe di gestione delle email
     /// </summary>
     public class gestEmail
     {
-        /// <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;
+        #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;
+
+        #endregion Protected Fields
+
+        #region Public Fields
+
+        /// <summary>
+        /// metodo singleton gestione email...
+        /// </summary>
+        public static gestEmail ge = new gestEmail(memLayer.ML.CRS("_smtpCli"));
+
+        /// <summary>
+        /// metodo singleton gestione email CON AUTH utente...
+        /// </summary>
+        public static gestEmail geAuth = new gestEmail(memLayer.ML.CRS("_smtpCli"), memLayer.ML.CRS("_emailUser"), memLayer.ML.CRS("_emailPwd"));
+
+        #endregion Public Fields
+
+        #region Public Constructors
+
         /// <summary>
         /// metodo static per la gestione delle email
         /// </summary>
@@ -532,6 +1030,7 @@ namespace SteamWare
             _username = "";
             _password = "";
         }
+
         /// <summary>
         /// metodo static per la gestione delle email
         /// </summary>
@@ -545,6 +1044,7 @@ namespace SteamWare
             _username = user;
             _password = pwd;
         }
+
         /// <summary>
         /// metodo static per la gestione delle email
         /// </summary>
@@ -557,126 +1057,10 @@ namespace SteamWare
             _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>
-        /// <param name="_allegati">allegati del messaggio</param>
-        public bool mandaEmailNoLog(string _mailFrom, string _mailTo, string _oggetto, string _corpo, AlternateView[] _allegati)
-        {
-            bool answ = false;
-            // sostituisco eventuali a capo nel corpo messaggio...
-            _corpo = _corpo.Replace("\r", "<br />");
-            _corpo = _corpo.Replace("\n", "<br />");
-            //_useAIMSmtp
-            if (memLayer.ML.CRB("_useAIMSmtp"))
-            {
-                answ = sendWithAIMClient(_mailFrom, _mailTo, _oggetto, _corpo, _allegati);
-            }
-            else
-            {
-                answ = sendWithNetClient(_mailFrom, _mailTo, _oggetto, _corpo, _allegati);
-            }
 
-            return answ;
-        }
-        /// <summary>
-        /// Invia con metodo del client AIM x compatilbiiltà SSL implicito and co
-        /// https://sourceforge.net/projects/netimplicitssl/
-        /// </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>
-        /// <param name="_allegati">allegati del messaggio</param>
-        /// <returns></returns>
-        private bool sendWithAIMClient(string _mailFrom, string _mailTo, string _oggetto, string _corpo, AlternateView[] _allegati)
-        {
-            // Generate Message 
-            var mymessage = new MimeMailMessage();
-            mymessage.From = new MimeMailAddress(_mailFrom);
-            mymessage.To.Add(_mailTo);
-            mymessage.Subject = _oggetto;
-            mymessage.Body = _corpo;
-            if (_allegati != null)
-            {
-#if false
-      // eventualmente aggiungo allegati...
-      foreach (AlternateView allegato in _allegati)
-      {
-        mymessage.Attachments.Add((MimeAttachment)allegato); 
-      }
-#endif
-            }
+        #endregion Public Constructors
 
-            // Create Smtp Client      
-            int port = 465;
-            if (!string.IsNullOrEmpty(memLayer.ML.CRS("_PortSSL")))
-            {
-                port = memLayer.ML.CRI("_PortSSL");
-            }
-
-            var emailer = new SmtpSocketClient();
-            emailer.Host = _smtpCli;
-            emailer.Port = port;
-            emailer.SslType = SslMode.Ssl;
-            emailer.User = (_username);
-            emailer.Password = _password;
-            emailer.AuthenticationMode = AuthenticationType.Base64;
-            emailer.Timeout = 5000;
-            // The authentication types depends on your server, it can be plain, base 64 or none. 
-            //if you do not need user name and password means you are using default credentials 
-            // In this case, your authentication type is none            
-            emailer.MailMessage = mymessage;
-            emailer.SendCompleted += OnMailSent;
-            emailer.SendMailAsync();
-
-
-            return true;
-        }
-        /// <summary>
-        /// Encode in Base64
-        /// </summary>
-        /// <param name="plainText"></param>
-        /// <returns></returns>
-        public static string Base64Encode(string plainText)
-        {
-            var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);
-            return System.Convert.ToBase64String(plainTextBytes);
-        }
-        /// <summary>
-        /// Decode in Base64
-        /// </summary>
-        /// <param name="base64EncodedData"></param>
-        /// <returns></returns>
-        public static string Base64Decode(string base64EncodedData)
-        {
-            var base64EncodedBytes = System.Convert.FromBase64String(base64EncodedData);
-            return System.Text.Encoding.UTF8.GetString(base64EncodedBytes);
-        }
-
-        // A simple call back function:
-        private void OnMailSent(object sender, AsyncCompletedEventArgs e)
-        {
-            if (e.UserState != null)
-            {
-                logger.lg.scriviLog(e.UserState.ToString());
-            }
-
-            if (e.Cancelled)
-            {
-                logger.lg.scriviLog("Invio cancellato");
-            }
-            Console.Out.WriteLine("is it canceled? " + e.Cancelled);
-
-            if (e.Error != null)
-            {
-                logger.lg.scriviLog("Invio con errori: " + e.Error.Message);
-            }
-        }
+        #region Private Methods
 
         /// <summary>
         /// CallBack chiusura invio
@@ -702,10 +1086,83 @@ namespace SteamWare
             }
         }
 
+        // A simple call back function:
+        private void OnMailSent(object sender, AsyncCompletedEventArgs e)
+        {
+            if (e.UserState != null)
+            {
+                logger.lg.scriviLog(e.UserState.ToString());
+            }
+
+            if (e.Cancelled)
+            {
+                logger.lg.scriviLog("Invio cancellato");
+            }
+            Console.Out.WriteLine("is it canceled? " + e.Cancelled);
+
+            if (e.Error != null)
+            {
+                logger.lg.scriviLog("Invio con errori: " + e.Error.Message);
+            }
+        }
+
+        /// <summary>
+        /// Invia con metodo del client AIM x compatilbiiltà SSL implicito and co
+        /// https://sourceforge.net/projects/netimplicitssl/
+        /// </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>
+        /// <param name="_allegati">allegati del messaggio</param>
+        /// <returns></returns>
+        private bool sendWithAIMClient(string _mailFrom, string _mailTo, string _oggetto, string _corpo, AlternateView[] _allegati)
+        {
+            // Generate Message
+            var mymessage = new MimeMailMessage();
+            mymessage.From = new MimeMailAddress(_mailFrom);
+            mymessage.To.Add(_mailTo);
+            mymessage.Subject = _oggetto;
+            mymessage.Body = _corpo;
+            if (_allegati != null)
+            {
+#if false
+      // eventualmente aggiungo allegati...
+      foreach (AlternateView allegato in _allegati)
+      {
+        mymessage.Attachments.Add((MimeAttachment)allegato);
+      }
+#endif
+            }
+
+            // Create Smtp Client
+            int port = 465;
+            if (!string.IsNullOrEmpty(memLayer.ML.CRS("_PortSSL")))
+            {
+                port = memLayer.ML.CRI("_PortSSL");
+            }
+
+            var emailer = new SmtpSocketClient();
+            emailer.Host = _smtpCli;
+            emailer.Port = port;
+            emailer.SslType = SslMode.Ssl;
+            emailer.User = (_username);
+            emailer.Password = _password;
+            emailer.AuthenticationMode = AuthenticationType.Base64;
+            emailer.Timeout = 5000;
+            // The authentication types depends on your server, it can be plain, base 64 or none.
+            //if you do not need user name and password means you are using default credentials
+            // In this case, your authentication type is none
+            emailer.MailMessage = mymessage;
+            emailer.SendCompleted += OnMailSent;
+            emailer.SendMailAsync();
+
+            return true;
+        }
 
         /// <summary>
         /// Invia con metodo del client Net standard
-        /// </summary>                        
+        /// </summary>
         /// <param name="_mailFrom">email mittente</param>
         /// <param name="_mailTo">email destinatario</param>
         /// <param name="_oggetto">oggetto dell'email</param>
@@ -740,9 +1197,11 @@ namespace SteamWare
                         case "HIGH":
                             messaggio.Priority = MailPriority.High;
                             break;
+
                         case "LOW":
                             messaggio.Priority = MailPriority.Low;
                             break;
+
                         case "NORM":
                         default:
                             messaggio.Priority = MailPriority.Normal;
@@ -778,18 +1237,32 @@ namespace SteamWare
             }
         }
 
+        #endregion Private Methods
+
+        #region Public Methods
+
         /// <summary>
-        /// procedura invio email
+        /// Decode in Base64
         /// </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)
+        /// <param name="base64EncodedData"></param>
+        /// <returns></returns>
+        public static string Base64Decode(string base64EncodedData)
         {
-            // chiamo procedura con alelgati nulli...
-            return mandaEmailNoLog(_mailFrom, _mailTo, _oggetto, _corpo, null);
+            var base64EncodedBytes = System.Convert.FromBase64String(base64EncodedData);
+            return System.Text.Encoding.UTF8.GetString(base64EncodedBytes);
         }
+
+        /// <summary>
+        /// Encode in Base64
+        /// </summary>
+        /// <param name="plainText"></param>
+        /// <returns></returns>
+        public static string Base64Encode(string plainText)
+        {
+            var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);
+            return System.Convert.ToBase64String(plainTextBytes);
+        }
+
         /// <summary>
         /// procedura invio email + scrittura in log!
         /// </summary>
@@ -818,6 +1291,7 @@ namespace SteamWare
             }
             return fatto;
         }
+
         /// <summary>
         /// procedura invio email + scrittura in log!
         /// </summary>
@@ -841,393 +1315,48 @@ namespace SteamWare
             }
             return fatto;
         }
-        /// <summary>
-        /// metodo singleton gestione email...
-        /// </summary>
-        public static gestEmail ge = new gestEmail(memLayer.ML.CRS("_smtpCli"));
-        /// <summary>
-        /// metodo singleton gestione email CON AUTH utente...
-        /// </summary>
-        public static gestEmail geAuth = new gestEmail(memLayer.ML.CRS("_smtpCli"), memLayer.ML.CRS("_emailUser"), memLayer.ML.CRS("_emailPwd"));
-    }
 
-    #endregion
-
-    #region gestione stringhe
-
-    namespace StringSplitter
-    {
         /// <summary>
-        /// Tipo di comparazione, Binary == CaseSensitive, Text = insensitive
+        /// procedura invio email
         /// </summary>
-        public enum ComparisonMethod
+        /// <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>
+        /// <param name="_allegati">allegati del messaggio</param>
+        public bool mandaEmailNoLog(string _mailFrom, string _mailTo, string _oggetto, string _corpo, AlternateView[] _allegati)
         {
-            /// <summary>
-            /// tipo controllo : binario
-            /// </summary>
-            Binary = 0,
-            /// <summary>
-            /// tipo controllo : text
-            /// </summary>
-            Text = 1
-        }
-
-        /// <summary>
-        /// Funzione di splitting compatibile con multi-character e multi-line
-        /// </summary>
-        public class CSplitter
-        {
-            /// <summary>
-            /// stringa da splittare
-            /// </summary>
-            private static string m_Expression;
-            /// <summary>
-            /// Delimiter con cui splittare
-            /// </summary>
-            private static string m_Delimiter;
-            /// <summary>
-            /// Costruttore dello Splitter
-            /// </summary>
-            public CSplitter()
+            bool answ = false;
+            // sostituisco eventuali a capo nel corpo messaggio...
+            _corpo = _corpo.Replace("\r", "<br />");
+            _corpo = _corpo.Replace("\n", "<br />");
+            //_useAIMSmtp
+            if (memLayer.ML.CRB("_useAIMSmtp"))
             {
-                // non fa nulla all'inizializzazione
+                answ = sendWithAIMClient(_mailFrom, _mailTo, _oggetto, _corpo, _allegati);
+            }
+            else
+            {
+                answ = sendWithNetClient(_mailFrom, _mailTo, _oggetto, _corpo, _allegati);
             }
 
-            /// <summary>
-            /// comparatore case sensitive
-            /// </summary>
-            /// <param name="StringIndex"></param>
-            /// <param name="DelimiterIndex"></param>
-            /// <returns></returns>
-            private static bool isValidDelimiterBinary(int StringIndex, int DelimiterIndex)
-            {
-                if (DelimiterIndex == m_Delimiter.Length)
-                {
-                    return true;
-                }
-
-                if (StringIndex == m_Expression.Length)
-                {
-                    return false;
-                }
-                //If the current character of the expression matches 
-                //the current character of the Delimiter, 
-                //then go to next character
-                if (m_Expression[StringIndex] ==
-                    m_Delimiter[DelimiterIndex])
-                {
-                    return isValidDelimiterBinary(StringIndex + 1,
-                        DelimiterIndex + 1);
-                }
-                else
-                {
-                    return false;
-                }
-            }
-            /// <summary>
-            /// comparatore case insensitive
-            /// </summary>
-            /// <param name="StringIndex"></param>
-            /// <param name="DelimiterIndex"></param>
-            /// <returns></returns>
-            private static bool isValidDelimiterText(int StringIndex, int DelimiterIndex)
-            {
-                if (DelimiterIndex == m_Delimiter.Length)
-                {
-                    return true;
-                }
-
-                if (StringIndex == m_Expression.Length)
-                {
-                    return false;
-                }
-                //If the current character of the expression 
-                //matches the current character of the Delimiter, 
-                //then go to next character
-                if (Char.ToLower(m_Expression[StringIndex])
-                    == Char.ToLower(m_Delimiter[DelimiterIndex]))
-                {
-                    return isValidDelimiterText(StringIndex + 1,
-                        DelimiterIndex + 1);
-                }
-                else
-                {
-                    return false;
-                }
-            }
-
-            /// <summary>
-            /// parte principale dello splitter
-            /// </summary>
-            /// <param name="Expression">stringa da splittare</param>
-            /// <param name="Delimiter">delimitatore ricercato</param>
-            /// <param name="SingleSeparator">true=il delimiter � un blocco unico, false=qualsiasi oggetto del delimiter fa split (come split base)</param>
-            /// <param name="Count"></param>
-            /// <param name="Compare">0 -> Binary=CaseSensitive, 1 -> Text=case insensitive</param>
-            /// <returns></returns>
-            public static string[] Split(string Expression, string Delimiter, bool SingleSeparator, int Count, ComparisonMethod Compare)
-            {
-                //Update Private Members 
-                m_Expression = Expression;
-                m_Delimiter = Delimiter;
-
-                //Array to hold Splitted Tokens
-                System.Collections.ArrayList Tokens =
-                    new System.Collections.ArrayList();
-                //If not using single separator, 
-                //then use the regular split function
-                if (!SingleSeparator)
-                {
-                    if (Count >= 0)
-                    {
-                        return Expression.Split(Delimiter.ToCharArray(), Count);
-                    }
-                    else
-                    {
-                        return Expression.Split(Delimiter.ToCharArray());
-                    }
-                }
-
-                //Check if count = 0 then return an empty array 
-                if (Count == 0)
-                {
-                    return new string[0];
-                }
-                else
-                    //Check if Count = 1 then return the whole expression
-                    if (Count == 1)
-                {
-                    return new string[] { Expression };
-                }
-                else
-                {
-                    Count--;
-                }
-
-                // Indexer to loop over the string with 
-                int i;
-                //The Start index of the current 
-                //token in the expression
-                int iStart = 0;
-
-                if (Compare == ComparisonMethod.Binary)
-                {
-                    for (i = 0; i < Expression.Length; i++)
-                    {
-                        if (isValidDelimiterBinary(i, 0))
-                        {
-                            //Assign New Token 
-                            Tokens.Add(Expression.Substring(iStart,
-                                i - iStart));
-                            //Update Index 
-                            i += Delimiter.Length - 1;
-                            //Update Current Token Start index
-                            iStart = i + 1;
-                            //If we reached the tokens limit , then exit For 
-                            if (Tokens.Count == Count && Count >= 0)
-                            {
-                                break;
-                            }
-                        }
-                    }
-                }
-                else
-                {
-                    for (i = 0; i < Expression.Length; i++)
-                    {
-                        if (isValidDelimiterText(i, 0))
-                        {
-                            //Assign New Token 
-                            Tokens.Add(Expression.Substring(iStart,
-                                i - iStart));
-                            //Update Index 
-                            i += Delimiter.Length - 1;
-                            //Update Current Token Start index
-                            iStart = i + 1;
-                            //If we reached the tokens limit , then exit For 
-                            if (Tokens.Count == Count && Count >= 0)
-                            {
-                                break;
-                            }
-                        }
-                    }
-                }
-                string LastToken = "";
-                //If there is still data & have not been added
-                if (iStart < Expression.Length)
-                {
-                    LastToken = Expression.Substring(iStart,
-                        Expression.Length - iStart);
-                    if (LastToken == Delimiter)
-                    {
-                        Tokens.Add(null);
-                    }
-                    else
-                    {
-                        Tokens.Add(LastToken);
-                    }
-                }
-                else
-                    //If there is no elements in the tokens array, 
-                    //then pass the whole string as the one element
-                    if (Tokens.Count == 0)
-                {
-                    Tokens.Add(Expression);
-                }
-                //Return Splitted Tokens
-                return (string[])
-                    Tokens.ToArray(Type.GetType("System.String"));
-            }
-            /// <summary>
-            /// elimina dal nome file il tipo (desinenza)
-            /// </summary>
-            /// <param name="nomeCompleto"></param>
-            /// <returns></returns>
-            public string nomeFileNoExt(string nomeCompleto)
-            {
-                string[] valori = Split(nomeCompleto, ".", true, 0, ComparisonMethod.Text);
-                return valori[valori.Length - 2];
-            }
-        }
-    }
-
-    #endregion
-
-    /// <summary>
-    /// fornisce dati di base per l'utente
-    /// </summary>
-    public class anagrData
-    {
-        /// <summary>
-        /// fornisce cognome e nome utente formattati a partire dall'username e dalla tabella UTENTE
-        /// </summary>
-        /// <param name="username"></param>
-        /// <returns></returns>
-        public string datiUtenteDaUsername(string username)
-        {
-            string answ = "";
-            DataLayer_AnagGenTableAdapters.UTENTETableAdapter taUtente = new SteamWare.DataLayer_AnagGenTableAdapters.UTENTETableAdapter();
-            try
-            {
-                DataLayer_AnagGen.UTENTERow _rigaUt = taUtente.GetData().FindByUSER_NAME(username);
-                answ = String.Format("{0} {1}", _rigaUt.COGNOME, _rigaUt.NOME);
-            }
-            catch
-            { }
             return answ;
         }
-        /// <summary>
-        /// restituisce la riga completa dall'username richiesto
-        /// </summary>
-        /// <param name="username"></param>
-        /// <returns></returns>
-        public DataLayer_AnagGen.UTENTERow rigaUtenteDaUsername(string username)
-        {
-            DataLayer_AnagGenTableAdapters.UTENTETableAdapter taUtente = new SteamWare.DataLayer_AnagGenTableAdapters.UTENTETableAdapter();
-            try
-            {
-                return taUtente.GetData().FindByUSER_NAME(username);
-            }
-            catch
-            {
-                return null;
-            }
-        }
-    }
-
-    /// <summary>
-    /// utility x dns e naming
-    /// </summary>
-    public class dnsUtils
-    {
-        /// <summary>
-        /// calcola il nome del computer dato l'IP
-        /// </summary>
-        /// <param name="IP"></param>
-        /// <returns></returns>
-        public static string DetermineCompName(string IP)
-        {
-            IPAddress myIP = IPAddress.Parse(IP);
-            IPHostEntry GetIPHost = Dns.GetHostEntry(myIP);
-            List<string> compName = GetIPHost.HostName.ToString().Split('.').ToList();
-            return compName.First();
-        }
-        /// <summary>
-        /// Metodo x restituire nome dato IP tramite Reverse Lookup
-        /// </summary>
-        /// <param name="ip"></param>
-        /// <returns></returns>
-        public static string ReverseLookup(string ip)
-        {
-            if (string.IsNullOrEmpty(ip))
-            {
-                return ip;
-            }
-
-            try
-            {
-                return Dns.GetHostEntry(ip).HostName; //.Select(entry => entry.HostName).FirstOrDefault() ?? ip;
-            }
-            catch (SocketException) { return ip; }
-        }
-        /// <summary>
-        /// scarica una pagina da URL e fornisce testo string
-        /// </summary>
-        /// <param name="URL">Indirizzo pagina (completo)</param>
-        /// <param name="user">username (se necessario)</param>
-        /// <param name="passwd">password (se necessaria)</param>
-        /// <returns></returns>
-        public static string wgetPage(string URL, string user, string passwd)
-        {
-            string page = "";
-            try
-            {
-                using (var client = new WebClient())
-                {
-                    client.Credentials = new NetworkCredential(user, passwd);
-                    page = client.DownloadString(URL);
-                }
-            }
-            catch
-            { }
-            return page;
-        }
 
         /// <summary>
-        /// manda pacchetto ARP
+        /// procedura invio email
         /// </summary>
-        /// <param name="DestIP"></param>
-        /// <param name="SrcIP"></param>
-        /// <param name="pMacAddr"></param>
-        /// <param name="PhyAddrLen"></param>
-        /// <returns></returns>
-        [DllImport("iphlpapi.dll", ExactSpelling = true)]
-        public static extern int SendARP(int DestIP, int SrcIP, [Out] byte[] pMacAddr, ref int PhyAddrLen);
-        /// <summary>
-        /// fornisce mac address dato nome/IP
-        /// </summary>
-        /// <param name="sName"></param>
-        /// <returns></returns>
-        public static string GetMacAddress(string sName)
+        /// <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)
         {
-            string s = string.Empty;
-            System.Net.IPHostEntry Tempaddr = null;
-            Tempaddr = Dns.GetHostEntry(sName);
-            System.Net.IPAddress[] TempAd = Tempaddr.AddressList;
-            string[] Ipaddr = new string[3];
-            foreach (IPAddress TempA in TempAd)
-            {
-                Ipaddr[1] = TempA.ToString();
-                byte[] ab = new byte[6];
-                int len = ab.Length;
-                int r = SendARP(BitConverter.ToInt32(TempA.GetAddressBytes(), 0), 0, ab, ref len);
-                string sMAC = BitConverter.ToString(ab, 0, 6);
-                Ipaddr[2] = sMAC;
-                s = sMAC;
-            }
-            return s;
+            // chiamo procedura con alelgati nulli...
+            return mandaEmailNoLog(_mailFrom, _mailTo, _oggetto, _corpo, null);
         }
 
+        #endregion Public Methods
     }
 
     /// <summary>
@@ -1235,6 +1364,8 @@ namespace SteamWare
     /// </summary>
     public class jsUtils
     {
+        #region Public Methods
+
         /// <summary>
         /// restituisce la stringa di codice javascript x conferma client comprensiva di messaggio tradotto specifico
         /// </summary>
@@ -1242,9 +1373,9 @@ namespace SteamWare
         /// <returns></returns>
         public static string getCBE(object lemma)
         {
-
             return string.Format("return confirm('{0}'); ", user_std.UtSn.Traduci(lemma.ToString()));
         }
+
         /// <summary>
         /// restituisce la stringa di codice javascript x conferma client comprensiva di messaggio tradotto specifico
         /// </summary>
@@ -1265,35 +1396,89 @@ namespace SteamWare
             }
             return answ;
         }
+
+        #endregion Public Methods
     }
+
     /// <summary>
-    ///  classi helper gestione URL
+    /// classe gestione valori percentuali per semplificare edit utente (moltiplicati x 100 appunto)
     /// </summary>
-    public class urlUtils
+    public class percentuali
     {
+        #region Public Methods
+
         /// <summary>
-        /// chiama un URL e restituisce (se richiesto) il risultato ricevuto
+        /// converte da numero a percentuale (es 0.053 --> 5,3%)
         /// </summary>
-        /// <param name="url">url da chiamare</param>
-        /// <param name="returnAnsw">se si vuole in risposta il contenuto della risposta alla chiamata</param>
+        /// <param name="originalVal"></param>
         /// <returns></returns>
-        public static string callUrl(string url, bool returnAnsw)
+        public static decimal num2perc(string originalVal)
         {
-            string answ = "";
+            decimal answ = 0;
+            // ora controllo se c'� valore > 1...
             try
             {
-                WebRequest request = HttpWebRequest.Create(url);
-                WebResponse response = request.GetResponse();
-                StreamReader reader = new StreamReader(response.GetResponseStream());
-                if (returnAnsw)
-                {
-                    answ = reader.ReadToEnd();
-                }
+                // inizio convertendo ..
+                answ = Convert.ToDecimal(originalVal);
+                answ = answ * 100;
             }
             catch
             { }
             return answ;
         }
+
+        /// <summary>
+        /// converte da percentuale a numero (es 5,3% --> 0.053)
+        /// </summary>
+        /// <param name="originalVal"></param>
+        /// <returns></returns>
+        public static decimal perc2num(string originalVal)
+        {
+            decimal answ = 0;
+            // se contiene "%" lo tolgo...
+            originalVal = originalVal.Replace("%", "");
+            // ora controllo se c'� valore > 1...
+            try
+            {
+                // inizio convertendo ..
+                answ = Convert.ToDecimal(originalVal);
+                answ = answ / 100;
+            }
+            catch
+            { }
+            return answ;
+        }
+
+        #endregion Public Methods
+    }
+
+    /// <summary>
+    /// Classe gestione divisioni
+    /// </summary>
+    public class ratio
+    {
+        #region Public Methods
+
+        /// <summary>
+        /// Effettua il calcolo del rapporto numeratore/denominatore come DECIMAL con gestione denominatore != 0
+        /// </summary>
+        /// <param name="numVal">numeratore</param>
+        /// <param name="denVal">denominatore</param>
+        /// <returns></returns>
+        public static decimal getDecimal(object numVal, object denVal)
+        {
+            decimal answ = 0;
+            decimal num = 0;
+            decimal den = 1;
+            decimal.TryParse(numVal.ToString(), out num);
+            decimal.TryParse(denVal.ToString(), out den);
+            // se il denominatore � 0 --> 1
+            den = (den == 0) ? 1 : den;
+            answ = num / den;
+            return answ;
+        }
+
+        #endregion Public Methods
     }
 
     /// <summary>
@@ -1301,51 +1486,8 @@ namespace SteamWare
     /// </summary>
     public class SteamCrypto
     {
-        /// <summary>
-        /// cifra un messaggio con una password
-        /// </summary>
-        /// <param name="Message"></param>
-        /// <param name="Passphrase"></param>
-        /// <returns></returns>
-        public static string EncryptString(string Message, string Passphrase)
-        {
-            byte[] Results;
-            UTF8Encoding UTF8 = new UTF8Encoding();
+        #region Public Methods
 
-            // Step 1. We hash the passphrase using MD5
-            // We use the MD5 hash generator as the result is a 128 bit byte array
-            // which is a valid length for the TripleDES encoder we use below
-
-            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
-            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));
-
-            // Step 2. Create a new TripleDESCryptoServiceProvider object
-            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
-
-            // Step 3. Setup the encoder
-            TDESAlgorithm.Key = TDESKey;
-            TDESAlgorithm.Mode = CipherMode.ECB;
-            TDESAlgorithm.Padding = PaddingMode.PKCS7;
-
-            // Step 4. Convert the input string to a byte[]
-            byte[] DataToEncrypt = UTF8.GetBytes(Message);
-
-            // Step 5. Attempt to encrypt the string
-            try
-            {
-                ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
-                Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
-            }
-            finally
-            {
-                // Clear the TripleDes and Hashprovider services of any sensitive information
-                TDESAlgorithm.Clear();
-                HashProvider.Clear();
-            }
-
-            // Step 6. Return the encrypted string as a base64 encoded string
-            return Convert.ToBase64String(Results);
-        }
         /// <summary>
         /// decifra un messaggio con una password
         /// </summary>
@@ -1401,6 +1543,52 @@ namespace SteamWare
             return answ;
         }
 
+        /// <summary>
+        /// cifra un messaggio con una password
+        /// </summary>
+        /// <param name="Message"></param>
+        /// <param name="Passphrase"></param>
+        /// <returns></returns>
+        public static string EncryptString(string Message, string Passphrase)
+        {
+            byte[] Results;
+            UTF8Encoding UTF8 = new UTF8Encoding();
+
+            // Step 1. We hash the passphrase using MD5
+            // We use the MD5 hash generator as the result is a 128 bit byte array
+            // which is a valid length for the TripleDES encoder we use below
+
+            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
+            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));
+
+            // Step 2. Create a new TripleDESCryptoServiceProvider object
+            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
+
+            // Step 3. Setup the encoder
+            TDESAlgorithm.Key = TDESKey;
+            TDESAlgorithm.Mode = CipherMode.ECB;
+            TDESAlgorithm.Padding = PaddingMode.PKCS7;
+
+            // Step 4. Convert the input string to a byte[]
+            byte[] DataToEncrypt = UTF8.GetBytes(Message);
+
+            // Step 5. Attempt to encrypt the string
+            try
+            {
+                ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
+                Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
+            }
+            finally
+            {
+                // Clear the TripleDes and Hashprovider services of any sensitive information
+                TDESAlgorithm.Clear();
+                HashProvider.Clear();
+            }
+
+            // Step 6. Return the encrypted string as a base64 encoded string
+            return Convert.ToBase64String(Results);
+        }
+
         /// <summary>
         /// genera hash di una stringa in MD5 (es x hash gravatar)
         /// </summary>
@@ -1412,10 +1600,10 @@ namespace SteamWare
             using (MD5 md5Hash = MD5.Create())
             {
                 hash = GetMd5Hash(md5Hash, Message);
-
             }
             return hash;
         }
+
         /// <summary>
         /// Crea un hash MD5
         /// </summary>
@@ -1424,7 +1612,6 @@ namespace SteamWare
         /// <returns></returns>
         public static string GetMd5Hash(MD5 md5Hash, string input)
         {
-
             // Convert the input string to a byte array and compute the hash.
             byte[] data = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(input));
 
@@ -1432,7 +1619,7 @@ namespace SteamWare
             // and create a string.
             StringBuilder sBuilder = new StringBuilder();
 
-            // Loop through each byte of the hashed data 
+            // Loop through each byte of the hashed data
             // and format each one as a hexadecimal string.
             for (int i = 0; i < data.Length; i++)
             {
@@ -1442,6 +1629,7 @@ namespace SteamWare
             // Return the hexadecimal string.
             return sBuilder.ToString();
         }
+
         /// <summary>
         /// Verify a hash against a string.
         /// </summary>
@@ -1467,74 +1655,16 @@ namespace SteamWare
             }
         }
 
+        #endregion Public Methods
     }
-    /// <summary>
-    /// classe gestione valori percentuali per semplificare edit utente (moltiplicati x 100 appunto)
-    /// </summary>
-    public class percentuali
-    {
-        /// <summary>
-        /// converte da percentuale a numero (es 5,3% --> 0.053)
-        /// </summary>
-        /// <param name="originalVal"></param>
-        /// <returns></returns>
-        public static decimal perc2num(string originalVal)
-        {
-            decimal answ = 0;
-            // se contiene "%" lo tolgo...
-            originalVal = originalVal.Replace("%", "");
-            // ora controllo se c'� valore > 1...
-            try
-            {
-                // inizio convertendo ..
-                answ = Convert.ToDecimal(originalVal);
-                answ = answ / 100;
-            }
-            catch
-            { }
-            return answ;
-        }
-        /// <summary>
-        /// converte da numero a percentuale (es 0.053 --> 5,3%)
-        /// </summary>
-        /// <param name="originalVal"></param>
-        /// <returns></returns>
-        public static decimal num2perc(string originalVal)
-        {
-            decimal answ = 0;
-            // ora controllo se c'� valore > 1...
-            try
-            {
-                // inizio convertendo ..
-                answ = Convert.ToDecimal(originalVal);
-                answ = answ * 100;
-            }
-            catch
-            { }
-            return answ;
-        }
-    }
+
     /// <summary>
     /// gestione helper tempi ciclo
     /// </summary>
     public class TempiCiclo
     {
-        /// <summary>
-        /// formatta in minuti/sec partendo da min.cent
-        /// </summary>
-        /// <param name="minCent"></param>
-        /// <returns></returns>
-        public static string minSec(object minCent)
-        {
-            string answ = "";
-            try
-            {
-                answ = string.Format("{0:mm}:{0:ss}", minCent2Sec(Convert.ToDecimal(minCent.ToString().Replace(".", ","))));
-            }
-            catch
-            { }
-            return answ;
-        }
+        #region Public Methods
+
         /// <summary>
         /// conversione da tempo minuti centesimali a  minuti/secondi
         /// </summary>
@@ -1551,30 +1681,25 @@ namespace SteamWare
             { }
             return answ;
         }
-    }
-    /// <summary>
-    /// Classe gestione divisioni
-    /// </summary>
-    public class ratio
-    {
+
         /// <summary>
-        /// Effettua il calcolo del rapporto numeratore/denominatore come DECIMAL con gestione denominatore != 0
+        /// formatta in minuti/sec partendo da min.cent
         /// </summary>
-        /// <param name="numVal">numeratore</param>
-        /// <param name="denVal">denominatore</param>
+        /// <param name="minCent"></param>
         /// <returns></returns>
-        public static decimal getDecimal(object numVal, object denVal)
+        public static string minSec(object minCent)
         {
-            decimal answ = 0;
-            decimal num = 0;
-            decimal den = 1;
-            decimal.TryParse(numVal.ToString(), out num);
-            decimal.TryParse(denVal.ToString(), out den);
-            // se il denominatore � 0 --> 1
-            den = (den == 0) ? 1 : den;
-            answ = num / den;
+            string answ = "";
+            try
+            {
+                answ = string.Format("{0:mm}:{0:ss}", minCent2Sec(Convert.ToDecimal(minCent.ToString().Replace(".", ","))));
+            }
+            catch
+            { }
             return answ;
         }
+
+        #endregion Public Methods
     }
 
     /// <summary>
@@ -1582,10 +1707,8 @@ namespace SteamWare
     /// </summary>
     public class ucEvent : EventArgs
     {
-        /// <summary>
-        /// tipo di evento segnalato
-        /// </summary>
-        public ucEvType tipoEvento { get; set; }
+        #region Public Constructors
+
         /// <summary>
         /// inizializzazione oggetto EventArg specifico
         /// </summary>
@@ -1594,5 +1717,50 @@ namespace SteamWare
         {
             tipoEvento = evento;
         }
+
+        #endregion Public Constructors
+
+        #region Public Properties
+
+        /// <summary>
+        /// tipo di evento segnalato
+        /// </summary>
+        public ucEvType tipoEvento { get; set; }
+
+        #endregion Public Properties
     }
-}
+
+    /// <summary>
+    ///  classi helper gestione URL
+    /// </summary>
+    public class urlUtils
+    {
+        #region Public Methods
+
+        /// <summary>
+        /// chiama un URL e restituisce (se richiesto) il risultato ricevuto
+        /// </summary>
+        /// <param name="url">url da chiamare</param>
+        /// <param name="returnAnsw">se si vuole in risposta il contenuto della risposta alla chiamata</param>
+        /// <returns></returns>
+        public static string callUrl(string url, bool returnAnsw)
+        {
+            string answ = "";
+            try
+            {
+                WebRequest request = HttpWebRequest.Create(url);
+                WebResponse response = request.GetResponse();
+                StreamReader reader = new StreamReader(response.GetResponseStream());
+                if (returnAnsw)
+                {
+                    answ = reader.ReadToEnd();
+                }
+            }
+            catch
+            { }
+            return answ;
+        }
+
+        #endregion Public Methods
+    }
+}
\ No newline at end of file