Samuele Locatelli
1447 lines
54 KiB
C#
1447 lines
54 KiB
C#
using EgwCoreLib.Razor.Data;
|
|
using Microsoft.AspNetCore.Identity.UI.Services;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using StackExchange.Redis;
|
|
using System.Diagnostics;
|
|
using System.Text;
|
|
using WebDoorCreator.Core;
|
|
using WebDoorCreator.Data.Controllers;
|
|
using WebDoorCreator.Data.DbModels;
|
|
|
|
namespace WebDoorCreator.UI.Data
|
|
{
|
|
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)
|
|
{
|
|
_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);
|
|
}
|
|
Log.Info("Avviata classe WebDoorCreatorService");
|
|
}
|
|
|
|
#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);
|
|
// elimino cache redis...
|
|
RedisValue pattern = new RedisValue($"{Constants.rKeyCompany}");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
await Task.Delay(1);
|
|
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>();
|
|
// 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");
|
|
return dbResult;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
|
|
/// <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>();
|
|
|
|
//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());
|
|
}
|
|
|
|
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 edgeType = "";
|
|
string sizeVal = "";
|
|
string swingType = "";
|
|
int numHier = 1;
|
|
List<GraphicParamsModel> listGraphicParams = new List<GraphicParamsModel>();
|
|
List<ListValuesTempModel> listValues = new List<ListValuesTempModel>();
|
|
ListValuesTempModel Values = new ListValuesTempModel();
|
|
|
|
dbController.TestTablesTruncate();
|
|
|
|
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]);
|
|
|
|
// parto con obj base
|
|
sizeVal = fIniDef.ReadString("Size", "Width", "0.0");
|
|
|
|
ListValuesTempModel listValObj = new ListValuesTempModel()
|
|
{
|
|
TableName = "DoorDef",
|
|
FieldName = "Sizing",
|
|
Value = "Width",
|
|
Label = "Width",
|
|
Ordinal = 1,
|
|
DefaultVal = sizeVal,
|
|
InputType = "TextBox",
|
|
isSerializable = true
|
|
};
|
|
listValues.Add(listValObj);
|
|
sizeVal = fIniDef.ReadString("Size", "Height", "0.0");
|
|
listValObj = new ListValuesTempModel()
|
|
{
|
|
TableName = "DoorDef",
|
|
FieldName = "Sizing",
|
|
Value = "Height",
|
|
Label = "Height",
|
|
Ordinal = 2,
|
|
DefaultVal = sizeVal,
|
|
InputType = "TextBox",
|
|
isSerializable = true
|
|
};
|
|
listValues.Add(listValObj);
|
|
sizeVal = fIniDef.ReadString("Size", "Thickness", "0.0");
|
|
listValObj = new ListValuesTempModel()
|
|
{
|
|
TableName = "DoorDef",
|
|
FieldName = "Sizing",
|
|
Value = "Thickness",
|
|
Label = "Thickness",
|
|
Ordinal = 3,
|
|
DefaultVal = sizeVal,
|
|
InputType = "TextBox",
|
|
isSerializable = true
|
|
};
|
|
listValues.Add(listValObj);
|
|
sizeVal = fIniDef.ReadString("Size", "Swing", "UNDEF");
|
|
listValObj = new ListValuesTempModel()
|
|
{
|
|
TableName = "DoorDef",
|
|
FieldName = "Sizing",
|
|
Value = "Swing",
|
|
Label = "Swing",
|
|
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 = "DoorDef",
|
|
FieldName = "EdgeS",
|
|
Value = "EdgesList",
|
|
Label = "EdgesList",
|
|
Ordinal = 0,
|
|
DefaultVal = edgesList.ToString(),
|
|
InputType = "ComboBox",
|
|
isSerializable = true
|
|
};
|
|
listValues.Add(listValObj);
|
|
sizeVal = fIniDef.ReadString("Edge", "HingeEdge", "UNDEF");
|
|
listValObj = new ListValuesTempModel()
|
|
{
|
|
TableName = "DoorDef",
|
|
FieldName = "Edge",
|
|
Value = "HingeEdge",
|
|
Label = "Hinge Edge",
|
|
Ordinal = 1,
|
|
DefaultVal = edgesList.ToString(),
|
|
InputType = "ComboBox",
|
|
isSerializable = true
|
|
};
|
|
listValues.Add(listValObj);
|
|
sizeVal = fIniDef.ReadString("Edge", "TopEdge", "UNDEF");
|
|
listValObj = new ListValuesTempModel()
|
|
{
|
|
TableName = "DoorDef",
|
|
FieldName = "Edge",
|
|
Value = "TopEdge",
|
|
Label = "Top Edge",
|
|
Ordinal = 2,
|
|
DefaultVal = edgesList.ToString(),
|
|
InputType = "ComboBox",
|
|
isSerializable = true
|
|
};
|
|
listValues.Add(listValObj);
|
|
sizeVal = fIniDef.ReadString("Edge", "BottomEdge", "UNDEF");
|
|
listValObj = new ListValuesTempModel()
|
|
{
|
|
TableName = "DoorDef",
|
|
FieldName = "Edge",
|
|
Value = "BottomEdge",
|
|
Label = "Bottom Edge",
|
|
Ordinal = 3,
|
|
DefaultVal = edgesList.ToString(),
|
|
InputType = "ComboBox",
|
|
isSerializable = true
|
|
};
|
|
listValues.Add(listValObj);
|
|
sizeVal = fIniDef.ReadString("Edge", "LockEdge", "UNDEF");
|
|
listValObj = new ListValuesTempModel()
|
|
{
|
|
TableName = "DoorDef",
|
|
FieldName = "Edge",
|
|
Value = "LockEdge",
|
|
Label = "Lock Edge",
|
|
Ordinal = 4,
|
|
DefaultVal = edgesList.ToString(),
|
|
InputType = "ComboBox",
|
|
isSerializable = true
|
|
};
|
|
listValues.Add(listValObj);
|
|
|
|
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");
|
|
bool compoTemplateIsActive = true;
|
|
string layerName = fIni.ReadString("Layer", "LayerName", "LAYER");
|
|
if (isActive == "0")
|
|
{
|
|
compoTemplateIsActive = false;
|
|
}
|
|
// lo slash indica l'alias
|
|
var compoNameSplit = compoName.Split("/");
|
|
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 = 0,
|
|
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);
|
|
//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);
|
|
|
|
return fatto;
|
|
}
|
|
|
|
public string DecriptData(string encData)
|
|
{
|
|
return SteamCrypto.DecryptString(encData, Constants.passPhrase);
|
|
}
|
|
|
|
/// <summary>
|
|
/// CElimina record posta
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DoorDelete(DoorModel currRec)
|
|
{
|
|
int DoorId = currRec.DoorId;
|
|
int OrderId = currRec.OrderId;
|
|
// elimino sul DB
|
|
bool answ = await dbController.DoorDelete(DoorId);
|
|
// svuoto cache
|
|
await DoorFlushCache(DoorId);
|
|
await DoorOpFlushCache(DoorId);
|
|
await OrderDetailFlushCache(OrderId);
|
|
await OrdersFlushCache();
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clean redis DOORS cache
|
|
/// </summary>
|
|
/// <param name="DoorId">0 = all</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DoorFlushCache(int DoorId)
|
|
{
|
|
RedisValue pattern = new RedisValue($"{Constants.rKeyDoor}:*");
|
|
if (DoorId > 0)
|
|
{
|
|
pattern = new RedisValue($"{Constants.rKeyDoor}:{DoorId}:*");
|
|
}
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Doors list by orderId
|
|
/// </summary>
|
|
public async Task<List<DoorModel>?> DoorGetByOrderId(int orderId)
|
|
{
|
|
string source = "DB";
|
|
List<DoorModel>? dbResult = new List<DoorModel>();
|
|
// 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<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");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add door
|
|
/// </summary>
|
|
/// <param name="newRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<int> DoorInsert(DoorModel newRec)
|
|
{
|
|
var dbResult = await dbController.DoorInsert(newRec);
|
|
// elimino cache redis dati ordine...
|
|
await OrderDetailFlushCache(newRec.OrderId);
|
|
await OrdersFlushCache();
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adding or removing a single door
|
|
/// </summary>
|
|
/// <param name="DoorId">Record id to edit or add</param>
|
|
/// <param name="isAdd">States if it has to be added or removing a door</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DoorModQty(int OrderId, int DoorId, bool isAdd)
|
|
{
|
|
var dbResult = await dbController.DoorModQty(DoorId, isAdd);
|
|
// svuoto cache
|
|
await DoorFlushCache(DoorId);
|
|
await DoorOpFlushCache(DoorId);
|
|
await OrderDetailFlushCache(OrderId);
|
|
await OrdersFlushCache();
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Eliminazione DoorOP
|
|
/// </summary>
|
|
/// <param name="currDoorOp"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DoorOpDelete(DoorOpModel currDoorOp)
|
|
{
|
|
var 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();
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Eliminazione DoorOP list
|
|
/// </summary>
|
|
/// <param name="currDoorOpList"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DoorOpDeleteRange(List<DoorOpModel> currDoorOpList)
|
|
{
|
|
var 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();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clean redis DOORS OP cache
|
|
/// </summary>
|
|
/// <param name="DoorId">0 = all</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DoorOpFlushCache(int DoorId)
|
|
{
|
|
RedisValue pattern = new RedisValue($"{Constants.rKeyDoorOp}*");
|
|
if (DoorId > 0)
|
|
{
|
|
pattern = new RedisValue($"{Constants.rKeyDoorOp}:{DoorId}*");
|
|
}
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Doors list by orderId
|
|
/// </summary>
|
|
public async Task<List<DoorOpModel>?> DoorOpGetByDoorId(int doorId)
|
|
{
|
|
string source = "DB";
|
|
List<DoorOpModel>? dbResult = new List<DoorOpModel>();
|
|
// 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");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// lista DoorOpList necessarie all'init
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<DoorOpTypeModel>> DoorOpGetDefault()
|
|
{
|
|
List<DoorOpTypeModel>? dbResult = new List<DoorOpTypeModel>();
|
|
string source = "DB";
|
|
// cerco da cache
|
|
string currKey = $"{Constants.rKeyDoorOpType}:DEFAULT";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
#if false
|
|
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
|
|
{
|
|
#endif
|
|
dbResult = await dbController.DoorOpTypeGetDefault();
|
|
#if false
|
|
rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
|
|
await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
|
|
}
|
|
#endif
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new List<DoorOpTypeModel>();
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"DoorOpGetDefault | {source} in: {ts.TotalMilliseconds} ms");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
var 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();
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Doors list by orderId
|
|
/// </summary>
|
|
public async Task<List<DoorOpTypeModel>?> DoorOpTypeGetAll()
|
|
{
|
|
string source = "DB";
|
|
List<DoorOpTypeModel>? dbResult = new List<DoorOpTypeModel>();
|
|
// cerco da cache
|
|
string currKey = $"{Constants.rKeyDoorOpType}";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
#if false
|
|
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
|
|
{
|
|
rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
|
|
await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
|
|
}
|
|
#endif
|
|
dbResult = dbController.DoorOpTypeGetAll();
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new List<DoorOpTypeModel>();
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"DoorOpTypeGetAll | {source} in: {ts.TotalMilliseconds} ms");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiornamento DoorOP
|
|
/// </summary>
|
|
/// <param name="currDoorOp"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DoorOpUpdate(DoorOpModel currDoorOp)
|
|
{
|
|
var dbResult = await dbController.DoorOpUpdate(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();
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update or add door
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> DoorUpsert(DoorModel currRec)
|
|
{
|
|
var 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();
|
|
return dbResult;
|
|
}
|
|
|
|
public string EncriptData(string rawData)
|
|
{
|
|
return SteamCrypto.EncryptString(rawData, Constants.passPhrase);
|
|
}
|
|
|
|
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();
|
|
|
|
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
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
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>();
|
|
// 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");
|
|
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 = "";
|
|
// 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");
|
|
return dbResult;
|
|
}
|
|
|
|
public async Task<bool> ListValuesLuaNgeInsert(string rootPath)
|
|
{
|
|
List<ListValuesTempModel> values = new List<ListValuesTempModel>();
|
|
string[] dirs = Directory.GetDirectories(rootPath);
|
|
foreach (string dir in dirs)
|
|
{
|
|
string compoCode = "";
|
|
string[] templateDirectories = Directory.GetDirectories(dir);
|
|
|
|
string[] iniFiles = Directory.GetFiles(dir, "Config.ini");
|
|
|
|
int ordin = 1;
|
|
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");
|
|
compoCode = compoName.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]}".Replace(" ", "_"),
|
|
Label = @$"{tName[tName.Length - 1]}",
|
|
Ordinal = 0,
|
|
DefaultVal = " ",
|
|
InputType = " ",
|
|
};
|
|
values.Add(folderNames);
|
|
}
|
|
|
|
foreach (string templateFile in templateFiles)
|
|
{
|
|
ListValuesTempModel temp = new ListValuesTempModel()
|
|
{
|
|
TableName = $"{compoCode}".Replace(" ", "_"),
|
|
FieldName = "template",
|
|
Value = @$"{tName[tName.Length - 1]}\{Path.GetFileName(templateFile).Split(".")[0]}".Replace(" ", "_"),
|
|
Label = Path.GetFileName(templateFile).Split(".")[0],
|
|
Ordinal = ordin,
|
|
DefaultVal = " ",
|
|
InputType = " ",
|
|
};
|
|
|
|
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($"GraphicParamsGetAll | Duplicated key: {temp.TableName} {temp.FieldName} {temp.Value} ");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool fatto = await dbController.ListValuesAdd(values);
|
|
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add new order
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> OrderAdd(OrderModel currRec)
|
|
{
|
|
var dbResult = await dbController.OrderAdd(currRec);
|
|
// elimino cache redis...
|
|
RedisValue pattern = new RedisValue($"{Constants.rKeyOrderStatus}:*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
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.rKeyOrderDetail}:*");
|
|
if (OrderId > 0)
|
|
{
|
|
pattern = new RedisValue($"{Constants.rKeyOrderDetail}:{OrderId}");
|
|
}
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove order
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> OrderRem(int OrdId)
|
|
{
|
|
var dbResult = await dbController.OrderRem(OrdId);
|
|
// elimino cache redis...
|
|
RedisValue pattern = new RedisValue($"{Constants.rKeyOrderStatus}:*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clean redis ORDERS cache
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <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>();
|
|
// 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
|
|
{
|
|
dbResult = dbController.OrderStatusGetAll(companyId, orderStatus, dataFrom, dataTo);
|
|
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");
|
|
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
|
|
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");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// roles list
|
|
/// </summary>
|
|
public async Task<List<AspNetRoles>?> RolesGetAll()
|
|
{
|
|
string source = "DB";
|
|
|
|
List<AspNetRoles>? dbResult = new List<AspNetRoles>();
|
|
// 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");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Users roles list
|
|
/// </summary>
|
|
public async Task<List<AspNetUsers>?> UsersGetAll()
|
|
{
|
|
string source = "DB";
|
|
|
|
List<AspNetUsers>? dbResult = new List<AspNetUsers>();
|
|
// 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");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Users roles list
|
|
/// </summary>
|
|
public async Task<AspNetUsers> UsersGetById(string userId)
|
|
{
|
|
string source = "DB";
|
|
|
|
AspNetUsers dbResult = new AspNetUsers();
|
|
// 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");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Users roles list
|
|
/// </summary>
|
|
public async Task<List<UsersViewModel>?> UserViewGetAll()
|
|
{
|
|
string source = "DB";
|
|
|
|
List<UsersViewModel>? dbResult = new List<UsersViewModel>();
|
|
// 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");
|
|
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>>();
|
|
// 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");
|
|
return dbResult;
|
|
}
|
|
|
|
public async Task<bool> VocLemmaInsert(string rootPath)
|
|
{
|
|
bool fatto = false;
|
|
|
|
List<VocabularyTempModel> VocLemmas = new List<VocabularyTempModel>();
|
|
|
|
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].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("=");
|
|
//string trad = "";
|
|
if (lineSplit.Length != 1)
|
|
{
|
|
VocabularyTempModel newVocLemma = new VocabularyTempModel()
|
|
{
|
|
Lingua = lang,
|
|
Lemma = lineSplit[0],
|
|
Traduzione = lineSplit[1]
|
|
};
|
|
VocLemmas.Add(newVocLemma);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fatto = await dbController.VocLemmaInsert(VocLemmas);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"VocLemmaInsert in: {ts.TotalMilliseconds} ms");
|
|
return fatto;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Fields
|
|
|
|
protected Random rnd = new Random();
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Private Fields
|
|
|
|
private static IConfiguration _configuration = null!;
|
|
|
|
private static JsonSerializerSettings? JSSettings;
|
|
|
|
private static Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
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>
|
|
/// Oggetto per connessione a REDIS
|
|
/// </summary>
|
|
private IConnectionMultiplexer redisConn;
|
|
|
|
/// <summary>
|
|
/// Oggetto DB redis da impiegare x chiamate R/W
|
|
/// </summary>
|
|
private IDatabase redisDb = null!;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Properties
|
|
|
|
/// <summary>
|
|
/// Durata cache lunga (+ 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 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;
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |