using EgwCoreLib.Utils;
using MailKit.Search;
using Microsoft.AspNetCore.Identity.UI.Services;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using NLog;
using Org.BouncyCastle.Asn1.Pkcs;
using StackExchange.Redis;
using System.Diagnostics;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Cryptography;
using System.Text;
using WebDoorCreator.Core;
using WebDoorCreator.Data.Controllers;
using WebDoorCreator.Data.DbModels;
using WebDoorCreator.Data.DTO;

namespace WebDoorCreator.Data.Services
{
    public class WebDoorCreatorService
    {
        #region Public Fields

        public static WebDoorCreatorController dbController = null!;

        #endregion Public Fields

        #region Public Constructors

        public WebDoorCreatorService(IConfiguration configuration, IConnectionMultiplexer redisConnMult, IEmailSender emailSender)
        {
            Log.Info("WebDoorCreatorService starting...");
            _configuration = configuration;
            _emailSender = emailSender;
            // Conf cache
            redisConn = redisConnMult;
            redisDb = this.redisConn.GetDatabase();

            // json serializer... FIX errore loop circolare https://www.ryadel.com/en/jsonserializationexception-self-referencing-loop-detected-error-fix-entity-framework-asp-net-core/
            JSSettings = new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
            };

            // cod app
            CodApp = _configuration["CodApp"];
            // Conf DB
            string connStr = _configuration.GetConnectionString("WDC.DB");
            if (string.IsNullOrEmpty(connStr))
            {
                Log.Info("ConnString empty!");
            }
            else
            {
                dbController = new WebDoorCreatorController(configuration);
            }
            // conf log
            logTimingEnable = configuration.GetValue<bool>("RuntimeOpt:LogTimingEnable");
            statSampleSize = configuration.GetValue<int>("RuntimeOpt:StatSampleSize");
            // conf serializzatore DDF...
            string vers = _configuration.GetValue<string>("ConfDDF:VersNumber");
            bool remDoorOp = _configuration.GetValue<bool>("ConfDDF:RemoveDoorOps");
            var headRows = _configuration.GetSection("ConfDDF:Header").Get<List<string>>();
            var footRows = _configuration.GetSection("ConfDDF:Footer").Get<List<string>>();
            currDdfConv = new DDF.Converter(vers, remDoorOp, headRows, footRows);
            // chiudo log
            Log.Info("WebDoorCreatorService started!");
        }

        #endregion Public Constructors

        #region Public Properties

        public string CodApp { get; set; } = "";

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Update company
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> CompanyAddMod(CompanyModel currRec)
        {
            var dbResult = await dbController.CompanyAddMod(currRec);
            try
            {
                // elimino cache redis...
                RedisValue pattern = new RedisValue($"{Constants.rKeyCompany}");
                bool answ = await ExecFlushRedisPattern(pattern);
                await Task.Delay(1);
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during CompanyAddMod: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Company list filtered by company id
        /// </summary>
        /// <param name="id">Id to filter (0=ALL)</param>
        /// <returns></returns>
        public async Task<List<CompanyModel>> CompanyGetByKey(int id)
        {
            string source = "DB";
            List<CompanyModel> dbResult = new List<CompanyModel>();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyCompany}:{id}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<CompanyModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<CompanyModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.CompanyGetByKey(id);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<CompanyModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"CompanyGetAll | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during CompanyGetByKey: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Conta i componenti missing presenti sul DB ma non su FS
        /// </summary>
        /// <param name="defaultPath"></param>
        /// <returns></returns>
        public async Task<int> CompoCountMissing(string defaultPath)
        {
            await Task.Delay(1);
            int numMissing = 0;
            // ciclo x tutti gli oggetti "FOLDER" della tabella
            try
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                // recupero dizionario componenti - directory
                Dictionary<string, string> DictCompoDir = getCompoDict(defaultPath);
                var listTemplate = await ListValuesGetAll("*", "template");
                if (listTemplate != null && listTemplate.Count > 0)
                {
                    // ciclo elenco template...
                    foreach (var item in listTemplate)
                    {
                        string fPath = Path.Combine(defaultPath, item.TableName, item.Value);
                        if (DictCompoDir.ContainsKey(item.TableName))
                        {
                            fPath = Path.Combine(DictCompoDir[item.TableName], item.Value);
                        }
                        // se non contiene "." aggiungo ".lua"
                        if (!item.Label.Contains("."))
                        {
                            fPath += ".lua";
                        }
                        // controllo se esiste...
                        if (!File.Exists(fPath))
                        {
                            numMissing++;
                            Log.Debug($"Found missing file: {fPath}");
                        }
                    }
                }
                sw.Stop();
                TimeSpan ts = sw.Elapsed;
                Log.Debug($"CompoCountMissing in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during CompoCountMissing: {exc}{Environment.NewLine}");
            }
            return numMissing;
        }

        /// <summary>
        /// Conta i componenti missing presenti sul DB ma non su FS
        /// </summary>
        /// <param name="defaultPath"></param>
        /// <returns></returns>
        public async Task<bool> CompoFixMissing(string defaultPath)
        {
            bool fixDone = false;
            int numFixed = 0;
            await Task.Delay(1);
            // ciclo x tutti gli oggetti "FOLDER" della tabella
            try
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                // recupero dizionario componenti - directory
                Dictionary<string, string> DictCompoDir = getCompoDict(defaultPath);
                var listTemplate = await ListValuesGetAll("*", "template");
                if (listTemplate != null && listTemplate.Count > 0)
                {
                    // ciclo elenco template...
                    foreach (var item in listTemplate)
                    {
                        string fPath = Path.Combine(defaultPath, item.TableName, item.Value);
                        if (DictCompoDir.ContainsKey(item.TableName))
                        {
                            fPath = Path.Combine(DictCompoDir[item.TableName], item.Value);
                        }
                        // se non contiene "." aggiungo ".lua"
                        if (!item.Label.Contains("."))
                        {
                            fPath += ".lua";
                        }
                        // controllo se esiste...
                        if (!File.Exists(fPath))
                        {
                            var fDir = Path.GetDirectoryName(fPath); 
                            // verifico directory...
                            if(!Directory.Exists(fDir))
                            {
                                Directory.CreateDirectory(fDir);
                            }
                            // creo file...
                            var newFile = File.Create(fPath);
                            Log.Info($"Created missing file: {fPath}");
                            newFile.Close();
                            numFixed++;
                        }
                    }
                }
                sw.Stop();
                TimeSpan ts = sw.Elapsed;
                Log.Debug($"CompoFixMissing | {numFixed} fixed in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during CompoFixMissing: {exc}{Environment.NewLine}");
            }
            fixDone = numFixed > 0;
            return fixDone;
        }

        /// <summary>
        /// Getting a list of all the active components
        /// </summary>
        /// <param name="rootPath">Path to start</param>
        /// <returns></returns>
        public async Task<List<string>> CompoGetAllActive(string rootPath)
        {
            await Task.Delay(1);
            List<string> listActiveCompo = new List<string>();

            try
            {
                //estraggo la lista di componenti che sono attive per il cliente
                IniFile fIni = new IniFile(rootPath);
                string compoDDF = fIni.ReadString("CompoOrder", "CompoDDFOrder", "CONFIG");
                var compoDDFList = compoDDF.Split(",");
                foreach (string compo in compoDDFList)
                {
                    listActiveCompo.Add(compo.Trim());
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during CompoGetAllActive: {exc}{Environment.NewLine}");
            }
            return listActiveCompo;
        }

        /// <summary>
        /// Setting all the component list
        /// </summary>
        /// <param name="rootPath">Path to start</param>
        /// <returns></returns>
        public async Task<bool> CompoListSetAll(string rootPath)
        {
            bool fatto = false;
            string compoName = "";
            string sizeVal = "";
            List<GraphicParamsModel> listGraphicParams = new List<GraphicParamsModel>();
            List<ListValuesTempModel> listValues = new List<ListValuesTempModel>();
            ListValuesTempModel Values = new ListValuesTempModel();

            try
            {
                List<string> listActiveCompo = await CompoGetAllActive(Path.Combine(rootPath, @"Default.ini"));
                List<HardwareModel> listCompoS = new List<HardwareModel>();
                // estraggo tutte le sotto directory della cartella \EgtData\Doors\EgtCompoBase\Compo
                string[] dirs = Directory.GetDirectories(rootPath, "*", SearchOption.TopDirectoryOnly);

                // elenco obj da inserire
                List<DoorOpTypeModel> ListObjDOT = new List<DoorOpTypeModel>();

                string[] DefaultFile = Directory.GetFiles(rootPath, "Default.ini");

                IniFile fIniDef = new IniFile(DefaultFile[0]);

                ListValuesTempModel listValObj = new ListValuesTempModel()
                {
                    TableName = "Properties",
                    FieldName = "DoorDef",
                    Value = "Properties",
                    Label = "Properties",
                    Ordinal = 1,
                    DefaultVal = "Maple, Oak, Pine, Birch, Walnut",
                    InputType = ""
                };
                listValues.Add(listValObj);

                listValObj = new ListValuesTempModel()
                {
                    TableName = "Finishing",
                    FieldName = "DoorDef",
                    Value = "Finishing",
                    Label = "Finishing",
                    Ordinal = 1,
                    DefaultVal = "Varnishing, Veneer",
                    InputType = ""
                };
                listValues.Add(listValObj);

                listValObj = new ListValuesTempModel()
                {
                    TableName = "All",
                    FieldName = "OrderStep",
                    Value = "10",
                    Label = "Door Draft",
                    Ordinal = 10,
                    DefaultVal = "#EF6C00",
                    InputType = ""
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "All",
                    FieldName = "OrderStep",
                    Value = "20",
                    Label = "Sent to DCA",
                    Ordinal = 20,
                    DefaultVal = "#FBC02D",
                    InputType = ""
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "All",
                    FieldName = "OrderStep",
                    Value = "30",
                    Label = "Approved By Maker",
                    Ordinal = 30,
                    DefaultVal = "#2962FF",
                    InputType = ""
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "All",
                    FieldName = "OrderStep",
                    Value = "40",
                    Label = "Approved By Customer",
                    Ordinal = 40,
                    DefaultVal = "#673AB7",
                    InputType = ""
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "All",
                    FieldName = "OrderStep",
                    Value = "50",
                    Label = "ERP",
                    Ordinal = 50,
                    DefaultVal = "#00B8D4",
                    InputType = ""
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "All",
                    FieldName = "OrderStep",
                    Value = "60",
                    Label = "In Production",
                    Ordinal = 60,
                    DefaultVal = "#43A047",
                    InputType = ""
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "All",
                    FieldName = "OrderStep",
                    Value = "70",
                    Label = "Delivered",
                    Ordinal = 70,
                    DefaultVal = "#AEEA00",
                    InputType = ""
                };

                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "All",
                    FieldName = "DoorDefStep",
                    Value = "10",
                    Label = "Door",
                    Ordinal = 10,
                    DefaultVal = "#448AFF",
                    InputType = ""
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "All",
                    FieldName = "DoorDefStep",
                    Value = "20",
                    Label = "Hardware",
                    Ordinal = 20,
                    DefaultVal = "#448AFF",
                    InputType = ""
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "All",
                    FieldName = "DoorDefStep",
                    Value = "30",
                    Label = "Report",
                    Ordinal = 30,
                    DefaultVal = "#448AFF",
                    InputType = ""
                };
                listValues.Add(listValObj);

                // parto con obj base
                sizeVal = fIniDef.ReadString("Size", "Width", "0.0");

                listValObj = new ListValuesTempModel()
                {
                    TableName = "Size",
                    FieldName = "DoorDef",
                    Value = "Width",
                    Label = "50001",
                    Ordinal = 1,
                    DefaultVal = sizeVal,
                    InputType = "TextBox",
                    isSerializable = true
                };
                listValues.Add(listValObj);
                sizeVal = fIniDef.ReadString("Size", "Height", "0.0");
                listValObj = new ListValuesTempModel()
                {
                    TableName = "Size",
                    FieldName = "DoorDef",
                    Value = "Height",
                    Label = "50002",
                    Ordinal = 2,
                    DefaultVal = sizeVal,
                    InputType = "TextBox",
                    isSerializable = true
                };
                listValues.Add(listValObj);
                sizeVal = fIniDef.ReadString("Size", "Thickness", "0.0");
                listValObj = new ListValuesTempModel()
                {
                    TableName = "Size",
                    FieldName = "DoorDef",
                    Value = "Thickness",
                    Label = "50003",
                    Ordinal = 3,
                    DefaultVal = sizeVal,
                    InputType = "TextBox",
                    isSerializable = true
                };
                listValues.Add(listValObj);
                sizeVal = fIniDef.ReadString("Size", "SwingList", "UNDEF");
                listValObj = new ListValuesTempModel()
                {
                    TableName = "Swing",
                    FieldName = "DoorDef",
                    Value = "Swing",
                    Label = "50004",
                    Ordinal = 1,
                    DefaultVal = sizeVal,
                    InputType = "TextBox",
                    isSerializable = true
                };
                listValues.Add(listValObj);
                //sizeVal = fIniDef.ReadString("Edge", "EdgeTypeList", "UNDEF");
                StringBuilder edgesList = new StringBuilder();
                for (int x = 1; x <= 11; x++)
                {
                    var edge = fIniDef.ReadString("Edge", $"EdgeType{x}", "UNDEF");
                    if (x != 11)
                    {
                        edgesList.Append($"{edge.Split("/")[0]},");
                    }
                    else
                    {
                        edgesList.Append($"{edge.Split("/")[0]}");
                    }
                }
                listValObj = new ListValuesTempModel()
                {
                    TableName = "Profiles",
                    FieldName = "DoorDef",
                    Value = "lockedge",
                    Label = "50005",
                    Ordinal = 1,
                    DefaultVal = "",
                    InputType = "",
                    isSerializable = true
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "Profiles",
                    FieldName = "DoorDef",
                    Value = "hingeedge",
                    Label = "50006",
                    Ordinal = 2,
                    DefaultVal = "",
                    InputType = "",
                    isSerializable = true
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "Profiles",
                    FieldName = "DoorDef",
                    Value = "top",
                    Label = "50007",
                    Ordinal = 3,
                    DefaultVal = "",
                    InputType = "",
                    isSerializable = true
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "Profiles",
                    FieldName = "DoorDef",
                    Value = "bottom",
                    Label = "50008",
                    Ordinal = 4,
                    DefaultVal = "",
                    InputType = "",
                    isSerializable = true
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "Profiles",
                    FieldName = "DoorDef",
                    Value = "type",
                    Label = "50424",
                    Ordinal = 5,
                    DefaultVal = edgesList.ToString(),
                    InputType = "ComboBox",
                    isSerializable = true
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "Profiles",
                    FieldName = "DoorDef",
                    Value = "machining",
                    Label = "90312",
                    Ordinal = 6,
                    DefaultVal = "ON,OFF",
                    InputType = "ComboBox",
                    isSerializable = true
                };
                listValues.Add(listValObj);
                listValObj = new ListValuesTempModel()
                {
                    TableName = "Profiles",
                    FieldName = "DoorDef",
                    Value = "overmaterial",
                    Label = "90312",
                    Ordinal = 7,
                    DefaultVal = "0.1",
                    InputType = "ComboBox",
                    isSerializable = true
                };
                listValues.Add(listValObj);
                int i = 0;

                foreach (string dir in dirs)
                {
                    int numPar = 1;
                    int numHead = 1;
                    // scansione della directory...
                    string[] files = Directory.GetFiles(dir, "Config.ini");
                    compoName = "";
                    //iterazione per cercare tutti numPar file "Config.ini" nelle sotto directory
                    foreach (string file in files)
                    {
                        //leggo tutte le linee del file
                        List<string> lines = File.ReadAllLines(file).ToList();
                        IniFile fIni = new IniFile(file);
                        Guid opCode = Guid.NewGuid();
                        //cerco la sezione del file ed estraggo il nome del componente
                        compoName = fIni.ReadString("Compo", "Name", "COMPONAME");
                        //cerco la sezione del file ed estraggo se numPar template sono attivi per il seguente componente
                        var isActive = fIni.ReadString("Template", "IsActive", "1");
                        string layerName = fIni.ReadString("Layer", "LayerName", "LAYER");
                        // lo slash indica l'alias
                        var compoNameSplit = compoName.Split("/");

                        var compoAcArray = listActiveCompo.ToArray();
                        var x = Array.FindIndex(compoAcArray, row => row == compoNameSplit[0]);

                        if (listActiveCompo.Contains(compoNameSplit[0].ToString()))
                        {
                            //creo il componente (padre)
                            listValObj = new ListValuesTempModel()
                            {
                                TableName = $"{compoNameSplit[0]}".Trim(),
                                FieldName = "Hardware",
                                Value = $"{compoNameSplit[0]}",
                                Label = $"{compoNameSplit[1]}",
                                Ordinal = x,
                                DefaultVal = " ",
                                InputType = " "
                            };
                            //HardwareModel compoConfig = new HardwareModel() { compoName = $"{compoNameSplit[0]}", compoAlias = compoNameSplit[1].ToString(), compoLayerName = layerName, compoTemplateIsActive = compoTemplateIsActive };
                            //await dbController.CompoAdd(compoConfig);
                            //listCompoS.Add(compoConfig);
                            listValues.Add(listValObj);
                            i++;
                            //cerco all'interno del file tutte le sezioni che contengono "[Graphic" così da poter prendere il nome della sezione ES: [Graphic parameters1] = Graphic parameters1
                            var lineToSearch = lines.Where(x => x.Contains("[Graphic")).ToList();
                            numHead = 1;
                            foreach (var match in lineToSearch)
                            {
                                var listV = await GraphicParamsGetAll(file, match, numHead, numPar, $"{compoNameSplit[0]}");

                                foreach (var item in listV)
                                {
                                    listValues.Add(item);
                                }

                                numHead++;
                            }
                            numPar++;
                        }
                    }
                }

                fatto = await dbController.ListValuesAdd(listValues);
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during CompoListSetAll: {exc}{Environment.NewLine}");
            }

            return fatto;
        }

