diff --git a/GPW_Admin/WebUserControls/mod_adminDipendenti.ascx.cs b/GPW_Admin/WebUserControls/mod_adminDipendenti.ascx.cs
index 8a3ec60..3797cc1 100644
--- a/GPW_Admin/WebUserControls/mod_adminDipendenti.ascx.cs
+++ b/GPW_Admin/WebUserControls/mod_adminDipendenti.ascx.cs
@@ -495,11 +495,15 @@ namespace GPW_Admin.WebUserControls
 
         private static void fullRefresh()
         {
+                licenzeGPW.resetLicenseData();
             // eseguo call di recupero da online
             bool refreshApp = licenzeGPW.RefreshAppInfo().Result;
             bool refreshAct = licenzeGPW.RefreshActInfo().Result;
             bool refreshPayload = licenzeGPW.RefreshPayload().Result;
             //bool refreshLic = licenzeGPW.RefreshLicInfo().Result;
+            //if (refreshApp && refreshAct && refreshPayload)
+            //{
+            //}
         }
 
         private void fixVisibility()
diff --git a/GPW_Data/licenzeGPW.cs b/GPW_Data/licenzeGPW.cs
index a068e11..216e3fa 100644
--- a/GPW_Data/licenzeGPW.cs
+++ b/GPW_Data/licenzeGPW.cs
@@ -25,22 +25,84 @@ namespace GPW_data
         //private static string apiUrl = "https://localhost:44351/";
         private static string apiUrl = "https://liman.egalware.com/ELM.API/";
 
-        private static string rkeyInstall = memLayer.ML.redHash($"LiMan:Install");
-        private static string rkeyNumInstall = memLayer.ML.redHash($"LiMan:NumInstall");
-        private static string rkeyAuth = memLayer.ML.redHash($"LiMan:Auth");
-        private static string rkeyMKey = memLayer.ML.redHash($"LiMan:rkeyMKey");
+        private static int cacheTTL = 60 * 5;
         private static string rkeyActInfo = memLayer.ML.redHash($"LiMan:ActInfo");
-        private static string rkeyDipAct = memLayer.ML.redHash($"LiMan:DipAct");
         private static string rkeyAppInfo = memLayer.ML.redHash($"LiMan:AppInfo");
+        private static string rkeyAuth = memLayer.ML.redHash($"LiMan:Auth");
+        private static string rkeyDipAct = memLayer.ML.redHash($"LiMan:DipAct");
+        private static string rkeyInstall = memLayer.ML.redHash($"LiMan:Install");
         private static string rkeyLicInfo = memLayer.ML.redHash($"LiMan:LicInfo");
+        private static string rkeyMKey = memLayer.ML.redHash($"LiMan:rkeyMKey");
+        private static string rkeyNumInstall = memLayer.ML.redHash($"LiMan:NumInstall");
         private static string rkeyPayload = memLayer.ML.redHash($"LiMan:Payload");
         private static string rkeyTickets = memLayer.ML.redHash($"LiMan:Tickets");
         private static string rkeyVetoRefPayL = memLayer.ML.redHash($"LiMan:VetoRefPayL");
 
-        private static int cacheTTL = 60 * 5;
-
         #endregion Private Fields
 
+        #region Private Properties
+
+        /// <summary>
+        /// Info applicativo corrente (da cache con eventuale recupero online...)
+        /// </summary>
+        private static LiManObj.ApplicativoDTO InfoApplicativo
+        {
+            get
+            {
+                LiManObj.ApplicativoDTO answ = new LiManObj.ApplicativoDTO();
+                // cerco da cache
+                string rawData = memLayer.ML.getRSV(rkeyLicInfo);
+                // se no ci fosse --> refresh online!
+                if (string.IsNullOrEmpty(rawData))
+                {
+                    var fatto = RefreshAppInfo().Result;
+                    if (fatto)
+                    {
+                        rawData = memLayer.ML.getRSV(rkeyLicInfo);
+                    }
+                }
+                if (!string.IsNullOrEmpty(rawData))
+                {
+                    try
+                    {
+                        // verifico se ho 1 risultato o molti...se inizia per "[" è molti
+                        if (rawData.StartsWith("["))
+                        {
+                            // POTREBBE darmi + di 1 risultato, prendo + recente...
+                            List<LiManObj.ApplicativoDTO> infoList = JsonConvert.DeserializeObject<List<LiManObj.ApplicativoDTO>>(rawData);
+                            if (infoList != null)
+                            {
+                                answ = infoList.OrderByDescending(x => x.Scadenza).FirstOrDefault();
+                            }
+                        }
+                        else
+                        {
+                            answ = JsonConvert.DeserializeObject<LiManObj.ApplicativoDTO>(rawData);
+                        }
+                    }
+                    catch
+                    { }
+                }
+                return answ;
+            }
+        }
+
+        /// <summary>
+        /// Durata cache statica locale dati licenza, random circa 1 h
+        /// </summary>
+        private static int LicCacheTTL
+        {
+            get
+            {
+                Random rndGen = new Random();
+                return rndGen.Next(50, 70) * 60;
+            }
+        }
+
+        private static LiManObj.ApplicativoDTO myInfoApplicativo { get; set; }
+
+        #endregion Private Properties
+
         #region Public Properties
 
         /// <summary>
