From 6f392378620d6498bf23a4a6516a280a2270953e Mon Sep 17 00:00:00 2001
From: Samuele Locatelli <samuele@steamware.net>
Date: Tue, 16 Nov 2021 19:35:07 +0100
Subject: [PATCH 01/14] Update ulteriore classi API

---
 Core/SupportRequest.cs               | 1 +
 LiMan.DB/Controllers/DbController.cs | 2 +-
 LiMan.UI/LiMan.UI.csproj             | 2 +-
 LiMan.UI/Resources/ChangeLog.html    | 2 +-
 LiMan.UI/Resources/VersNum.txt       | 2 +-
 LiMan.UI/Resources/manifest.xml      | 2 +-
 6 files changed, 6 insertions(+), 5 deletions(-)
diff --git a/Core/SupportRequest.cs b/Core/SupportRequest.cs
index 1582ace..cab22a3 100644
--- a/Core/SupportRequest.cs
+++ b/Core/SupportRequest.cs
@@ -14,6 +14,7 @@ namespace Core
         public string CodImp { get; set; } = "";
         public string CodInst { get; set; } = "";
         public string ContactEmail { get; set; } = "";
+        public string ContactName { get; set; } = "";
         public string ContactPhone { get; set; } = "";
         public int idxSubLic { get; set; } = 0;
 
diff --git a/LiMan.DB/Controllers/DbController.cs b/LiMan.DB/Controllers/DbController.cs
index 63b7e2c..f4e902c 100644
--- a/LiMan.DB/Controllers/DbController.cs
+++ b/LiMan.DB/Controllers/DbController.cs
@@ -53,7 +53,7 @@ namespace LiMan.DB.Controllers
                     // calcolo DTO Attivazione
                     var itemsTgt = localDbCtx
                         .DbSetSubLicenze
-                        .Where(x => x.CodImpiego == item.Key && x.Chiave == item.Value && x.LicenzaNav.Chiave == MasterKey && x.VetoUnlock < oggi)
+                        .Where(x => x.CodImpiego == item.Key && x.Chiave == item.Value && x.LicenzaNav.Chiave == MasterKey && x.VetoUnlock <= oggi)
                         .ToList();
                     // se trovate aggiungo ad elenco...
                     if (itemsTgt != null && itemsTgt.Count > 0)
diff --git a/LiMan.UI/LiMan.UI.csproj b/LiMan.UI/LiMan.UI.csproj
index 61fb80c..7311663 100644
--- a/LiMan.UI/LiMan.UI.csproj
+++ b/LiMan.UI/LiMan.UI.csproj
@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>net6.0</TargetFramework>
-        <Version>1.1.2111.1618</Version>
+        <Version>1.1.2111.1619</Version>
         <RootNamespace>LiMan.UI</RootNamespace>
         <AssemblyName>LiMan.UI</AssemblyName>
     </PropertyGroup>
diff --git a/LiMan.UI/Resources/ChangeLog.html b/LiMan.UI/Resources/ChangeLog.html
index 89f81a8..e5366ec 100644
--- a/LiMan.UI/Resources/ChangeLog.html
+++ b/LiMan.UI/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>License Manager</i>
-    <h4>Versione: 1.1.2111.1618</h4>
+    <h4>Versione: 1.1.2111.1619</h4>
     <br />
     Note di rilascio:
     <ul>
diff --git a/LiMan.UI/Resources/VersNum.txt b/LiMan.UI/Resources/VersNum.txt
index 352ab4e..c86e812 100644
--- a/LiMan.UI/Resources/VersNum.txt
+++ b/LiMan.UI/Resources/VersNum.txt
@@ -1 +1 @@
-1.1.2111.1618
+1.1.2111.1619
diff --git a/LiMan.UI/Resources/manifest.xml b/LiMan.UI/Resources/manifest.xml
index 59648ab..bfcabc1 100644
--- a/LiMan.UI/Resources/manifest.xml
+++ b/LiMan.UI/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.1.2111.1618</version>
+  <version>1.1.2111.1619</version>
   <url>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/LiMan.UI.zip</url>
   <changelog>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>

From 0b69ed8662028c91d9f3844b85fb2c62643374f2 Mon Sep 17 00:00:00 2001
From: Samuele Locatelli <samuele@steamware.net>
Date: Wed, 17 Nov 2021 11:09:35 +0100
Subject: [PATCH 02/14] aggiunto conf x email send

---
 LiMan.Api/Data/ApiDataService.cs      | 20 ++++++++-
 LiMan.Api/Startup.cs                  | 20 ++++++---
 LiMan.Api/appsettings.json            | 40 ++++++++++++-----
 LiMan.DB/MailKitEmailSender.cs        | 65 +++++++++++++++++++++++++++
 LiMan.DB/MailKitEmailSenderOptions.cs | 36 +++++++++++++++
 LiMan.UI/appsettings.json             | 40 ++++++++++++-----
 6 files changed, 189 insertions(+), 32 deletions(-)
 create mode 100644 LiMan.DB/MailKitEmailSender.cs
 create mode 100644 LiMan.DB/MailKitEmailSenderOptions.cs

diff --git a/LiMan.Api/Data/ApiDataService.cs b/LiMan.Api/Data/ApiDataService.cs
index 05274d4..7cd1059 100644
--- a/LiMan.Api/Data/ApiDataService.cs
+++ b/LiMan.Api/Data/ApiDataService.cs
@@ -1,4 +1,5 @@
 ﻿using Core;
+using Microsoft.AspNetCore.Identity.UI.Services;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using NLog;
@@ -20,8 +21,8 @@ namespace LiMan.APi.Data
 
         private static IConfiguration _configuration;
         private static ILogger<ApiDataService> _logger;
-
         private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
+        private readonly IEmailSender _emailSender;
 
         #endregion Private Fields
 
@@ -38,10 +39,11 @@ namespace LiMan.APi.Data
         /// </summary>
         /// <param name="configuration"></param>
         /// <param name="logger"></param>
-        public ApiDataService(IConfiguration configuration, ILogger<ApiDataService> logger)
+        public ApiDataService(IConfiguration configuration, ILogger<ApiDataService> logger, IEmailSender emailSender)
         {
             _logger = logger;
             _configuration = configuration;
+            _emailSender = emailSender;
             // conf DB
             string connStrDB = _configuration.GetConnectionString("LiMan.DB");
             if (string.IsNullOrEmpty(connStrDB))
@@ -310,6 +312,20 @@ namespace LiMan.APi.Data
             return await Task.FromResult(dbResult);
         }
 
+        public async Task<bool> SendEmail(string destEmail, string oggetto, string corpo)
+        {
+            bool answ = false;
+            try
+            {
+                await _emailSender.SendEmailAsync(destEmail, oggetto, corpo);
+                answ = true;
+            }
+            catch
+            { }
+
+            return answ;
+        }
+
         /// <summary>
         /// Esegue aggiunta Ticket richeisto + restitusice aperti x cliente
         /// </summary>
diff --git a/LiMan.Api/Startup.cs b/LiMan.Api/Startup.cs
index 495c66b..d4c2264 100644
--- a/LiMan.Api/Startup.cs
+++ b/LiMan.Api/Startup.cs
@@ -1,19 +1,15 @@
 using LiMan.APi.Data;
+using LiMan.DB;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.AspNetCore.HttpsPolicy;
-using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Identity.UI.Services;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 using Microsoft.OpenApi.Models;
 using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Reflection;
-using System.Threading.Tasks;
 
 namespace LiMan.Serv
 {
@@ -77,6 +73,18 @@ namespace LiMan.Serv
                 c.IncludeXmlComments(xmlPath);
             });
 
+            // abilitazione x email management con MailKit
+            services.AddTransient<IEmailSender, MailKitEmailSender>();
+            services.Configure<MailKitEmailSenderOptions>(options =>
+            {
+                options.Host_Address = Configuration["ExternalProviders:MailKit:SMTP:Address"];
+                options.Host_Port = Convert.ToInt32(Configuration["ExternalProviders:MailKit:SMTP:Port"]);
+                options.Host_Username = Configuration["ExternalProviders:MailKit:SMTP:Account"];
+                options.Host_Password = Configuration["ExternalProviders:MailKit:SMTP:Password"];
+                options.Sender_EMail = Configuration["ExternalProviders:MailKit:SMTP:SenderEmail"];
+                options.Sender_Name = Configuration["ExternalProviders:MailKit:SMTP:SenderName"];
+            });
+
             services.AddSingleton<ApiDataService>();
         }
 
diff --git a/LiMan.Api/appsettings.json b/LiMan.Api/appsettings.json
index 51ed134..f6956e1 100644
--- a/LiMan.Api/appsettings.json
+++ b/LiMan.Api/appsettings.json
@@ -1,15 +1,31 @@
 {
-    "Logging": {
-        "LogLevel": {
-            "Default": "Information",
-            "Microsoft": "Warning",
-            "Microsoft.Hosting.Lifetime": "Information"
-        }
-    },
-    "AllowedHosts": "*",
-    "ConnectionStrings": {
-        "LiMan.GLS": "Server=SQLSTEAM;Database=SteamWare_Auth;User ID=sa;Password=keyhammer;integrated security=False;MultipleActiveResultSets=True;App=LiMan.API;",
-        "LiMan.DB": "Server=SQLSTEAM;Database=LiMan.DB;User ID=sa;Password=keyhammer;integrated security=False;MultipleActiveResultSets=True;App=LiMan.API;",
-        "Redis": "localhost:6379"
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
     }
+  },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "LiMan.GLS": "Server=SQLSTEAM;Database=SteamWare_Auth;User ID=sa;Password=keyhammer;integrated security=False;MultipleActiveResultSets=True;App=LiMan.API;",
+    "LiMan.DB": "Server=SQLSTEAM;Database=LiMan.DB;User ID=sa;Password=keyhammer;integrated security=False;MultipleActiveResultSets=True;App=LiMan.API;",
+    "Redis": "localhost:6379"
+  },
+  "ExternalProviders": {
+    "MailKit": {
+      "SMTP": {
+        "Address": "smtp.gmail.com",
+        "Port": "465",
+        "Account": "steamwarebot@gmail.com",
+        "Password": "drmfsls16",
+        "SenderEmail": "steamwarebot@gmail.com",
+        "SenderName": "Steamware Email BOT"
+      }
+    }
+  },
+  "MailDest": {
+    "Admin": "samuele@steamware.net",
+    "ProcOp": "ceo@steamware.net"
+  }
 }
\ No newline at end of file
diff --git a/LiMan.DB/MailKitEmailSender.cs b/LiMan.DB/MailKitEmailSender.cs
new file mode 100644
index 0000000..53cdba5
--- /dev/null
+++ b/LiMan.DB/MailKitEmailSender.cs
@@ -0,0 +1,65 @@
+﻿using MailKit.Net.Smtp;
+using Microsoft.AspNetCore.Identity.UI.Services;
+using Microsoft.Extensions.Options;
+using MimeKit;
+using MimeKit.Text;
+using System.Threading.Tasks;
+
+namespace LiMan.DB
+{
+    /// <summary>
+    /// Implementazione interfaccia email con pacchetto MailKIT
+    ///
+    /// https://www.ryadel.com/en/asp-net-core-send-email-messages-smtp-mailkit/
+    /// </summary>
+    public class MailKitEmailSender : IEmailSender
+    {
+        #region Public Constructors
+
+        public MailKitEmailSender(IOptions<MailKitEmailSenderOptions> options)
+        {
+            this.Options = options.Value;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Properties
+
+        public MailKitEmailSenderOptions Options { get; set; }
+
+        #endregion Public Properties
+
+        #region Public Methods
+
+        public Task Execute(string to, string subject, string message)
+        {
+            // create message
+            var email = new MimeMessage();
+            email.Sender = MailboxAddress.Parse(Options.Sender_EMail);
+            if (!string.IsNullOrEmpty(Options.Sender_Name))
+                email.Sender.Name = Options.Sender_Name;
+            email.From.Add(email.Sender);
+            email.To.Add(MailboxAddress.Parse(to));
+            email.Subject = subject;
+            email.Body = new TextPart(TextFormat.Html) { Text = message };
+
+            // send email
+            using (var smtp = new SmtpClient())
+            {
+                smtp.Connect(Options.Host_Address, Options.Host_Port, Options.Host_SecureSocketOptions);
+                smtp.Authenticate(Options.Host_Username, Options.Host_Password);
+                smtp.Send(email);
+                smtp.Disconnect(true);
+            }
+
+            return Task.FromResult(true);
+        }
+
+        public Task SendEmailAsync(string email, string subject, string message)
+        {
+            return Execute(email, subject, message);
+        }
+
+        #endregion Public Methods
+    }
+}
\ No newline at end of file
diff --git a/LiMan.DB/MailKitEmailSenderOptions.cs b/LiMan.DB/MailKitEmailSenderOptions.cs
new file mode 100644
index 0000000..43de307
--- /dev/null
+++ b/LiMan.DB/MailKitEmailSenderOptions.cs
@@ -0,0 +1,36 @@
+﻿using MailKit.Security;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LiMan.DB
+{
+    public class MailKitEmailSenderOptions
+    {
+        #region Public Constructors
+
+        public MailKitEmailSenderOptions()
+        {
+            Host_SecureSocketOptions = SecureSocketOptions.Auto;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Properties
+
+        public string Host_Address { get; set; }
+
+        public string Host_Password { get; set; }
+        public int Host_Port { get; set; }
+
+        public SecureSocketOptions Host_SecureSocketOptions { get; set; }
+        public string Host_Username { get; set; }
+        public string Sender_EMail { get; set; }
+
+        public string Sender_Name { get; set; }
+
+        #endregion Public Properties
+    }
+}
\ No newline at end of file
diff --git a/LiMan.UI/appsettings.json b/LiMan.UI/appsettings.json
index ad09909..4667c39 100644
--- a/LiMan.UI/appsettings.json
+++ b/LiMan.UI/appsettings.json
@@ -1,15 +1,31 @@
 {
-    "Logging": {
-        "LogLevel": {
-            "Default": "Information",
-            "Microsoft": "Warning",
-            "Microsoft.Hosting.Lifetime": "Information"
-        }
-    },
-    "AllowedHosts": "*",
-    "ConnectionStrings": {
-        "LiMan.GLS": "Server=SQLSTEAM;Database=SteamWare_Auth;User ID=sa;Password=keyhammer;integrated security=False;MultipleActiveResultSets=True;App=LiMan.UI;",
-        "LiMan.DB": "Server=SQLSTEAM;Database=LiMan.DB;User ID=sa;Password=keyhammer;integrated security=False;MultipleActiveResultSets=True;App=LiMan.UI;",
-        "Redis": "localhost:6379"
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
     }
+  },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "LiMan.GLS": "Server=SQLSTEAM;Database=SteamWare_Auth;User ID=sa;Password=keyhammer;integrated security=False;MultipleActiveResultSets=True;App=LiMan.UI;",
+    "LiMan.DB": "Server=SQLSTEAM;Database=LiMan.DB;User ID=sa;Password=keyhammer;integrated security=False;MultipleActiveResultSets=True;App=LiMan.UI;",
+    "Redis": "localhost:6379"
+  },
+  "ExternalProviders": {
+    "MailKit": {
+      "SMTP": {
+        "Address": "smtp.gmail.com",
+        "Port": "465",
+        "Account": "steamwarebot@gmail.com",
+        "Password": "drmfsls16",
+        "SenderEmail": "steamwarebot@gmail.com",
+        "SenderName": "Steamware Email BOT"
+      }
+    }
+  },
+  "MailDest": {
+    "Admin": "samuele@steamware.net",
+    "ProcOp": "ceo@steamware.net"
+  }
 }
\ No newline at end of file

From cce92a6ac7a588d4819cfa4370334d5aecf3436b Mon Sep 17 00:00:00 2001
From: Samuele Locatelli <samuele@steamware.net>
Date: Wed, 17 Nov 2021 11:16:09 +0100
Subject: [PATCH 03/14] Update modello LogCall

