Samuele Locatelli
850 lines
33 KiB
C#
850 lines
33 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 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($"{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 = $"{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;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
|
|
public string DecriptData(string encData)
|
|
{
|
|
return SteamCrypto.DecryptString(encData, passPhrase);
|
|
}
|
|
|
|
/// <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 doorId, bool isAdd)
|
|
{
|
|
var dbResult = await dbController.DoorModQty(doorId, isAdd);
|
|
// elimino cache redis dati porta...
|
|
RedisValue pattern = new RedisValue($"{rKeyDoor}:*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
// elimino cache redis dati ordine...
|
|
pattern = new RedisValue($"{rKeyOrderStatus}:*");
|
|
answ = await ExecFlushRedisPattern(pattern);
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Doors list by orderId
|
|
/// </summary>
|
|
public async Task<List<DoorModel>?> DoorsGetByOrderId(int orderId)
|
|
{
|
|
string source = "DB";
|
|
|
|
List<DoorModel>? dbResult = new List<DoorModel>();
|
|
// cerco da cache
|
|
string currKey = $"{rKeyDoor}:{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($"DoorsGetByOrderId | {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 porta...
|
|
bool answ = await DoorFlushCache(newRec.DoorId);
|
|
// elimino cache redis dati ordine...
|
|
answ = answ && await OrdersFlushCache();
|
|
return dbResult;
|
|
}
|
|
|
|
/// <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($"{rKeyDoor}:*");
|
|
if (DoorId > 0)
|
|
{
|
|
pattern = new RedisValue($"{rKeyDoor}:{DoorId}:*");
|
|
}
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return answ;
|
|
}
|
|
|
|
/// <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, passPhrase);
|
|
}
|
|
|
|
public async Task<bool> FlushRedisCache()
|
|
{
|
|
await Task.Delay(1);
|
|
RedisValue pattern = new RedisValue($"{redisBaseAddr}*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Getting a list of all the active components
|
|
/// </summary>
|
|
/// <param name="rootPath">Path to start</param>
|
|
/// <returns></returns>
|
|
public async Task<List<string>> GetAllActiveCompo(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;
|
|
}
|
|
|
|
public async Task<List<OrderStatusViewModel>?> GetOrderStatus(int companyId, int orderStatus, DateTime dataFrom, DateTime dataTo)
|
|
{
|
|
string source = "DB";
|
|
|
|
List<OrderStatusViewModel>? dbResult = new List<OrderStatusViewModel>();
|
|
// cerco da cache
|
|
string currKey = $"{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.GetOrderStatus(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($"GetOrderStatus | {source} in: {ts.TotalMilliseconds} ms");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// roles list
|
|
/// </summary>
|
|
public async Task<List<AspNetRoles>?> GetRolesAll()
|
|
{
|
|
string source = "DB";
|
|
|
|
List<AspNetRoles>? dbResult = new List<AspNetRoles>();
|
|
// cerco da cache
|
|
string currKey = 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.GetRolesAll();
|
|
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($"GetRolesAll | {source} in: {ts.TotalMilliseconds} ms");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Users roles list
|
|
/// </summary>
|
|
public async Task<List<AspNetUsers>?> GetUsersAll()
|
|
{
|
|
string source = "DB";
|
|
|
|
List<AspNetUsers>? dbResult = new List<AspNetUsers>();
|
|
// cerco da cache
|
|
string currKey = 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.GetUsersAll();
|
|
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($"GetUsersAll | {source} in: {ts.TotalMilliseconds} ms");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Users roles list
|
|
/// </summary>
|
|
public async Task<AspNetUsers> GetUsersById(string userId)
|
|
{
|
|
string source = "DB";
|
|
|
|
AspNetUsers dbResult = new AspNetUsers();
|
|
// cerco da cache
|
|
string currKey = $"{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.GetUsersById(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($"GetUsersById | {source} in: {ts.TotalMilliseconds} ms");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Users roles list
|
|
/// </summary>
|
|
public async Task<List<UsersViewModel>?> GetUserView()
|
|
{
|
|
string source = "DB";
|
|
|
|
List<UsersViewModel>? dbResult = new List<UsersViewModel>();
|
|
// cerco da cache
|
|
string currKey = 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.GetUserView();
|
|
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($"GetUserView | {source} in: {ts.TotalMilliseconds} ms");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Company list
|
|
/// </summary>
|
|
public async Task<List<ListValuesModel>?> ListValuesGetAll(string tableName, string fieldName)
|
|
{
|
|
string source = "DB";
|
|
|
|
List<ListValuesModel>? dbResult = new List<ListValuesModel>();
|
|
// cerco da cache
|
|
string currKey = $"{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;
|
|
}
|
|
|
|
/// <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($"{rKeyOrderStatus}:*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return dbResult;
|
|
}
|
|
/// <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($"{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($"{rKeyOrderStatus}:*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setting all the component list
|
|
/// </summary>
|
|
/// <param name="rootPath">Path to start</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> SetAllCompoList(string rootPath)
|
|
{
|
|
bool fatto = false;
|
|
string compoName = "";
|
|
int n = 1;
|
|
int i = 1;
|
|
List<GraphicParamsModel> listGraphicParams = new List<GraphicParamsModel>();
|
|
|
|
dbController.TablesTruncate();
|
|
|
|
List<string> listActiveCompo = await GetAllActiveCompo(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);
|
|
|
|
foreach (string dir in dirs)
|
|
{
|
|
//iterazione per cercare tutti i file "Config.ini" nelle sotto directory
|
|
string[] files = Directory.GetFiles(dir, "Config.ini");
|
|
|
|
compoName = "";
|
|
//iterazione per cercare tutti i file "Config.ini" nelle sotto directory
|
|
foreach (string file in files)
|
|
{
|
|
List<string> lines = File.ReadAllLines(file).ToList(); //leggo tutte le linee del file
|
|
IniFile fIni = new IniFile(file);
|
|
Guid opCode = Guid.NewGuid();
|
|
compoName = fIni.ReadString("Compo", "Name", "COMPONAME"); //cerco la sezione del file ed estraggo il nome del componente
|
|
var isActive = fIni.ReadString("Template", "IsActive", "1");//cerco la sezione del file ed estraggo se i template sono attivi per il seguente componente
|
|
bool compoTemplateIsActive = true;
|
|
string layerName = fIni.ReadString("Layer", "LayerName", "LAYER");
|
|
if (isActive == "0")
|
|
{
|
|
compoTemplateIsActive = false;
|
|
}
|
|
var compoNameSplit = compoName.Split("/"); // lo slash indica l'alias
|
|
if (listActiveCompo.Contains(compoNameSplit[0].ToString()))
|
|
{
|
|
HardwareModel compoConfig = new HardwareModel() { compoName = compoNameSplit[0].ToString(), compoAlias = compoNameSplit[1].ToString(), compoLayerName = layerName, compoTemplateIsActive = compoTemplateIsActive }; //creo il componente (padre)
|
|
await dbController.CompoAdd(compoConfig);
|
|
listCompoS.Add(compoConfig);
|
|
var lineToSearch = lines.Where(x => x.Contains("[Graphic")).ToList(); //cerco all'interno del file tutte le sezioni che contengono "[Graphic" così da poter prendere il nome della sezione ES: [Graphic parameters1] = Graphic parameters1
|
|
n = 1;
|
|
foreach (var match in lineToSearch)
|
|
{
|
|
listGraphicParams = await SetGraphicParams(file, match, n, i);
|
|
n++;
|
|
}
|
|
|
|
DoorOpTypeModel doorOpType = new DoorOpTypeModel()
|
|
{
|
|
Description = $"DOOR OPERATION TYPE FOR {compoNameSplit[0].ToString()}",
|
|
OpCode = opCode.ToString(),
|
|
HasHw = true,
|
|
IsConcrete = true,
|
|
HwCode = compoNameSplit[0].ToString(),
|
|
DoorOpIdPathFromPatriarch = HierarchyId.Parse("/1/"),
|
|
JsoncConfig = JsonConvert.SerializeObject(listGraphicParams)
|
|
};
|
|
|
|
await dbController.DoorOpTypeAdd(doorOpType);
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
List<Edges> edges = new List<Edges>();
|
|
edges.Add(new Edges());
|
|
List<Sizing> sizing = new List<Sizing>();
|
|
sizing.Add(new Sizing());
|
|
List<Opening> opening = new List<Opening>();
|
|
opening.Add(new Opening());
|
|
Guid opCodeEdges = Guid.NewGuid();
|
|
Guid opCodeSizing = Guid.NewGuid();
|
|
Guid opCodeOpening = Guid.NewGuid();
|
|
DoorOpTypeModel doorOpTypeEdges = new DoorOpTypeModel()
|
|
{
|
|
Description = "DOOR OPERATION TYPE FOR Edges",
|
|
OpCode = opCodeEdges.ToString(),
|
|
HasHw = false,
|
|
IsConcrete = true,
|
|
DoorOpIdPathFromPatriarch = HierarchyId.Parse("/1/"),
|
|
JsoncConfig = JsonConvert.SerializeObject(edges)
|
|
};
|
|
DoorOpTypeModel doorOpTypeSizing = new DoorOpTypeModel()
|
|
{
|
|
Description = "DOOR OPERATION TYPE FOR Sizing",
|
|
OpCode = opCodeSizing.ToString(),
|
|
HasHw = false,
|
|
IsConcrete = true,
|
|
DoorOpIdPathFromPatriarch = HierarchyId.Parse("/1/"),
|
|
JsoncConfig = JsonConvert.SerializeObject(sizing)
|
|
};
|
|
DoorOpTypeModel doorOpTypeOpening = new DoorOpTypeModel()
|
|
{
|
|
Description = "DOOR OPERATION TYPE FOR Opening",
|
|
OpCode = opCodeOpening.ToString(),
|
|
HasHw = false,
|
|
IsConcrete = true,
|
|
DoorOpIdPathFromPatriarch = HierarchyId.Parse("/1/"),
|
|
JsoncConfig = JsonConvert.SerializeObject(opening)
|
|
};
|
|
|
|
await dbController.DoorOpTypeAdd(doorOpTypeEdges);
|
|
await dbController.DoorOpTypeAdd(doorOpTypeSizing);
|
|
await dbController.DoorOpTypeAdd(doorOpTypeOpening);
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setting the graphic parameters for components
|
|
/// </summary>
|
|
/// <param name="file"></param>
|
|
/// <param name="match"></param>
|
|
/// <param name="n"></param>
|
|
/// <param name="i"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<GraphicParamsModel>> SetGraphicParams(string file, string match, int n, int i)
|
|
{
|
|
await Task.Delay(1);
|
|
List<GraphicParamsModel> listGraphicParams = new List<GraphicParamsModel>();
|
|
|
|
IniFile fIni = new IniFile(file);
|
|
//estraggo la lista di componenti che sono attive per il cliente
|
|
var graphicParamsName = fIni.ReadSection(match.Substring(1, match.Length - 2)); //cerco il contenuto delle sezioni
|
|
if (int.Parse(match.Substring(match.Length - 2, 1)) == n) //controllo se tra i numeri di graphic params vi è un buco ES: Graphic parameters1 Graphic parameters3 se il buco c'è salto tutti i parametri che stanno dopo il buco ==> tengo conto solo di Graphic parameters1
|
|
{
|
|
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];
|
|
}
|
|
|
|
GraphicParamsModel graphicParams = new GraphicParamsModel() { compoId = i, graphicParamsN = match.Substring(1, match.Length - 2), graphicParamKey = param.Split("=")[0], graphicParamName = CompoParamName, graphicParamAlias = CompoParamAlias, graphicParamType = compoParamsSplit[0], graphicParamDefaultVal = compoParamsSplit[2] };
|
|
listGraphicParams.Add(graphicParams); //creo nuovo oggetto parametro che conterrà anche il nome del componente per creare relazione
|
|
await dbController.ParamAdd(graphicParams);
|
|
}
|
|
else
|
|
{
|
|
GraphicParamsModel graphicParams = new GraphicParamsModel() { compoId = i, graphicParamsN = match.Substring(1, match.Length - 2), graphicParamKey = param.Split("=")[0], graphicParamName = compoParams };
|
|
listGraphicParams.Add(graphicParams); //creo nuovo oggetto parametro che conterrà anche il nome del componente per creare relazione
|
|
await dbController.ParamAdd(graphicParams);
|
|
}
|
|
}
|
|
}
|
|
|
|
return listGraphicParams;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Fields
|
|
|
|
protected const string passPhrase = "9eb4660f-8753-46bc-b23b-08759ba03fe9";
|
|
|
|
//#region Protected Fields
|
|
protected const string redisBaseAddr = "WDC";
|
|
|
|
//#endregion Public Methods
|
|
protected const string rKeyCompany = $"{redisBaseAddr}:Cache:Company";
|
|
|
|
protected const string rKeyDoor = $"{redisBaseAddr}:Cache:Doors";
|
|
|
|
protected const string rKeyListValues = $"{redisBaseAddr}:Cache:ListValues";
|
|
|
|
protected const string rKeyOrderStatus = $"{redisBaseAddr}:Cache:OrderStatus";
|
|
|
|
protected const string rKeyRoles = $"{redisBaseAddr}:Cache:Roles";
|
|
|
|
protected const string rKeyUsers = $"{redisBaseAddr}:Cache:Users";
|
|
|
|
protected const string rKeyUsersView = $"{redisBaseAddr}:Cache:UsersView";
|
|
|
|
protected Random rnd = new Random();
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Private Fields
|
|
|
|
private static IConfiguration _configuration = null!;
|
|
|
|
private static JsonSerializerSettings? JSSettings;
|
|
|
|
private static NLog.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;
|
|
|
|
//ISubscriber sub = redis.GetSubscriber();
|
|
/// <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
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
}
|
|
} |