@@ -125,483 +187,6 @@ namespace GPW_data
 
         #endregion Public Properties
 
-        #region Private Properties
-
-        /// <summary>
-        /// Info applicativo corrente (da cache con eventuale recupero online...)
-        /// </summary>
-        private static LiManObj.ApplicativoDTO InfoApplicativo
-        {
-            get
-            {
-                LiManObj.ApplicativoDTO answ = new LiManObj.ApplicativoDTO();
-                // cerco da cache
-                string rawData = memLayer.ML.getRSV(rkeyLicInfo);
-                // se no ci fosse --> refresh online!
-                if (string.IsNullOrEmpty(rawData))
-                {
-                    var fatto = RefreshAppInfo().Result;
-                    if (fatto)
-                    {
-                        rawData = memLayer.ML.getRSV(rkeyLicInfo);
-                    }
-                }
-                if (!string.IsNullOrEmpty(rawData))
-                {
-                    try
-                    {
-                        // verifico se ho 1 risultato o molti...se inizia per "[" è molti
-                        if (rawData.StartsWith("["))
-                        {
-                            // POTREBBE darmi + di 1 risultato, prendo + recente...
-                            List<LiManObj.ApplicativoDTO> infoList = JsonConvert.DeserializeObject<List<LiManObj.ApplicativoDTO>>(rawData);
-                            if (infoList != null)
-                            {
-                                answ = infoList.OrderByDescending(x => x.Scadenza).FirstOrDefault();
-                            }
-                        }
-                        else
-                        {
-                            answ = JsonConvert.DeserializeObject<LiManObj.ApplicativoDTO>(rawData);
-                        }
-                    }
-                    catch
-                    { }
-                }
-                return answ;
-            }
-        }
-
-        /// <summary>
-        /// Durata cache statica locale dati licenza, random circa 1 h
-        /// </summary>
-        private static int LicCacheTTL
-        {
-            get
-            {
-                Random rndGen = new Random();
-                return rndGen.Next(50, 70) * 60;
-            }
-        }
-
-        private static LiManObj.ApplicativoDTO myInfoApplicativo { get; set; }
-
-        #endregion Private Properties
-
-        #region Public Methods
-
-        /// <summary>
-        /// Verifica attivazione licenza dato codice impiego
-        /// </summary>
-        /// <param name="CodImpiego"></param>
-        /// <returns></returns>
-        public static async Task<bool> checkActivation(string CodImpiego)
-        {
-            bool answ = false;
-            // cerco online
-            RestClient client = new RestClient(apiUrl);
-            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
-            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
-            var request = new RestRequest($"/api/attivazioni/verifica?chiave={MKeyEnc}&CodImpiego={CodImpiego}", DataFormat.Json);
-            var response = client.Get(request);
-            // controllo risposta
-            if (response.StatusCode == System.Net.HttpStatusCode.OK)
-            {
-                // verifico risposta
-                string rawData = response.Content;
-                try
-                {
-                    // deserializzo
-                    AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
-                    answ = datiAttivazione != null && datiAttivazione.CodImpiego == CodImpiego;
-                }
-                catch
-                { }
-            }
-            return await Task.FromResult(answ);
-        }
-
-        /// <summary>
-        /// Verifica attivazione licenza dato codice impiego
-        /// </summary>
-        /// <param name="CodImpiego"></param>
-        /// <returns></returns>
-        public static async Task<bool> checkActivationUnlocked(string CodImpiego)
-        {
-            bool answ = false;
-            // cerco online
-            RestClient client = new RestClient(apiUrl);
-            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
-            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
-            var request = new RestRequest($"/api/attivazioni/verifica?chiave={MKeyEnc}&CodImpiego={CodImpiego}", DataFormat.Json);
-            var response = client.Get(request);
-            // controllo risposta
-            if (response.StatusCode == System.Net.HttpStatusCode.OK)
-            {
-                // verifico risposta
-                string rawData = response.Content;
-                try
-                {
-                    // deserializzo
-                    AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
-                    if (datiAttivazione != null)
-                    {
-                        // verifico se il veto sia scaduto
-                        answ = datiAttivazione.VetoUnlock <= DateTime.Today;
-                    }
-                }
-                catch
-                { }
-            }
-            return await Task.FromResult(answ);
-        }
-
-        /// <summary>
-        /// Effettua refresh ActivationInfo con chiamata remota (sovrascrivendo info locali Redis)
-        /// </summary>
-        /// <returns></returns>
-        public static async Task<bool> RefreshActInfo()
-        {
-            bool answ = false;
-
-            // cerco online
-            RestClient client = new RestClient(apiUrl);
-            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
-            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
-            var request = new RestRequest($"/api/attivazioni/?chiave={MKeyEnc}", DataFormat.Json);
-            var response = client.Get(request);
-            // controllo risposta
-            if (response.StatusCode == System.Net.HttpStatusCode.OK)
-            {
-                answ = true;
-                // salvo in redis contenuto serializzato
-                string rawData = response.Content;
-                // salvo in redis per 7 gg
-                memLayer.ML.setRSV(rkeyActInfo, rawData, LicCacheTTL);
-            }
-            return await Task.FromResult(answ);
-        }
-
-        /// <summary>
-        /// Effettua refresh AppInfo con chiamata remota (sovrascrivendo info locali Redis)
-        /// </summary>
-        /// <returns></returns>
-        public static async Task<bool> RefreshAppInfo()
-        {
-            bool answ = false;
-
-            // cerco online
-            RestClient client = new RestClient(apiUrl);
-            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
-            var request = new RestRequest($"/api/applicazione/{installazione}?CodApp={applicazione}", DataFormat.Json);
-            var response = client.Get(request);
-            // controllo risposta
-            if (response.StatusCode == System.Net.HttpStatusCode.OK)
-            {
-                answ = true;
-                // salvo in redis contenuto serializzato
-                string rawData = response.Content;
-                // salvo in redis per 7 gg
-                memLayer.ML.setRSV(rkeyAppInfo, rawData, LicCacheTTL);
-            }
-            return await Task.FromResult(answ);
-        }
-
-        /// <summary>
-        /// Effettua refresh LicenseInfo con chiamata remota (sovrascrivendo info locali Redis)
-        /// </summary>
-        /// <returns></returns>
-        public static async Task<bool> RefreshLicInfo()
-        {
-            bool answ = false;
-
-            // cerco online
-            RestClient client = new RestClient(apiUrl);
-            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
-            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
-            var request = new RestRequest($"/api/licenza/{installazione}?CodApp={applicazione}&Chiave={MKeyEnc}", DataFormat.Json);
-            var response = client.Get(request);
-            // controllo risposta
-            if (response.StatusCode == System.Net.HttpStatusCode.OK)
-            {
-                answ = true;
-                // salvo in redis contenuto serializzato
-                string rawData = response.Content;
-                // salvo in redis per 7 gg
-                memLayer.ML.setRSV(rkeyLicInfo, rawData, LicCacheTTL);
-            }
-            return await Task.FromResult(answ);
-        }
-
-        /// <summary>
-        /// Effettua refresh Payload su server (Remoto) e recupera info licenza in locale (sovrascrivendo info locali Redis)
-        /// </summary>
-        /// <returns></returns>
-        public static async Task<bool> RefreshPayload()
-        {
-            bool answ = false;
-            // svuoto payload calcolato in primis (ttl a 1 sec)...
-            memLayer.ML.setRSV(rkeyPayload, "", 1);
-
-            // cerco online
-            RestClient client = new RestClient(apiUrl);
-            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
-            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
-            var request = new RestRequest($"/api/licenza/refreshPayload", DataFormat.Json);
-            string newEnigma = calcHash($"{DateTime.Now:yyyyMMddHHmmss}");
-            LicenseCoord newBody = new LicenseCoord()
-            {
-                MasterKey = MasterKey,
-                CodInst = installazione,
-                CodApp = applicazione,
-                Enigma = newEnigma
-            };
-            request.AddJsonBody(newBody);
-            var response = client.Post(request);
-            // controllo risposta
-            if (response.StatusCode == System.Net.HttpStatusCode.OK)
-            {
-                answ = true;
-                // salvo in redis contenuto serializzato
-                string rawData = response.Content;
-                // salvo in redis per 7 gg
-                memLayer.ML.setRSV(rkeyLicInfo, rawData, LicCacheTTL);
-            }
-            return await Task.FromResult(answ);
-        }
-
-        /// <summary>
-        /// Tenta invio di un ticket x licenza indicata
-        /// </summary>
-        /// <param name="contName"></param>
-        /// <param name="contEmail"></param>
-        /// <param name="contPhone"></param>
-        /// <param name="reqBody"></param>
-        /// <param name="codImpiego"></param>
-        /// <param name="idxSubLic"></param>
-        /// <returns></returns>
-        public static async Task<bool> sendTicketReq(string contName, string contEmail, string contPhone, string reqBody, string codImpiego, int idxSubLic)
-        {
-            bool answ = false;
-            // cerco online
-            RestClient client = new RestClient(apiUrl);
-            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
-            var request = new RestRequest($"/api/ticket/sendReq", DataFormat.Json);
-
-            SupportRequest richiesta = new SupportRequest()
-            {
-                ContactName = contName,
-                ContactEmail = contEmail,
-                ContactPhone = contPhone,
-                ReqBody = reqBody,
-                CodInst = installazione,
-                CodApp = applicazione,
-                MasterKey = MasterKey,
-                idxSubLic = idxSubLic,
-                CodImp = codImpiego
-            };
-
-            request.AddJsonBody(richiesta);
-            var response = client.Post(request);
-
-            // controllo risposta
-            if (response.StatusCode == System.Net.HttpStatusCode.OK)
-            {
-                // verifico risposta
-                string rawData = response.Content;
-                try
-                {
-                    if (rawData.StartsWith("["))
-                    {
-                        // deserializzo
-                        List<TicketDTO> tickets = JsonConvert.DeserializeObject<List<TicketDTO>>(rawData);
-                        answ = tickets != null;
-                    }
-                    else
-                    {
-                        // deserializzo singolo
-                        TicketDTO tickets = JsonConvert.DeserializeObject<TicketDTO>(rawData);
-                        answ = tickets != null;
-                    }
-                }
-                catch
-                { }
-            }
-            return await Task.FromResult(answ);
-        }
-
-        /// <summary>
-        /// Tenta attivazione licenza dato codice impiego
-        /// </summary>
-        /// <param name="CodImpiego"></param>
-        /// <returns></returns>
-        public static async Task<bool> tryActivation(string CodImpiego, string Chiave)
-        {
-            bool answ = false;
-            // cerco online
-            RestClient client = new RestClient(apiUrl);
-            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
-            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
-            var request = new RestRequest($"/api/attivazioni", DataFormat.Json);
-            Dictionary<string, string> parDict = new Dictionary<string, string>();
-            parDict.Add(CodImpiego, Chiave);
-            UserLicenseRequest newBody = new UserLicenseRequest()
-            {
-                MasterKey = MasterKey,
-                ParamDict = parDict
-            };
-            request.AddJsonBody(newBody);
-            var response = client.Post(request);
-            // controllo risposta
-            if (response.StatusCode == System.Net.HttpStatusCode.OK)
-            {
-                // verifico risposta
-                string rawData = response.Content;
-                try
-                {
-                    // deserializzo
-                    AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
-                    answ = datiAttivazione != null;
-                }
-                catch
-                { }
-            }
-            return await Task.FromResult(answ);
-        }
-
-        /// <summary>
-        /// Tenta attivazione licenze dato dizionario codici impiego + chiavi
-        /// </summary>
-        /// <param name="ParamsList">Dizionario parametri attivazione di tipo (CodImpiego,Chiave)</param>
-        /// <returns></returns>
-        public static async Task<bool> tryActivationMult(Dictionary<string, string> ParamsList)
-        {
-            bool answ = false;
-            // cerco online
-            RestClient client = new RestClient(apiUrl);
-            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
-            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
-            var request = new RestRequest($"/api/attivazioni", DataFormat.Json);
-            UserLicenseRequest newBody = new UserLicenseRequest()
-            {
-                MasterKey = MasterKey,
-                ParamDict = ParamsList
-            };
-            request.AddJsonBody(newBody);
-            var response = client.Post(request);
-            // controllo risposta
-            if (response.StatusCode == System.Net.HttpStatusCode.OK)
-            {
-                // verifico risposta
-                string rawData = response.Content;
-                try
-                {
-                    if (rawData.StartsWith("["))
-                    {
-                        // deserializzo
-                        List<AttivazioneDTO> datiAttivazione = JsonConvert.DeserializeObject<List<AttivazioneDTO>>(rawData);
-                        answ = datiAttivazione != null;
-                    }
-                    else
-                    {
-                        // deserializzo singolo
-                        AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
-                        answ = datiAttivazione != null;
-                    }
-                }
-                catch
-                { }
-            }
-            return await Task.FromResult(answ);
-        }
-
-        /// <summary>
-        /// Tenta disattivazione licenza dato codice impiego
-        /// </summary>
-        /// <param name="ParamsList">Dizionario codici da eliminare (CodImpiego/uSERkEY)</param>
-        /// <returns></returns>
-        public static async Task<bool> tryDeactivation(Dictionary<string, string> ParamsList)
-        {
-            bool answ = false;
-            // cerco attivazione...
-            var refreshDone = RefreshActInfo().Result;
-            if (refreshDone)
-            {
-                // cerco online
-                RestClient client = new RestClient(apiUrl);
-                //client.Authenticator = new HttpBasicAuthenticator("username", "password");
-                var request = new RestRequest($"/api/attivazioni", DataFormat.Json);
-                UserLicenseRequest newBody = new UserLicenseRequest()
-                {
-                    MasterKey = MasterKey,
-                    ParamDict = ParamsList
-                };
-                request.AddJsonBody(newBody);
-                var response = client.Delete(request);
-                // controllo risposta
-                if (response.StatusCode == System.Net.HttpStatusCode.OK)
-                {
-                    // verifico risposta
-                    string rawData = response.Content;
-                    bool.TryParse(rawData, out answ);
-                }
-            }
-
-            return await Task.FromResult(answ);
-        }
-
-        /// <summary>
-        /// Tenta refresh licenza dato codice impiego (aggiorna la authKey...)
-        /// </summary>
-        /// <param name="CodImpiego"></param>
-        /// <returns></returns>
-        public static async Task<bool> tryRefreshActivation(string CodImpiego, string Chiave)
-        {
-            bool answ = false;
-            // cerco online
-            RestClient client = new RestClient(apiUrl);
-            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
-            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
-            var request = new RestRequest($"/api/attivazioni/refreshKey", DataFormat.Json);
-            Dictionary<string, string> parDict = new Dictionary<string, string>();
-            parDict.Add(CodImpiego, Chiave);
-            UserLicenseRequest newBody = new UserLicenseRequest()
-            {
-                MasterKey = MasterKey,
-                ParamDict = parDict
-            };
-            request.AddJsonBody(newBody);
-            var response = client.Post(request);
-            // controllo risposta
-            if (response.StatusCode == System.Net.HttpStatusCode.OK)
-            {
-                // verifico risposta
-                string rawData = response.Content;
-                try
-                {
-                    if (rawData.StartsWith("["))
-                    {
-                        // deserializzo
-                        List<AttivazioneDTO> datiAttivazione = JsonConvert.DeserializeObject<List<AttivazioneDTO>>(rawData);
-                        answ = datiAttivazione != null;
-                    }
-                    else
-                    {
-                        // deserializzo singolo
-                        AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
-                        answ = datiAttivazione != null;
-                    }
-                }
-                catch
-                { }
-            }
-            return await Task.FromResult(answ);
-        }
-
-        public static bool userPayloadOk(int idxDip) => _userPayloadOk(idxDip);
-
-        #endregion Public Methods
-
         #region Private Methods
 
         /// <summary>