---
 LiMan.DB/DBModels/LogCallModel.cs             |  29 ++
 LiMan.DB/LMDbContext.cs                       |  15 +-
 LiMan.DB/LiMan.DB.csproj                      |   8 +-
 .../20211117101539_AddLogCalls.Designer.cs    | 331 ++++++++++++++++++
 .../Migrations/20211117101539_AddLogCalls.cs  |  32 ++
 .../Migrations/LMDbContextModelSnapshot.cs    |  22 ++
 6 files changed, 425 insertions(+), 12 deletions(-)
 create mode 100644 LiMan.DB/DBModels/LogCallModel.cs
 create mode 100644 LiMan.DB/Migrations/20211117101539_AddLogCalls.Designer.cs
 create mode 100644 LiMan.DB/Migrations/20211117101539_AddLogCalls.cs

diff --git a/LiMan.DB/DBModels/LogCallModel.cs b/LiMan.DB/DBModels/LogCallModel.cs
new file mode 100644
index 0000000..cbc751d
--- /dev/null
+++ b/LiMan.DB/DBModels/LogCallModel.cs
@@ -0,0 +1,29 @@
+﻿using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using static LiMan.DB.Enum;
+
+#nullable disable
+
+namespace LiMan.DB.DBModels
+{
+    // <Auto-Generated>
+    // This is here so CodeMaid doesn't reorganize this document
+    // </Auto-Generated>
+    //[Index(nameof(Installazione), nameof(Active), nameof(DiskStatus))]
+    [Table("LogCall")]
+    public partial class LogCallModel
+    {
+        #region Public Properties
+
+        public DateTime DataRif { get; set; }
+        public string CodInst { get; set; }
+        public string CodApp { get; set; }
+        public string TargetUrl { get; set; }
+        public int NumCall { get; set; } = 0;
+       
+
+        #endregion Public Properties
+    }
+}
\ No newline at end of file
diff --git a/LiMan.DB/LMDbContext.cs b/LiMan.DB/LMDbContext.cs
index 15d535c..27a1305 100644
--- a/LiMan.DB/LMDbContext.cs
+++ b/LiMan.DB/LMDbContext.cs
@@ -49,23 +49,17 @@ namespace LiMan.DB
         #region Public Properties
 
         public virtual DbSet<ApplicativoModel> DbSetApp { get; set; }
-
         public virtual DbSet<InstallazioneModel> DbSetInst { get; set; }
-
         public virtual DbSet<LicenzaModel> DbSetLicenze { get; set; }
-
+        public virtual DbSet<LogCallModel> DbSetLogCall { get; set; }
         public virtual DbSet<LogLicenzaModel> DbSetLogLicenze { get; set; }
         public virtual DbSet<SubLicenzaModel> DbSetSubLicenze { get; set; }
-
         public virtual DbSet<TicketModel> DbSetTicket { get; set; }
 
         #endregion Public Properties
-
-        #region Private Methods
-
+        
         partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
 
-        #endregion Private Methods
 
         #region Protected Methods
 
@@ -89,6 +83,11 @@ namespace LiMan.DB
         {
             modelBuilder.HasAnnotation("Relational:Collation", "SQL_Latin1_General_CP1_CI_AS");
 
+            modelBuilder.Entity<LogCallModel>(entity =>
+            {
+                entity.HasKey(e => new { e.DataRif, e.CodInst, e.CodApp, e.TargetUrl });
+            });
+
             OnModelCreatingPartial(modelBuilder);
         }
 
diff --git a/LiMan.DB/LiMan.DB.csproj b/LiMan.DB/LiMan.DB.csproj
index fb5bd7e..221d743 100644
--- a/LiMan.DB/LiMan.DB.csproj
+++ b/LiMan.DB/LiMan.DB.csproj
@@ -5,10 +5,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <Folder Include="Migrations\" />
-  </ItemGroup>
-
-  <ItemGroup>
+    <PackageReference Include="MailKit" Version="2.15.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="5.0.10" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.UI" Version="5.0.10" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="5.0.10" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="5.0.10" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.10" />
@@ -17,6 +16,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="5.0.1" />
+    <PackageReference Include="MimeKit" Version="2.15.1" />
     <PackageReference Include="NLog" Version="4.7.11" />
   </ItemGroup>
 
diff --git a/LiMan.DB/Migrations/20211117101539_AddLogCalls.Designer.cs b/LiMan.DB/Migrations/20211117101539_AddLogCalls.Designer.cs
new file mode 100644
index 0000000..d107d63
--- /dev/null
+++ b/LiMan.DB/Migrations/20211117101539_AddLogCalls.Designer.cs
@@ -0,0 +1,331 @@
+﻿// <auto-generated />
+using System;
+using LiMan.DB;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace LiMan.DB.Migrations
+{
+    [DbContext(typeof(LMDbContext))]
+    [Migration("20211117101539_AddLogCalls")]
+    partial class AddLogCalls
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Relational:Collation", "SQL_Latin1_General_CP1_CI_AS")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128)
+                .HasAnnotation("ProductVersion", "5.0.10")
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("LiMan.DB.DBModels.ApplicativoModel", b =>
+                {
+                    b.Property<string>("CodApp")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Descrizione")
+                        .HasMaxLength(250)
+                        .HasColumnType("nvarchar(250)");
+
+                    b.HasKey("CodApp");
+
+                    b.ToTable("Applicativi");
+                });
+
+            modelBuilder.Entity("LiMan.DB.DBModels.InstallazioneModel", b =>
+                {
+                    b.Property<string>("CodInst")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Cliente")
+                        .HasMaxLength(250)
+                        .HasColumnType("nvarchar(250)");
+
+                    b.Property<string>("Contatto")
+                        .HasMaxLength(250)
+                        .HasColumnType("nvarchar(250)");
+
+                    b.Property<string>("Descrizione")
+                        .HasMaxLength(250)
+                        .HasColumnType("nvarchar(250)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(250)
+                        .HasColumnType("nvarchar(250)");
+
+                    b.HasKey("CodInst");
+
+                    b.ToTable("Installazioni");
+                });
+
+            modelBuilder.Entity("LiMan.DB.DBModels.LicenzaModel", b =>
+                {
+                    b.Property<int>("IdxLic")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Chiave")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CodApp")
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("CodInst")
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<DateTime>("DataEnigma")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Descrizione")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Enigma")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Locked")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("NumLicenze")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("Scadenza")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Tipo")
+                        .HasColumnType("int");
+
+                    b.HasKey("IdxLic");
+
+                    b.HasIndex("CodApp");
+
+                    b.HasIndex("CodInst");
+
+                    b.ToTable("Licenze");
+                });
+
+            modelBuilder.Entity("LiMan.DB.DBModels.LogCallModel", b =>
+                {
+                    b.Property<DateTime>("DataRif")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CodInst")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("CodApp")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("TargetUrl")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("NumCall")
+                        .HasColumnType("int");
+
+                    b.HasKey("DataRif", "CodInst", "CodApp", "TargetUrl");
+
+                    b.ToTable("LogCall");
+                });
+
+            modelBuilder.Entity("LiMan.DB.DBModels.LogLicenzaModel", b =>
+                {
+                    b.Property<int>("IdxLogLic")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Chiave")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CodApp")
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("CodInst")
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Descrizione")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("IdxLic")
+                        .HasColumnType("int");
+
+                    b.Property<int>("NumLicenze")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Scadenza")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Tipo")
+                        .HasColumnType("int");
+
+                    b.HasKey("IdxLogLic");
+
+                    b.HasIndex("CodApp");
+
+                    b.HasIndex("CodInst");
+
+                    b.HasIndex("IdxLic");
+
+                    b.ToTable("LogLicenze");
+                });
+
+            modelBuilder.Entity("LiMan.DB.DBModels.SubLicenzaModel", b =>
+                {
+                    b.Property<int>("IdxSubLic")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Chiave")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CodImpiego")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("IdxLic")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Tipo")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("VetoUnlock")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("IdxSubLic");
+
+                    b.HasIndex("IdxLic");
+
+                    b.ToTable("SubLicenze");
+                });
+
+            modelBuilder.Entity("LiMan.DB.DBModels.TicketModel", b =>
+                {
+                    b.Property<int>("IdxTicket")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CodImpiego")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactEmail")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactPhone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("DtReq")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("IdxLic")
+                        .HasColumnType("int");
+
+                    b.Property<int>("IdxSubLic")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ReqBody")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SupplAnsw")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplEmail")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplUserCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Tipo")
+                        .HasColumnType("int");
+
+                    b.HasKey("IdxTicket");
+
+                    b.HasIndex("IdxLic");
+
+                    b.ToTable("TicketLog");
+                });
+
+            modelBuilder.Entity("LiMan.DB.DBModels.LicenzaModel", b =>
+                {
+                    b.HasOne("LiMan.DB.DBModels.ApplicativoModel", "ApplicativoNav")
+                        .WithMany()
+                        .HasForeignKey("CodApp");
+
+                    b.HasOne("LiMan.DB.DBModels.InstallazioneModel", "InstallazioneNav")
+                        .WithMany()
+                        .HasForeignKey("CodInst");
+
+                    b.Navigation("ApplicativoNav");
+
+                    b.Navigation("InstallazioneNav");
+                });
+
+            modelBuilder.Entity("LiMan.DB.DBModels.LogLicenzaModel", b =>
+                {
+                    b.HasOne("LiMan.DB.DBModels.ApplicativoModel", "ApplicativoNav")
+                        .WithMany()
+                        .HasForeignKey("CodApp");
+
+                    b.HasOne("LiMan.DB.DBModels.InstallazioneModel", "InstallazioneNav")
+                        .WithMany()
+                        .HasForeignKey("CodInst");
+
+                    b.HasOne("LiMan.DB.DBModels.LicenzaModel", "LicenzaNav")
+                        .WithMany()
+                        .HasForeignKey("IdxLic")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ApplicativoNav");
+
+                    b.Navigation("InstallazioneNav");
+
+                    b.Navigation("LicenzaNav");
+                });
+
+            modelBuilder.Entity("LiMan.DB.DBModels.SubLicenzaModel", b =>
+                {
+                    b.HasOne("LiMan.DB.DBModels.LicenzaModel", "LicenzaNav")
+                        .WithMany("Attivazioni")
+                        .HasForeignKey("IdxLic")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LicenzaNav");
+                });
+
+            modelBuilder.Entity("LiMan.DB.DBModels.TicketModel", b =>
+                {
+                    b.HasOne("LiMan.DB.DBModels.LicenzaModel", "LicenzaNav")
+                        .WithMany("Tickets")
+                        .HasForeignKey("IdxLic")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LicenzaNav");
+                });
+
+            modelBuilder.Entity("LiMan.DB.DBModels.LicenzaModel", b =>
+                {
+                    b.Navigation("Attivazioni");
+
+                    b.Navigation("Tickets");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/LiMan.DB/Migrations/20211117101539_AddLogCalls.cs b/LiMan.DB/Migrations/20211117101539_AddLogCalls.cs
new file mode 100644
index 0000000..3bf3604
--- /dev/null
+++ b/LiMan.DB/Migrations/20211117101539_AddLogCalls.cs
@@ -0,0 +1,32 @@
+﻿using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace LiMan.DB.Migrations
+{
+    public partial class AddLogCalls : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "LogCall",
+                columns: table => new
+                {
+                    DataRif = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    CodInst = table.Column<string>(type: "nvarchar(450)", nullable: false),
+                    CodApp = table.Column<string>(type: "nvarchar(450)", nullable: false),
+                    TargetUrl = table.Column<string>(type: "nvarchar(450)", nullable: false),
+                    NumCall = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LogCall", x => new { x.DataRif, x.CodInst, x.CodApp, x.TargetUrl });
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "LogCall");
+        }
+    }
+}
diff --git a/LiMan.DB/Migrations/LMDbContextModelSnapshot.cs b/LiMan.DB/Migrations/LMDbContextModelSnapshot.cs
index b342fbd..b52d5fc 100644
--- a/LiMan.DB/Migrations/LMDbContextModelSnapshot.cs
+++ b/LiMan.DB/Migrations/LMDbContextModelSnapshot.cs
@@ -111,6 +111,28 @@ namespace LiMan.DB.Migrations
                     b.ToTable("Licenze");
                 });
 
