zaccaria.majid
645 lines
22 KiB
C#
645 lines
22 KiB
C#
using EgwCoreLib.Razor.Data;
|
|
using Microsoft.AspNetCore.Identity.UI.Services;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using StackExchange.Redis;
|
|
using System.Diagnostics;
|
|
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
|
|
|
|
#region Company methods
|
|
|
|
|
|
/// <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;
|
|
}
|
|
|
|
/// <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;
|
|
}
|
|
|
|
#endregion Company methods
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
|
|
#region Cache 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;
|
|
}
|
|
|
|
public async Task<bool> FlushRedisCache()
|
|
{
|
|
await Task.Delay(1);
|
|
RedisValue pattern = new RedisValue($"{redisBaseAddr}");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return answ;
|
|
}
|
|
|
|
#endregion Cache methods
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
|
|
#region Security Methods
|
|
|
|
public string DecriptData(string encData)
|
|
{
|
|
return SteamCrypto.DecryptString(encData, passPhrase);
|
|
}
|
|
|
|
public string EncriptData(string rawData)
|
|
{
|
|
return SteamCrypto.EncryptString(rawData, passPhrase);
|
|
}
|
|
|
|
#endregion Security Methods
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
|
|
#region User Methods
|
|
|
|
/// <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>
|
|
/// 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;
|
|
}
|
|
|
|
#endregion User Methods
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
|
|
#region Roles Methods
|
|
|
|
/// <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;
|
|
}
|
|
|
|
#endregion Roles Methods
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
|
|
#region Order status Methods
|
|
|
|
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;
|
|
}
|
|
|
|
#endregion Order status Methods
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
|
|
#region Order Methods
|
|
|
|
/// <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);
|
|
await Task.Delay(1);
|
|
return dbResult;
|
|
}
|
|
|
|
#endregion Order Methods
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
|
|
#region Door Methods
|
|
|
|
/// <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>
|
|
/// 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...
|
|
RedisValue pattern = new RedisValue($"{rKeyDoor}:{currRec.DoorId}:*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
// elimino cache redis dati ordine...
|
|
pattern = new RedisValue($"{rKeyOrderStatus}:*");
|
|
answ = await ExecFlushRedisPattern(pattern);
|
|
await Task.Delay(1);
|
|
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 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);
|
|
await Task.Delay(1);
|
|
return dbResult;
|
|
}
|
|
|
|
#endregion Door Methods
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------------*/
|
|
|
|
#region ListValues Methods
|
|
|
|
/// <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;
|
|
}
|
|
|
|
#endregion ListValues Methods
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected 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
|
|
|
|
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 rKeyOrderStatus = $"{redisBaseAddr}:Cache:OrderStatus";
|
|
protected const string rKeyUsers = $"{redisBaseAddr}:Cache:Users";
|
|
protected const string rKeyUsersView = $"{redisBaseAddr}:Cache:UsersView";
|
|
protected const string rKeyRoles = $"{redisBaseAddr}:Cache:Roles";
|
|
protected const string rKeyDoor = $"{redisBaseAddr}:Cache:Doors";
|
|
protected const string rKeyListValues = $"{redisBaseAddr}:Cache:ListValues";
|
|
|
|
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
|
|
}
|
|
} |