@@ -891,25 +476,6 @@ namespace GPW_data
             return getDipAttivi().Count;
         }
 
-        public static DS_Applicazione.DipendentiDataTable getDipAttivi()
-        {
-            DS_Applicazione.DipendentiDataTable answ = new DS_Applicazione.DipendentiDataTable();
-            // cerco da cache
-            string rawData = memLayer.ML.getRSV(rkeyDipAct);
-            // se no ci fosse --> refresh online!
-            if (string.IsNullOrEmpty(rawData))
-            {
-                answ = DataProxy.DP.taDipendenti.getAttivi(false);
-                rawData = JsonConvert.SerializeObject(answ);
-                memLayer.ML.setRSV(rkeyDipAct, rawData, cacheTTL);
-            }
-            else
-            {
-                answ = JsonConvert.DeserializeObject<DS_Applicazione.DipendentiDataTable>(rawData);
-            }
-            return answ;
-        }
-
         /// <summary>
         /// Calcolo Hash data stringa input
         /// </summary>
@@ -1009,14 +575,6 @@ namespace GPW_data
             return await Task.FromResult(answ);
         }
 
-        public static void resetTicketCache()
-        {
-            // resetto cache tickets a 1 sec e vuoto
-            memLayer.ML.setRSV(rkeyTickets, "", 1);
-            // ricarico
-            var newList = getTickets();
-        }
-
         private static void tryCheckPayloadOnline(ref bool answ, ref string currPayload)
         {
             try
@@ -1044,5 +602,458 @@ namespace GPW_data
         }
 
         #endregion Private Methods