+            modelBuilder.Entity("LiMan.DB.DBModels.LogCallModel", b =>
+                {
+                    b.Property<DateTime>("DataRif")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CodInst")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("CodApp")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("TargetUrl")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("NumCall")
+                        .HasColumnType("int");
+
+                    b.HasKey("DataRif", "CodInst", "CodApp", "TargetUrl");
+
+                    b.ToTable("LogCall");
+                });
+
             modelBuilder.Entity("LiMan.DB.DBModels.LogLicenzaModel", b =>
                 {
                     b.Property<int>("IdxLogLic")

From e210ccfb87ef6cee104703caca03bad576b2d206 Mon Sep 17 00:00:00 2001
From: Samuele Locatelli <samuele@steamware.net>
Date: Wed, 17 Nov 2021 11:16:36 +0100
Subject: [PATCH 04/14] Completato insert email preliminare

---
 LiMan.Api/LiMan.APi.xml           |  2 +-
 LiMan.UI/Data/LiManDataService.cs | 20 ++++++++++++++++++--
 LiMan.UI/LiMan.UI.csproj          |  2 +-
 LiMan.UI/Resources/ChangeLog.html |  2 +-
 LiMan.UI/Resources/VersNum.txt    |  2 +-
 LiMan.UI/Resources/manifest.xml   |  2 +-
 LiMan.UI/Startup.cs               | 14 ++++++++++++++
 7 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/LiMan.Api/LiMan.APi.xml b/LiMan.Api/LiMan.APi.xml
index 52caca2..f1bd39e 100644
--- a/LiMan.Api/LiMan.APi.xml
+++ b/LiMan.Api/LiMan.APi.xml
@@ -209,7 +209,7 @@
             Classe astrazione accesso dati
             </summary>
         </member>
-        <member name="M:LiMan.APi.Data.ApiDataService.#ctor(Microsoft.Extensions.Configuration.IConfiguration,Microsoft.Extensions.Logging.ILogger{LiMan.APi.Data.ApiDataService})">
+        <member name="M:LiMan.APi.Data.ApiDataService.#ctor(Microsoft.Extensions.Configuration.IConfiguration,Microsoft.Extensions.Logging.ILogger{LiMan.APi.Data.ApiDataService},Microsoft.AspNetCore.Identity.UI.Services.IEmailSender)">
             <summary>
             Init classe
             </summary>
diff --git a/LiMan.UI/Data/LiManDataService.cs b/LiMan.UI/Data/LiManDataService.cs
index 457d60b..a4bd2c1 100644
--- a/LiMan.UI/Data/LiManDataService.cs
+++ b/LiMan.UI/Data/LiManDataService.cs
@@ -11,6 +11,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using static LiMan.DB.Enum;
+using Microsoft.AspNetCore.Identity.UI.Services;
 
 namespace LiMan.UI.Data
 {
@@ -20,8 +21,8 @@ namespace LiMan.UI.Data
 
         private static IConfiguration _configuration;
         private static ILogger<LiManDataService> _logger;
-
         private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
+        private readonly IEmailSender _emailSender;
         private readonly IDistributedCache distributedCache;
         private readonly IMemoryCache memoryCache;
 
@@ -54,10 +55,11 @@ namespace LiMan.UI.Data
 
         #region Public Constructors
 
-        public LiManDataService(IConfiguration configuration, ILogger<LiManDataService> logger, IMemoryCache memoryCache, IDistributedCache distributedCache)
+        public LiManDataService(IConfiguration configuration, ILogger<LiManDataService> logger, IMemoryCache memoryCache, IDistributedCache distributedCache, IEmailSender emailSender)
         {
             _logger = logger;
             _configuration = configuration;
+            _emailSender = emailSender;
             // conf cache
             this.memoryCache = memoryCache;
             this.distributedCache = distributedCache;
@@ -547,6 +549,20 @@ namespace LiMan.UI.Data
             dbControllerGLS.rollBackEntity(item);
         }
 
+        public async Task<bool> SendEmail(string destEmail, string oggetto, string corpo)
+        {
+            bool answ = false;
+            try
+            {
+                await _emailSender.SendEmailAsync(destEmail, oggetto, corpo);
+                answ = true;
+            }
+            catch
+            { }
+
+            return answ;
+        }
+
         /// <summary>
         /// Aggiornamentos tato ticket
         /// </summary>
diff --git a/LiMan.UI/LiMan.UI.csproj b/LiMan.UI/LiMan.UI.csproj
index 7311663..06f0a0a 100644
--- a/LiMan.UI/LiMan.UI.csproj
+++ b/LiMan.UI/LiMan.UI.csproj
@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>net6.0</TargetFramework>
-        <Version>1.1.2111.1619</Version>
+        <Version>1.1.2111.1711</Version>
         <RootNamespace>LiMan.UI</RootNamespace>
         <AssemblyName>LiMan.UI</AssemblyName>
     </PropertyGroup>
diff --git a/LiMan.UI/Resources/ChangeLog.html b/LiMan.UI/Resources/ChangeLog.html
index e5366ec..1231513 100644
--- a/LiMan.UI/Resources/ChangeLog.html
+++ b/LiMan.UI/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>License Manager</i>
-    <h4>Versione: 1.1.2111.1619</h4>
+    <h4>Versione: 1.1.2111.1711</h4>
     <br />
     Note di rilascio:
     <ul>
diff --git a/LiMan.UI/Resources/VersNum.txt b/LiMan.UI/Resources/VersNum.txt
index c86e812..d29da94 100644
--- a/LiMan.UI/Resources/VersNum.txt
+++ b/LiMan.UI/Resources/VersNum.txt
@@ -1 +1 @@
-1.1.2111.1619
+1.1.2111.1711
diff --git a/LiMan.UI/Resources/manifest.xml b/LiMan.UI/Resources/manifest.xml
index bfcabc1..6c66990 100644
--- a/LiMan.UI/Resources/manifest.xml
+++ b/LiMan.UI/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.1.2111.1619</version>
+  <version>1.1.2111.1711</version>
   <url>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/LiMan.UI.zip</url>
   <changelog>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>
diff --git a/LiMan.UI/Startup.cs b/LiMan.UI/Startup.cs
index 2bae00f..57cfb22 100644
--- a/LiMan.UI/Startup.cs
+++ b/LiMan.UI/Startup.cs
@@ -1,3 +1,4 @@
+using LiMan.DB;
 using LiMan.UI.Data;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Components;
@@ -13,6 +14,7 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Identity.UI.Services;
 
 namespace LiMan.UI
 {
@@ -97,6 +99,18 @@ namespace LiMan.UI
                 options.InstanceName = "LiMan";
             });
 
+            // abilitazione x email management con MailKit
+            services.AddTransient<IEmailSender, MailKitEmailSender>();
+            services.Configure<MailKitEmailSenderOptions>(options =>
+            {
+                options.Host_Address = Configuration["ExternalProviders:MailKit:SMTP:Address"];
+                options.Host_Port = Convert.ToInt32(Configuration["ExternalProviders:MailKit:SMTP:Port"]);
+                options.Host_Username = Configuration["ExternalProviders:MailKit:SMTP:Account"];
+                options.Host_Password = Configuration["ExternalProviders:MailKit:SMTP:Password"];
+                options.Sender_EMail = Configuration["ExternalProviders:MailKit:SMTP:SenderEmail"];
+                options.Sender_Name = Configuration["ExternalProviders:MailKit:SMTP:SenderName"];
+            });
+
             services.AddLocalization();
 
             services.AddRazorPages();

From 0edbc0eadad08f17504650d45e35cd8c353f86f0 Mon Sep 17 00:00:00 2001
From: Samuele Locatelli <samuele@steamware.net>
Date: Wed, 17 Nov 2021 11:38:19 +0100
Subject: [PATCH 05/14] Aggiunta primo metodo x log chiamate

---
 .../Controllers/InstallazioniController.cs    |  8 +--
 LiMan.Api/Data/ApiDataService.cs              | 24 +++++++
 LiMan.DB/Controllers/DbController.cs          | 64 +++++++++++++++++++
 3 files changed, 92 insertions(+), 4 deletions(-)

diff --git a/LiMan.Api/Controllers/InstallazioniController.cs b/LiMan.Api/Controllers/InstallazioniController.cs
index 5cd7312..4cba9c2 100644
--- a/LiMan.Api/Controllers/InstallazioniController.cs
+++ b/LiMan.Api/Controllers/InstallazioniController.cs
@@ -33,7 +33,7 @@ namespace LiMan.APi.Controllers
         /// <param name="DataService"></param>
         public InstallazioniController(ApiDataService DataService)
         {
-            _DataService = DataService;
+            dataService = DataService;
             Log.Info("Avviata classe InstallazioniController");
         }
 
@@ -44,7 +44,7 @@ namespace LiMan.APi.Controllers
         /// <summary>
         /// Dataservice x accesso DB
         /// </summary>
-        protected ApiDataService _DataService { get; set; }
+        protected ApiDataService dataService { get; set; }
 
         #endregion Protected Properties
 
@@ -59,9 +59,9 @@ namespace LiMan.APi.Controllers
         [HttpGet("{id}")]
         public async Task<List<string>> Get(string id)
         {
-            var result = await _DataService.LicenzeByCliente(id);
+            var result = await dataService.LicenzeByCliente(id);
             var listaApp = result.Select(x => x.CodApp).ToList();
-
+            await dataService.recordCall(id, "*", "GET.api/installazioni");
             return listaApp;
         }
 
diff --git a/LiMan.Api/Data/ApiDataService.cs b/LiMan.Api/Data/ApiDataService.cs
index 7cd1059..2252b0e 100644
--- a/LiMan.Api/Data/ApiDataService.cs
+++ b/LiMan.Api/Data/ApiDataService.cs
@@ -1,4 +1,5 @@
 ﻿using Core;
+using LiMan.DB.DBModels;
 using Microsoft.AspNetCore.Identity.UI.Services;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
@@ -59,6 +60,28 @@ namespace LiMan.APi.Data
 
         #endregion Public Constructors
 
+        /// <summary>
+        /// Effettua registrazione chiamata verificando se vada messa sul DB o in redis...
+        /// </summary>
+        /// <param name="codInst"></param>
+        /// <param name="codApp"></param>
+        /// <param name="targetUrl"></param>
+        protected static async Task<bool> recordCall(string codInst, string codApp, string targetUrl)
+        {
+            // FARE !!! per ora registra SEMPRE il record...
+            bool fatto = false;
+            LogCallModel newRec = new LogCallModel()
+            {
+                CodInst = codInst,
+                CodApp = codApp,
+                TargetUrl = targetUrl,
+                DataRif = DateTime.Now,
+                NumCall = 1
+            };
+            fatto = await dbController.LogCallUpsert(newRec);
+            return fatto;
+        }
+
         #region Internal Methods
 
         /// <summary>
@@ -68,6 +91,7 @@ namespace LiMan.APi.Data
         /// <returns></returns>
         internal async Task<DB.DTO.ApplicativoDTO> LicenzaRefreshPayload(LicenseCoord appInfo)
         {
+            // registro chiamata
             // chiamo metodo x ricalcolare payload dato enigma
             bool done = await dbController.LicenseUpdatePayload(appInfo.CodInst, appInfo.CodApp, appInfo.MasterKey, appInfo.Enigma);
             // ora recupero i dati
diff --git a/LiMan.DB/Controllers/DbController.cs b/LiMan.DB/Controllers/DbController.cs
index f4e902c..fbc5437 100644
--- a/LiMan.DB/Controllers/DbController.cs
+++ b/LiMan.DB/Controllers/DbController.cs
@@ -653,6 +653,70 @@ namespace LiMan.DB.Controllers
             return Task.FromResult(fatto);
         }
 
+        /// <summary>
+        /// Elenco LOG chiamate all'API dato filtro + limite record
+        /// </summary>
+        /// <param name="CodApp"></param>
+        /// <param name="CodInst"></param>
+        /// <param name="DateMax"></param>
+        /// <param name="maxNumRec"></param>
+        /// <returns></returns>
+        public List<LogCallModel> LogCallGetFilt(string CodApp, string CodInst, DateTime DateMax, int maxNumRec = 360)
+        {
+            List<LogCallModel> dbResult = new List<LogCallModel>();
+            using (LMDbContext localDbCtx = new LMDbContext(_configuration))
+            {
+                // recupero lista...
+                dbResult = localDbCtx
+                            .DbSetLogCall
+                            .Where(x => x.CodApp == CodApp && x.CodInst == CodInst && x.DataRif <= DateMax)
+                            .OrderByDescending(x => x.DataRif)
+                            .Take(maxNumRec)
+                            .ToList();
+            }
+            return dbResult;
+        }
+
+        /// <summary>
+        /// Update/insert record Loc chiamate API
+        /// </summary>
+        /// <param name="currRequest"></param>
+        /// <returns></returns>
+        public bool LogCallUpsert(LogCallModel currRequest)
+        {
+            bool fatto = false;
+            using (LMDbContext localDbCtx = new LMDbContext(_configuration))
+            {
+                // !!!FixMe provare se va
+                if (true)
+                {
+                    localDbCtx.Update(currRequest);
+                }
+                else
+                {
+                    // cerco record esistente...
+                    var currRec = localDbCtx
+                                    .DbSetLogCall
+                                    .Where(x => x.CodApp == currRequest.CodApp && x.CodInst == currRequest.CodInst && x.DataRif == currRequest.DataRif && x.TargetUrl == currRequest.TargetUrl)
+                                    .FirstOrDefault();
+
+                    // se trovo aggiorno
+                    currRec.NumCall = currRequest.NumCall;
+
+                    //altrimenti aggiungo
+                    localDbCtx
+                        .DbSetLogCall
+                        .Add(currRequest);
+                }
+
+                // salvo
+                localDbCtx.SaveChanges();
+
+                fatto = true;
+            }
+            return fatto;
+        }
+
         /// <summary>
         /// Annulla modifiche su una specifica entity (cancel update)
         /// </summary>

From 2f561086b08715ed0e6fdd4adcbe0b729279fadd Mon Sep 17 00:00:00 2001
From: Samuele Locatelli <samuele@steamware.net>
Date: Wed, 17 Nov 2021 11:44:49 +0100
Subject: [PATCH 06/14] Integrato primo logCall x 3 metodi API

---
 LiMan.Api/Controllers/ApplicazioneController.cs |  7 ++++---
 .../Controllers/InstallazioniController.cs      |  2 +-
 LiMan.Api/Controllers/LicenzaController.cs      | 17 +++++++++--------
 3 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/LiMan.Api/Controllers/ApplicazioneController.cs b/LiMan.Api/Controllers/ApplicazioneController.cs
index fd1d71c..863cbb6 100644
--- a/LiMan.Api/Controllers/ApplicazioneController.cs
+++ b/LiMan.Api/Controllers/ApplicazioneController.cs
@@ -33,7 +33,7 @@ namespace LiMan.APi.Controllers
         /// <param name="DataService"></param>
         public ApplicazioneController(ApiDataService DataService)
         {
-            _DataService = DataService;
+            dataService = DataService;
             Log.Info("Avviata classe ApplicazioneController");
         }
 
@@ -44,7 +44,7 @@ namespace LiMan.APi.Controllers
         /// <summary>
         /// Dataservice x accesso DB
         /// </summary>
-        protected ApiDataService _DataService { get; set; }
+        protected ApiDataService dataService { get; set; }
 
         #endregion Protected Properties
 
@@ -60,7 +60,8 @@ namespace LiMan.APi.Controllers
         [HttpGet("{id}")]
         public async Task<List<DB.DTO.ApplicativoDTO>> Get(string id, string CodApp)
         {
-            var result = await _DataService.ApplicativiSearch(id, CodApp, true);
+            var result = await dataService.ApplicativiSearch(id, CodApp, true);
+            await dataService.recordCall(id, CodApp, $"[GET][api/applicazione]");
             return result;
         }
 
diff --git a/LiMan.Api/Controllers/InstallazioniController.cs b/LiMan.Api/Controllers/InstallazioniController.cs
index 4cba9c2..64902e3 100644
--- a/LiMan.Api/Controllers/InstallazioniController.cs
+++ b/LiMan.Api/Controllers/InstallazioniController.cs
@@ -61,7 +61,7 @@ namespace LiMan.APi.Controllers
         {
             var result = await dataService.LicenzeByCliente(id);
             var listaApp = result.Select(x => x.CodApp).ToList();
-            await dataService.recordCall(id, "*", "GET.api/installazioni");
+            await dataService.recordCall(id, "*", "[GET][api/installazioni]");
             return listaApp;
         }
 
diff --git a/LiMan.Api/Controllers/LicenzaController.cs b/LiMan.Api/Controllers/LicenzaController.cs
index bb7ba4e..283d011 100644
--- a/LiMan.Api/Controllers/LicenzaController.cs
+++ b/LiMan.Api/Controllers/LicenzaController.cs
@@ -34,7 +34,7 @@ namespace LiMan.APi.Controllers
         /// <param name="DataService"></param>
         public LicenzaController(ApiDataService DataService)
         {
-            _DataService = DataService;
+            dataService = DataService;
             Log.Info("Avviata classe LicenzaController");
         }
 
@@ -45,7 +45,7 @@ namespace LiMan.APi.Controllers
         /// <summary>
         /// Dataservice x accesso DB
         /// </summary>
-        protected ApiDataService _DataService { get; set; }
+        protected ApiDataService dataService { get; set; }
 
         #endregion Protected Properties
 
@@ -62,8 +62,8 @@ namespace LiMan.APi.Controllers
         [HttpGet("{id}")]
         public async Task<List<DB.DTO.ApplicativoDTO>> Get(string id, string CodApp, string Chiave)
         {
-            var result = await _DataService.LicenzeSearch(id, CodApp, Chiave, false);
-
+            var result = await dataService.LicenzeSearch(id, CodApp, Chiave, false);
+            await dataService.recordCall(id, CodApp, $"[GET][api/licenza][{Chiave}]");
             return result;
         }
 
@@ -76,20 +76,21 @@ namespace LiMan.APi.Controllers
         [HttpPost()]
         public async Task<List<DB.DTO.ApplicativoDTO>> Get([FromBody] LicenseCoord AppInfo)
         {
-            var result = await _DataService.LicenzeSearch(AppInfo.CodInst, AppInfo.CodApp, AppInfo.MasterKey, false);
-
+            var result = await dataService.LicenzeSearch(AppInfo.CodInst, AppInfo.CodApp, AppInfo.MasterKey, false);
+            await dataService.recordCall(AppInfo.CodInst, AppInfo.CodApp, $"[POST][api/licenza][{AppInfo.MasterKey}]");
             return result;
         }
 
+        /// POST api/licenza/refreshPayload
         /// <summary>
         /// Effettua refresh del payload calcolato ed aggiorna record ed infine lo restituisce
         /// </summary>
         /// <param name="AppInfo">Info licenza in formato LicenseCoord</param>
-        // POST api/attivazioni/refreshPayload
         [HttpPost("refreshPayload")]
         public async Task<DB.DTO.ApplicativoDTO> RefreshPayload([FromBody] LicenseCoord AppInfo)
         {
-            var done = await _DataService.LicenzaRefreshPayload(AppInfo);
+            var done = await dataService.LicenzaRefreshPayload(AppInfo);
+            await dataService.recordCall(AppInfo.CodInst, AppInfo.CodApp, $"[POST][api/licenza/refreshPayload][{AppInfo.MasterKey}]");
             return done;
         }
 

From e038865484c09361fe4bb0380ddc9fdde9e5d22f Mon Sep 17 00:00:00 2001
From: Samuele Locatelli <samuele@steamware.net>
Date: Wed, 17 Nov 2021 15:30:18 +0100
Subject: [PATCH 07/14] Update x completare bozza gestione statistiche API

---
 Core/Core.csproj                              |   2 +-
 Core/SampleStats.cs                           |  16 +
 .../Controllers/AttivazioniController.cs      |  59 ++--
 LiMan.Api/Controllers/TicketController.cs     |  14 +-
 LiMan.Api/Data/ApiDataService.cs              | 310 ++++++++++++++++--
 LiMan.Api/LiMan.APi.csproj                    |   6 +-
 LiMan.Api/LiMan.APi.xml                       | 139 +++++++-
 .../Properties/PublishProfiles/IIS01.pubxml   |   2 +-
 .../Properties/PublishProfiles/IIS02.pubxml   |   2 +-
 .../PublishProfiles/W2019-IIS-DEV.pubxml      |   2 +-
 LiMan.Api/Startup.cs                          |  12 +
 LiMan.Api/appsettings.json                    |  16 +-
 LiMan.DB/Controllers/DbController.cs          |  18 +-
 LiMan.DB/LiMan.DB.csproj                      |   2 +-
 LiMan.GLS/LiMan.GLS.csproj                    |   2 +-
 LiMan.UI/LiMan.UI.csproj                      |   2 +-
 LiMan.UI/Resources/ChangeLog.html             |   2 +-
 LiMan.UI/Resources/VersNum.txt                |   2 +-
 LiMan.UI/Resources/manifest.xml               |   2 +-
 19 files changed, 521 insertions(+), 89 deletions(-)
 create mode 100644 Core/SampleStats.cs

diff --git a/Core/Core.csproj b/Core/Core.csproj
index dbc1517..f208d30 100644
--- a/Core/Core.csproj
+++ b/Core/Core.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
 </Project>
diff --git a/Core/SampleStats.cs b/Core/SampleStats.cs
new file mode 100644
index 0000000..236b7e7
--- /dev/null
+++ b/Core/SampleStats.cs
@@ -0,0 +1,16 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Core
+{
+    public class SampleStats
+    {
+        public string Name { get; set; } = "NA";
+        public DateTime DtFirst { get; set; } = DateTime.Now;
+        public DateTime DtLast { get; set; } = DateTime.Now;
+        public List<string> VList { get; set; } = new List<string>();
+    }
+}
diff --git a/LiMan.Api/Controllers/AttivazioniController.cs b/LiMan.Api/Controllers/AttivazioniController.cs
index 124307f..0ca8683 100644
--- a/LiMan.Api/Controllers/AttivazioniController.cs
+++ b/LiMan.Api/Controllers/AttivazioniController.cs
@@ -34,7 +34,7 @@ namespace LiMan.APi.Controllers
         /// <param name="DataService"></param>
         public AttivazioniController(ApiDataService DataService)
         {
-            _DataService = DataService;
+            dataService = DataService;
             Log.Info("Avviata classe AttivazioniController");
         }
 
@@ -45,7 +45,7 @@ namespace LiMan.APi.Controllers
         /// <summary>
         /// Dataservice x accesso DB
         /// </summary>
-        protected ApiDataService _DataService { get; set; }
+        protected ApiDataService dataService { get; set; }
 
         #endregion Protected Properties
 
@@ -58,7 +58,13 @@ namespace LiMan.APi.Controllers
         [HttpDelete()]
         public async Task<bool> Delete([FromBody] UserLicenseRequest CurrRequest)
         {
-            bool done = await _DataService.AttivazioniDelete(CurrRequest.MasterKey, CurrRequest.ParamDict);
+            bool done = await dataService.AttivazioniDelete(CurrRequest.MasterKey, CurrRequest.ParamDict);
+            // se ho qualcosa da loggare...
+            foreach (var item in CurrRequest.ParamDict)
+            {
+                // registro 1 riga x ogni record...
+                await dataService.recordCall(CurrRequest.MasterKey, $"[DELETE][api/attivazioni][{item.Key}|{item.Value}]");
+            }
             return done;
         }
 
@@ -72,8 +78,9 @@ namespace LiMan.APi.Controllers
         public async Task<List<DB.DTO.AttivazioneDTO>> Get(string chiave)
         {
             List<DB.DTO.AttivazioneDTO> result = new List<DB.DTO.AttivazioneDTO>();
-            var dbResult = await _DataService.AttivazioniByMasterKey(chiave, false);
+            var dbResult = await dataService.AttivazioniByMasterKey(chiave, false);
             result = (dbResult != null) ? dbResult : result;
+            await dataService.recordCall(chiave, $"[GET][api/attivazioni][{chiave}]");
             return result;
         }
 
@@ -88,9 +95,14 @@ namespace LiMan.APi.Controllers
             List<DB.DTO.AttivazioneDTO> currData = new List<DB.DTO.AttivazioneDTO>();
 
             // eseguo tentativo generazione attivazioni da licenza...
-            bool done = await _DataService.AttivazioniTryAdd(CurrRequest.MasterKey, CurrRequest.ParamDict, 60);
-            currData = await _DataService.AttivazioniByMasterKey(CurrRequest.MasterKey, false);
-
+            bool done = await dataService.AttivazioniTryAdd(CurrRequest.MasterKey, CurrRequest.ParamDict, 60);
+            currData = await dataService.AttivazioniByMasterKey(CurrRequest.MasterKey, false);
+            // se ho qualcosa da loggare...
+            foreach (var item in CurrRequest.ParamDict)
+            {
+                // registro 1 riga x ogni record...
+                await dataService.recordCall(CurrRequest.MasterKey, $"[POST][api/attivazioni][{item.Key}|{item.Value}]");
+            }
             return currData;
         }
 
@@ -98,16 +110,21 @@ namespace LiMan.APi.Controllers
         /// Richiesta di refresh delle key associate ai CodImpiego da una lista di chiavi di licenza sub
         /// </summary>
         /// <param name="CurrRequest">Obj Richiesta con licenza MASTER + Elenco codici impiego (key) + valori in formato dizionari</param>
-        // POST api/attivazioni
+        // POST api/attivazioni/refreshKey
         [HttpPost("refreshKey")]
         public async Task<List<DB.DTO.AttivazioneDTO>> refreshKey([FromBody] UserLicenseRequest CurrRequest)
         {
             List<DB.DTO.AttivazioneDTO> currData = new List<DB.DTO.AttivazioneDTO>();
 
             // eseguo tentativo generazione attivazioni da licenza...
-            bool done = await _DataService.AttivazioniTryRefresh(CurrRequest.MasterKey, CurrRequest.ParamDict);
-            currData = await _DataService.AttivazioniByMasterKey(CurrRequest.MasterKey, false);
-
+            bool done = await dataService.AttivazioniTryRefresh(CurrRequest.MasterKey, CurrRequest.ParamDict);
+            currData = await dataService.AttivazioniByMasterKey(CurrRequest.MasterKey, false);
+            // se ho qualcosa da loggare...
+            foreach (var item in CurrRequest.ParamDict)
+            {
+                // registro 1 riga x ogni record...
+                await dataService.recordCall(CurrRequest.MasterKey, $"[POST][api/attivazioni/refreshKey][{item.Key}|{item.Value}]");
+            }
             return currData;
         }
 
@@ -115,11 +132,12 @@ namespace LiMan.APi.Controllers
         /// Eliminazione di TUTTE le attivazioni SCADUTE
         /// </summary>
         /// <param name="chiave">Licenza MASTER</param>
-        // DELETE api/attivazioni/5
+        // DELETE api/attivazioni/resetAvail
         [HttpDelete("resetAvail")]
         public async Task<bool> ResetAvail(string chiave)
         {
-            bool done = await _DataService.AttivazioniResetAvail(chiave);
+            bool done = await dataService.AttivazioniResetAvail(chiave);
+            await dataService.recordCall(chiave, $"[DELETE][api/attivazioni/resetAvail][{chiave}]");
             return done;
         }
 
@@ -127,27 +145,20 @@ namespace LiMan.APi.Controllers
         /// Verifica recupero un record di sub licenza
         /// </summary>
         /// <param name="chiave">Licenza MASTER</param>
-        /// <param name="CodImpiego">Codice univoco impiego licenza</param>
+        /// <param name="codImpiego">Codice univoco impiego licenza</param>
         /// <returns></returns>
         // GET api/attivazioni/verifica/5
         [HttpGet("verifica")]
-        public async Task<DB.DTO.AttivazioneDTO> VerificaImpiego(string chiave, string CodImpiego)
+        public async Task<DB.DTO.AttivazioneDTO> VerificaImpiego(string chiave, string codImpiego)
         {
             DB.DTO.AttivazioneDTO result = new DB.DTO.AttivazioneDTO();
-            var dbResult = await _DataService.AttivazioneSearch(chiave, CodImpiego, false);
+            var dbResult = await dataService.AttivazioneSearch(chiave, codImpiego, false);
             result = (dbResult != null) ? dbResult : result;
+            await dataService.recordCall(chiave, $"[GET][api/attivazioni/verifica][{chiave}|{codImpiego}]");
             return result;
         }
 
         #endregion Public Methods
 
-#if false
-        // PUT api/attivazioni/5
-        [HttpPut("{id}")]
-        public void Put(int id, [FromBody] string value)
-        {
-        }
-
-#endif
     }
 }