        /// <summary>
        /// Lista configurazione
        /// </summary>
        /// <returns></returns>
        public async Task<List<ConfigModel>> ConfigGetAll()
        {
            string source = "DB";
            List<ConfigModel>? dbResult = new List<ConfigModel>();
            try
            {
                string currKey = $"{Constants.rKeyConfig}:Table";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<ConfigModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<ConfigModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.ConfigGetAll();
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<ConfigModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"ConfigGetAll | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"ConfigGetAll during CompoListSetAll: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Recupera una singola chaive di config da cache/DB
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public async Task<ConfigModel?> ConfigGetKey(string chiave)
        {
            string source = "DB";
            // cerco in cache direttamente la chiave... altrimenti da redis/db
            ConfigModel? keyResult = null;
            try
            {
                string currKey = $"{Constants.rKeyConfig}:Dict:{chiave}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<ConfigModel>(rawData);
                    if (tempResult == null)
                    {
                        keyResult = new ConfigModel();
                    }
                    else
                    {
                        keyResult = tempResult;
                    }
                    keyResult = JsonConvert.DeserializeObject<ConfigModel>(rawData);
                }
                else
                {
                    var listConfig = await ConfigGetAll();
                    keyResult = listConfig.FirstOrDefault(x => x.chiave == chiave);
                    rawData = JsonConvert.SerializeObject(keyResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"ConfigGetKey | {chiave} | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during ConfigGetKey: {exc}{Environment.NewLine}");
            }
            return await Task.FromResult(keyResult);
        }

        public async Task<int> createDoor(int idOrd, string userId, string currMeaUnit)
        {
            int answ = 0;
            try
            {
                // conto le porte x questo ordine e uso x chiamata successiva...
                var door4ord = await DoorGetByOrderId(idOrd);
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                int numDoors = door4ord?.Count + 1 ?? 1;
                List<DoorOpModel> listOp = new List<DoorOpModel>();
                DateTime adesso = DateTime.Now;
                // creo una nuova porta...
                DoorModel newDoor = new DoorModel()
                {
                    OrderId = idOrd,
                    MeasureUnit = currMeaUnit,
                    UserIdIns = userId,
                    UserIdMod = userId,
                    UserIdLock = userId,
                    DateIns = adesso,
                    DateMod = adesso,
                    DateLockExpiry = adesso.AddHours(1),
                    DoorDescript = $"ORD {idOrd} | Door {numDoors:00}",
                    DoorExtCode = $"ORD {idOrd} | Ext Code --",
                    Quantity = 1,
                    UnitCost = 0,
                    ParentId = 1
                };
                // chiamo metodo x insert...
                var doorId = await DoorInsert(newDoor);
                // aggiungo le lavorazioni standard...
                var doorOpList = await DoorOpGetDefault();
                var listRecordEdge = await ListValuesGetAll("Profiles", "DoorDef");
                var listRecordSizing = await ListValuesGetAll("Size", "DoorDef");
                var listRecordSwing = await ListValuesGetAll("Swing", "DoorDef");
                var listRecordProperties = await ListValuesGetAll("Properties", "DoorDef");
                var listRecordFinishing = await ListValuesGetAll("Finishing", "DoorDef");
                ListValuesModel? profCurrType = null;
                ListValuesModel? profCurrMach = null;
                ListValuesModel? profCurrOverMat = null;
                if (listRecordEdge != null)
                {
                    profCurrType = listRecordEdge.Where(x => x.Value == "type").FirstOrDefault();
                    profCurrMach = listRecordEdge.Where(x => x.Value == "machining").FirstOrDefault();
                    profCurrOverMat = listRecordEdge.Where(x => x.Value == "overmaterial").FirstOrDefault();
                }
                Dictionary<string, Dictionary<string, List<string>>> itemsDictDef = new Dictionary<string, Dictionary<string, List<string>>>();
                Dictionary<string, Dictionary<string, string>> itemsDictAct = new Dictionary<string, Dictionary<string, string>>();
                Dictionary<string, List<string>> paramsDict = new Dictionary<string, List<string>>();
                Dictionary<string, string> actDict = new Dictionary<string, string>();
                List<string> listDefVal = new List<string>();
                List<string> listDefValCurrMach = new List<string>();
                List<string> listDefValOverMat = new List<string>();
                List<string> defaultParamsList = new List<string>();

                #region Gestione Properties

                if (listRecordProperties != null)
                {
                    foreach (var item in listRecordProperties)
                    {
                        foreach (var param in item.DefaultVal.Split(","))
                        {
                            listDefVal.Add(param.Trim());
                            if (!actDict.ContainsKey(item.Value))
                            {
                                actDict.Add(item.Value, item.DefaultVal.Trim().Split(",")[0]);
                                paramsDict.Add(item.Value, listDefVal);
                            }
                            //itemsDict.Add(itemOld.Value, paramsDict);
                            //paramsDict.Clear();
                        }

                        //listDefVal = new List<string>() { itemOld.DefaultVal.Trim() };
                    }
                    itemsDictDef.Add("Properties", paramsDict);
                    itemsDictAct.Add("Properties", actDict);
                    //defaultParamsList.Add(listDefVal);
                }
                var jsonDef = JsonConvert.SerializeObject(itemsDictDef);
                var jsonAct = JsonConvert.SerializeObject(itemsDictAct);

                DoorOpModel doorOpToAdd = new DoorOpModel()
                {
                    DateIns = adesso,
                    DateMod = adesso,
                    UserIdIns = userId,
                    UserIdMod = userId,
                    ObjectId = "Properties",
                    DoorId = doorId,
                    JsoncConfigVal = jsonDef,
                    JsoncActVal = jsonAct,
                    userConfirm = userId,
                    DtConfirm = adesso
                };
                listOp.Add(doorOpToAdd);

                #endregion Gestione Properties

                paramsDict.Clear();
                actDict.Clear();
                itemsDictDef.Clear();
                itemsDictAct.Clear();
                listDefVal.Clear();

                #region Gestione Finishing

                if (listRecordFinishing != null)
                {
                    foreach (var item in listRecordFinishing)
                    {
                        foreach (var param in item.DefaultVal.Split(","))
                        {
                            listDefVal.Add(param.Trim());
                            if (!actDict.ContainsKey(item.Value))
                            {
                                actDict.Add(item.Value, item.DefaultVal.Trim().Split(",")[0]);
                                paramsDict.Add(item.Value, listDefVal);
                            }
                            //itemsDict.Add(itemOld.Value, paramsDict);
                            //paramsDict.Clear();
                        }

                        //listDefVal = new List<string>() { itemOld.DefaultVal.Trim() };
                    }
                    itemsDictDef.Add("Finishing", paramsDict);
                    itemsDictAct.Add("Finishing", actDict);
                    //defaultParamsList.Add(listDefVal);
                }
                jsonDef = JsonConvert.SerializeObject(itemsDictDef);
                jsonAct = JsonConvert.SerializeObject(itemsDictAct);

                doorOpToAdd = new DoorOpModel()
                {
                    DateIns = adesso,
                    DateMod = adesso,
                    UserIdIns = userId,
                    UserIdMod = userId,
                    ObjectId = "Finishing",
                    DoorId = doorId,
                    JsoncConfigVal = jsonDef,
                    JsoncActVal = jsonAct,
                    userConfirm = userId,
                    DtConfirm = adesso
                };
                listOp.Add(doorOpToAdd);

                #endregion Gestione Finishing

                paramsDict.Clear();
                actDict.Clear();
                itemsDictDef.Clear();
                itemsDictAct.Clear();
                listDefVal.Clear();

                #region Gestione sizing

                if (listRecordSizing != null)
                {
                    foreach (var item in listRecordSizing)
                    {
                        listDefVal = new List<string>() { item.DefaultVal.Trim() };
                        if (!actDict.ContainsKey(item.Value))
                        {
                            actDict.Add(item.Value, item.DefaultVal.Trim());
                            paramsDict.Add(item.Value, listDefVal);
                        }
                    }
                    itemsDictDef.Add("Size", paramsDict);
                    itemsDictAct.Add("Size", actDict);
                    //defaultParamsList.Add(listDefVal);
                }
                jsonDef = JsonConvert.SerializeObject(itemsDictDef);
                jsonAct = JsonConvert.SerializeObject(itemsDictAct);

                doorOpToAdd = new DoorOpModel()
                {
                    DateIns = adesso,
                    DateMod = adesso,
                    UserIdIns = userId,
                    UserIdMod = userId,
                    ObjectId = "Size",
                    DoorId = doorId,
                    JsoncConfigVal = jsonDef,
                    JsoncActVal = jsonAct,
                    userConfirm = userId,
                    DtConfirm = adesso
                };
                listOp.Add(doorOpToAdd);

                #endregion Gestione sizing

                paramsDict.Clear();
                actDict.Clear();
                itemsDictDef.Clear();
                itemsDictAct.Clear();
                listDefVal.Clear();

                #region Gestione Swing

                if (listRecordSwing != null)
                {
                    foreach (var item in listRecordSwing)
                    {
                        foreach (var param in item.DefaultVal.Split(","))
                        {
                            listDefVal.Add(param.Trim());
                            if (!actDict.ContainsKey(item.Value))
                            {
                                actDict.Add(item.Value, item.DefaultVal.Trim().Split(",")[0]);
                                paramsDict.Add(item.Value, listDefVal);
                            }
                            //itemsDict.Add(itemOld.Value, paramsDict);
                            //paramsDict.Clear();
                        }

                        //listDefVal = new List<string>() { itemOld.DefaultVal.Trim() };
                    }
                    itemsDictDef.Add("Swing", paramsDict);
                    itemsDictAct.Add("Swing", actDict);
                    //defaultParamsList.Add(listDefVal);
                }
                jsonDef = JsonConvert.SerializeObject(itemsDictDef);
                jsonAct = JsonConvert.SerializeObject(itemsDictAct);

                doorOpToAdd = new DoorOpModel()
                {
                    DateIns = adesso,
                    DateMod = adesso,
                    UserIdIns = userId,
                    UserIdMod = userId,
                    ObjectId = "Swing",
                    DoorId = doorId,
                    JsoncConfigVal = jsonDef,
                    JsoncActVal = jsonAct,
                    userConfirm = userId,
                    DtConfirm = adesso
                };
                listOp.Add(doorOpToAdd);

                #endregion Gestione Swing

                paramsDict.Clear();
                actDict.Clear();
                itemsDictDef.Clear();
                itemsDictAct.Clear();
                listDefVal.Clear();

                #region Gestione Profiles

                if (listRecordEdge != null)
                {
                    listDefVal.Clear();
                    if (profCurrType != null)
                    {
                        foreach (var param in profCurrType.DefaultVal.Split(","))
                        {
                            listDefVal.Add(param.Trim());
                            if (!actDict.ContainsKey(profCurrType.Value))
                            {
                                actDict.Add(profCurrType.Value, param.Trim());
                                paramsDict.Add(profCurrType.Value, listDefVal);
                                //listDefVal.Clear();
                            }
                            //itemsDict.Add(itemOld.Value, paramsDict);
                            //paramsDict.Clear();
                        }
                        if (profCurrMach != null)
                        {
                            //listDefVal.Clear();
                            foreach (var param in profCurrMach.DefaultVal.Split(","))
                            {
                                listDefValCurrMach.Add(param.Trim());
                                if (!actDict.ContainsKey(profCurrMach.Value))
                                {
                                    paramsDict.Add(profCurrMach.Value, listDefValCurrMach);
                                    actDict.Add(profCurrMach.Value, profCurrMach.DefaultVal.Trim().Split(",")[0]);
                                    //listDefVal.Clear();
                                }
                                //itemsDict.Add(itemOld.Value, paramsDict);
                                //paramsDict.Clear();
                            }
                        }
                        if (profCurrOverMat != null)
                        {
                            //listDefVal.Clear();
                            if (!paramsDict.ContainsKey(profCurrOverMat.Value))
                            {
                                listDefValOverMat.Add(profCurrOverMat.DefaultVal.Trim());
                                paramsDict.Add(profCurrOverMat.Value, listDefValOverMat);
                                actDict.Add(profCurrOverMat.Value, profCurrOverMat.DefaultVal.Trim());
                            }
                        }
                    }
                    foreach (var item in listRecordEdge.Where(x => x.Value != "type" && x.Value != "machining" && x.Value != "overmaterial"))
                    {
                        if (!itemsDictDef.ContainsKey(item.Value))
                        {
                            itemsDictDef.Add(item.Value, paramsDict);
                        }
                        if (!itemsDictAct.ContainsKey(item.Value))
                        {
                            itemsDictAct.Add(item.Value, actDict);
                        }
                        //defaultParamsList.Add(listDefVal);
                        //defaultDict.Add(itemOld.Label, listDefVal);
                    }
                }
                //actDict.Add(HwToShow.TableName, actParamsList);

                jsonDef = JsonConvert.SerializeObject(itemsDictDef);
                jsonAct = JsonConvert.SerializeObject(itemsDictAct);

                doorOpToAdd = new DoorOpModel()
                {
                    DateIns = adesso,
                    DateMod = adesso,
                    UserIdIns = userId,
                    UserIdMod = userId,
                    ObjectId = "Profiles",
                    DoorId = doorId,
                    JsoncConfigVal = jsonDef,
                    JsoncActVal = jsonAct,
                    userConfirm = userId,
                    DtConfirm = adesso
                };
                listOp.Add(doorOpToAdd);

                #endregion Gestione Profiles

                // salvo Door OP associate
                bool fatto = await DoorOpInsert(doorId, listOp);

                if (fatto)
                {
                    answ = doorId;
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"createDoor | {doorId}  in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during createDoor: {exc}{Environment.NewLine}");
            }
            return answ;
        }

        public string DecriptData(string encData)
        {
            return SteamCrypto.DecryptString(encData, Constants.passPhrase);
        }

        /// <summary>
        /// Clone a copy of the door in the specified order
        /// </summary>
        /// <param name="doorId">Record id to edit or add</param>
        /// <param name="doorCode">Code associated to door</param>
        /// <param name="doorDescr">Description for the door</param>
        /// <param name="orderId">Destination order where door must be placed</param>
        /// <param name="userName">userName for cloning</param>
        /// <param name="isClone">
        /// true = cloning a door and save TypeId from orig, false = save to template order
        /// </param>
        /// <returns></returns>
        public async Task<int> DoorCloneToOrder(int doorId, string doorCode, string doorDescr, int orderId, string userName, bool isClone)
        {
            int newDoorId = 0;
            var doorOps2Add = new List<DoorOpModel>();
            try
            {
                var CurrDoor = await DoorGetByKey(doorId);
                var DoorOpsList = await DoorOpGetByDoorId(doorId);
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                if (DoorOpsList != null)
                {
                    var doorOps2Clone = DoorOpsList?.Where(x => x.DoorId == doorId).ToList();
                    //var door2Clone = CurrDoor;
                    if (CurrDoor != null)
                    {
                        var doorToAdd = CurrDoor.ObjClone(userName);
                        // imposto dati per la porta...
                        doorToAdd.OrderId = orderId;
                        doorToAdd.ParentId = isClone ? CurrDoor.DoorId : 1;
                        doorToAdd.Quantity = 1;
                        doorToAdd.DoorExtCode = doorCode;
                        doorToAdd.DoorDescript = doorDescr;
                        // salvo!
                        newDoorId = await DoorInsert(doorToAdd);
                        if (newDoorId != 0 && doorOps2Clone != null)
                        {
                            foreach (var item in doorOps2Clone)
                            {
                                var doorOp2Add = item.ObjClone(userName, newDoorId);
                                doorOps2Add.Add(doorOp2Add);
                            }
                            // salvo!
                            await DoorOpInsert(newDoorId, doorOps2Add);
                        }
                    }
                }

                // await dbController.DoorModQty(NewQty, doorId, isAdd); svuoto cache
                await DoorFlushCache(doorId);
                await DoorOpFlushCache(doorId);
                await OrderDetailFlushCache(orderId);
                await OrdersFlushCache();
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorCloneToOrder | {doorId} | {orderId} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorCloneToOrder: {exc}{Environment.NewLine}");
            }
            return newDoorId;
        }

        /// <summary>
        /// CElimina record posta
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> DoorDelete(DoorModel currRec)
        {
            bool answ = false;
            try
            {
                int DoorId = currRec.DoorId;
                int OrderId = currRec.OrderId;
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                // elimino sul DB
                answ = await dbController.DoorDelete(DoorId);
                // svuoto cache
                await DoorFlushCache(DoorId);
                await DoorOpFlushCache(DoorId);
                await OrderDetailFlushCache(OrderId);
                await OrdersFlushCache();
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorDelete | {DoorId} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorDelete: {exc}{Environment.NewLine}");
            }
            return answ;
        }

        /// <summary>
        /// Clean redis DOORS cache
        /// </summary>
        /// <param name="DoorId">0 = all</param>
        /// <returns></returns>
        public async Task<bool> DoorFlushCache(int DoorId)
        {
            bool answ = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                RedisValue pattern = new RedisValue($"{Constants.rKeyDoor}:*");
                if (DoorId > 0)
                {
                    pattern = new RedisValue($"{Constants.rKeyDoor}:{DoorId}:*");
                }
                answ = await ExecFlushRedisPattern(pattern);
                pattern = new RedisValue($"{Constants.rKeyDoorsByOrder}:*");
                answ = await ExecFlushRedisPattern(pattern);
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorDelete | {DoorId} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorFlushCache: {exc}{Environment.NewLine}");
            }
            return answ;
        }

        /// <summary>
        /// Doors key (DoorId)
        /// </summary>
        public async Task<List<DoorModel>?> DoorGet2Del()
        {
            List<DoorModel>? dbResult = new List<DoorModel>();
            try
            {
                Stopwatch sw = new Stopwatch();
                if (logTimingEnable)
                {
                    sw.Start();
                }
                dbResult = dbController.DoorGet2Del();
                if (dbResult == null)
                {
                    dbResult = new List<DoorModel>();
                }
                if (logTimingEnable)
                {
                    sw.Stop();
                    // gestione statistiche
                    await ProcStatLog("DoorGet2Del", sw.Elapsed, 2, 1);
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorGet2Del: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Doors key (DoorId)
        /// </summary>
        public async Task<DoorModel?> DoorGetByKey(int doorId)
        {
            string source = "DB";
            DoorModel? dbResult = new DoorModel();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyDoor}:Single:{doorId}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<DoorModel>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new DoorModel();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.DoorGetByKey(doorId);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new DoorModel();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorGetByKey | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorGetByKey: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Doors list by numRec
        /// </summary>
        public async Task<List<DoorModel>?> DoorGetByOrderId(int orderId)
        {
            string source = "DB";
            List<DoorModel>? dbResult = new List<DoorModel>();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyDoorsByOrder}:{orderId}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<DoorModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<DoorModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.DoorsGetByOrderId(orderId);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<DoorModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorGetByOrderId | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorGetByOrderId: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Doors list, last in desc order
        /// </summary>
        public async Task<List<DoorModel>?> DoorGetLast(int numRec)
        {
            string source = "DB";
            List<DoorModel>? dbResult = new List<DoorModel>();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyDoorLast}:{numRec}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<DoorModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<DoorModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.DoorsGetLast(numRec);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, FastCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<DoorModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorGetLast | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorGetLast: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Add door
        /// </summary>
        /// <param name="newRec"></param>
        /// <returns></returns>
        public async Task<int> DoorInsert(DoorModel newRec)
        {
            int dbResult = 0;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = await dbController.DoorInsert(newRec);
                // elimino cache redis dati ordine...
                await OrderDetailFlushCache(newRec.OrderId);
                await OrdersFlushCache();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorInsert | {newRec.DoorId} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorInsert: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Eliminazione DoorOP
        /// </summary>
        /// <param name="currDoorOp"></param>
        /// <returns></returns>
        public async Task<bool> DoorOpDelete(DoorOpModel currDoorOp)
        {
            bool dbResult = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = await dbController.DoorOpDelete(currDoorOp);
                // elimino cache redis dati porta...
                bool answ = await DoorOpFlushCache(currDoorOp.DoorId);
                answ = answ && await DoorFlushCache(currDoorOp.DoorId);
                // elimino cache redis dati ordine...
                answ = answ && await OrdersFlushCache();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpDelete | {currDoorOp.DoorOpId} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpDelete: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Eliminazione DoorOP list
        /// </summary>
        /// <param name="currDoorOpList"></param>
        /// <returns></returns>
        public async Task<bool> DoorOpDeleteRange(List<DoorOpModel> currDoorOpList)
        {
            bool dbResult = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = await dbController.DoorOpDeleteRange(currDoorOpList);
                // elimino cache redis dati porta...
                foreach (var item in currDoorOpList)
                {
                    bool answ = await DoorOpFlushCache(item.DoorId);
                    answ = answ && await DoorFlushCache(item.DoorId);
                    // elimino cache redis dati ordine...
                    answ = answ && await OrdersFlushCache();
                }
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpDeleteRange in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpDeleteRange: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Clean redis DOORS OP cache
        /// </summary>
        /// <param name="DoorId">0 = all</param>
        /// <returns></returns>
        public async Task<bool> DoorOpFlushCache(int DoorId)
        {
            bool answ = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                RedisValue pattern = new RedisValue($"{Constants.rKeyDoorOp}*");
                if (DoorId > 0)
                {
                    pattern = new RedisValue($"{Constants.rKeyDoorOp}:{DoorId}*");
                }
                answ = await ExecFlushRedisPattern(pattern);
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpFlushCache in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpFlushCache: {exc}{Environment.NewLine}");
            }
            return answ;
        }

        /// <summary>
        /// Doors list by numRec
        /// </summary>
        public async Task<List<DoorOpModel>> DoorOpGetByDoorId(int DoorId)
        {
            string source = "DB";
            List<DoorOpModel>? dbResult = new List<DoorOpModel>();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyDoorOp}:{DoorId}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<DoorOpModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<DoorOpModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.DoorOpGetByDoorId(DoorId);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<DoorOpModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpGetByDoorId | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpFlushCache: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Doors list by numRec
        /// </summary>
        public async Task<DoorOpModel> DoorOpGetById(int doorOpId)
        {
            await Task.Delay(1);
            string source = "DB";
            DoorOpModel? dbResult = new DoorOpModel();
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = dbController.DoorOpGetById(doorOpId);
                if (dbResult == null)
                {
                    dbResult = new DoorOpModel();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpGetById | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpGetById: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Create DDF from doorId
        /// </summary>
        public async Task<string> DoorOpGetDDF(int DoorId)
        {
            string resultDDF = "";
            List<string> ordListVal = new List<string>();
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                var listOpAll = await DoorOpGetByDoorId(DoorId);
                if (listOpAll != null)
                {
                    List<DoorOpModel> listOp = listOpAll.Where(x => x.userConfirm != "" && x.DtConfirm != null).ToList();
                    if (listOp != null)
                    {
                        // chiamo metodo x avewre DDF serializzato
                        var CurrentCompoOrder = await ListValuesGetAll("*", "Hardware");
                        if (CurrentCompoOrder != null)
                        {
                            foreach (var item in CurrentCompoOrder.OrderBy(x => x.Ordinal).ToList())
                            {
                                ordListVal.Add(item.TableName);
                            }
                        }
                        // riordino
                        listOp = listOp.OrderBy(d => ordListVal.IndexOf(d.ObjectId)).ToList();
                        // converto in DDF!
                        resultDDF = currDdfConv.GetSerialized(listOp);
                    }
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpGetDDF | in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpGetDDF: {exc}{Environment.NewLine}");
            }
            return resultDDF;
        }

        /// <summary>
        /// lista DoorOpList necessarie all'init
        /// </summary>
        /// <returns></returns>
        public async Task<List<DoorOpTypeModel>> DoorOpGetDefault()
        {
            List<DoorOpTypeModel>? dbResult = new List<DoorOpTypeModel>();
            string source = "DB";
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyDoorOpType}:DEFAULT";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = await dbController.DoorOpTypeGetDefault();
                if (dbResult == null)
                {
                    dbResult = new List<DoorOpTypeModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpGetDefault | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpGetDefault: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Restitusice i CurrVals + GraphParams aggiornati dati valori Folder/template
        /// </summary>
        /// <param name="ObjectId">Obj x cui è richiesto il ricalcolo parametri</param>
        /// <param name="currVal">Dizionario dei valori attuali</param>
        /// <param name="currParams">Dizionario di obj x GraphParams</param>
        /// <returns></returns>
        public async Task<(Dictionary<string, string>, Dictionary<string, List<string>>)> DoorOpGetUpdatedVals(string ObjectId, Dictionary<string, string> currVal, Dictionary<string, List<string>> currParams, string currTemplShape)
        {
            await Task.Delay(1);
            // duplico oggetti da tornare
            Dictionary<string, string> currValUpd = new Dictionary<string, string>();
            Dictionary<string, List<string>> currParamsUpd = new Dictionary<string, List<string>>();
            string default2Design = "";
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                // cerco il setup del template selezionato
                var listRecordTmp = await ListValuesGetAll(ObjectId, currTemplShape);
                if (listRecordTmp != null && currVal.ContainsKey("Folder") && currVal.ContainsKey(currTemplShape))
                {
                    string actKey = currVal[currTemplShape];
                    var firstTemplate = listRecordTmp.Where(x => x.Value == actKey).FirstOrDefault();
                    if (firstTemplate != null)
                    {
                        if (firstTemplate.DefaultVal != "")
                        {
                            default2Design = firstTemplate.DefaultVal;
                        }
                        else
                        {
                            default2Design = "1";
                        }
                    }
                    // elimino dai valori di setup e attuali quanto non sia template/folder...
                    currValUpd = currVal.Where(x => x.Key == "Folder" || x.Key == currTemplShape).ToDictionary(x => x.Key, x => x.Value);
                    // preparo setup valori
                    List<string> listDefVal = new List<string>();
                    var listRecordGP = await ListValuesGetAll(ObjectId, $"Graphic Parameters{default2Design}");
                    if (listRecordGP != null)
                    {
                        foreach (var item in listRecordGP)
                        {
                            if (item.isSerializable && item.DefaultVal.Contains(","))
                            {
                                listDefVal = item.DefaultVal.Trim().Split(",").ToList();
                                currValUpd.Add(item.Value.Trim(), item.DefaultVal.Trim().Split(",")[0].Split("/")[0]);
                            }
                            else
                            {
                                if (item.DefaultVal.Contains("/"))
                                {
                                    listDefVal = new List<string>() { item.DefaultVal.Trim().Split("/")[0] };
                                    currValUpd.Add(item.Value.Trim(), item.DefaultVal.Trim().Split("/")[0]);
                                }
                                else
                                {
                                    listDefVal = new List<string>() { item.DefaultVal.Trim() };
                                    currValUpd.Add(item.Value.Trim(), item.DefaultVal.Trim());
                                }
                            }
                            //defaultParamsList.Add(listDefVal);
                            currParamsUpd.Add(item.Value.Trim(), listDefVal);
                        }
                    }
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpGetUpdatedVals in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpGetUpdatedVals: {exc}{Environment.NewLine}");
            }
            return (currValUpd, currParamsUpd);
        }

        /// <summary>
        /// Add doorOP list
        /// </summary>
        /// <param name="DoorId"></param>
        /// <param name="newOpList"></param>
        /// <returns></returns>
        public async Task<bool> DoorOpInsert(int DoorId, List<DoorOpModel> newOpList)
        {
            bool dbResult = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = await dbController.DoorOpInsert(newOpList);
                // elimino cache redis dati porta...
                bool answ = await DoorOpFlushCache(DoorId);
                answ = answ && await DoorFlushCache(DoorId);
                // elimino cache redis dati ordine...
                answ = answ && await OrdersFlushCache();
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpInsert in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpInsert: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Effettua il setup dei Graph parameters date info template selezionato
        /// </summary>
        /// <param name="currDoorOp"></param>
        /// <returns></returns>
        public async Task<DoorOpModel> DoorOpSetupGraphParams(DoorOpModel currDoorOp)
        {
            string default2Design = "";
            Dictionary<string, string>? actDict = new Dictionary<string, string>();
            Dictionary<string, string>? actDictNew = new Dictionary<string, string>();
            Dictionary<string, List<string>>? defaultDictNew = new Dictionary<string, List<string>>();
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                // per prima cosa deserializzo i valori attuali dal record...
                if (!string.IsNullOrEmpty(currDoorOp.JsoncActVal))
                {
                    actDict = JsonConvert.DeserializeObject<Dictionary<string, string>>(currDoorOp.JsoncActVal);
                    // verifico di avere valori validi
                    if (actDict != null)
                    {
                        // cerco il setup del template selezionato
                        var listRecordTmp = await ListValuesGetAll(currDoorOp.ObjectId, "template");
                        if (listRecordTmp != null && actDict.ContainsKey("Folder") && (actDict.ContainsKey("template") || actDict.ContainsKey("shape")))
                        {
                            string actKey = actDict["template"];// Path.Combine(actDict["Folder"], actDict["template"]);
                            var firstTemplate = listRecordTmp.Where(x => x.Value == actKey).FirstOrDefault();
                            if (firstTemplate != null)
                            {
                                if (firstTemplate.DefaultVal != "")
                                {
                                    default2Design = firstTemplate.DefaultVal;
                                }
                                else
                                {
                                    default2Design = "1";
                                }
                            }
                            // elimino dai valori di setup e attuali quanto non sia template/folder...
                            actDictNew = actDict.Where(x => x.Key == "Folder" || x.Key == "template").ToDictionary(x => x.Key, x => x.Value);
                            // preparo setup valori
                            List<string> listDefVal = new List<string>();
                            var listRecordGP = await ListValuesGetAll(currDoorOp.ObjectId, $"Graphic Parameters{default2Design}");
                            if (listRecordGP != null)
                            {
                                foreach (var item in listRecordGP)
                                {
                                    if (item.isSerializable && item.DefaultVal.Contains(","))
                                    {
                                        listDefVal = item.DefaultVal.Trim().Split(",").ToList();
                                        actDictNew.Add(item.Value.Trim(), item.DefaultVal.Trim().Split(",")[0].Split("/")[0]);
                                    }
                                    else
                                    {
                                        if (item.DefaultVal.Contains("/"))
                                        {
                                            listDefVal = new List<string>() { item.DefaultVal.Trim().Split("/")[0] };
                                            actDictNew.Add(item.Value.Trim(), item.DefaultVal.Trim().Split("/")[0]);
                                        }
                                        else
                                        {
                                            listDefVal = new List<string>() { item.DefaultVal.Trim() };
                                            actDictNew.Add(item.Value.Trim(), item.DefaultVal.Trim());
                                        }
                                    }
                                    //defaultParamsList.Add(listDefVal);
                                    defaultDictNew.Add(item.Value.Trim(), listDefVal);
                                }
                            }
                            // ri-serializzo e salvo!
                            currDoorOp.JsoncActVal = JsonConvert.SerializeObject(actDictNew);
                            currDoorOp.JsoncConfigVal = JsonConvert.SerializeObject(defaultDictNew);
                        }
                    }
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpSetupGraphParams in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpSetupGraphParams: {exc}{Environment.NewLine}");
            }
            return currDoorOp;
        }

        /// <summary>
        /// Bulk add door op types
        /// </summary>
        /// <param name="currRecList"></param>
        /// <returns></returns>
        public async Task<bool> DoorOpTypeAddRange(List<DoorOpTypeModel> currRecList)
        {
            bool dbResult = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string rootPathNew = _configuration.GetValue<string>("CompoBaseDirs:NewCompoDir");
                string rootPathOld = _configuration.GetValue<string>("CompoBaseDirs:CurrCompoDir");

                dbResult = await dbController.DoorOpTypeAddRange(currRecList);

                foreach (var item in currRecList)
                {
                    var pathSplit = item.OpCode.Split("\\");
                    var allDirectories = Directory.GetDirectories(rootPathNew, $"{pathSplit[pathSplit.Length - 3]}\\{pathSplit[pathSplit.Length - 2]}", SearchOption.AllDirectories);

                    foreach (string dir in allDirectories)
                    {
                        string dirToCreate = dir.Replace(rootPathNew, rootPathOld);
                        Directory.CreateDirectory(dirToCreate);
                    }
                    var allFiles = Directory.GetFiles(Path.Combine(rootPathNew, pathSplit[pathSplit.Length - 3], pathSplit[pathSplit.Length - 2]), pathSplit.Last(), SearchOption.AllDirectories);

                    foreach (string newPath in allFiles)
                    {
                        File.Copy(newPath, newPath.Replace(rootPathNew, rootPathOld), true);
                    }
                }
                // elimino cache redis dati porta...
                bool answ = await ExecFlushRedisPattern(Constants.rKeyDoorOpType);

                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpTypeAddRange in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpTypeAddRange: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Doors list by numRec
        /// </summary>
        public async Task<List<DoorOpTypeModel>?> DoorOpTypeGetAll()
        {
            await Task.Delay(1);
            string source = "DB";
            List<DoorOpTypeModel>? dbResult = new List<DoorOpTypeModel>();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyDoorOpType}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = dbController.DoorOpTypeGetAll();
                if (dbResult == null)
                {
                    dbResult = new List<DoorOpTypeModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpTypeGetAll | {source} in: {ts.TotalMilliseconds} ms"); stopWatch.Stop();
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpTypeGetAll: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Door Operation Types
        /// </summary>
        public async Task<List<DoorOpTypeModel>?> DoorOpTypeGetByHwCode(string hwCode, int parentId)
        {
            string source = "DB";

            List<DoorOpTypeModel>? dbResult = new List<DoorOpTypeModel>();
            string currKey = "";
            try
            {
                // cerco da cache
                if (hwCode == "*")
                {
                    currKey = $"{Constants.rKeyDoorOpType}";
                }
                else
                {
                    currKey = $"{Constants.rKeyDoorOpType}:{hwCode}";
                }
                if (hwCode == "*" && parentId == -1)
                {
                    // extracting entire set
                    currKey = $"{Constants.rKeyDoorOpType}";
                }
                else if (hwCode != "*" && parentId == -1)
                {
                    currKey = $"{Constants.rKeyDoorOpType}:{hwCode}";
                }
                else if (hwCode == "*" && parentId >= 0)
                {
                    currKey = $"{Constants.rKeyDoorOpType}:{parentId}";
                }
                else if (hwCode != "*" && parentId >= 0)
                {
                    currKey = $"{Constants.rKeyDoorOpType}:{hwCode}:{parentId}";
                }
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<DoorOpTypeModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<DoorOpTypeModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.DoorOpTypeGetFiltered(hwCode, parentId);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<DoorOpTypeModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpTypeGetByHwCode | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpTypeGetByHwCode: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        public async Task<List<DoorOpTypeModel>> DoorOpTypeGetByPath(string path)
        {
            string source = "DB";

            List<DoorOpTypeModel>? dbResult = new List<DoorOpTypeModel>();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyDoorOpType}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<DoorOpTypeModel>>(rawData)?.Where(x => x.OpCode.StartsWith(path)).ToList();
                    if (tempResult == null)
                    {
                        dbResult = new List<DoorOpTypeModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpTypeGetByPath | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpTypeGetByPath: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Aggiornamento DoorOP
        /// </summary>
        /// <param name="currDoorOps"></param>
        /// <returns></returns>
        public async Task<bool> DoorOpUpdate(List<DoorOpModel> currDoorOps)
        {
            bool dbResult = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = await dbController.DoorOpUpdate(currDoorOps);
                // elimino cache redis dati porta...
                bool answ = await DoorOpFlushCache(currDoorOps.FirstOrDefault()!.DoorId);
                answ = answ && await DoorFlushCache(currDoorOps.FirstOrDefault()!.DoorId);
                // elimino cache redis dati ordine...
                answ = answ && await OrdersFlushCache();
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorOpUpdate in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorOpUpdate: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Update costing for dictionary of doors
        /// </summary>
        /// <param name="DoorUnitCosts"></param>
        /// <returns></returns>
        public async Task<bool> DoorUpdateCosts(Dictionary<int, decimal> DoorUnitCosts)
        {
            bool dbResult = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = await dbController.DoorUpdateCosts(DoorUnitCosts);
                // elimino cache redis dati porte...
                bool answ = false;
                foreach (var item in DoorUnitCosts)
                {
                    answ = await DoorFlushCache(item.Key);
                }
                // elimino cache redis dati ordine...
                answ = answ && await OrdersFlushCache();
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorUpdateCosts in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorUpdateCosts: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Update or add door
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> DoorUpsert(DoorModel currRec)
        {
            bool dbResult = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = await dbController.DoorUpsert(currRec);
                // elimino cache redis dati porta...
                bool answ = await DoorFlushCache(currRec.DoorId);
                // elimino cache redis dati ordine...
                answ = answ && await OrdersFlushCache();
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"DoorUpsert | {currRec.DoorId} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during DoorUpsert: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        public string EncriptData(string rawData)
        {
            return SteamCrypto.EncryptString(rawData, Constants.passPhrase);
        }

        public async Task<bool> FlushCustomPattern(string keyWord)
        {
            await Task.Delay(1);
            RedisValue pattern = new RedisValue($"{Constants.redisBaseAddr}:{keyWord}:*");
            bool answ = await ExecFlushRedisPattern(pattern);
            return answ;
        }

        public async Task<bool> FlushRedisCache()
        {
            await Task.Delay(1);
            RedisValue pattern = new RedisValue($"{Constants.redisBaseAddr}*");
            bool answ = await ExecFlushRedisPattern(pattern);
            return answ;
        }

        public async Task<List<ListValuesTempModel>> GraphicParamsGetAll(string file, string match, int n, int i, string HwCode)
        {
            await Task.Delay(1);
            List<ListValuesTempModel> listValuesTemp = new List<ListValuesTempModel>();
            ListValuesTempModel listValObj = new ListValuesTempModel();
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                IniFile fIni = new IniFile(file);
                //cerco il contenuto delle sezioni
                var graphicParamsName = fIni.ReadSection(match.Substring(1, match.Length - 2));
                //controllo se tra numPar numeri di graphic params vi è un buco ES: Graphic parameters1  Graphic parameters3   se il buco c'è salto tutti numPar parametri che stanno dopo il buco ==> tengo conto solo di Graphic parameters1
                if (int.Parse(match.Substring(match.Length - 2, 1)) == n)
                {
                    int ordinal = 1;
                    foreach (string param in graphicParamsName)
                    {
                        string compoParams = fIni.ReadString(match.Substring(1, match.Length - 2), $"{param.Split("=")[0]}", "CONFIG"); //cerco il parametro nella sezione
                        var compoParamsSplit = compoParams.Split(";");

                        string CompoParamName = "";
                        string CompoParamAlias = "";
                        if (param.Split("=")[0].StartsWith("Param"))
                        {
                            if (compoParamsSplit[1].Contains("/"))
                            {
                                CompoParamName = compoParamsSplit[1].Split("/")[0];
                                CompoParamAlias = compoParamsSplit[1].Split("/")[1];
                            }
                            else if (compoParamsSplit[1].Contains(" "))
                            {
                                CompoParamName = compoParamsSplit[1].Split(" ")[1];
                                //CompoParamAlias = compoParamsSplit[1].Split(" ")[1];
                            }

                            //creo nuovo oggetto parametro che conterrà anche il nome del componente per creare relazione

                            listValObj = new ListValuesTempModel()
                            {
                                TableName = $"{HwCode}".Trim(),
                                FieldName = match.Substring(1, match.Length - 2),
                                Value = CompoParamName,
                                Label = CompoParamAlias,
                                Ordinal = ordinal,
                                DefaultVal = param.Split("=")[1].Split(";")[2],
                                InputType = param.Split("=")[1].Split(";")[0],
                                isSerializable = true
                            };

                            if (listValuesTemp.Where(x => x.TableName == listValObj.TableName && x.FieldName == listValObj.FieldName && x.Value == listValObj.Value).Count() == 0 && listValObj.TableName != null && listValObj.FieldName != null && listValObj.Value != null)
                            {
                                listValuesTemp.Add(listValObj);
                                ordinal++;
                            }
                            else
                            {
                                Log.Error($"GraphicParamsGetAll | Duplicated key: {listValObj.TableName} {listValObj.FieldName} {listValObj.Value} ");
                            }
                        }
                        else
                        {
                        }
                    }
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"GraphicParamsGetAll | {file} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during GraphicParamsGetAll: {exc}{Environment.NewLine}");
            }
            return listValuesTemp;
        }

        /// <summary>
        /// Estraggo tutte le lingue disponibili per questa applicazione
        /// </summary>
        /// <returns></returns>
        public async Task<List<LanguageModel>?> LanguageGetAll()
        {
            string source = "DB";

            List<LanguageModel>? dbResult = new List<LanguageModel>();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyLanguage}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<LanguageModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<LanguageModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.LanguageGetAll();
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<LanguageModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"LanguageGetAll | {source} in: {ts.TotalMilliseconds} ms"); stopWatch.Stop();
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during LanguageGetAll: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// List values
        /// </summary>
        public async Task<List<ListValuesModel>?> ListValuesGetAll(string tableName, string fieldName)
        {
            string source = "DB";

            List<ListValuesModel>? dbResult = new List<ListValuesModel>();
            string currKey = "";
            try
            {
                // cerco da cache
                currKey = $"{Constants.rKeyListValues}:{tableName}:{fieldName}";

                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<ListValuesModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<ListValuesModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.ListValuesGetAll(tableName, fieldName);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<ListValuesModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"ListValuesGetAll | {source} in: {ts.TotalMilliseconds} ms"); stopWatch.Stop();
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during ListValuesGetAll: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        public async Task<bool> ListValuesLuaNgeInsert(string defaultPath)
        {
            await Task.Delay(1);
            List<ListValuesTempModel> values = new List<ListValuesTempModel>();
            List<DoorOpTypeModel> doorOpTypesList = new List<DoorOpTypeModel>();
            MD5 md5 = MD5.Create();
            bool answ = false;

            try
            {
                // ciclo nelle directories usando la colonna opcode
                string compoCode = "";
                string compoTempOrShape = "";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string[] hwDirectories = Directory.GetDirectories(defaultPath);

                int ordin = 1;
                foreach (var hw in hwDirectories)
                {
                    string[] iniFiles = Directory.GetFiles(hw, "Config.ini");
                    string[] templateDirectories = Directory.GetDirectories(hw);

                    foreach (string templateDirectory in templateDirectories)
                    {
                        var tName = templateDirectory.Split("\\");
                        //var fName = templateDirectory.Split("\\");

                        foreach (var file in iniFiles)
                        {
                            List<string> lines = File.ReadAllLines(file).ToList();
                            IniFile fIni = new IniFile(file);

                            var compoName = fIni.ReadString("Compo", "Name", "COMPONAME");
                            var compoT = fIni.ReadString("Template", "Name", "TEMPSHAPE");
                            compoCode = compoName.Split("/")[0].Trim();
                            compoTempOrShape = compoT.Split("/")[0].Trim();
                        }

                        string[] templateFiles = Directory.GetFiles(templateDirectory);
                        if (templateFiles.Length > 0)
                        {
                            ListValuesTempModel folderNames = new ListValuesTempModel()
                            {
                                TableName = $"{compoCode}".Replace(" ", "_"),
                                FieldName = "Folder",
                                Value = @$"{tName[tName.Length - 1]}",
                                Label = @$"{tName[tName.Length - 1]}",
                                Ordinal = 0,
                                DefaultVal = " ",
                                InputType = " ",
                            };
                            values.Add(folderNames);
                        }

                        foreach (string templateFile in templateFiles)
                        {
                            FileInfo fi = new FileInfo(templateFile);
                            string defGpNum = "";
                            var lines = File.ReadAllLines(templateFile).ToList();

                            foreach (var line in lines)
                            {
                                if (line.StartsWith("--") && line.Contains("Default"))
                                {
                                    if (line.Split("=")[1] != null)
                                    {
                                        defGpNum = line.Split("=")[1];
                                    }
                                    else
                                    {
                                        defGpNum = " ";
                                    }
                                }
                            }

                            var fileName = "";
                            if (Path.GetFileName(templateFile).Split(".")[1] == "lua")
                            {
                                fileName = Path.GetFileName(templateFile).Split(".")[0];
                            }
                            else
                            {
                                fileName = Path.GetFileName(templateFile);
                            }

                            ListValuesTempModel temp = new ListValuesTempModel()
                            {
                                TableName = $"{compoCode}".Replace(" ", "_"),
                                FieldName = compoTempOrShape,
                                Value = @$"{tName[tName.Length - 1]}\{fileName}",
                                Label = fileName,
                                Ordinal = ordin,
                                DefaultVal = defGpNum,
                                InputType = " ",
                            };
                            var fileContent = File.ReadAllBytes(templateFile);
                            var hash = md5.ComputeHash(fileContent);
                            var oldMD5 = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
                            if (values.Where(x => x.TableName == temp.TableName && x.FieldName == temp.FieldName && x.Value == temp.Value).Count() == 0 && temp.TableName != null && temp.FieldName != null && temp.Value != null)
                            {
                                values.Add(temp);
                                ordin++;
                            }
                            else
                            {
                                Log.Error($"ListValuesLuaNgeInsert | Duplicated key: {temp.TableName} {temp.FieldName} {temp.Value} ");
                            }
                        }
                    }
                }
                answ = await dbController.ListValuesAdd(values);
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"ListValuesLuaNgeInsert in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during ListValuesLuaNgeInsert: {exc}{Environment.NewLine}");
            }

            return answ;
        }

        /// <summary>
        /// Add new order
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<int> OrderAdd(OrderModel currRec)
        {
            int dbResult = 0;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = await dbController.OrderAdd(currRec);
                // elimino cache redis...
                RedisValue pattern = new RedisValue($"{Constants.rKeyOrderStatus}:*");
                bool answ = await ExecFlushRedisPattern(pattern);
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"OrderAdd | {currRec.OrderExtCode} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during OrderAdd: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Clean REDIS order detail data in cache
        /// </summary>
        /// <param name="OrderId">0 = all</param>
        /// <returns></returns>
        public async Task<bool> OrderDetailFlushCache(int OrderId)
        {
            RedisValue pattern = new RedisValue($"{Constants.rKeyDoorsByOrder}:*");
            if (OrderId > 0)
            {
                pattern = new RedisValue($"{Constants.rKeyDoorsByOrder}:{OrderId}");
            }
            bool answ = await ExecFlushRedisPattern(pattern);
            return answ;
        }

        /// <summary>
        /// Order (content) cloning
        /// </summary>
        /// <param name="OrdIdSrc"></param>
        /// <param name="OrdIdDest"></param>
        /// <param name="UsrIdMod"></param>
        /// <returns></returns>
        public async Task<bool> OrderDuplicate(int OrdIdSrc, int OrdIdDest, string UsrIdMod)
        {
            bool dbResult = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = await dbController.OrderDuplicate(OrdIdSrc, OrdIdDest, UsrIdMod);
                // elimino cache redis...
                RedisValue pattern = new RedisValue($"{Constants.rKeyOrderStatus}:*");
                bool answ = await ExecFlushRedisPattern(pattern);
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"OrderDuplicate | {OrdIdSrc} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during OrderDuplicate: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        public async Task<List<OrderModel>?> OrderGetByCompStatus(int CompanyId, int StatusId)
        {
            string source = "DB";

            List<OrderModel>? dbResult = new List<OrderModel>();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyOrderByComp}:{CompanyId}:{StatusId}"; ;
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<OrderModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<OrderModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.OrderGetByCompStatus(CompanyId, StatusId);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<OrderModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"OrderGetByCompStatus | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during OrderGetByCompStatus: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        public async Task<OrderModel?> OrderGetByKey(int orderId)
        {
            string source = "DB";

            OrderModel? dbResult = new OrderModel();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyOrderDetail}:{orderId}"; ;
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<OrderModel>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new OrderModel();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.OrderGetByKey(orderId);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, LongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new OrderModel();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"OrderGetByKey | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during OrderGetByKey: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Remove order
        /// </summary>
        /// <param name="OrdId"></param>
        /// <returns></returns>
        public async Task<bool> OrderRem(int OrdId)
        {
            bool dbResult = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = await dbController.OrderRem(OrdId);
                // elimino cache redis...
                RedisValue pattern = new RedisValue($"{Constants.rKeyOrderStatus}:*");
                bool answ = await ExecFlushRedisPattern(pattern);
                pattern = new RedisValue($"{Constants.rKeyOrderByComp}:*");
                answ = await ExecFlushRedisPattern(pattern);
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"OrderRem | {OrdId} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during OrderRem: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Clean redis ORDERS cache
        /// </summary>
        /// <returns></returns>
        public async Task<bool> OrdersFlushCache()
        {
            RedisValue pattern = new RedisValue($"{Constants.rKeyOrderStatus}:*");
            bool answ = await ExecFlushRedisPattern(pattern);
            return answ;
        }

        public async Task<List<OrderStatusViewModel>?> OrderStatusGetFilt(int companyId, int orderStatus, DateTime dataFrom, DateTime dataTo)
        {
            string source = "DB";

            List<OrderStatusViewModel>? dbResult = new List<OrderStatusViewModel>();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyOrderStatus}:{companyId}:{orderStatus}:{dataFrom:yyyyMMdd}:{dataTo:yyyyMMdd}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<OrderStatusViewModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<OrderStatusViewModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    var rawResult = dbController.OrderStatusGetAll(companyId, orderStatus, dataFrom, dataTo);
                    // ordino desc in ram...
                    dbResult = rawResult.OrderByDescending(x => x.OrderId).ToList();
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<OrderStatusViewModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"OrderStatusGetFilt | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during OrderStatusGetFilt: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Updating an order code/description
        /// </summary>
        /// <param name="orderId"></param>
        /// <param name="newCode"></param>
        /// <param name="newDescript"></param>
        /// <returns></returns>
        public async Task<bool> OrderUpdateDescript(int orderId, string newCode, string newDescript)
        {
            var dbResult = await dbController.OrderUpdateDescript(orderId, newCode, newDescript);
            // elimino cache redis dati ordine...
            bool answ = await FlushRedisCache();
            return dbResult;
        }

        /// <summary>
        /// Updating an order promised date
        /// </summary>
        /// <param name="orderId"></param>
        /// <param name="dateProm"></param>
        /// <returns></returns>
        public async Task<bool> OrderUpdatePromDate(int orderId, DateTime dateProm)
        {
            bool dbResult = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();

                dbResult = await dbController.OrderUpdatePromDate(orderId, dateProm);
                // elimino cache redis dati ordine...
                bool answ = await FlushRedisCache();
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"OrderUpdatePromDate | {orderId} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during OrderUpdatePromDate: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Updating an order status
        /// </summary>
        /// <param name="orderId"></param>
        /// <param name="newStatus"></param>
        /// <returns></returns>
        public async Task<bool> OrderUpdateStatus(int orderId, int newStatus)
        {
            bool dbResult = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();

                dbResult = dbResult = await dbController.OrderUpdateStatus(orderId, newStatus);
                // elimino cache redis dati ordine...
                bool answ = await ExecFlushRedisPattern($"{Constants.rKeyOrderStatus}:*");
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"OrderUpdateStatus | {orderId} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during OrderUpdateStatus: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Graphic parameters list by hw id
        /// </summary>
        public async Task<List<GraphicParamsModel>?> ParamGetByHwId(int hwId)
        {
            string source = "DB";

            List<GraphicParamsModel>? dbResult = new List<GraphicParamsModel>();
            // cerco da cache
            try
            {
                string currKey = $"{Constants.rKeyGraphicParameters}:{hwId}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<GraphicParamsModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<GraphicParamsModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.ParamGetByHwId(hwId);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<GraphicParamsModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"ParamGetByHwId | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during ParamGetByHwId: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        public async Task<bool> populateHws()
        {
            bool answ = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string rootPath = _configuration.GetValue<string>("CompoBaseDirs:NewCompoDir");
                List<string> listActiveCompo = await CompoGetAllActive(Path.Combine(rootPath, @"Default.ini"));
                string[] dirs = Directory.GetDirectories(rootPath);
                List<DoorOpTypeModel> doorOpTypesList = new List<DoorOpTypeModel>();
                foreach (string dir in dirs)
                {
                    string compoCode = "";
                    string[] templateDirectories = Directory.GetDirectories(dir);

                    string[] iniFiles = Directory.GetFiles(dir, "Config.ini");

                    foreach (var file in iniFiles)
                    {
                        List<string> lines = File.ReadAllLines(file).ToList();
                        IniFile fIni = new IniFile(file);

                        var compoName = fIni.ReadString("Compo", "Name", "COMPONAME");
                        var compoT = fIni.ReadString("Template", "Name", "TEMPSHAPE");
                        compoCode = compoName.Split("/")[0].Trim();
                    }
                    if (listActiveCompo.Contains(compoCode))
                    {
                        DoorOpTypeModel tempHwType = new DoorOpTypeModel()
                        {
                            ParentId = 0,
                            Description = $"Hardware Type {compoCode.Replace(" ", "_")}",
                            OpCode = @$"{dir}",
                            HasHw = true,
                            IsConcrete = true,
                            HwCode = $"{compoCode}".Replace(" ", "_")
                        };
                        doorOpTypesList.Add(tempHwType);
                    }
                }
                //scrivo su db hws
                //*await dbController.DoorOpTypeAddRange(doorOpTypesList);
                string currKey = $"{Constants.rKeyDoorOpType}";
                string rawData = JsonConvert.SerializeObject(doorOpTypesList, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"populateHws in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during populateHws: {exc}{Environment.NewLine}");
            }
            return answ;
        }

        /// <summary>
        /// Dati x print report ordini
        /// </summary>
        /// <param name="orderId"></param>
        /// <returns></returns>
        public async Task<List<PrtRepOrderModel>?> PreRepOrderGetByKey(int orderId)
        {
            string source = "DB";
            List<PrtRepOrderModel>? dbResult = new List<PrtRepOrderModel>();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyOrderStatus}:{orderId}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<PrtRepOrderModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<PrtRepOrderModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    var rawResult = dbController.PreRepOrderGetByKey(orderId);
                    // ordino desc in ram...
                    dbResult = rawResult.OrderByDescending(x => x.OrderId).ToList();
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<PrtRepOrderModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"PreRepOrderGetByKey | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during populateHws: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Get single hash record
        /// </summary>
        /// <param name="currKey">Redis Key for Hashlist</param>
        /// <param name="chiave">Requested key on list</param>
        /// <returns>Value as Int</returns>
        public async Task<int> RedHashGetInt(RedisKey currKey, string chiave)
        {
            int result = 0;
            Stopwatch sw = new Stopwatch();
            if (logTimingEnable)
            {
                sw.Start();
            }
            var hasVal = await redisDb.HashExistsAsync(currKey, chiave);
            if (hasVal)
            {
                var rawRes = await redisDb.HashGetAsync(currKey, chiave);
                if (rawRes.HasValue)
                {
                    int.TryParse($"{rawRes}", out result);
                }
            }
            if (logTimingEnable)
            {
                sw.Stop();
                // gestione statistiche
                await ProcStatLog("RedHashGetInt", sw.Elapsed, 0, 0.3);
            }
            return result;
        }

        /// <summary>
        /// Get single hash record
        /// </summary>
        /// <param name="currKey">Redis Key for Hashlist</param>
        /// <param name="chiave">Requested key on list</param>
        /// <param name="doTimeLog">Execute time log processing</param>
        /// <returns>Value as string</returns>
        public async Task<string> RedHashGetString(RedisKey currKey, string chiave, bool doTimeLog)
        {
            string result = "";
            Stopwatch sw = new Stopwatch();
            if (logTimingEnable && doTimeLog)
            {
                sw.Start();
            }
            var hasVal = await redisDb.HashExistsAsync(currKey, chiave);
            if (hasVal)
            {
                var rawRes = await redisDb.HashGetAsync(currKey, chiave);
                if (rawRes.HasValue)
                {
                    result = $"{rawRes}";
                }
            }
            if (logTimingEnable && doTimeLog)
            {
                sw.Stop();
                // gestione statistiche
                await ProcStatLog("RedHashGetString", sw.Elapsed, 0, 0.3);
            }
            return result;
        }

        /// <summary>
        /// Remove for single hash record
        /// </summary>
        /// <param name="currKey">Chiave redis della Hashlist</param>
        /// <param name="chiave">Chiave nella HashList</param>
        /// <returns>Esito rimozione</returns>
        public async Task<bool> RedHashRemove(RedisKey currKey, string chiave)
        {
            bool fatto = false;
            Stopwatch sw = new Stopwatch();
            if (logTimingEnable)
            {
                sw.Start();
            }
            fatto = await redisDb.HashDeleteAsync(currKey, chiave);
            if (logTimingEnable)
            {
                sw.Stop();
                // gestione statistiche
                await ProcStatLog("RedHashRemove", sw.Elapsed, 0, 0.3);
            }
            return fatto;
        }

        /// <summary>
        /// Effettua upsert in HasList redis
        /// </summary>
        /// <param name="currKey">Chiave redis della Hashlist</param>
        /// <param name="chiave">Chiave nella HashList</param>
        /// <param name="valore">Valore da salvare</param>
        /// <param name="doTimeLog">Gestione log time abilitata</param>
        /// <returns>Num record nella HashList</returns>
        public async Task<long> RedHashUpsert(RedisKey currKey, string chiave, string valore, bool doTimeLog = true)
        {
            long numReq = 0;
            Stopwatch sw = new Stopwatch();
            if (logTimingEnable && doTimeLog)
            {
                sw.Start();
            }
            await redisDb.HashSetAsync(currKey, chiave, valore);
            numReq = await redisDb.HashLengthAsync(currKey);
            if (logTimingEnable && doTimeLog)
            {
                sw.Stop();
                // gestione statistiche
                await ProcStatLog("RedHashUpsert", sw.Elapsed, 0, 0.3);
            }
            return numReq;
        }

        /// <summary>
        /// Bulk delete chiavi su redis
        /// </summary>
        /// <param name="doorId"></param>
        /// <returns></returns>
        public async Task<bool> RedisBulkDelByDoorId(int doorId)
        {
            await FlushCustomPattern($"Cache:Door:{doorId}");
            await FlushCustomPattern($"CalcRequests:CacheDDF:{doorId}");
            await FlushCustomPattern($"CalcRequests:CacheSVG:{doorId}");
            await FlushCustomPattern($"CalcRequests:Errors:{doorId}");

            return true;
        }

        /// <summary>
        /// roles list
        /// </summary>
        public async Task<List<AspNetRoles>?> RolesGetAll()
        {
            string source = "DB";

            List<AspNetRoles>? dbResult = new List<AspNetRoles>();
            try
            {
                // cerco da cache
                string currKey = Constants.rKeyRoles;
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<AspNetRoles>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<AspNetRoles>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.RolesGetAll();
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<AspNetRoles>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"RolesGetAll | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during RolesGetAll: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Esegue scansione dir richeista
        /// </summary>
        /// <param name="rootPath"></param>
        /// <param name="useCache">indica se leggere da cache Redis(true) o da FS (false)</param>
        /// <returns></returns>
        public async Task<Dictionary<string, FileDTO>> scanSrcDestDir(string rootPath, bool useCache)
        {
            await Task.Delay(1);
            string mode = "FS";
            string currKey = $"{Constants.rKeyDirsScan}:{rootPath}";
            string? rawData = "";
            List<FileDTO> dirAFiles = new List<FileDTO>();
            Dictionary<string, FileDTO> filesDict = new Dictionary<string, FileDTO>();
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();

                if (useCache)
                {
                    mode = "cache";
                    rawData = await redisDb.StringGetAsync(currKey);
                    if (!string.IsNullOrEmpty(rawData))
                    {
                        var rawList = JsonConvert.DeserializeObject<Dictionary<string, FileDTO>>(rawData);
                        if (rawList != null)
                        {
                            filesDict = rawList;
                        }
                    }
                }
                else
                {
                    string[] dirs = Directory.GetDirectories(rootPath);

                    using (MD5 md5 = MD5.Create())
                    {
                        foreach (var dir in dirs)
                        {
                            string[] iniFiles = Directory.GetFiles(dir, "Config.ini");
                            string compoCode = "";
                            foreach (var file in iniFiles)
                            {
                                List<string> lines = File.ReadAllLines(file).ToList();
                                IniFile fIni = new IniFile(file);

                                var compoName = fIni.ReadString("Compo", "Name", "COMPONAME");
                                var compoT = fIni.ReadString("Template", "Name", "TEMPSHAPE");
                                compoCode = compoName.Split("/")[0].Trim();
                            }
                            string[] templateDirectories = Directory.GetDirectories(dir);

                            foreach (var tplDir in templateDirectories)
                            {
                                string[] tpls = Directory.GetFiles(tplDir, "*");
                                //var archiviedFiles = dbController.DoorOpTypeGetByPath(tplDir);
                                foreach (var tpl in tpls)
                                {
                                    FileInfo fi = new FileInfo(tpl);
                                    var fileName = Path.GetFileName(tpl).Split("\\")[Path.GetFileName(tpl).Split("\\").Length - 1];
                                    var fileContent = File.ReadAllBytes(tpl);
                                    var hash = md5.ComputeHash(fileContent);
                                    var newMD5 = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
                                    FileDTO currFileInfo = new FileDTO()
                                    {
                                        //FileBaseDir = tplDir,
                                        //FileAbsPath = fi.FullName,
                                        FileRelPath = fileName,
                                        FileDim = fi.Length,
                                        FileMD5 = newMD5,
                                        lastModTime = fi.LastWriteTime
                                    };
                                    string relDirPath = fi.FullName.Replace($"{rootPath}\\", "");
                                    var src = relDirPath.Split("\\").ToArray();
                                    //var src = fi.FullName.Split("\\").Skip(6).ToArray();
                                    StringBuilder sb = new StringBuilder();
                                    foreach (var line in src)
                                    {
                                        if (src.Last().ToString() == line)
                                        {
                                            sb.Append($"{line}");
                                        }
                                        else
                                        {
                                            sb.Append($"{line}\\");
                                        }
                                    }

                                    if (!filesDict.ContainsKey(sb.ToString()))
                                    {
                                        filesDict.Add(sb.ToString(), currFileInfo);
                                    }
                                }
                            }
                        }
                    }

                    rawData = JsonConvert.SerializeObject(filesDict);
                    await redisDb.StringSetAsync(currKey, rawData);
                }

                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"scanSrcDestDir | {mode} | done in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during scanSrcDestDir: {exc}{Environment.NewLine}");
            }
            return filesDict;
        }

        /// <summary>
        /// Restituisce dati statistica richiesta
        /// </summary>
        /// <param name="statName">Nome statistica</param>
        /// <returns></returns>
        public async Task<ExecStats> StatGetAsync(string statName)
        {
            ExecStats answ = new ExecStats(0, new TimeSpan());
            RedisKey currKey = new RedisKey(Constants.STATS_DATA);
            // cerco nella hashTable...
            var rawData = await RedHashGetString(currKey, statName, false);
            // se c'è rileggo ed aggiorno
            if (!string.IsNullOrEmpty(rawData))
            {
                var currStat = JsonConvert.DeserializeObject<ExecStats>(rawData);
                if (currStat != null)
                {
                    answ = currStat;
                }
            }
            return answ;
        }

        /// <summary>
        /// Resetta dati statistica esecuzione x log restituendo i valori precedentemente contenuti
        /// </summary>
        /// <param name="statName">Nome statistica</param>
        /// <returns></returns>
        public async Task<ExecStats> StatReset(string statName)
        {
            RedisKey currKey = new RedisKey(Constants.STATS_DATA);
            ExecStats answ = await StatGetAsync(statName);
            // ora rimuovo valore
            await RedHashRemove(currKey, statName);
            return answ;
        }

        /// <summary>
        /// Effettua upsert dati statistica esecuzione x log
        /// </summary>
        /// <param name="statName">Nome statistica</param>
        /// <param name="duration">Durata esecuzione come timespan</param>
        /// <param name="evMultipl">moltiplicatore soglia x log statistica (default = 1)</param>
        /// <returns></returns>
        public async Task<bool> StatUpsert(string statName, TimeSpan duration, double evMultipl)
        {
            bool answ = false;
            RedisKey currKey = new RedisKey(Constants.STATS_DATA);
            // cerco nella hashTable...
            var rawData = await RedHashGetString(currKey, statName, false);
            // di default inizializzo a null...
            ExecStats newStat = new ExecStats(1, duration);
            // se c'è rileggo ed aggiorno
            if (!string.IsNullOrEmpty(rawData))
            {
                var currStat = JsonConvert.DeserializeObject<ExecStats>(rawData);
                if (currStat != null)
                {
                    currStat.NumCall++;
                    currStat.TotalTime += duration;
                    newStat = currStat;
                }
            }
            // ora aggiorno su redis
            rawData = JsonConvert.SerializeObject(newStat);
            var numRec = await RedHashUpsert(currKey, statName, rawData, false);
            // verifico se da considerare superato limite sample
            answ = newStat.NumCall >= (int)(statSampleSize * evMultipl);
            return answ;
        }

        /// <summary>
        /// Update company
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> UserAddMod(AspNetUsers currRec)
        {
            var dbResult = await dbController.UserAddMod(currRec);
            // elimino cache redis...
            RedisValue pattern = new RedisValue($"{Constants.rKeyCompany}");
            bool answ = await ExecFlushRedisPattern(pattern);
            await Task.Delay(1);
            return dbResult;
        }

        /// <summary>
        /// Users roles list
        /// </summary>
        public async Task<List<AspNetUsers>?> UsersGetAll()
        {
            string source = "DB";

            List<AspNetUsers>? dbResult = new List<AspNetUsers>();
            try
            {
                // cerco da cache
                string currKey = Constants.rKeyUsers;
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<AspNetUsers>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<AspNetUsers>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.UsersGetAll();
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<AspNetUsers>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"UsersGetAll | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during UsersGetAll: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Users roles list
        /// </summary>
        public async Task<AspNetUsers> UsersGetById(string userId)
        {
            string source = "DB";

            AspNetUsers dbResult = new AspNetUsers();
            try
            {
                // cerco da cache
                string currKey = $"{Constants.rKeyUsers}:{userId}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<AspNetUsers>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new AspNetUsers();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.UsersGetById(userId);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new AspNetUsers();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"UsersGetById | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during UsersGetById: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        /// <summary>
        /// Users roles list
        /// </summary>
        public async Task<List<UsersViewModel>?> UserViewGetAll()
        {
            string source = "DB";

            List<UsersViewModel>? dbResult = new List<UsersViewModel>();
            try
            {
                // cerco da cache
                string currKey = Constants.rKeyUsersView;
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<UsersViewModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<UsersViewModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.UserViewGetAll();
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<UsersViewModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"UserViewGetAll | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during UserViewGetAll: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        public async Task<VocabularyTempModel?> VocLemmaFindByKeys(string lingua, string lemma)
        {
            string source = "DB";
            VocabularyTempModel? dbResult = new VocabularyTempModel();
            try
            {
                // cerco da cache
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string currKey = $"{Constants.rKeyVocLemma}:{lingua}:{lemma}";
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<VocabularyTempModel>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new VocabularyTempModel();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = await dbController.VocLemmaFindByKeys(lingua, lemma);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new VocabularyTempModel();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"VocLemmaFindByKeys | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during VocLemmaFindByKeys: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        public async Task<Dictionary<string, Dictionary<string, string>>?> VocLemmaGetAll()
        {
            string source = "DB";
            Dictionary<string, Dictionary<string, string>>? dbResult = new Dictionary<string, Dictionary<string, string>>();
            try
            {
                // cerco da cache
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string currKey = $"{Constants.rKeyVocLemma}";
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new Dictionary<string, Dictionary<string, string>>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.VocLemmaGetAll();
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new Dictionary<string, Dictionary<string, string>>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"VocLemmaGetAll | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during VocLemmaGetAll: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        public async Task<bool> VocLemmaInsert()
        {
            bool fatto = false;

            List<VocabularyTempModel> VocLemmas = new List<VocabularyTempModel>();
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                fatto = await dbController.VocLemmaInsert();
                RedisValue pattern = new RedisValue($"{Constants.rKeyVocLemma}");
                bool answ = await ExecFlushRedisPattern(pattern);
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"VocLemmaInsert in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during VocLemmaInsert: {exc}{Environment.NewLine}");
            }
            return fatto;
        }

        public async Task<List<VocabularyTempModel>> VocLemmaInsertPrepare(string rootPath)
        {
            //bool fatto = false;
            await Task.Delay(1);
            List<VocabularyTempModel> VocLemmas = new List<VocabularyTempModel>();
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();

                string[] files = Directory.GetFiles(rootPath, "*");
                string lang = "";
                foreach (string file in files)
                {
                    var fileName = file.Split(".");

                    //lang = fileName[0].Split("\\").TakeLast(1).ToString().Substring(fileName[0].Length - 2, 2);

                    //leggo tutte le linee del file
                    List<string> lines = File.ReadAllLines(file).ToList();

                    foreach (var line in lines)
                    {
                        if (!line.StartsWith("//") && line != "")
                        {
                            string[] lineSplit = line.Split("=");
                            if (lineSplit[0] == "0")
                            {
                                if (lineSplit[1] != "ENG")
                                {
                                    lang = lineSplit[1];
                                }
                                else
                                {
                                    lang = "EN";
                                }
                            }
                            //string trad = "";
                            if (lineSplit.Length != 1)
                            {
                                VocabularyTempModel newVocLemma = new VocabularyTempModel()
                                {
                                    Lingua = lang,
                                    Lemma = lineSplit[0],
                                    Traduzione = lineSplit[1]
                                };
                                VocLemmas.Add(newVocLemma);
                            }
                        }
                    }
                }
                await dbController.VocLemmaInsertPrepare(VocLemmas);
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"VocLemmaInsertPrepare in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during VocLemmaInsertPrepare: {exc}{Environment.NewLine}");
            }
            return VocLemmas;
        }

        public async Task<bool> VocLemmaSetConf(string lingua, string lemma, bool isConf)
        {
            bool fatto = false;
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                fatto = await dbController.VocLemmaSetConf(lingua, lemma, isConf);
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"VocLemmaSetConf in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during VocLemmaSetConf: {exc}{Environment.NewLine}");
            }
            return fatto;
        }

        public async Task<Dictionary<string, Dictionary<string, string>>> VocLemmaTEMPGetAll()
        {
            await Task.Delay(1);
            string source = "DB";
            Dictionary<string, Dictionary<string, string>> dbResult = new Dictionary<string, Dictionary<string, string>>();
            try
            {
                // cerco da cache
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                dbResult = dbController.VocLemmaTEMPGetAll();
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"VocLemmaGetAll | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during VocLemmaGetAll: {exc}{Environment.NewLine}");
            }
            return dbResult;
        }

        #endregion Public Methods

        #region Protected Properties

        protected WebDoorCreator.Data.DDF.Converter currDdfConv { get; set; } = null!;

        #endregion Protected Properties

        #region Protected Methods

        protected Dictionary<string, string> getCompoDict(string defaultPath)
        {
            ///dizionario componenti - directory
            Dictionary<string, string> DictCompoDir = new Dictionary<string, string>();
            // in primis cerco le directory fisiche e la loro rappresentazione come nome componente...
            string[] hwDirectories = Directory.GetDirectories(defaultPath);
            foreach (var hw in hwDirectories)
            {
                string[] iniFiles = Directory.GetFiles(hw, "Config.ini");
                if (iniFiles != null && iniFiles.Length > 0)
                {
                    List<string> lines = File.ReadAllLines(iniFiles[0]).ToList();
                    IniFile fIni = new IniFile(iniFiles[0]);

                    var compoName = fIni.ReadString("Compo", "Name", "COMPONAME");
                    string compoCode = compoName.Split("/")[0].Trim();

                    // aggiungo al dizionari
                    if (!DictCompoDir.ContainsKey(compoCode))
                    {
                        DictCompoDir.Add(compoCode, hw);
                    }
                }
            }

            return DictCompoDir;
        }

        #endregion Protected Methods

        #region Private Fields

        private static IConfiguration _configuration = null!;

        private static JsonSerializerSettings? JSSettings;

        private static Logger Log = LogManager.GetCurrentClassLogger();

        /// <summary>
        /// Dimensione campione da registrare e trascrivere in log
        /// </summary>
        private static int statSampleSize = 1;

        private readonly IEmailSender _emailSender;

        /// <summary>
        /// Durata cache lunga IN SECONDI
        /// </summary>
        private int cacheTtlLong = 60 * 5;

        /// <summary>
        /// Durata cache breve IN SECONDI
        /// </summary>
        private int cacheTtlShort = 60 * 1;

        /// <summary>
        /// abilitazione time log con stopwatch
        /// </summary>
        private bool logTimingEnable = false;

        /// <summary>
        /// Oggetto per connessione a REDIS
        /// </summary>
        private IConnectionMultiplexer redisConn;

        /// <summary>
        /// Oggetto DB redis da impiegare x chiamate R/W
        /// </summary>
        private IDatabase redisDb = null!;

        private Random rnd = new Random();

        #endregion Private Fields

        #region Private Properties

        /// <summary>
        /// Durata cache breve (1 min circa + perturbazione percentuale +/-10%)
        /// </summary>
        private TimeSpan FastCache
        {
            get => TimeSpan.FromSeconds(cacheTtlShort * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata cache lunga (+ perturbazione percentuale +/-10%)
        /// </summary>
        private TimeSpan LongCache
        {
            get => TimeSpan.FromSeconds(cacheTtlLong * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata cache molto breve (10 sec circa + perturbazione percentuale +/-10%)
        /// </summary>
        private TimeSpan UltraFastCache
        {
            get => TimeSpan.FromSeconds(cacheTtlShort / 6 * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata cache lunga (+ perturbazione percentuale +/-10%)
        /// </summary>
        private TimeSpan UltraLongCache
        {
            get => TimeSpan.FromSeconds(cacheTtlLong * 10 * rnd.Next(900, 1100) / 1000);
        }

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Esegue flush memoria redis dato pattern
        /// </summary>
        /// <param name="pattern"></param>
        /// <returns></returns>
        private async Task<bool> ExecFlushRedisPattern(RedisValue pattern)
        {
            bool answ = false;
            var listEndpoints = redisConn.GetEndPoints();
            foreach (var endPoint in listEndpoints)
            {
                //var server = redisConnAdmin.GetServer(listEndpoints[0]);
                var server = redisConn.GetServer(endPoint);
                if (server != null)
                {
                    var keyList = server.Keys(redisDb.Database, pattern);
                    foreach (var item in keyList)
                    {
                        await redisDb.KeyDeleteAsync(item);
                    }
                    answ = true;
                }
            }

            return answ;
        }

        /// <summary>
        /// Processa log statistiche:
        /// - accumula dati
        /// - se superata soglia (soglia x evMultipl) registra log
        /// </summary>
        /// <param name="statName">nome statistica</param>
        /// <param name="elapsed">durata evento tracciato</param>
        /// <param name="logLevReq">
        /// livello richiesto: 0:trace, 1:debug, 2:info, 3:warn, 4:error, 5: fatal, 6: off
        /// </param>
        /// <param name="evMultipl">moltiplicatore soglia x log statistica (default = 1)</param>
        /// <returns></returns>
        private async Task ProcStatLog(string statName, TimeSpan elapsed, int logLevReq, double evMultipl)
        {
            bool doWrite = await StatUpsert(statName, elapsed, evMultipl);
            if (doWrite)
            {
                // recupero e resetto
                ExecStats statRec = await StatReset(statName);
                string logMsg = $"Eseguito {statName} x {statRec.NumCall} | {statRec.AvgTime.TotalMilliseconds:N3}ms";
                switch (logLevReq)
                {
                    case 0:
                        Log.Trace(logMsg);
                        break;

                    case 1:
                        Log.Debug(logMsg);
                        break;

                    case 2:
                        Log.Info(logMsg);
                        break;

                    case 3:
                        Log.Warn(logMsg);
                        break;

                    case 4:
                        Log.Error(logMsg);
                        break;

                    case 5:
                        Log.Fatal(logMsg);
                        break;

                    case 6:
                    default:
                        Log.Error(logMsg);
                        break;
                }
            }
        }

        #endregion Private Methods

#if false

        public async Task<List<DoorOpTypeModel>> scanAndCompare()
        {
            List<DoorOpTypeModel> doorOpTypesList = new List<DoorOpTypeModel>();
            List<int> tempStats = new List<int>();
            List<DoorOpTypeModel> archiviedFiles = new List<DoorOpTypeModel>();
            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string rootPathNew = _configuration.GetValue<string>("CompoBaseDirs:NewCompoDir");
                string rootPathOld = _configuration.GetValue<string>("CompoBaseDirs:CurrCompoDir");

                System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create();
                string newMD5 = "";

                var oldFiles = await scanSrcDestDir(rootPathOld);
                var newFiles = await scanSrcDestDir(rootPathNew);

                long currFileDim = 0;
                DateTime currFileLastMod = DateTime.Now;
                // ciclo sui file in area NEW x confrontare con old
                foreach (var itemNew in newFiles)
                {
                    currFileDim = itemNew.FileDim;
                    currFileLastMod = itemNew.lastModTime;
                    newMD5 = itemNew.FileMD5;

                    var currTpl = oldFiles.Where(t => t.FileRelPath == itemNew.FileRelPath.Replace("NewComp", "CurComp") && t.FileMD5 == itemNew.FileMD5).FirstOrDefault();
                    if (currTpl != null)
                    {
                        // verifica sul DB
                        archiviedFiles = await DoorOpTypeGetByPath(currTpl.FileBaseDir);
                        var path2Search = archiviedFiles
                                                    .Where(x => x.OpCode == currTpl.FileAbsPath)
                                                    .FirstOrDefault();
                        tempStats.Add(0);
                        if (path2Search == null)
                        {
                        }
                        else if (path2Search.FileMD5 != newMD5 || path2Search.FileDim != currFileDim || path2Search.LastMod != currFileLastMod)
                        {
                            path2Search.FileDim = currFileDim;
                            path2Search.FileMD5 = newMD5;
                            path2Search.LastMod = currFileLastMod;
                            path2Search.Description = "modded";
                            path2Search.status = 2;
                            //await dbController.DoorOpTypeUpdate(path2Search);
                        }
                    }
                    else
                    {
                        DoorOpTypeModel tempTpl = new DoorOpTypeModel()
                        {
                            ParentId = 0,
                            //-.-------Description = $"Template for {itemNew.HwCode}",
                            OpCode = @$"{itemNew.FileAbsPath.Replace("NewComp", "CurComp")}",
                            HasHw = true,
                            IsConcrete = true,
                            //HwCode = itemNew.HwCode,
                            FileDim = currFileDim,
                            FileMD5 = newMD5,
                            LastMod = currFileLastMod,
                            status = 1
                        };
                        doorOpTypesList.Add(tempTpl);
                        oldFiles.Add(itemNew);
                    }
                }
                string currKey = $"{Constants.rKeyDoorOpType}";
                string rawData = JsonConvert.SerializeObject(doorOpTypesList, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
                archiviedFiles.Clear();
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"scanAndCompare in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during scanAndCompare: {exc}{Environment.NewLine}");
            }

            return doorOpTypesList;
        }

#endif
        /// <summary>
        /// Esegue scansione dir richeista
        /// </summary>
        /// <param name="rootPath"></param>
        /// <returns></returns>
#if false
        public async Task<List<FileDTO>> scanSrcDestDir(string rootPath)
        {
            await Task.Delay(1);
            List<FileDTO> dirAFiles = new List<FileDTO>();

            try
            {
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();

                string[] dirs = Directory.GetDirectories(rootPath);

                using (MD5 md5 = MD5.Create())
                {
                    foreach (var dir in dirs)
                    {
                        string[] iniFiles = Directory.GetFiles(dir, "Config.ini");
                        string compoCode = "";
                        foreach (var file in iniFiles)
                        {
                            List<string> lines = File.ReadAllLines(file).ToList();
                            IniFile fIni = new IniFile(file);

                            var compoName = fIni.ReadString("Compo", "Name", "COMPONAME");
                            var compoT = fIni.ReadString("Template", "Name", "TEMPSHAPE");
                            compoCode = compoName.Split("/")[0].Trim();
                        }
                        string[] templateDirectories = Directory.GetDirectories(dir);

                        foreach (var tplDir in templateDirectories)
                        {
                            string[] tpls = Directory.GetFiles(tplDir, "*");
                            var archiviedFiles = dbController.DoorOpTypeGetByPath(tplDir);
                            foreach (var tpl in tpls)
                            {
                                FileInfo fi = new FileInfo(tpl);
                                var fileName = Path.GetFileName(tpl).Split("\\")[Path.GetFileName(tpl).Split("\\").Length - 1];
                                var fileContent = File.ReadAllBytes(tpl);
                                var hash = md5.ComputeHash(fileContent);
                                var newMD5 = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
                                FileDTO currFileInfo = new FileDTO()
                                {
                                    HwCode = compoCode.Replace(" ", "_"),
                                    FileBaseDir = tplDir,
                                    FileAbsPath = fi.FullName,
                                    FileRelPath = fileName,
                                    FileDim = fi.Length,
                                    FileMD5 = newMD5,
                                    lastModTime = fi.LastWriteTime
                                };
                                dirAFiles.Add(currFileInfo);
                            }
                        }
                    }
                }

                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"scanSrcDestDir in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Exception during scanSrcDestDir: {exc}{Environment.NewLine}");
            }
            return dirAFiles;
        }

#endif
    }
}