+
+        #region Public Methods
+
+        /// <summary>
+        /// Verifica attivazione licenza dato codice impiego
+        /// </summary>
+        /// <param name="CodImpiego"></param>
+        /// <returns></returns>
+        public static async Task<bool> checkActivation(string CodImpiego)
+        {
+            bool answ = false;
+            // cerco online
+            RestClient client = new RestClient(apiUrl);
+            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
+            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
+            var request = new RestRequest($"/api/attivazioni/verifica?chiave={MKeyEnc}&CodImpiego={CodImpiego}", DataFormat.Json);
+            var response = client.Get(request);
+            // controllo risposta
+            if (response.StatusCode == System.Net.HttpStatusCode.OK)
+            {
+                // verifico risposta
+                string rawData = response.Content;
+                try
+                {
+                    // deserializzo
+                    AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
+                    answ = datiAttivazione != null && datiAttivazione.CodImpiego == CodImpiego;
+                }
+                catch
+                { }
+            }
+            return await Task.FromResult(answ);
+        }
+
+        /// <summary>
+        /// Verifica attivazione licenza dato codice impiego
+        /// </summary>
+        /// <param name="CodImpiego"></param>
+        /// <returns></returns>
+        public static async Task<bool> checkActivationUnlocked(string CodImpiego)
+        {
+            bool answ = false;
+            // cerco online
+            RestClient client = new RestClient(apiUrl);
+            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
+            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
+            var request = new RestRequest($"/api/attivazioni/verifica?chiave={MKeyEnc}&CodImpiego={CodImpiego}", DataFormat.Json);
+            var response = client.Get(request);
+            // controllo risposta
+            if (response.StatusCode == System.Net.HttpStatusCode.OK)
+            {
+                // verifico risposta
+                string rawData = response.Content;
+                try
+                {
+                    // deserializzo
+                    AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
+                    if (datiAttivazione != null)
+                    {
+                        // verifico se il veto sia scaduto
+                        answ = datiAttivazione.VetoUnlock <= DateTime.Today;
+                    }
+                }
+                catch
+                { }
+            }
+            return await Task.FromResult(answ);
+        }
+
+        public static DS_Applicazione.DipendentiDataTable getDipAttivi()
+        {
+            DS_Applicazione.DipendentiDataTable answ = new DS_Applicazione.DipendentiDataTable();
+            // cerco da cache
+            string rawData = memLayer.ML.getRSV(rkeyDipAct);
+            // se no ci fosse --> refresh online!
+            if (string.IsNullOrEmpty(rawData))
+            {
+                answ = DataProxy.DP.taDipendenti.getAttivi(false);
+                rawData = JsonConvert.SerializeObject(answ);
+                memLayer.ML.setRSV(rkeyDipAct, rawData, cacheTTL);
+            }
+            else
+            {
+                answ = JsonConvert.DeserializeObject<DS_Applicazione.DipendentiDataTable>(rawData);
+            }
+            return answ;
+        }
+
+        /// <summary>
+        /// Effettua refresh ActivationInfo con chiamata remota (sovrascrivendo info locali Redis)
+        /// </summary>
+        /// <returns></returns>
+        public static async Task<bool> RefreshActInfo()
+        {
+            bool answ = false;
+
+            // cerco online
+            RestClient client = new RestClient(apiUrl);
+            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
+            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
+            var request = new RestRequest($"/api/attivazioni/?chiave={MKeyEnc}", DataFormat.Json);
+            var response = client.Get(request);
+            // controllo risposta
+            if (response.StatusCode == System.Net.HttpStatusCode.OK)
+            {
+                answ = true;
+                // salvo in redis contenuto serializzato
+                string rawData = response.Content;
+                // salvo in redis per 7 gg
+                memLayer.ML.setRSV(rkeyActInfo, rawData, LicCacheTTL);
+            }
+            return await Task.FromResult(answ);
+        }
+
+        /// <summary>
+        /// Effettua refresh AppInfo con chiamata remota (sovrascrivendo info locali Redis)
+        /// </summary>
+        /// <returns></returns>
+        public static async Task<bool> RefreshAppInfo()
+        {
+            bool answ = false;
+
+            // cerco online
+            RestClient client = new RestClient(apiUrl);
+            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
+            var request = new RestRequest($"/api/applicazione/{installazione}?CodApp={applicazione}", DataFormat.Json);
+            var response = client.Get(request);
+            // controllo risposta
+            if (response.StatusCode == System.Net.HttpStatusCode.OK)
+            {
+                answ = true;
+                // salvo in redis contenuto serializzato
+                string rawData = response.Content;
+                // salvo in redis per 7 gg
+                memLayer.ML.setRSV(rkeyAppInfo, rawData, LicCacheTTL);
+            }
+            return await Task.FromResult(answ);
+        }
+
+        /// <summary>
+        /// Effettua refresh LicenseInfo con chiamata remota (sovrascrivendo info locali Redis)
+        /// </summary>
+        /// <returns></returns>
+        public static async Task<bool> RefreshLicInfo()
+        {
+            bool answ = false;
+
+            // cerco online
+            RestClient client = new RestClient(apiUrl);
+            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
+            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
+            var request = new RestRequest($"/api/licenza/{installazione}?CodApp={applicazione}&Chiave={MKeyEnc}", DataFormat.Json);
+            var response = client.Get(request);
+            // controllo risposta
+            if (response.StatusCode == System.Net.HttpStatusCode.OK)
+            {
+                answ = true;
+                // salvo in redis contenuto serializzato
+                string rawData = response.Content;
+                // salvo in redis per 7 gg
+                memLayer.ML.setRSV(rkeyLicInfo, rawData, LicCacheTTL);
+            }
+            return await Task.FromResult(answ);
+        }
+
+        /// <summary>
+        /// Effettua refresh Payload su server (Remoto) e recupera info licenza in locale (sovrascrivendo info locali Redis)
+        /// </summary>
+        /// <returns></returns>
+        public static async Task<bool> RefreshPayload()
+        {
+            bool answ = false;
+            // svuoto payload calcolato in primis (ttl a 1 sec)...
+            memLayer.ML.setRSV(rkeyPayload, "", 1);
+
+            // cerco online
+            RestClient client = new RestClient(apiUrl);
+            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
+            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
+            var request = new RestRequest($"/api/licenza/refreshPayload", DataFormat.Json);
+            string newEnigma = calcHash($"{DateTime.Now:yyyyMMddHHmmss}");
+            LicenseCoord newBody = new LicenseCoord()
+            {
+                MasterKey = MasterKey,
+                CodInst = installazione,
+                CodApp = applicazione,
+                Enigma = newEnigma
+            };
+            request.AddJsonBody(newBody);
+            var response = client.Post(request);
+            // controllo risposta
+            if (response.StatusCode == System.Net.HttpStatusCode.OK)
+            {
+                answ = true;
+                // salvo in redis contenuto serializzato
+                string rawData = response.Content;
+                // salvo in redis per 7 gg
+                memLayer.ML.setRSV(rkeyLicInfo, rawData, LicCacheTTL);
+            }
+            return await Task.FromResult(answ);
+        }
+
+        public static void resetLicenseData()
+        {
+            memLayer.ML.setRSV(rkeyDipAct, "", 1);
+            memLayer.ML.setRSV(rkeyPayload, "", 1);
+            memLayer.ML.setRSV(rkeyLicInfo, "", 1);
+            memLayer.ML.setRSV(rkeyActInfo, "", 1);
+        }
+
+        public static void resetTicketCache()
+        {
+            // resetto cache tickets a 1 sec e vuoto
+            memLayer.ML.setRSV(rkeyTickets, "", 1);
+            // ricarico
+            var newList = getTickets();
+        }
+
+        /// <summary>
+        /// Tenta invio di un ticket x licenza indicata
+        /// </summary>
+        /// <param name="contName"></param>
+        /// <param name="contEmail"></param>
+        /// <param name="contPhone"></param>
+        /// <param name="reqBody"></param>
+        /// <param name="codImpiego"></param>
+        /// <param name="idxSubLic"></param>
+        /// <returns></returns>
+        public static async Task<bool> sendTicketReq(string contName, string contEmail, string contPhone, string reqBody, string codImpiego, int idxSubLic)
+        {
+            bool answ = false;
+            // cerco online
+            RestClient client = new RestClient(apiUrl);
+            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
+            var request = new RestRequest($"/api/ticket/sendReq", DataFormat.Json);
+
+            SupportRequest richiesta = new SupportRequest()
+            {
+                ContactName = contName,
+                ContactEmail = contEmail,
+                ContactPhone = contPhone,
+                ReqBody = reqBody,
+                CodInst = installazione,
+                CodApp = applicazione,
+                MasterKey = MasterKey,
+                idxSubLic = idxSubLic,
+                CodImp = codImpiego
+            };
+
+            request.AddJsonBody(richiesta);
+            var response = client.Post(request);
+
+            // controllo risposta
+            if (response.StatusCode == System.Net.HttpStatusCode.OK)
+            {
+                // verifico risposta
+                string rawData = response.Content;
+                try
+                {
+                    if (rawData.StartsWith("["))
+                    {
+                        // deserializzo
+                        List<TicketDTO> tickets = JsonConvert.DeserializeObject<List<TicketDTO>>(rawData);
+                        answ = tickets != null;
+                    }
+                    else
+                    {
+                        // deserializzo singolo
+                        TicketDTO tickets = JsonConvert.DeserializeObject<TicketDTO>(rawData);
+                        answ = tickets != null;
+                    }
+                }
+                catch
+                { }
+            }
+            return await Task.FromResult(answ);
+        }
+
+        /// <summary>
+        /// Tenta attivazione licenza dato codice impiego
+        /// </summary>
+        /// <param name="CodImpiego"></param>
+        /// <returns></returns>
+        public static async Task<bool> tryActivation(string CodImpiego, string Chiave)
+        {
+            bool answ = false;
+            // cerco online
+            RestClient client = new RestClient(apiUrl);
+            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
+            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
+            var request = new RestRequest($"/api/attivazioni", DataFormat.Json);
+            Dictionary<string, string> parDict = new Dictionary<string, string>();
+            parDict.Add(CodImpiego, Chiave);
+            UserLicenseRequest newBody = new UserLicenseRequest()
+            {
+                MasterKey = MasterKey,
+                ParamDict = parDict
+            };
+            request.AddJsonBody(newBody);
+            var response = client.Post(request);
+            // controllo risposta
+            if (response.StatusCode == System.Net.HttpStatusCode.OK)
+            {
+                // verifico risposta
+                string rawData = response.Content;
+                try
+                {
+                    // deserializzo
+                    AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
+                    answ = datiAttivazione != null;
+                    resetLicenseData();
+                }
+                catch
+                { }
+            }
+            return await Task.FromResult(answ);
+        }
+
+        /// <summary>
+        /// Tenta attivazione licenze dato dizionario codici impiego + chiavi
+        /// </summary>
+        /// <param name="ParamsList">Dizionario parametri attivazione di tipo (CodImpiego,Chiave)</param>
+        /// <returns></returns>
+        public static async Task<bool> tryActivationMult(Dictionary<string, string> ParamsList)
+        {
+            bool answ = false;
+            // cerco online
+            RestClient client = new RestClient(apiUrl);
+            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
+            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
+            var request = new RestRequest($"/api/attivazioni", DataFormat.Json);
+            UserLicenseRequest newBody = new UserLicenseRequest()
+            {
+                MasterKey = MasterKey,
+                ParamDict = ParamsList
+            };
+            request.AddJsonBody(newBody);
+            var response = client.Post(request);
+            // controllo risposta
+            if (response.StatusCode == System.Net.HttpStatusCode.OK)
+            {
+                // verifico risposta
+                string rawData = response.Content;
+                try
+                {
+                    if (rawData.StartsWith("["))
+                    {
+                        // deserializzo
+                        List<AttivazioneDTO> datiAttivazione = JsonConvert.DeserializeObject<List<AttivazioneDTO>>(rawData);
+                        answ = datiAttivazione != null;
+                    }
+                    else
+                    {
+                        // deserializzo singolo
+                        AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
+                        answ = datiAttivazione != null;
+                        resetLicenseData();
+                    }
+                }
+                catch
+                { }
+            }
+            return await Task.FromResult(answ);
+        }
+
+        /// <summary>
+        /// Tenta disattivazione licenza dato codice impiego
+        /// </summary>
+        /// <param name="ParamsList">Dizionario codici da eliminare (CodImpiego/uSERkEY)</param>
+        /// <returns></returns>
+        public static async Task<bool> tryDeactivation(Dictionary<string, string> ParamsList)
+        {
+            bool answ = false;
+            // cerco attivazione...
+            var refreshDone = RefreshActInfo().Result;
+            if (refreshDone)
+            {
+                // cerco online
+                RestClient client = new RestClient(apiUrl);
+                //client.Authenticator = new HttpBasicAuthenticator("username", "password");
+                var request = new RestRequest($"/api/attivazioni", DataFormat.Json);
+                UserLicenseRequest newBody = new UserLicenseRequest()
+                {
+                    MasterKey = MasterKey,
+                    ParamDict = ParamsList
+                };
+                request.AddJsonBody(newBody);
+                var response = client.Delete(request);
+                // controllo risposta
+                if (response.StatusCode == System.Net.HttpStatusCode.OK)
+                {
+                    // verifico risposta
+                    string rawData = response.Content;
+                    bool.TryParse(rawData, out answ);
+                    resetLicenseData();
+                }
+            }
+
+            return await Task.FromResult(answ);
+        }
+
+        /// <summary>
+        /// Tenta refresh licenza dato codice impiego (aggiorna la authKey...)
+        /// </summary>
+        /// <param name="CodImpiego"></param>
+        /// <returns></returns>
+        public static async Task<bool> tryRefreshActivation(string CodImpiego, string Chiave)
+        {
+            bool answ = false;
+            // cerco online
+            RestClient client = new RestClient(apiUrl);
+            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
+            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
+            var request = new RestRequest($"/api/attivazioni/refreshKey", DataFormat.Json);
+            Dictionary<string, string> parDict = new Dictionary<string, string>();
+            parDict.Add(CodImpiego, Chiave);
+            UserLicenseRequest newBody = new UserLicenseRequest()
+            {
+                MasterKey = MasterKey,
+                ParamDict = parDict
+            };
+            request.AddJsonBody(newBody);
+            var response = client.Post(request);
+            // controllo risposta
+            if (response.StatusCode == System.Net.HttpStatusCode.OK)
+            {
+                // verifico risposta
+                string rawData = response.Content;
+                try
+                {
+                    if (rawData.StartsWith("["))
+                    {
+                        // deserializzo
+                        List<AttivazioneDTO> datiAttivazione = JsonConvert.DeserializeObject<List<AttivazioneDTO>>(rawData);
+                        answ = datiAttivazione != null;
+                    }
+                    else
+                    {
+                        // deserializzo singolo
+                        AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
+                        answ = datiAttivazione != null;
+                        resetLicenseData();
+                    }
+                }
+                catch
+                { }
+            }
+            return await Task.FromResult(answ);
+        }
+
+        public static bool userPayloadOk(int idxDip) => _userPayloadOk(idxDip);
+
+        #endregion Public Methods
     }
 }
\ No newline at end of file