\ No newline at end of file
diff --git a/LiMan.Api/Controllers/TicketController.cs b/LiMan.Api/Controllers/TicketController.cs
index aa50816..b4b685d 100644
--- a/LiMan.Api/Controllers/TicketController.cs
+++ b/LiMan.Api/Controllers/TicketController.cs
@@ -34,7 +34,7 @@ namespace LiMan.APi.Controllers
         /// <param name="DataService"></param>
         public TicketController(ApiDataService DataService)
         {
-            _DataService = DataService;
+            dataService = DataService;
             Log.Info("Avviata classe TicketController");
         }
 
@@ -45,7 +45,7 @@ namespace LiMan.APi.Controllers
         /// <summary>
         /// Dataservice x accesso DB
         /// </summary>
-        protected ApiDataService _DataService { get; set; }
+        protected ApiDataService dataService { get; set; }
 
         #endregion Protected Properties
 
@@ -62,8 +62,8 @@ namespace LiMan.APi.Controllers
         [HttpGet("{id}")]
         public async Task<List<DB.DBModels.TicketModel>> Get(string id, string CodApp, string Chiave)
         {
-            var result = await _DataService.TicketByCliente(id, CodApp, Chiave);
-
+            var result = await dataService.TicketByCliente(id, CodApp, Chiave);
+            await dataService.recordCall(id, CodApp, $"[GET][api/ticket][{Chiave}]");
             return result;
         }
 
@@ -80,11 +80,11 @@ namespace LiMan.APi.Controllers
             if (CurrRequest.IsValid)
             {
                 // registro richiesta
-                var insRes = await _DataService.TicketAdd(CurrRequest);
+                var insRes = await dataService.TicketAdd(CurrRequest);
             }
             // restituisco richieste aperte
-            result = await _DataService.TicketByCliente(CurrRequest.CodInst, CurrRequest.CodApp, CurrRequest.MasterKey);
-
+            result = await dataService.TicketByCliente(CurrRequest.CodInst, CurrRequest.CodApp, CurrRequest.MasterKey);
+            await dataService.recordCall(CurrRequest.CodInst, CurrRequest.CodApp, $"[POST][api/ticket/sendReq][{CurrRequest.MasterKey}]");
             return result;
         }
 
diff --git a/LiMan.Api/Data/ApiDataService.cs b/LiMan.Api/Data/ApiDataService.cs
index 2252b0e..255625f 100644
--- a/LiMan.Api/Data/ApiDataService.cs
+++ b/LiMan.Api/Data/ApiDataService.cs
@@ -1,15 +1,19 @@
 ﻿using Core;
 using LiMan.DB.DBModels;
 using Microsoft.AspNetCore.Identity.UI.Services;
+using Microsoft.Extensions.Caching.Distributed;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
 using NLog;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Text;
 using System.Threading.Tasks;
 using static LiMan.DB.Enum;
+using StackExchange.Redis.Extensions.Core.Abstractions;
 
 namespace LiMan.APi.Data
 {
@@ -24,15 +28,58 @@ namespace LiMan.APi.Data
         private static ILogger<ApiDataService> _logger;
         private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
         private readonly IEmailSender _emailSender;
+        private readonly IDistributedCache distributedCache;
+        private readonly IRedisCacheClient _redisCacheClient;
+
+        /// <summary>
+        /// Durata assoluta massima della cache IN SECONDI
+        /// </summary>
+        private int chAbsExp = 60 * 5;
+
+        /// <summary>
+        /// Durata della cache IN SECONDI in modalità inattiva (non acceduta) prima di venire rimossa
+        /// NON estende oltre il tempo massimo di validità della cache (chAbsExp)
+        /// </summary>
+        private int chSliExp = 60 * 2;
 
         #endregion Private Fields
 
         #region Public Fields
 
+        /// <summary>
+        /// Classe Accesso metodi DB
+        /// </summary>
         public static LiMan.DB.Controllers.DbController dbController;
 
         #endregion Public Fields
 
+        /// <summary>
+        /// Recupero chiave da redis
+        /// </summary>
+        /// <param name="rKey"></param>
+        /// <returns></returns>
+        protected async Task<string> getRSV(string rKey)
+        {
+            string answ = await _redisCacheClient.GetDbFromConfiguration().GetAsync<string>(rKey);
+            return answ;
+        }
+
+        /// <summary>
+        /// Salvataggio chiave in redis
+        /// </summary>
+        /// <param name="rKey"></param>
+        /// <param name="rVal"></param>
+        /// <param name="ttlSec"></param>
+        /// <returns></returns>
+        protected async Task<bool> setRSV(string rKey, string rVal, int ttlSec)
+        {
+            bool fatto = false;
+            await _redisCacheClient.GetDbFromConfiguration().AddAsync<string>(rKey, rVal, DateTimeOffset.Now.AddSeconds(ttlSec));
+            fatto = true;
+            return fatto;
+        }
+
+
         #region Public Constructors
 
         /// <summary>
@@ -40,11 +87,17 @@ namespace LiMan.APi.Data
         /// </summary>
         /// <param name="configuration"></param>
         /// <param name="logger"></param>
-        public ApiDataService(IConfiguration configuration, ILogger<ApiDataService> logger, IEmailSender emailSender)
+        /// <param name="distributedCache"></param>
+        /// <param name="emailSender"></param>
+        /// <param name="redisCacheClient"></param>
+        public ApiDataService(IConfiguration configuration, ILogger<ApiDataService> logger, IDistributedCache distributedCache, IEmailSender emailSender, IRedisCacheClient redisCacheClient)
         {
             _logger = logger;
             _configuration = configuration;
             _emailSender = emailSender;
+            this.distributedCache = distributedCache;
+            _redisCacheClient = redisCacheClient;
+
             // conf DB
             string connStrDB = _configuration.GetConnectionString("LiMan.DB");
             if (string.IsNullOrEmpty(connStrDB))
@@ -60,46 +113,21 @@ namespace LiMan.APi.Data
 
         #endregion Public Constructors
 
-        /// <summary>
-        /// Effettua registrazione chiamata verificando se vada messa sul DB o in redis...
-        /// </summary>
-        /// <param name="codInst"></param>
-        /// <param name="codApp"></param>
-        /// <param name="targetUrl"></param>
-        protected static async Task<bool> recordCall(string codInst, string codApp, string targetUrl)
-        {
-            // FARE !!! per ora registra SEMPRE il record...
-            bool fatto = false;
-            LogCallModel newRec = new LogCallModel()
-            {
-                CodInst = codInst,
-                CodApp = codApp,
-                TargetUrl = targetUrl,
-                DataRif = DateTime.Now,
-                NumCall = 1
-            };
-            fatto = await dbController.LogCallUpsert(newRec);
-            return fatto;
-        }
-
-        #region Internal Methods
+        #region Private Methods
 
         /// <summary>
-        /// Effettua refresh del payload della licenza dato info + enigma generato dal client
+        /// Parametri per generare opzioni cache
         /// </summary>
-        /// <param name="appInfo"></param>
+        /// <param name="multFact">Fattore di moltiplica cache (se 1 --> 2 e 5 min)</param>
         /// <returns></returns>
-        internal async Task<DB.DTO.ApplicativoDTO> LicenzaRefreshPayload(LicenseCoord appInfo)
+        private DistributedCacheEntryOptions cacheOpt(int multFact)
         {
-            // registro chiamata
-            // chiamo metodo x ricalcolare payload dato enigma
-            bool done = await dbController.LicenseUpdatePayload(appInfo.CodInst, appInfo.CodApp, appInfo.MasterKey, appInfo.Enigma);
-            // ora recupero i dati
-            var licList = await LicenzeSearch(appInfo.CodInst, appInfo.CodApp, appInfo.MasterKey, false);
-            return licList.FirstOrDefault();
+            var numSecAbsExp = multFact <= 0 ? chAbsExp : chAbsExp * multFact;
+            var numSecSliExp = multFact <= 0 ? chSliExp : chSliExp * multFact;
+            return new DistributedCacheEntryOptions().SetAbsoluteExpiration(DateTime.Now.AddSeconds(numSecAbsExp)).SetSlidingExpiration(TimeSpan.FromSeconds(numSecSliExp));
         }
 
-        #endregion Internal Methods
+        #endregion Private Methods
 
         #region Public Methods
 
@@ -295,6 +323,51 @@ namespace LiMan.APi.Data
             dbController.Dispose();
         }
 
+        /// <summary>
+        /// Elenco licenze dato cliente
+        /// </summary>
+        /// <param name="chiave">Chiave Licenza x ricerca</param>
+        /// <returns></returns>
+        public async Task<LicenzaModel> LicenzaByMasterKey(string chiave)
+        {
+            LicenzaModel dbResult = new LicenzaModel();
+            string cacheKey = $"DATA:Licenze:ListByKey:{chiave}";
+            string rawData;
+            var redisDataList = await distributedCache.GetAsync(cacheKey);
+            if (redisDataList != null)
+            {
+                rawData = Encoding.UTF8.GetString(redisDataList);
+                dbResult = JsonConvert.DeserializeObject<LicenzaModel>(rawData);
+            }
+            else
+            {
+                Stopwatch stopWatch = new Stopwatch();
+                stopWatch.Start();
+                dbResult = dbController.LicenzaByKey(chiave);
+                rawData = JsonConvert.SerializeObject(dbResult);
+                redisDataList = Encoding.UTF8.GetBytes(rawData);
+                await distributedCache.SetAsync(cacheKey, redisDataList, cacheOpt(5));
+                stopWatch.Stop();
+                TimeSpan ts = stopWatch.Elapsed;
+                Log.Trace($"Effettuata lettura da DB per LicenzaByMasterKey: {ts.TotalMilliseconds} ms");
+            }
+            return await Task.FromResult(dbResult);
+        }
+
+        /// <summary>
+        /// Effettua refresh del payload della licenza dato info + enigma generato dal client
+        /// </summary>
+        /// <param name="appInfo"></param>
+        /// <returns></returns>
+        public async Task<DB.DTO.ApplicativoDTO> LicenzaRefreshPayload(LicenseCoord appInfo)
+        {
+            // chiamo metodo x ricalcolare payload dato enigma
+            bool done = await dbController.LicenseUpdatePayload(appInfo.CodInst, appInfo.CodApp, appInfo.MasterKey, appInfo.Enigma);
+            // ora recupero i dati
+            var licList = await LicenzeSearch(appInfo.CodInst, appInfo.CodApp, appInfo.MasterKey, false);
+            return licList.FirstOrDefault();
+        }
+
         /// <summary>
         /// Elenco licenze dato cliente
         /// </summary>
@@ -335,7 +408,176 @@ namespace LiMan.APi.Data
 
             return await Task.FromResult(dbResult);
         }
+        /// <summary>
+        /// Chiave redis x statistiche in acquisizione
+        /// </summary>
+        protected const string rKeySampleStats = "DATA:SampleStats:Curr";
+        /// <summary>
+        /// Chiave redis x statistiche in acquisizione
+        /// </summary>
+        protected const string rKeySampleVars = "DATA:SampleStats:Vars";
 
+        /// <summary>
+        /// Recupera statistiche correnti
+        /// </summary>
+        /// <returns></returns>
+        protected async Task<SampleStats> getCurrStats()
+        {
+            DateTime adesso = DateTime.Now;
+            SampleStats answ = new SampleStats()
+            {
+                Name = "ApiStats"
+            };
+            // in primis check data/ora prima/ultima scrittura del set... (2 date, lista chiavi gestite)
+            string rawData = await getRSV(rKeySampleStats);
+            if (rawData != null)
+            {
+                answ = JsonConvert.DeserializeObject<SampleStats>(rawData);
+            }
+            // controllo se scadute...
+            if (adesso.Subtract(answ.DtFirst).TotalMinutes > 60)
+            {
+                // se scaduto --> registrazione set sul DB (async), resettando i vari contatori...
+                bool salvato = await saveStatsToDb(answ.VList);
+                // inizio NUOVO set vuoto con record corrente
+                answ = new SampleStats()
+                {
+                    Name = "ApiStats"
+                };
+                // salvo!
+                await setCurrStats(answ);
+            }
+            // restituisco record!
+            return answ;
+        }
+
+        /// <summary>
+        /// TTL da 1 h x cache Redis
+        /// </summary>
+        protected const int hourTTL = 60 * 60;
+
+        /// <summary>
+        /// Salva statistiche correnti
+        /// </summary>
+        /// <returns></returns>
+        protected async Task<bool> setCurrStats(SampleStats newVal)
+        {
+            bool answ = false;
+            string rawData = JsonConvert.SerializeObject(newVal);
+            answ = await setRSV(rKeySampleStats, rawData, 24 * hourTTL);
+            return answ;
+        }
+
+        /// <summary>
+        /// Incrementa contatore x la chiave redis indicata...
+        /// </summary>
+        /// <returns></returns>
+        protected async Task<bool> redCountIncr(string rKey)
+        {
+            bool answ = false;
+            int currCount = 0;
+            string rawVal = await getRSV(rKey);
+            if (string.IsNullOrEmpty(rawVal))
+            {
+                int.TryParse(rawVal, out currCount);
+            }
+            currCount++;
+            answ = await setRSV(rKey, $"{currCount}", 2 * hourTTL);
+            return answ;
+        }
+        /// <summary>
+        /// Resetta contatore x la chiave redis indicata...
+        /// </summary>
+        /// <returns></returns>
+        protected async Task<bool> redCountClear(string rKey)
+        {
+            bool answ = false;
+            int currCount = 0;
+            answ = await setRSV(rKey, $"{currCount}", 2 * hourTTL);
+            return answ;
+        }
+
+        /// <summary>
+        /// Effettua registrazione chiamata verificando se vada messa sul DB o in redis...
+        /// </summary>
+        /// <param name="codInst"></param>
+        /// <param name="codApp"></param>
+        /// <param name="targetUrl"></param>
+        public async Task<bool> recordCall(string codInst, string codApp, string targetUrl)
+        {
+            bool fatto = false;
+
+            // in primis recupero statistiche (e nel mentre eventualmente salvo su DB)
+            SampleStats currStats = await getCurrStats();
+
+            // preparo chiave x dato da loggare
+            string currKey = $"{rKeySampleVars}:{codInst}:{codApp}:{targetUrl}";
+
+            // verifico presenza contatore corrente altrimenti aggiungo e salvo...
+            if (!currStats.VList.Contains(currKey))
+            {
+                currStats.VList.Add(currKey);
+                // salvo!
+                await setCurrStats(currStats);
+            }
+            // incremento valore contatore corrente
+            await redCountIncr(currKey);
+
+            return fatto;
+        }
+
+        /// <summary>
+        /// Registro su DB le statistiche delle chiavi in elenco, resettando i vari contatori quando fatto
+        /// </summary>
+        /// <param name="keyList">Elenco key nel formato {rKeySampleVars}:{codInst}:{codApp}:{targetUrl}</param>
+        public async Task<bool> saveStatsToDb(List<string> keyList)
+        {
+            bool fatto = false;
+            // ciclo x eseguire 1:1
+            foreach (var item in keyList)
+            {
+                // scompongo key... senza url di base
+                string[] valStr = item.Replace($"{rKeySampleVars}:", "").Split(":");
+                if (valStr.Length > 2)
+                {
+                    LogCallModel newRec = new LogCallModel()
+                    {
+                        CodInst = valStr[0],
+                        CodApp = valStr[1],
+                        TargetUrl = valStr[2],
+                        DataRif = DateTime.Now,
+                        NumCall = 1
+                    };
+                    fatto = await dbController.LogCallUpsert(newRec);
+                    if (fatto)
+                    {
+                        await redCountClear(item);
+                    }
+                }
+            }
+            return fatto;
+        }
+
+        /// <summary>
+        /// Effettua registrazione da codice chiave...
+        /// </summary>
+        /// <param name="chiave"></param>
+        /// <param name="targetUrl"></param>
+        public async Task<bool> recordCall(string chiave, string targetUrl)
+        {
+            // valutare se cache key --> lic...
+            var currLic = await LicenzaByMasterKey(chiave);
+            var fatto = await recordCall(currLic.CodInst, currLic.CodApp, targetUrl);
+            return fatto;
+        }
+
+        /// <summary>
+        /// Invio email richiesta
+        /// </summary>
+        /// <param name="destEmail"></param>
+        /// <param name="oggetto"></param>
+        /// <param name="corpo"></param>
+        /// <returns></returns>
         public async Task<bool> SendEmail(string destEmail, string oggetto, string corpo)
         {
             bool answ = false;
diff --git a/LiMan.Api/LiMan.APi.csproj b/LiMan.Api/LiMan.APi.csproj
index 08c163a..61666c4 100644
--- a/LiMan.Api/LiMan.APi.csproj
+++ b/LiMan.Api/LiMan.APi.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk.Web">
 
     <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>net5.0</TargetFramework>
     </PropertyGroup>
 
     <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
@@ -16,8 +16,12 @@
     </ItemGroup>
 
     <ItemGroup>
+        <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="5.0.1" />
         <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
         <PackageReference Include="NLog.Web.AspNetCore" Version="4.14.0" />
+        <PackageReference Include="StackExchange.Redis" Version="2.2.88" />
+        <PackageReference Include="StackExchange.Redis.Extensions.AspNetCore" Version="7.1.1" />
+        <PackageReference Include="StackExchange.Redis.Extensions.Newtonsoft" Version="7.1.1" />
         <PackageReference Include="Swashbuckle.AspNetCore" Version="5.6.3" />
     </ItemGroup>
 
diff --git a/LiMan.Api/LiMan.APi.xml b/LiMan.Api/LiMan.APi.xml
index f1bd39e..3fb4243 100644
--- a/LiMan.Api/LiMan.APi.xml
+++ b/LiMan.Api/LiMan.APi.xml
@@ -20,7 +20,7 @@
             </summary>
             <param name="DataService"></param>
         </member>
-        <member name="P:LiMan.APi.Controllers.ApplicazioneController._DataService">
+        <member name="P:LiMan.APi.Controllers.ApplicazioneController.dataService">
             <summary>
             Dataservice x accesso DB
             </summary>
@@ -50,7 +50,7 @@
             </summary>
             <param name="DataService"></param>
         </member>
-        <member name="P:LiMan.APi.Controllers.AttivazioniController._DataService">
+        <member name="P:LiMan.APi.Controllers.AttivazioniController.dataService">
             <summary>
             Dataservice x accesso DB
             </summary>
@@ -90,7 +90,7 @@
             Verifica recupero un record di sub licenza
             </summary>
             <param name="chiave">Licenza MASTER</param>
-            <param name="CodImpiego">Codice univoco impiego licenza</param>
+            <param name="codImpiego">Codice univoco impiego licenza</param>
             <returns></returns>
         </member>
         <member name="T:LiMan.APi.Controllers.InstallazioniController">
@@ -109,7 +109,7 @@
             </summary>
             <param name="DataService"></param>
         </member>
-        <member name="P:LiMan.APi.Controllers.InstallazioniController._DataService">
+        <member name="P:LiMan.APi.Controllers.InstallazioniController.dataService">
             <summary>
             Dataservice x accesso DB
             </summary>
@@ -138,7 +138,7 @@
             </summary>
             <param name="DataService"></param>
         </member>
-        <member name="P:LiMan.APi.Controllers.LicenzaController._DataService">
+        <member name="P:LiMan.APi.Controllers.LicenzaController.dataService">
             <summary>
             Dataservice x accesso DB
             </summary>
@@ -162,6 +162,7 @@
             <returns></returns>
         </member>
         <member name="M:LiMan.APi.Controllers.LicenzaController.RefreshPayload(Core.LicenseCoord)">
+            POST api/licenza/refreshPayload
             <summary>
             Effettua refresh del payload calcolato ed aggiorna record ed infine lo restituisce
             </summary>
@@ -183,7 +184,7 @@
             </summary>
             <param name="DataService"></param>
         </member>
-        <member name="P:LiMan.APi.Controllers.TicketController._DataService">
+        <member name="P:LiMan.APi.Controllers.TicketController.dataService">
             <summary>
             Dataservice x accesso DB
             </summary>
@@ -209,18 +210,53 @@
             Classe astrazione accesso dati
             </summary>
         </member>
-        <member name="M:LiMan.APi.Data.ApiDataService.#ctor(Microsoft.Extensions.Configuration.IConfiguration,Microsoft.Extensions.Logging.ILogger{LiMan.APi.Data.ApiDataService},Microsoft.AspNetCore.Identity.UI.Services.IEmailSender)">
+        <member name="F:LiMan.APi.Data.ApiDataService.chAbsExp">
+            <summary>
+            Durata assoluta massima della cache IN SECONDI
+            </summary>
+        </member>
+        <member name="F:LiMan.APi.Data.ApiDataService.chSliExp">
+            <summary>
+            Durata della cache IN SECONDI in modalità inattiva (non acceduta) prima di venire rimossa
+            NON estende oltre il tempo massimo di validità della cache (chAbsExp)
+            </summary>
+        </member>
+        <member name="F:LiMan.APi.Data.ApiDataService.dbController">
+            <summary>
+            Classe Accesso metodi DB
+            </summary>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.getRSV(System.String)">
+            <summary>
+            Recupero chiave da redis
+            </summary>
+            <param name="rKey"></param>
+            <returns></returns>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.setRSV(System.String,System.String,System.Int32)">
+            <summary>
+            Salvataggio chiave in redis
+            </summary>
+            <param name="rKey"></param>
+            <param name="rVal"></param>
+            <param name="ttlSec"></param>
+            <returns></returns>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.#ctor(Microsoft.Extensions.Configuration.IConfiguration,Microsoft.Extensions.Logging.ILogger{LiMan.APi.Data.ApiDataService},Microsoft.Extensions.Caching.Distributed.IDistributedCache,Microsoft.AspNetCore.Identity.UI.Services.IEmailSender,StackExchange.Redis.Extensions.Core.Abstractions.IRedisCacheClient)">
             <summary>
             Init classe
             </summary>
             <param name="configuration"></param>
             <param name="logger"></param>
+            <param name="distributedCache"></param>
+            <param name="emailSender"></param>
+            <param name="redisCacheClient"></param>
         </member>
-        <member name="M:LiMan.APi.Data.ApiDataService.LicenzaRefreshPayload(Core.LicenseCoord)">
+        <member name="M:LiMan.APi.Data.ApiDataService.cacheOpt(System.Int32)">
             <summary>
-            Effettua refresh del payload della licenza dato info + enigma generato dal client
+            Parametri per generare opzioni cache
             </summary>
-            <param name="appInfo"></param>
+            <param name="multFact">Fattore di moltiplica cache (se 1 --> 2 e 5 min)</param>
             <returns></returns>
         </member>
         <member name="M:LiMan.APi.Data.ApiDataService.ApplicativiSearch(System.String,System.String,System.Boolean)">
@@ -296,6 +332,20 @@
             Dispose classe
             </summary>
         </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.LicenzaByMasterKey(System.String)">
+            <summary>
+            Elenco licenze dato cliente
+            </summary>
+            <param name="chiave">Chiave Licenza x ricerca</param>
+            <returns></returns>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.LicenzaRefreshPayload(Core.LicenseCoord)">
+            <summary>
+            Effettua refresh del payload della licenza dato info + enigma generato dal client
+            </summary>
+            <param name="appInfo"></param>
+            <returns></returns>
+        </member>
         <member name="M:LiMan.APi.Data.ApiDataService.LicenzeByCliente(System.String)">
             <summary>
             Elenco licenze dato cliente
@@ -313,6 +363,75 @@
             <param name="HideData">Indica se nascondere i dati sensibili</param>
             <returns></returns>
         </member>
+        <member name="F:LiMan.APi.Data.ApiDataService.rKeySampleStats">
+            <summary>
+            Chiave redis x statistiche in acquisizione
+            </summary>
+        </member>
+        <member name="F:LiMan.APi.Data.ApiDataService.rKeySampleVars">
+            <summary>
+            Chiave redis x statistiche in acquisizione
+            </summary>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.getCurrStats">
+            <summary>
+            Recupera statistiche correnti
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="F:LiMan.APi.Data.ApiDataService.hourTTL">
+            <summary>
+            TTL da 1 h x cache Redis
+            </summary>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.setCurrStats(Core.SampleStats)">
+            <summary>
+            Salva statistiche correnti
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.redCountIncr(System.String)">
+            <summary>
+            Incrementa contatore x la chiave redis indicata...
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.redCountClear(System.String)">
+            <summary>
+            Resetta contatore x la chiave redis indicata...
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.recordCall(System.String,System.String,System.String)">
+            <summary>
+            Effettua registrazione chiamata verificando se vada messa sul DB o in redis...
+            </summary>
+            <param name="codInst"></param>
+            <param name="codApp"></param>
+            <param name="targetUrl"></param>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.saveStatsToDb(System.Collections.Generic.List{System.String})">
+            <summary>
+            Registro su DB le statistiche delle chiavi in elenco, resettando i vari contatori quando fatto
+            </summary>
+            <param name="keyList">Elenco key nel formato {rKeySampleVars}:{codInst}:{codApp}:{targetUrl}</param>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.recordCall(System.String,System.String)">
+            <summary>
+            Effettua registrazione da codice chiave...
+            </summary>
+            <param name="chiave"></param>
+            <param name="targetUrl"></param>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.SendEmail(System.String,System.String,System.String)">
+            <summary>
+            Invio email richiesta
+            </summary>
+            <param name="destEmail"></param>
+            <param name="oggetto"></param>
+            <param name="corpo"></param>
+            <returns></returns>
+        </member>
         <member name="M:LiMan.APi.Data.ApiDataService.TicketAdd(Core.SupportRequest)">
             <summary>
             Esegue aggiunta Ticket richeisto + restitusice aperti x cliente
diff --git a/LiMan.Api/Properties/PublishProfiles/IIS01.pubxml b/LiMan.Api/Properties/PublishProfiles/IIS01.pubxml
index 74819e0..187f479 100644
--- a/LiMan.Api/Properties/PublishProfiles/IIS01.pubxml
+++ b/LiMan.Api/Properties/PublishProfiles/IIS01.pubxml
@@ -23,6 +23,6 @@ by editing this MSBuild file. In order to learn more about this please visit htt
     <EnableMsDeployAppOffline>True</EnableMsDeployAppOffline>
     <UserName>jenkins</UserName>
     <_SavePWD>True</_SavePWD>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/LiMan.Api/Properties/PublishProfiles/IIS02.pubxml b/LiMan.Api/Properties/PublishProfiles/IIS02.pubxml
index c5c0433..6f49e68 100644
--- a/LiMan.Api/Properties/PublishProfiles/IIS02.pubxml
+++ b/LiMan.Api/Properties/PublishProfiles/IIS02.pubxml
@@ -23,6 +23,6 @@ by editing this MSBuild file. In order to learn more about this please visit htt
     <EnableMsDeployAppOffline>True</EnableMsDeployAppOffline>
     <UserName>jenkins</UserName>
     <_SavePWD>True</_SavePWD>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/LiMan.Api/Properties/PublishProfiles/W2019-IIS-DEV.pubxml b/LiMan.Api/Properties/PublishProfiles/W2019-IIS-DEV.pubxml
index c60784c..25b5587 100644
--- a/LiMan.Api/Properties/PublishProfiles/W2019-IIS-DEV.pubxml
+++ b/LiMan.Api/Properties/PublishProfiles/W2019-IIS-DEV.pubxml
@@ -22,7 +22,7 @@ by editing this MSBuild file. In order to learn more about this please visit htt
     <EnableMsDeployAppOffline>True</EnableMsDeployAppOffline>
     <UserName>jenkins</UserName>
     <_SavePWD>True</_SavePWD>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
     <SelfContained>false</SelfContained>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/LiMan.Api/Startup.cs b/LiMan.Api/Startup.cs
index d4c2264..02b0fdd 100644
--- a/LiMan.Api/Startup.cs
+++ b/LiMan.Api/Startup.cs
@@ -7,6 +7,8 @@ using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.OpenApi.Models;
+using StackExchange.Redis.Extensions.Core.Configuration;
+using StackExchange.Redis.Extensions.Newtonsoft;
 using System;
 using System.IO;
 using System.Reflection;
@@ -85,6 +87,16 @@ namespace LiMan.Serv
                 options.Sender_Name = Configuration["ExternalProviders:MailKit:SMTP:SenderName"];
             });
 
+            //services.AddStackExchangeRedisCache(options =>
+            //{
+            //    options.Configuration = Configuration.GetConnectionString("Redis");
+            //});
+
+            services.AddStackExchangeRedisExtensions<NewtonsoftSerializer>((options) =>
+            {
+                return Configuration.GetSection("Redis").Get<RedisConfiguration>();
+            });
+
             services.AddSingleton<ApiDataService>();
         }
 
diff --git a/LiMan.Api/appsettings.json b/LiMan.Api/appsettings.json
index f6956e1..77041ab 100644
--- a/LiMan.Api/appsettings.json
+++ b/LiMan.Api/appsettings.json
@@ -10,7 +10,7 @@
   "ConnectionStrings": {
     "LiMan.GLS": "Server=SQLSTEAM;Database=SteamWare_Auth;User ID=sa;Password=keyhammer;integrated security=False;MultipleActiveResultSets=True;App=LiMan.API;",
     "LiMan.DB": "Server=SQLSTEAM;Database=LiMan.DB;User ID=sa;Password=keyhammer;integrated security=False;MultipleActiveResultSets=True;App=LiMan.API;",
-    "Redis": "localhost:6379"
+    "Redis": "localhost:6379,DefaultDatabase=13"
   },
   "ExternalProviders": {
     "MailKit": {
@@ -27,5 +27,19 @@
   "MailDest": {
     "Admin": "samuele@steamware.net",
     "ProcOp": "ceo@steamware.net"
+  },
+  "Redis": {
+    "Password": "",
+    "AllowAdmin": false,
+    "Ssl": false,
+    "ConnectTimeout": 6000,
+    "ConnectRetry": 2,
+    "Hosts": [
+      {
+        "Host": "localhost",
+        "Port": "6379"
+      }
+    ],
+    "Database": 14
   }
 }
\ No newline at end of file
diff --git a/LiMan.DB/Controllers/DbController.cs b/LiMan.DB/Controllers/DbController.cs
index fbc5437..5dd4786 100644
--- a/LiMan.DB/Controllers/DbController.cs
+++ b/LiMan.DB/Controllers/DbController.cs
@@ -653,6 +653,20 @@ namespace LiMan.DB.Controllers
             return Task.FromResult(fatto);
         }
 
+        public LicenzaModel LicenzaByKey(string MasterKey)
+        {
+            LicenzaModel dbResult = new LicenzaModel();
+            using (LMDbContext localDbCtx = new LMDbContext(_configuration))
+            {
+                DateTime oggi = DateTime.Today;
+                dbResult = localDbCtx
+                .DbSetLicenze
+                .Where(x => x.Chiave == MasterKey)
+                .FirstOrDefault();
+            }
+            return dbResult;
+        }
+
         /// <summary>
         /// Elenco LOG chiamate all'API dato filtro + limite record
         /// </summary>
@@ -682,7 +696,7 @@ namespace LiMan.DB.Controllers
         /// </summary>
         /// <param name="currRequest"></param>
         /// <returns></returns>
-        public bool LogCallUpsert(LogCallModel currRequest)
+        public async Task<bool> LogCallUpsert(LogCallModel currRequest)
         {
             bool fatto = false;
             using (LMDbContext localDbCtx = new LMDbContext(_configuration))
@@ -710,7 +724,7 @@ namespace LiMan.DB.Controllers
                 }
 
                 // salvo
-                localDbCtx.SaveChanges();
+                await localDbCtx.SaveChangesAsync();
 
                 fatto = true;
             }
diff --git a/LiMan.DB/LiMan.DB.csproj b/LiMan.DB/LiMan.DB.csproj
index 221d743..bbd05e0 100644
--- a/LiMan.DB/LiMan.DB.csproj
+++ b/LiMan.DB/LiMan.DB.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/LiMan.GLS/LiMan.GLS.csproj b/LiMan.GLS/LiMan.GLS.csproj
index 78f11cb..f77e57e 100644
--- a/LiMan.GLS/LiMan.GLS.csproj
+++ b/LiMan.GLS/LiMan.GLS.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/LiMan.UI/LiMan.UI.csproj b/LiMan.UI/LiMan.UI.csproj
index 06f0a0a..42f67ac 100644
--- a/LiMan.UI/LiMan.UI.csproj
+++ b/LiMan.UI/LiMan.UI.csproj
@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>net6.0</TargetFramework>
-        <Version>1.1.2111.1711</Version>
+        <Version>1.1.2111.1715</Version>
         <RootNamespace>LiMan.UI</RootNamespace>
         <AssemblyName>LiMan.UI</AssemblyName>
     </PropertyGroup>
diff --git a/LiMan.UI/Resources/ChangeLog.html b/LiMan.UI/Resources/ChangeLog.html
index 1231513..aca6ff0 100644
--- a/LiMan.UI/Resources/ChangeLog.html
+++ b/LiMan.UI/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>License Manager</i>
-    <h4>Versione: 1.1.2111.1711</h4>
+    <h4>Versione: 1.1.2111.1715</h4>
     <br />
     Note di rilascio:
     <ul>
diff --git a/LiMan.UI/Resources/VersNum.txt b/LiMan.UI/Resources/VersNum.txt
index d29da94..9c0facf 100644
--- a/LiMan.UI/Resources/VersNum.txt
+++ b/LiMan.UI/Resources/VersNum.txt
@@ -1 +1 @@
-1.1.2111.1711
+1.1.2111.1715
diff --git a/LiMan.UI/Resources/manifest.xml b/LiMan.UI/Resources/manifest.xml
index 6c66990..35c66ac 100644
--- a/LiMan.UI/Resources/manifest.xml
+++ b/LiMan.UI/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.1.2111.1711</version>
+  <version>1.1.2111.1715</version>
   <url>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/LiMan.UI.zip</url>
   <changelog>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>

From 2b0cbea431e20632701a733af5b1b4f6ae853cc2 Mon Sep 17 00:00:00 2001
From: Samuele Locatelli <samuele@steamware.net>
Date: Wed, 17 Nov 2021 15:32:18 +0100
Subject: [PATCH 08/14] Completo rollback core5.0 x testing debug

---
 LiMan.UI/LiMan.UI.csproj                                 | 2 +-
 LiMan.UI/Properties/PublishProfiles/IIS01.pubxml         | 2 +-
 LiMan.UI/Properties/PublishProfiles/IIS02.pubxml         | 2 +-
 LiMan.UI/Properties/PublishProfiles/W2019-IIS-DEV.pubxml | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/LiMan.UI/LiMan.UI.csproj b/LiMan.UI/LiMan.UI.csproj
index 42f67ac..28f683a 100644
--- a/LiMan.UI/LiMan.UI.csproj
+++ b/LiMan.UI/LiMan.UI.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
     <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>net5.0</TargetFramework>
         <Version>1.1.2111.1715</Version>
         <RootNamespace>LiMan.UI</RootNamespace>
         <AssemblyName>LiMan.UI</AssemblyName>
diff --git a/LiMan.UI/Properties/PublishProfiles/IIS01.pubxml b/LiMan.UI/Properties/PublishProfiles/IIS01.pubxml
index 81e712b..94ebf7d 100644
--- a/LiMan.UI/Properties/PublishProfiles/IIS01.pubxml
+++ b/LiMan.UI/Properties/PublishProfiles/IIS01.pubxml
@@ -22,7 +22,7 @@ by editing this MSBuild file. In order to learn more about this please visit htt
     <EnableMsDeployAppOffline>True</EnableMsDeployAppOffline>
     <UserName>jenkins</UserName>
     <_SavePWD>True</_SavePWD>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
     <SelfContained>false</SelfContained>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/LiMan.UI/Properties/PublishProfiles/IIS02.pubxml b/LiMan.UI/Properties/PublishProfiles/IIS02.pubxml
index 1847a26..aaca518 100644
--- a/LiMan.UI/Properties/PublishProfiles/IIS02.pubxml
+++ b/LiMan.UI/Properties/PublishProfiles/IIS02.pubxml
@@ -22,7 +22,7 @@ by editing this MSBuild file. In order to learn more about this please visit htt
     <EnableMsDeployAppOffline>True</EnableMsDeployAppOffline>
     <UserName>jenkins</UserName>
     <_SavePWD>True</_SavePWD>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
     <SelfContained>false</SelfContained>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/LiMan.UI/Properties/PublishProfiles/W2019-IIS-DEV.pubxml b/LiMan.UI/Properties/PublishProfiles/W2019-IIS-DEV.pubxml
index 3aaee28..c727b14 100644
--- a/LiMan.UI/Properties/PublishProfiles/W2019-IIS-DEV.pubxml
+++ b/LiMan.UI/Properties/PublishProfiles/W2019-IIS-DEV.pubxml
@@ -22,7 +22,7 @@ by editing this MSBuild file. In order to learn more about this please visit htt
     <EnableMsDeployAppOffline>True</EnableMsDeployAppOffline>
     <UserName>jenkins</UserName>
     <_SavePWD>True</_SavePWD>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
     <SelfContained>false</SelfContained>
   </PropertyGroup>
 </Project>
\ No newline at end of file

From 8a52b7d55a4e0d55f8c424f302e65bebeb0fe1a0 Mon Sep 17 00:00:00 2001
From: Samuele Locatelli <samuele@steamware.net>
Date: Wed, 17 Nov 2021 16:03:33 +0100
Subject: [PATCH 09/14] test update api

---
 LiMan.Api/Data/ApiDataService.cs | 47 ++++++++++++++++++++++++++++----
 LiMan.Api/LiMan.APi.xml          | 11 +++++++-
 2 files changed, 51 insertions(+), 7 deletions(-)

diff --git a/LiMan.Api/Data/ApiDataService.cs b/LiMan.Api/Data/ApiDataService.cs
index 255625f..1b428c6 100644
--- a/LiMan.Api/Data/ApiDataService.cs
+++ b/LiMan.Api/Data/ApiDataService.cs
@@ -28,7 +28,7 @@ namespace LiMan.APi.Data
         private static ILogger<ApiDataService> _logger;
         private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
         private readonly IEmailSender _emailSender;
-        private readonly IDistributedCache distributedCache;
+        //private readonly IDistributedCache distributedCache;
         private readonly IRedisCacheClient _redisCacheClient;
 
         /// <summary>
@@ -74,7 +74,21 @@ namespace LiMan.APi.Data
         protected async Task<bool> setRSV(string rKey, string rVal, int ttlSec)
         {
             bool fatto = false;
-            await _redisCacheClient.GetDbFromConfiguration().AddAsync<string>(rKey, rVal, DateTimeOffset.Now.AddSeconds(ttlSec));
+            await _redisCacheClient.GetDbFromConfiguration().AddAsync(rKey, rVal, DateTimeOffset.Now.AddSeconds(ttlSec));
+            fatto = true;
+            return fatto;
+        }
+        /// <summary>
+        /// Salvataggio chiave in redis
+        /// </summary>
+        /// <param name="rKey"></param>
+        /// <param name="rValInt"></param>
+        /// <param name="ttlSec"></param>
+        /// <returns></returns>
+        protected async Task<bool> setRSV(string rKey, int rValInt, int ttlSec)
+        {
+            bool fatto = false;
+            await _redisCacheClient.GetDbFromConfiguration().AddAsync<int>(rKey, rValInt, DateTimeOffset.Now.AddSeconds(ttlSec));
             fatto = true;
             return fatto;
         }
@@ -90,13 +104,14 @@ namespace LiMan.APi.Data
         /// <param name="distributedCache"></param>
         /// <param name="emailSender"></param>
         /// <param name="redisCacheClient"></param>
-        public ApiDataService(IConfiguration configuration, ILogger<ApiDataService> logger, IDistributedCache distributedCache, IEmailSender emailSender, IRedisCacheClient redisCacheClient)
+        public ApiDataService(IConfiguration configuration, ILogger<ApiDataService> logger, IEmailSender emailSender, IRedisCacheClient redisCacheClient)
+        //public ApiDataService(IConfiguration configuration, ILogger<ApiDataService> logger, IDistributedCache distributedCache, IEmailSender emailSender, IRedisCacheClient redisCacheClient)
         {
             _logger = logger;
             _configuration = configuration;
             _emailSender = emailSender;
-            this.distributedCache = distributedCache;
             _redisCacheClient = redisCacheClient;
+            //this.distributedCache = distributedCache;
 
             // conf DB
             string connStrDB = _configuration.GetConnectionString("LiMan.DB");
@@ -332,6 +347,7 @@ namespace LiMan.APi.Data
         {
             LicenzaModel dbResult = new LicenzaModel();
             string cacheKey = $"DATA:Licenze:ListByKey:{chiave}";
+#if false
             string rawData;
             var redisDataList = await distributedCache.GetAsync(cacheKey);
             if (redisDataList != null)
@@ -350,7 +366,26 @@ namespace LiMan.APi.Data
                 stopWatch.Stop();
                 TimeSpan ts = stopWatch.Elapsed;
                 Log.Trace($"Effettuata lettura da DB per LicenzaByMasterKey: {ts.TotalMilliseconds} ms");
+            } 
+#endif
+
+            string rawData = await getRSV(cacheKey);
+            if (!string.IsNullOrEmpty(rawData))
+            {
+                dbResult = JsonConvert.DeserializeObject<LicenzaModel>(rawData);
             }
+            else
+            {
+                Stopwatch stopWatch = new Stopwatch();
+                stopWatch.Start();
+                dbResult = dbController.LicenzaByKey(chiave);
+                rawData = JsonConvert.SerializeObject(dbResult);
+                await setRSV(cacheKey, rawData, hourTTL);
+                stopWatch.Stop();
+                TimeSpan ts = stopWatch.Elapsed;
+                Log.Trace($"Effettuata lettura da DB per LicenzaByMasterKey: {ts.TotalMilliseconds} ms");
+            }
+
             return await Task.FromResult(dbResult);
         }
 
@@ -482,7 +517,7 @@ namespace LiMan.APi.Data
                 int.TryParse(rawVal, out currCount);
             }
             currCount++;
-            answ = await setRSV(rKey, $"{currCount}", 2 * hourTTL);
+            answ = await setRSV(rKey, currCount, 2 * hourTTL);
             return answ;
         }
         /// <summary>
@@ -493,7 +528,7 @@ namespace LiMan.APi.Data
         {
             bool answ = false;
             int currCount = 0;
-            answ = await setRSV(rKey, $"{currCount}", 2 * hourTTL);
+            answ = await setRSV(rKey, currCount, 2 * hourTTL);
             return answ;
         }
 
diff --git a/LiMan.Api/LiMan.APi.xml b/LiMan.Api/LiMan.APi.xml
index 3fb4243..024eacb 100644
--- a/LiMan.Api/LiMan.APi.xml
+++ b/LiMan.Api/LiMan.APi.xml
@@ -242,7 +242,16 @@
             <param name="ttlSec"></param>
             <returns></returns>
         </member>
-        <member name="M:LiMan.APi.Data.ApiDataService.#ctor(Microsoft.Extensions.Configuration.IConfiguration,Microsoft.Extensions.Logging.ILogger{LiMan.APi.Data.ApiDataService},Microsoft.Extensions.Caching.Distributed.IDistributedCache,Microsoft.AspNetCore.Identity.UI.Services.IEmailSender,StackExchange.Redis.Extensions.Core.Abstractions.IRedisCacheClient)">
+        <member name="M:LiMan.APi.Data.ApiDataService.setRSV(System.String,System.Int32,System.Int32)">
+            <summary>
+            Salvataggio chiave in redis
+            </summary>
+            <param name="rKey"></param>
+            <param name="rValInt"></param>
+            <param name="ttlSec"></param>
+            <returns></returns>
+        </member>
+        <member name="M:LiMan.APi.Data.ApiDataService.#ctor(Microsoft.Extensions.Configuration.IConfiguration,Microsoft.Extensions.Logging.ILogger{LiMan.APi.Data.ApiDataService},Microsoft.AspNetCore.Identity.UI.Services.IEmailSender,StackExchange.Redis.Extensions.Core.Abstractions.IRedisCacheClient)">
             <summary>
             Init classe
             </summary>

From dd36b467189979afebb5c1e59ae4c3039a1845ca Mon Sep 17 00:00:00 2001
From: "Samuele E. Locatelli" <samuele@steamware.net>
Date: Wed, 17 Nov 2021 19:03:21 +0100
Subject: [PATCH 10/14] modifica traccia da salvare x check API calls

---
 LiMan.Api/Controllers/ApplicazioneController.cs |  2 +-
 LiMan.Api/Controllers/AttivazioniController.cs  | 13 ++++++-------
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/LiMan.Api/Controllers/ApplicazioneController.cs b/LiMan.Api/Controllers/ApplicazioneController.cs
index 863cbb6..3d3c86e 100644
--- a/LiMan.Api/Controllers/ApplicazioneController.cs
+++ b/LiMan.Api/Controllers/ApplicazioneController.cs
@@ -61,7 +61,7 @@ namespace LiMan.APi.Controllers
         public async Task<List<DB.DTO.ApplicativoDTO>> Get(string id, string CodApp)
         {
             var result = await dataService.ApplicativiSearch(id, CodApp, true);
-            await dataService.recordCall(id, CodApp, $"[GET][api/applicazione]");
+            await dataService.recordCall(id, CodApp, $"GET:api/applicazione");
             return result;
         }
 
diff --git a/LiMan.Api/Controllers/AttivazioniController.cs b/LiMan.Api/Controllers/AttivazioniController.cs
index 0ca8683..a349357 100644
--- a/LiMan.Api/Controllers/AttivazioniController.cs
+++ b/LiMan.Api/Controllers/AttivazioniController.cs
@@ -63,7 +63,7 @@ namespace LiMan.APi.Controllers
             foreach (var item in CurrRequest.ParamDict)
             {
                 // registro 1 riga x ogni record...
-                await dataService.recordCall(CurrRequest.MasterKey, $"[DELETE][api/attivazioni][{item.Key}|{item.Value}]");
+                await dataService.recordCall(CurrRequest.MasterKey, $"DELETE:api/attivazioni:{item.Key}|{item.Value}");
             }
             return done;
         }
@@ -80,7 +80,7 @@ namespace LiMan.APi.Controllers
             List<DB.DTO.AttivazioneDTO> result = new List<DB.DTO.AttivazioneDTO>();
             var dbResult = await dataService.AttivazioniByMasterKey(chiave, false);
             result = (dbResult != null) ? dbResult : result;
-            await dataService.recordCall(chiave, $"[GET][api/attivazioni][{chiave}]");
+            await dataService.recordCall(chiave, $"GET:api/attivazioni:{chiave}");
             return result;
         }
 
@@ -101,7 +101,7 @@ namespace LiMan.APi.Controllers
             foreach (var item in CurrRequest.ParamDict)
             {
                 // registro 1 riga x ogni record...
-                await dataService.recordCall(CurrRequest.MasterKey, $"[POST][api/attivazioni][{item.Key}|{item.Value}]");
+                await dataService.recordCall(CurrRequest.MasterKey, $"POST:api/attivazioni:{item.Key}|{item.Value}");
             }
             return currData;
         }
@@ -123,7 +123,7 @@ namespace LiMan.APi.Controllers
             foreach (var item in CurrRequest.ParamDict)
             {
                 // registro 1 riga x ogni record...
-                await dataService.recordCall(CurrRequest.MasterKey, $"[POST][api/attivazioni/refreshKey][{item.Key}|{item.Value}]");
+                await dataService.recordCall(CurrRequest.MasterKey, $"POST:api/attivazioni/refreshKey:{item.Key}__{item.Value}");
             }
             return currData;
         }
@@ -137,7 +137,7 @@ namespace LiMan.APi.Controllers
         public async Task<bool> ResetAvail(string chiave)
         {
             bool done = await dataService.AttivazioniResetAvail(chiave);
-            await dataService.recordCall(chiave, $"[DELETE][api/attivazioni/resetAvail][{chiave}]");
+            await dataService.recordCall(chiave, $"DELETE:api/attivazioni/resetAvail:{chiave}");
             return done;
         }
 
@@ -154,11 +154,10 @@ namespace LiMan.APi.Controllers
             DB.DTO.AttivazioneDTO result = new DB.DTO.AttivazioneDTO();
             var dbResult = await dataService.AttivazioneSearch(chiave, codImpiego, false);
             result = (dbResult != null) ? dbResult : result;
-            await dataService.recordCall(chiave, $"[GET][api/attivazioni/verifica][{chiave}|{codImpiego}]");
+            await dataService.recordCall(chiave, $"GET:api/attivazioni/verifica:{chiave}__{codImpiego}");
             return result;
         }
 
         #endregion Public Methods
-
     }
 }
\ No newline at end of file

From c5acc6dcf846ccad882d1c394458b6211d2d665b Mon Sep 17 00:00:00 2001
From: "Samuele E. Locatelli" <samuele@steamware.net>
Date: Wed, 17 Nov 2021 19:04:12 +0100
Subject: [PATCH 11/14] modifica metodo load/save dati su redis x API

---
 LiMan.Api/Data/ApiDataService.cs | 352 ++++++++++++++++---------------
 1 file changed, 184 insertions(+), 168 deletions(-)

diff --git a/LiMan.Api/Data/ApiDataService.cs b/LiMan.Api/Data/ApiDataService.cs
index 1b428c6..24278a7 100644
--- a/LiMan.Api/Data/ApiDataService.cs
+++ b/LiMan.Api/Data/ApiDataService.cs
@@ -22,12 +22,41 @@ namespace LiMan.APi.Data
     /// </summary>
     public class ApiDataService : IDisposable
     {
+        #region Public Fields
+
+        /// <summary>
+        /// Classe Accesso metodi DB
+        /// </summary>
+        public static LiMan.DB.Controllers.DbController dbController;
+
+        #endregion Public Fields
+
+        #region Protected Fields
+
+        /// <summary>
+        /// TTL da 1 h x cache Redis
+        /// </summary>
+        protected const int hourTTL = 60 * 60;
+
+        /// <summary>
+        /// Chiave redis x statistiche in acquisizione
+        /// </summary>
+        protected const string rKeySampleStats = "LiMan.UI:SampleStats:Curr";
+
+        /// <summary>
+        /// Chiave redis x statistiche in acquisizione
+        /// </summary>
+        protected const string rKeySampleVars = "LiMan.UI:SampleStats:Vars";
+
+        #endregion Protected Fields
+
         #region Private Fields
 
         private static IConfiguration _configuration;
         private static ILogger<ApiDataService> _logger;
         private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
         private readonly IEmailSender _emailSender;
+
         //private readonly IDistributedCache distributedCache;
         private readonly IRedisCacheClient _redisCacheClient;
 
@@ -44,56 +73,6 @@ namespace LiMan.APi.Data
 
         #endregion Private Fields
 
-        #region Public Fields
-
-        /// <summary>
-        /// Classe Accesso metodi DB
-        /// </summary>
-        public static LiMan.DB.Controllers.DbController dbController;
-
-        #endregion Public Fields
-
-        /// <summary>
-        /// Recupero chiave da redis
-        /// </summary>
-        /// <param name="rKey"></param>
-        /// <returns></returns>
-        protected async Task<string> getRSV(string rKey)
-        {
-            string answ = await _redisCacheClient.GetDbFromConfiguration().GetAsync<string>(rKey);
-            return answ;
-        }
-
-        /// <summary>
-        /// Salvataggio chiave in redis
-        /// </summary>
-        /// <param name="rKey"></param>
-        /// <param name="rVal"></param>
-        /// <param name="ttlSec"></param>
-        /// <returns></returns>
-        protected async Task<bool> setRSV(string rKey, string rVal, int ttlSec)
-        {
-            bool fatto = false;
-            await _redisCacheClient.GetDbFromConfiguration().AddAsync(rKey, rVal, DateTimeOffset.Now.AddSeconds(ttlSec));
-            fatto = true;
-            return fatto;
-        }
-        /// <summary>
-        /// Salvataggio chiave in redis
-        /// </summary>
-        /// <param name="rKey"></param>
-        /// <param name="rValInt"></param>
-        /// <param name="ttlSec"></param>
-        /// <returns></returns>
-        protected async Task<bool> setRSV(string rKey, int rValInt, int ttlSec)
-        {
-            bool fatto = false;
-            await _redisCacheClient.GetDbFromConfiguration().AddAsync<int>(rKey, rValInt, DateTimeOffset.Now.AddSeconds(ttlSec));
-            fatto = true;
-            return fatto;
-        }
-
-
         #region Public Constructors
 
         /// <summary>
@@ -128,22 +107,6 @@ namespace LiMan.APi.Data
 
         #endregion Public Constructors
 
-        #region Private Methods
-
-        /// <summary>
-        /// Parametri per generare opzioni cache
-        /// </summary>
-        /// <param name="multFact">Fattore di moltiplica cache (se 1 --> 2 e 5 min)</param>
-        /// <returns></returns>
-        private DistributedCacheEntryOptions cacheOpt(int multFact)
-        {
-            var numSecAbsExp = multFact <= 0 ? chAbsExp : chAbsExp * multFact;
-            var numSecSliExp = multFact <= 0 ? chSliExp : chSliExp * multFact;
-            return new DistributedCacheEntryOptions().SetAbsoluteExpiration(DateTime.Now.AddSeconds(numSecAbsExp)).SetSlidingExpiration(TimeSpan.FromSeconds(numSecSliExp));
-        }
-
-        #endregion Private Methods
-
         #region Public Methods
 
         /// <summary>
@@ -366,7 +329,7 @@ namespace LiMan.APi.Data
                 stopWatch.Stop();
                 TimeSpan ts = stopWatch.Elapsed;
                 Log.Trace($"Effettuata lettura da DB per LicenzaByMasterKey: {ts.TotalMilliseconds} ms");
-            } 
+            }
 #endif
 
             string rawData = await getRSV(cacheKey);
@@ -443,94 +406,6 @@ namespace LiMan.APi.Data
 
             return await Task.FromResult(dbResult);
         }
-        /// <summary>
-        /// Chiave redis x statistiche in acquisizione
-        /// </summary>
-        protected const string rKeySampleStats = "DATA:SampleStats:Curr";
-        /// <summary>
-        /// Chiave redis x statistiche in acquisizione
-        /// </summary>
-        protected const string rKeySampleVars = "DATA:SampleStats:Vars";
-
-        /// <summary>
-        /// Recupera statistiche correnti
-        /// </summary>
-        /// <returns></returns>
-        protected async Task<SampleStats> getCurrStats()
-        {
-            DateTime adesso = DateTime.Now;
-            SampleStats answ = new SampleStats()
-            {
-                Name = "ApiStats"
-            };
-            // in primis check data/ora prima/ultima scrittura del set... (2 date, lista chiavi gestite)
-            string rawData = await getRSV(rKeySampleStats);
-            if (rawData != null)
-            {
-                answ = JsonConvert.DeserializeObject<SampleStats>(rawData);
-            }
-            // controllo se scadute...
-            if (adesso.Subtract(answ.DtFirst).TotalMinutes > 60)
-            {
-                // se scaduto --> registrazione set sul DB (async), resettando i vari contatori...
-                bool salvato = await saveStatsToDb(answ.VList);
-                // inizio NUOVO set vuoto con record corrente
-                answ = new SampleStats()
-                {
-                    Name = "ApiStats"
-                };
-                // salvo!
-                await setCurrStats(answ);
-            }
-            // restituisco record!
-            return answ;
-        }
-
-        /// <summary>
-        /// TTL da 1 h x cache Redis
-        /// </summary>
-        protected const int hourTTL = 60 * 60;
-
-        /// <summary>
-        /// Salva statistiche correnti
-        /// </summary>
-        /// <returns></returns>
-        protected async Task<bool> setCurrStats(SampleStats newVal)
-        {
-            bool answ = false;
-            string rawData = JsonConvert.SerializeObject(newVal);
-            answ = await setRSV(rKeySampleStats, rawData, 24 * hourTTL);
-            return answ;
-        }
-
-        /// <summary>
-        /// Incrementa contatore x la chiave redis indicata...
-        /// </summary>
-        /// <returns></returns>
-        protected async Task<bool> redCountIncr(string rKey)
-        {
-            bool answ = false;
-            int currCount = 0;
-            string rawVal = await getRSV(rKey);
-            if (string.IsNullOrEmpty(rawVal))
-            {
-                int.TryParse(rawVal, out currCount);
-            }
-            currCount++;
-            answ = await setRSV(rKey, currCount, 2 * hourTTL);
-            return answ;
-        }
-        /// <summary>
-        /// Resetta contatore x la chiave redis indicata...
-        /// </summary>
-        /// <returns></returns>
-        protected async Task<bool> redCountClear(string rKey)
-        {
-            bool answ = false;
-            int currCount = 0;
-            answ = await setRSV(rKey, currCount, 2 * hourTTL);
-            return answ;
-        }
 
         /// <summary>
         /// Effettua registrazione chiamata verificando se vada messa sul DB o in redis...
@@ -561,6 +436,19 @@ namespace LiMan.APi.Data
             return fatto;
         }
 
+        /// <summary>
+        /// Effettua registrazione da codice chiave...
+        /// </summary>
+        /// <param name="chiave"></param>
+        /// <param name="targetUrl"></param>
+        public async Task<bool> recordCall(string chiave, string targetUrl)
+        {
+            // valutare se cache key --> lic...
+            var currLic = await LicenzaByMasterKey(chiave);
+            var fatto = await recordCall(currLic.CodInst, currLic.CodApp, targetUrl);
+            return fatto;
+        }
+
         /// <summary>
         /// Registro su DB le statistiche delle chiavi in elenco, resettando i vari contatori quando fatto
         /// </summary>
@@ -593,19 +481,6 @@ namespace LiMan.APi.Data
             return fatto;
         }
 
-        /// <summary>
-        /// Effettua registrazione da codice chiave...
-        /// </summary>
-        /// <param name="chiave"></param>
-        /// <param name="targetUrl"></param>
-        public async Task<bool> recordCall(string chiave, string targetUrl)
-        {
-            // valutare se cache key --> lic...
-            var currLic = await LicenzaByMasterKey(chiave);
-            var fatto = await recordCall(currLic.CodInst, currLic.CodApp, targetUrl);
-            return fatto;
-        }
-
         /// <summary>
         /// Invio email richiesta
         /// </summary>
@@ -693,6 +568,147 @@ namespace LiMan.APi.Data
 
         #endregion Public Methods
 
+        #region Protected Methods
+
+        /// <summary>
+        /// Recupera statistiche correnti
+        /// </summary>
+        /// <returns></returns>
+        protected async Task<SampleStats> getCurrStats()
+        {
+            DateTime adesso = DateTime.Now;
+            SampleStats answ = new SampleStats()
+            {
+                Name = "ApiStats"
+            };
+            // in primis check data/ora prima/ultima scrittura del set... (2 date, lista chiavi gestite)
+            string rawData = await getRSV(rKeySampleStats);
+            if (rawData != null)
+            {
+                answ = JsonConvert.DeserializeObject<SampleStats>(rawData);
+                // aggiorno ultimo controllo e salvo...
+                answ.DtLast = adesso;
+                // salvo!
+                await setCurrStats(answ);
+            }
+            // controllo se scadute...
+            if (adesso.Subtract(answ.DtFirst).TotalMinutes > 60)
+            {
+                // se scaduto --> registrazione set sul DB (async), resettando i vari contatori...
+                bool salvato = await saveStatsToDb(answ.VList);
+                // inizio NUOVO set vuoto con record corrente
+                answ = new SampleStats()
+                {
+                    Name = "ApiStats"
+                };
+                // salvo!
+                await setCurrStats(answ);
+            }
+            // restituisco record!
+            return answ;
+        }
+
+        /// <summary>
+        /// Recupero chiave da redis
+        /// </summary>
+        /// <param name="rKey"></param>
+        /// <returns></returns>
+        protected async Task<string> getRSV(string rKey)
+        {
+            string answ = await _redisCacheClient.GetDbFromConfiguration().GetAsync<string>(rKey);
+            return answ;
+        }
+
+        /// <summary>
+        /// Resetta contatore x la chiave redis indicata...
+        /// </summary>
+        /// <returns></returns>
+        protected async Task<bool> redCountClear(string rKey)
+        {
+            bool answ = false;
+            int currCount = 0;
+            answ = await setRSV(rKey, currCount, 2 * hourTTL);
+            return answ;
+        }
+
+        /// <summary>
+        /// Incrementa contatore x la chiave redis indicata...
+        /// </summary>
+        /// <returns></returns>
+        protected async Task<bool> redCountIncr(string rKey)
+        {
+            bool answ = false;
+            int currCount = 0;
+            string rawVal = await getRSV(rKey);
+            if (!string.IsNullOrEmpty(rawVal))
+            {
+                int.TryParse(rawVal, out currCount);
+            }
+            currCount++;
+            answ = await setRSV(rKey, currCount, 2 * hourTTL);
+            return answ;
+        }
+
+        /// <summary>
+        /// Salva statistiche correnti
+        /// </summary>
+        /// <returns></returns>
+        protected async Task<bool> setCurrStats(SampleStats newVal)
+        {
+            bool answ = false;
+            string rawData = JsonConvert.SerializeObject(newVal);
+            answ = await setRSV(rKeySampleStats, rawData, 24 * hourTTL);
+            return answ;
+        }
+
+        /// <summary>
+        /// Salvataggio chiave in redis
+        /// </summary>
+        /// <param name="rKey"></param>
+        /// <param name="rVal"></param>
+        /// <param name="ttlSec"></param>
+        /// <returns></returns>
+        protected async Task<bool> setRSV(string rKey, string rVal, int ttlSec)
+        {
+            bool fatto = false;
+            await _redisCacheClient.GetDbFromConfiguration().AddAsync(rKey, rVal, DateTimeOffset.Now.AddSeconds(ttlSec));
+            fatto = true;
+            return fatto;
+        }
+
+        /// <summary>
+        /// Salvataggio chiave in redis
+        /// </summary>
+        /// <param name="rKey"></param>
+        /// <param name="rValInt"></param>
+        /// <param name="ttlSec"></param>
+        /// <returns></returns>
+        protected async Task<bool> setRSV(string rKey, int rValInt, int ttlSec)
+        {
+            bool fatto = false;
+            await _redisCacheClient.GetDbFromConfiguration().AddAsync<int>(rKey, rValInt, DateTimeOffset.Now.AddSeconds(ttlSec));
+            fatto = true;
+            return fatto;
+        }
+
+        #endregion Protected Methods
+
+        #region Private Methods
+
+        /// <summary>
+        /// Parametri per generare opzioni cache
+        /// </summary>
+        /// <param name="multFact">Fattore di moltiplica cache (se 1 --> 2 e 5 min)</param>
+        /// <returns></returns>
+        private DistributedCacheEntryOptions cacheOpt(int multFact)
+        {
+            var numSecAbsExp = multFact <= 0 ? chAbsExp : chAbsExp * multFact;
+            var numSecSliExp = multFact <= 0 ? chSliExp : chSliExp * multFact;
+            return new DistributedCacheEntryOptions().SetAbsoluteExpiration(DateTime.Now.AddSeconds(numSecAbsExp)).SetSlidingExpiration(TimeSpan.FromSeconds(numSecSliExp));
+        }
+
+        #endregion Private Methods
+
 #if false
         /// <summary>
         /// Elenco ticket dato licenza (limitato a maxRec)

From db816e242797bd950d4ade260fb271095d530ddf Mon Sep 17 00:00:00 2001
From: "Samuele E. Locatelli" <samuele@steamware.net>
Date: Wed, 17 Nov 2021 19:04:15 +0100
Subject: [PATCH 12/14] refresh

---
 LiMan.DB/LiMan.DB.csproj          | 1 -
 LiMan.UI/LiMan.UI.csproj          | 2 +-
 LiMan.UI/Resources/ChangeLog.html | 2 +-
 LiMan.UI/Resources/VersNum.txt    | 2 +-
 LiMan.UI/Resources/manifest.xml   | 2 +-
 5 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/LiMan.DB/LiMan.DB.csproj b/LiMan.DB/LiMan.DB.csproj
index bbd05e0..dae6bfc 100644
--- a/LiMan.DB/LiMan.DB.csproj
+++ b/LiMan.DB/LiMan.DB.csproj
@@ -16,7 +16,6 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="5.0.1" />
-    <PackageReference Include="MimeKit" Version="2.15.1" />
     <PackageReference Include="NLog" Version="4.7.11" />
   </ItemGroup>
 
diff --git a/LiMan.UI/LiMan.UI.csproj b/LiMan.UI/LiMan.UI.csproj
index 28f683a..01a4c35 100644
--- a/LiMan.UI/LiMan.UI.csproj
+++ b/LiMan.UI/LiMan.UI.csproj
@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>net5.0</TargetFramework>
-        <Version>1.1.2111.1715</Version>
+        <Version>1.1.2111.1719</Version>
         <RootNamespace>LiMan.UI</RootNamespace>
         <AssemblyName>LiMan.UI</AssemblyName>
     </PropertyGroup>
diff --git a/LiMan.UI/Resources/ChangeLog.html b/LiMan.UI/Resources/ChangeLog.html
index aca6ff0..8d7b79a 100644
--- a/LiMan.UI/Resources/ChangeLog.html
+++ b/LiMan.UI/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>License Manager</i>
-    <h4>Versione: 1.1.2111.1715</h4>
+    <h4>Versione: 1.1.2111.1719</h4>
     <br />
     Note di rilascio:
     <ul>
diff --git a/LiMan.UI/Resources/VersNum.txt b/LiMan.UI/Resources/VersNum.txt
index 9c0facf..7232e07 100644
--- a/LiMan.UI/Resources/VersNum.txt
+++ b/LiMan.UI/Resources/VersNum.txt
@@ -1 +1 @@
-1.1.2111.1715
+1.1.2111.1719
diff --git a/LiMan.UI/Resources/manifest.xml b/LiMan.UI/Resources/manifest.xml
index 35c66ac..9cfa5fd 100644
--- a/LiMan.UI/Resources/manifest.xml
+++ b/LiMan.UI/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.1.2111.1715</version>
+  <version>1.1.2111.1719</version>
   <url>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/LiMan.UI.zip</url>
   <changelog>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>

From 1aae60d17d6cc4414fa146e04722a8e3c284d61c Mon Sep 17 00:00:00 2001
From: "Samuele E. Locatelli" <samuele@steamware.net>
Date: Wed, 17 Nov 2021 19:05:49 +0100
Subject: [PATCH 13/14] Completo modifica haskKey traccia redis

---
 LiMan.Api/Controllers/InstallazioniController.cs | 2 +-
 LiMan.Api/Controllers/LicenzaController.cs       | 6 +++---
 LiMan.Api/Controllers/TicketController.cs        | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/LiMan.Api/Controllers/InstallazioniController.cs b/LiMan.Api/Controllers/InstallazioniController.cs
index 64902e3..46c8c08 100644
--- a/LiMan.Api/Controllers/InstallazioniController.cs
+++ b/LiMan.Api/Controllers/InstallazioniController.cs
@@ -61,7 +61,7 @@ namespace LiMan.APi.Controllers
         {
             var result = await dataService.LicenzeByCliente(id);
             var listaApp = result.Select(x => x.CodApp).ToList();
-            await dataService.recordCall(id, "*", "[GET][api/installazioni]");
+            await dataService.recordCall(id, "*", "GET:api/installazioni");
             return listaApp;
         }
 
diff --git a/LiMan.Api/Controllers/LicenzaController.cs b/LiMan.Api/Controllers/LicenzaController.cs
index 283d011..f86e8f6 100644
--- a/LiMan.Api/Controllers/LicenzaController.cs
+++ b/LiMan.Api/Controllers/LicenzaController.cs
@@ -63,7 +63,7 @@ namespace LiMan.APi.Controllers
         public async Task<List<DB.DTO.ApplicativoDTO>> Get(string id, string CodApp, string Chiave)
         {
             var result = await dataService.LicenzeSearch(id, CodApp, Chiave, false);
-            await dataService.recordCall(id, CodApp, $"[GET][api/licenza][{Chiave}]");
+            await dataService.recordCall(id, CodApp, $"GET:api/licenza:{Chiave}");
             return result;
         }
 
@@ -77,7 +77,7 @@ namespace LiMan.APi.Controllers
         public async Task<List<DB.DTO.ApplicativoDTO>> Get([FromBody] LicenseCoord AppInfo)
         {
             var result = await dataService.LicenzeSearch(AppInfo.CodInst, AppInfo.CodApp, AppInfo.MasterKey, false);
-            await dataService.recordCall(AppInfo.CodInst, AppInfo.CodApp, $"[POST][api/licenza][{AppInfo.MasterKey}]");
+            await dataService.recordCall(AppInfo.CodInst, AppInfo.CodApp, $"POST:api/licenza:{AppInfo.MasterKey}");
             return result;
         }
 
@@ -90,7 +90,7 @@ namespace LiMan.APi.Controllers
         public async Task<DB.DTO.ApplicativoDTO> RefreshPayload([FromBody] LicenseCoord AppInfo)
         {
             var done = await dataService.LicenzaRefreshPayload(AppInfo);
-            await dataService.recordCall(AppInfo.CodInst, AppInfo.CodApp, $"[POST][api/licenza/refreshPayload][{AppInfo.MasterKey}]");
+            await dataService.recordCall(AppInfo.CodInst, AppInfo.CodApp, $"POST:api/licenza/refreshPayload:{AppInfo.MasterKey}");
             return done;
         }
 
diff --git a/LiMan.Api/Controllers/TicketController.cs b/LiMan.Api/Controllers/TicketController.cs
index b4b685d..2c41eae 100644
--- a/LiMan.Api/Controllers/TicketController.cs
+++ b/LiMan.Api/Controllers/TicketController.cs
@@ -63,7 +63,7 @@ namespace LiMan.APi.Controllers
         public async Task<List<DB.DBModels.TicketModel>> Get(string id, string CodApp, string Chiave)
         {
             var result = await dataService.TicketByCliente(id, CodApp, Chiave);
-            await dataService.recordCall(id, CodApp, $"[GET][api/ticket][{Chiave}]");
+            await dataService.recordCall(id, CodApp, $"GET:api/ticket:{Chiave}");
             return result;
         }
 
@@ -84,7 +84,7 @@ namespace LiMan.APi.Controllers
             }
             // restituisco richieste aperte
             result = await dataService.TicketByCliente(CurrRequest.CodInst, CurrRequest.CodApp, CurrRequest.MasterKey);
-            await dataService.recordCall(CurrRequest.CodInst, CurrRequest.CodApp, $"[POST][api/ticket/sendReq][{CurrRequest.MasterKey}]");
+            await dataService.recordCall(CurrRequest.CodInst, CurrRequest.CodApp, $"POST:api/ticket/sendReq:{CurrRequest.MasterKey}");
             return result;
         }
 

From 2c46dd90510947d4c256cd8ae5c43cb3421aad1e Mon Sep 17 00:00:00 2001
From: "Samuele E. Locatelli" <samuele@steamware.net>
Date: Wed, 17 Nov 2021 19:14:18 +0100
Subject: [PATCH 14/14] Fix comportamento inserimento su DB statistiche
 chaimate

---
 LiMan.DB/Controllers/DbController.cs | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/LiMan.DB/Controllers/DbController.cs b/LiMan.DB/Controllers/DbController.cs
index 5dd4786..d108ec5 100644
--- a/LiMan.DB/Controllers/DbController.cs
+++ b/LiMan.DB/Controllers/DbController.cs
@@ -701,22 +701,18 @@ namespace LiMan.DB.Controllers
             bool fatto = false;
             using (LMDbContext localDbCtx = new LMDbContext(_configuration))
             {
-                // !!!FixMe provare se va
-                if (true)
+                // cerco record esistente...
+                var currRec = localDbCtx
+                                .DbSetLogCall
+                                .Where(x => x.CodApp == currRequest.CodApp && x.CodInst == currRequest.CodInst && x.DataRif == currRequest.DataRif && x.TargetUrl == currRequest.TargetUrl)
+                                .FirstOrDefault();
+                if (currRec != null)
                 {
-                    localDbCtx.Update(currRequest);
+                    // se trovo aggiorno
+                    currRec.NumCall = currRequest.NumCall;
                 }
                 else
                 {
-                    // cerco record esistente...
-                    var currRec = localDbCtx
-                                    .DbSetLogCall
-                                    .Where(x => x.CodApp == currRequest.CodApp && x.CodInst == currRequest.CodInst && x.DataRif == currRequest.DataRif && x.TargetUrl == currRequest.TargetUrl)
-                                    .FirstOrDefault();
-
-                    // se trovo aggiorno
-                    currRec.NumCall = currRequest.NumCall;
-
                     //altrimenti aggiungo
                     localDbCtx
                         .DbSetLogCall
