Samuele Locatelli
919 lines
34 KiB
C#
919 lines
34 KiB
C#
using MP.Core.Conf;
|
|
using MP.Data.DbModels;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using StackExchange.Redis;
|
|
using System.Diagnostics;
|
|
using EgwCoreLib.Razor;
|
|
using EgwCoreLib.Razor.Data;
|
|
using EgwCoreLib.Utils;
|
|
|
|
namespace MP.INVE.Data
|
|
{
|
|
public class MiDataService : IDisposable
|
|
{
|
|
#region Public Constructors
|
|
|
|
public MiDataService(IConfiguration configuration, ILogger<MiDataService> logger)
|
|
{
|
|
_logger = logger;
|
|
_logger.LogInformation("Starting MiDataService INIT");
|
|
_configuration = configuration;
|
|
|
|
// setup compoenti REDIS
|
|
redisConn = ConnectionMultiplexer.Connect(_configuration.GetConnectionString("Redis"));
|
|
redisConnAdmin = ConnectionMultiplexer.Connect(_configuration.GetConnectionString("RedisAdmin"));
|
|
redisDb = redisConn.GetDatabase();
|
|
|
|
// leggo cache lungo periodo
|
|
int.TryParse(_configuration.GetValue<string>("ServerConf:redisLongTimeCache"), out redisLongTimeCache);
|
|
|
|
_logger.LogInformation("Redis INIT");
|
|
|
|
// conf DB
|
|
string connStrData = _configuration.GetConnectionString("MP.Data");
|
|
string connStrInve = _configuration.GetConnectionString("MP.Inve");
|
|
if (string.IsNullOrEmpty(connStrData) || string.IsNullOrEmpty(connStrInve))
|
|
{
|
|
_logger.LogError($"DbController: ConnString empty! connStrData: {connStrData} | connStrInve: {connStrInve}");
|
|
}
|
|
else
|
|
{
|
|
dbController = new MP.Data.Controllers.MpInveController(configuration);
|
|
_logger.LogInformation("DbController OK");
|
|
}
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Properties
|
|
|
|
public static MP.Data.Controllers.MpInveController dbController { get; set; } = null!;
|
|
|
|
/// <summary>
|
|
/// Dizionario dei tag configurati per IOB
|
|
/// </summary>
|
|
public Dictionary<string, List<TagData>> currTagConf { get; set; } = new Dictionary<string, List<TagData>>();
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Aggiornamento record selezionato
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<AnagArticoli_MAG> artBySearch(string artSearch)
|
|
{
|
|
var dbResult = dbController.artBySearch(artSearch);
|
|
// elimino cache redis...
|
|
await Task.Delay(1);
|
|
return dbResult;
|
|
}
|
|
|
|
public async Task<bool> CloseOpenSessione(int sessID, bool flgClose)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
bool result = false;
|
|
string source = "DB";
|
|
result = await dbController.CloseOpenSessione(sessID, flgClose);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"CloseOpenSessione Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public async Task<List<ConfigModel>> ConfigGetAll()
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<ConfigModel>? result = new List<ConfigModel>();
|
|
string source = "DB";
|
|
// cerco in redis...
|
|
RedisValue rawData = await redisDb.StringGetAsync(redisConfigBaseAddr);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<ConfigModel>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = await Task.FromResult(dbController.ConfigGetAll());
|
|
// serializzo e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(redisConfigBaseAddr, rawData, getRandTOut(redisLongTimeCache));
|
|
source = "DB";
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<ConfigModel>();
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"ConfigGetAll Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reset dati cache config
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task ConfigResetCache()
|
|
{
|
|
await redisDb.StringSetAsync(redisConfigBaseAddr, "");
|
|
}
|
|
|
|
public async Task<bool> DeleteMag(AnagMagModel Mag)
|
|
{
|
|
bool result = false;
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
result = await dbController.DeleteMag(Mag);
|
|
// elimino cache redis...
|
|
RedisValue pattern = new RedisValue($"{redisMagList}:*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"DeleteMag | Codice magazzino: {Mag.CodMag} | Descrizione magazzino: {Mag.DescMag} | {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public async Task<bool> deleteScansione(ScanDataModel scan)
|
|
{
|
|
bool result = false;
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
result = await dbController.deleteScansione(scan);
|
|
// elimino cache redis...
|
|
RedisValue pattern = new RedisValue($"{redisScanBaseAddr}*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"deleteScansione | Id scansione: {scan.ScanID} | Codice scansionato: {scan.ScanValue} | {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
// elimino record dal DB
|
|
}
|
|
|
|
public async Task<bool> deleteSessione(InventorySessionModel session)
|
|
{
|
|
bool result = false;
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
result = await dbController.deleteSessione(session);
|
|
// elimino cache redis...
|
|
RedisValue pattern = new RedisValue($"{redisBaseAddr}{redisSessionBaseAddr}*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"deleteSessione | Id sessione: {session.InveSessID} | Id sessione: {session.Description} | {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
// elimino record dal DB
|
|
}
|
|
|
|
public string DeriptData(string encData)
|
|
{
|
|
return SteamCrypto.DecryptString(encData, passPhrase);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
|
|
public List<AnagLottoModel> ElencoLotti()
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<AnagLottoModel>? result = new List<AnagLottoModel>();
|
|
// cerco in redis...
|
|
RedisValue rawData = redisDb.StringGet(redisLottiInterni);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<AnagLottoModel>>($"{rawData}");
|
|
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbController.ElencoLotti();
|
|
// serializzo e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
redisDb.StringSetAsync(redisLottiInterni, rawData, getRandTOut(redisLongTimeCache));
|
|
source = "DB";
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<AnagLottoModel>();
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"ElencoLotti Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public List<AnagOperatoriModel> ElencoOperatori()
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<AnagOperatoriModel>? result = new List<AnagOperatoriModel>();
|
|
// cerco in redis...
|
|
RedisValue rawData = redisDb.StringGet(redisElencoOperatori);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<AnagOperatoriModel>>($"{rawData}");
|
|
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbController.ElencoOperatori();
|
|
// serializzo e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
redisDb.StringSetAsync(redisElencoOperatori, rawData, getRandTOut(redisLongTimeCache));
|
|
source = "DB";
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<AnagOperatoriModel>();
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"ElencoOperatori Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public List<AnagUdcModel> ElencoUDC()
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<AnagUdcModel>? result = new List<AnagUdcModel>();
|
|
// cerco in redis...
|
|
RedisValue rawData = redisDb.StringGet(redisUdcBaseAddr);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<AnagUdcModel>>($"{rawData}");
|
|
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbController.ElencoUdc();
|
|
// serializzo e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
redisDb.StringSetAsync(redisUdcBaseAddr, rawData, getRandTOut(redisLongTimeCache));
|
|
source = "DB";
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<AnagUdcModel>();
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"ElencoUDC Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public string EncriptData(string rawData)
|
|
{
|
|
return SteamCrypto.EncryptString(rawData, passPhrase);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Export sessione scansioni inventario (in dettaglio)
|
|
/// </summary>
|
|
/// <param name="sessID"></param>
|
|
/// <returns></returns>
|
|
public List<VExpInveSession> ExportSessionDetail(int sessID)
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<VExpInveSession>? result = new List<VExpInveSession>();
|
|
result = dbController.ExportSessionDetail(sessID);
|
|
source = "DB";
|
|
if (result == null)
|
|
{
|
|
result = new List<VExpInveSession>();
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"ExportSessionDetail Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Svuota tutta la sessione dalla root di gestione
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<bool> FlushRedisCache()
|
|
{
|
|
await Task.Delay(1);
|
|
RedisValue pattern = new RedisValue($"{redisBaseAddr}*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Svuota solo il pat2Flush richiesto
|
|
/// </summary>
|
|
/// <param name="basePattern"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> FlushRedisCache(string basePattern)
|
|
{
|
|
await Task.Delay(1);
|
|
RedisValue pattern = new RedisValue($"{basePattern}*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary> Svuota cahce sessioni inventario <returns></returns>
|
|
public async Task<bool> FlushSessInvCache()
|
|
{
|
|
bool answ = await FlushRedisCache(redisSessionCurrList) && await FlushRedisCache(redisSessionHistList);
|
|
return answ;
|
|
}
|
|
|
|
public async Task<bool> InsertNewMag(AnagMagModel newMag)
|
|
{
|
|
bool result = false;
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
result = await dbController.InsertNewMag(newMag);
|
|
// elimino cache redis...
|
|
RedisValue pattern = new RedisValue($"{redisMagList}");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"InsertNewMag | Codice magazzino: {newMag.CodMag} | Descrizione magazzino: {newMag.DescMag} | {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
// aggiungo record al DB
|
|
}
|
|
|
|
public async Task<bool> InsertNewScansione(ScanDataModel newScan)
|
|
{
|
|
bool result = false;
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
result = await dbController.InsertNewScansione(newScan);
|
|
// elimino cache redis...
|
|
RedisValue pattern = new RedisValue(redisScanBaseAddr);
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"InsertNewScansione | Id scansione: {newScan.ScanID} | Id sessione: {newScan.InveSessID} | {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
// aggiungo record al DB
|
|
}
|
|
|
|
public async Task<bool> InsertNewSessione(InventorySessionModel newSess)
|
|
{
|
|
bool result = false;
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
result = await dbController.InsertNewSessione(newSess);
|
|
// elimino cache redis...
|
|
RedisValue pattern = new RedisValue($"{redisBaseAddr}{redisSessionBaseAddr}*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"InsertNewSessione | Id sessione: {newSess.InveSessID} | Descrizione sessione: {newSess.Description} | {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
// aggiungo record al DB
|
|
}
|
|
|
|
public InventorySessionModel InventSessByID(int sessID)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
InventorySessionModel result = new InventorySessionModel();
|
|
string source = "DB";
|
|
result = dbController.InventSessByID(sessID);
|
|
//if (result == null)
|
|
//{
|
|
// result = new InventorySessionModel();
|
|
//}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"InventSessByID Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public List<InventorySessionModel> InventSessCurrList()
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<InventorySessionModel>? result = new List<InventorySessionModel>();
|
|
string source = "DB";
|
|
// cerco in redis...
|
|
RedisValue rawData = redisDb.StringGet(redisSessionCurrList);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<InventorySessionModel>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbController.InventSessCurrList();
|
|
// serializzo e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
redisDb.StringSetAsync(redisSessionCurrList, rawData, getRandTOut(redisLongTimeCache));
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"InventSessCurrList Read from {source}: {ts.TotalMilliseconds}ms");
|
|
if (result == null)
|
|
{
|
|
result = new List<InventorySessionModel>();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public List<InventorySessionModel> InventSessHistList()
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<InventorySessionModel> result = new List<InventorySessionModel>();
|
|
string source = "DB";
|
|
// cerco in redis...
|
|
RedisValue rawData = redisDb.StringGet($"{redisSessionHistList}");
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<InventorySessionModel>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbController.InventSessHistList();
|
|
// serializzo e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
redisDb.StringSetAsync(redisSessionHistList, rawData, getRandTOut(redisLongTimeCache));
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"InventSessHistList Read from {source}: {ts.TotalMilliseconds}ms");
|
|
if (result == null)
|
|
{
|
|
result = new List<InventorySessionModel>();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public List<InveSessTotLotModel> InveSessTotLotList(int sessID)
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<InveSessTotLotModel>? result = new List<InveSessTotLotModel>();
|
|
result = dbController.InveSessTotLotList(sessID);
|
|
source = "DB";
|
|
if (result == null)
|
|
{
|
|
result = new List<InveSessTotLotModel>();
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"InveSessTotLotList Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public AnagUdcModel IsUDC(string udc)
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
AnagUdcModel? result = new AnagUdcModel();
|
|
result = dbController.IsUDC(udc);
|
|
source = "DB";
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"IsUDC Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public bool loginOperatore(int matrOpr, string authkey)
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
AnagOperatoriModel? result = new AnagOperatoriModel();
|
|
bool answ = false;
|
|
// cerco in redis...
|
|
RedisValue rawData = redisDb.StringGet($"{redisElencoOperatori}:{matrOpr}:{authkey}");
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<AnagOperatoriModel>($"{rawData}");
|
|
if (result != null)
|
|
{
|
|
answ = true;
|
|
source = "REDIS";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
answ = dbController.LoginOperatore(matrOpr, authkey);
|
|
if (answ)
|
|
{
|
|
result = ElencoOperatori().Where(x => (x.MatrOpr == matrOpr) && (x.authKey == authkey)).SingleOrDefault();
|
|
}
|
|
// serializzo e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
redisDb.StringSetAsync(redisOperatoreLogged, rawData, getRandTOut(redisLongTimeCache));
|
|
source = "DB";
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new AnagOperatoriModel();
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"loginOperatore Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return answ;
|
|
}
|
|
|
|
public List<AnagLottiArca> LottoEsterno(string codArt, string codLotto, string codMagazzino)
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<AnagLottiArca>? result = new List<AnagLottiArca>();
|
|
// cerco in redis...
|
|
result = dbController.LottoEsterno(codArt, codLotto, codMagazzino);
|
|
source = "DB";
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"LottoEsterno Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public AnagLottoModel LottoInterno(string lotto)
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
AnagLottoModel? result = new AnagLottoModel();
|
|
result = dbController.LottoInterno(lotto);
|
|
source = "DB";
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"LottoInterno Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public List<AnagMagModel> MagazziniList()
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<AnagMagModel> result = new List<AnagMagModel>();
|
|
string source = "DB";
|
|
// cerco in redis...
|
|
RedisValue rawData = redisDb.StringGet(redisMagList);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<AnagMagModel>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbController.MagazziniList();
|
|
// serializzo e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
redisDb.StringSetAsync(redisMagList, rawData, getRandTOut(redisLongTimeCache));
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"ElencoMagazzini Read from {source}: {ts.TotalMilliseconds}ms");
|
|
if (result == null)
|
|
{
|
|
result = new List<AnagMagModel>();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scansioni dato lotto e sessione
|
|
/// </summary>
|
|
/// <param name="lotto"></param>
|
|
/// <param name="inveSessId"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<ScanDataModel>> ScanByLottoSession(string lotto, int inveSessId)
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<ScanDataModel>? result = new List<ScanDataModel>();
|
|
result = dbController.ScanByLottoSession(lotto, inveSessId);
|
|
source = "DB";
|
|
stopWatch.Stop();
|
|
await Task.Delay(1);
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"ScanByLottoSession Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public List<ScanDataModel> ScanBySession(int idSessione)
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<ScanDataModel>? result = new List<ScanDataModel>();
|
|
// cerco in redis...
|
|
{
|
|
var ListAll = ScanList();
|
|
result = ListAll.Where(x => x.InveSessID == idSessione).ToList();
|
|
if (result == null)
|
|
{
|
|
result = new List<ScanDataModel>();
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"ScanBySession Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scansioni dati UDC e sessione
|
|
/// </summary>
|
|
/// <param name="udc"></param>
|
|
/// <param name="inveSessId"></param>
|
|
/// <returns></returns>
|
|
public ScanDataModel ScanByUdcSession(string udc, int inveSessId)
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
ScanDataModel? result = new ScanDataModel();
|
|
result = dbController.ScanByUdcSession(udc, inveSessId);
|
|
source = "DB";
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"ScanByUdcSession Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public List<ScanDataModel> ScanByValueSessionOpr(string scanData, int inveSessId, string Opr)
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<ScanDataModel>? result = new List<ScanDataModel>();
|
|
result = dbController.ScanByValueSessionOpr(scanData, inveSessId, Opr);
|
|
source = "DB";
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"ScanByValueSessionOpr Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public List<ScanDataModel> ScanList()
|
|
{
|
|
string source = "";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<ScanDataModel>? result = new List<ScanDataModel>();
|
|
// cerco in redis...
|
|
RedisValue rawData = redisDb.StringGet(redisScanBaseAddr);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<ScanDataModel>>($"{rawData}");
|
|
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbController.ScanList();
|
|
// serializzo e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
redisDb.StringSetAsync(redisScanBaseAddr, rawData, getRandTOut(redisLongTimeCache));
|
|
source = "DB";
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<ScanDataModel>();
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"ScanList Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public async Task<bool> TransferSessione(int sessID)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
bool result = false;
|
|
string source = "DB";
|
|
result = await dbController.TransferSessione(sessID);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"TransferSessione Read from {source}: {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce valore della stringa (SE disponibile)
|
|
/// </summary>
|
|
/// <param name="keyName"></param>
|
|
/// <returns></returns>
|
|
public async Task<string> tryGetConfig(string keyName)
|
|
{
|
|
string answ = "";
|
|
// preselezione valori
|
|
var configData = await ConfigGetAll();
|
|
var currRec = configData.FirstOrDefault(x => x.Chiave == keyName);
|
|
if (currRec != null)
|
|
{
|
|
answ = currRec.Valore;
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
public async Task<bool> UpdateMag(AnagMagModel Mag)
|
|
{
|
|
bool result = false;
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
result = await dbController.UpdateMag(Mag);
|
|
// elimino cache redis...
|
|
RedisValue pattern = new RedisValue($"{redisMagList}");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"UpdateMag | Codice magazzino: {Mag.CodMag} | Descrizione magazzino: {Mag.DescMag} | {ts.TotalMilliseconds}ms");
|
|
return result;
|
|
// aggiungo record al DB
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiornamento record selezionato
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> UpdateScan(ScanDataModel currRec)
|
|
{
|
|
var dbResult = await dbController.updateScan(currRec);
|
|
// elimino cache redis...
|
|
RedisValue pattern = new RedisValue(redisScanBaseAddr);
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
await Task.Delay(1);
|
|
return dbResult;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Fields
|
|
|
|
protected const string passPhrase = "7871D817-C71F-4DFC-BF12-00A95BE507B5";
|
|
|
|
protected Random rand = new Random();
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// Restituisce un timeout dai minuti richiesti + tempo random 1..60 sec
|
|
/// </summary>
|
|
/// <param name="stdMinutes"></param>
|
|
/// <returns></returns>
|
|
protected TimeSpan getRandTOut(int stdMinutes)
|
|
{
|
|
double rndValue = (double)stdMinutes + (double)rand.Next(1, 60) / 60;
|
|
return TimeSpan.FromMinutes(rndValue);
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Private Fields
|
|
|
|
private const string redisBaseAddr = "MP:INVE";
|
|
|
|
private const string redisConfigBaseAddr = ":Config";
|
|
|
|
private const string redisElencoOperatori = redisBaseAddr + redisOperatoriBaseAddr + ":ListOperatori";
|
|
|
|
private const string redisLottiBaseAddr = ":Lotti";
|
|
|
|
private const string redisLottiEsterni = redisBaseAddr + redisLottiBaseAddr + ":LottiEsterni";
|
|
|
|
private const string redisLottiInterni = redisBaseAddr + redisLottiBaseAddr + ":LottiInterni";
|
|
|
|
private const string redisMagList = redisBaseAddr + ":ListMag";
|
|
|
|
private const string redisOperatoreLogged = redisBaseAddr + redisOperatoriBaseAddr + ":OperatoreLogged";
|
|
|
|
private const string redisOperatoriBaseAddr = ":Operatore";
|
|
|
|
private const string redisScanBaseAddr = redisBaseAddr + ":Scan";
|
|
|
|
private const string redisSessionBaseAddr = ":Session";
|
|
|
|
private const string redisSessionCurrList = redisBaseAddr + redisSessionBaseAddr + ":ListSessHist";
|
|
|
|
private const string redisSessionHistList = redisBaseAddr + redisSessionBaseAddr + ":ListSessCurr";
|
|
|
|
private const string redisTotLottoAddr = ":TotaleLotto";
|
|
|
|
private const string redisUdcBaseAddr = ":UDC";
|
|
|
|
private static IConfiguration _configuration = null!;
|
|
|
|
private static ILogger<MiDataService> _logger = null!;
|
|
|
|
private static Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
/// <summary>
|
|
/// Oggetto vocabolario x uso continuo traduzione
|
|
/// </summary>
|
|
private List<VocabolarioModel> ObjVocabolario = new List<VocabolarioModel>();
|
|
|
|
/// <summary>
|
|
/// Oggetto per connessione a REDIS
|
|
/// </summary>
|
|
private ConnectionMultiplexer redisConn = null!;
|
|
|
|
/// <summary>
|
|
/// Oggetto per connessione a REDIS modalità admin (ex flux dati)
|
|
/// </summary>
|
|
private ConnectionMultiplexer redisConnAdmin = null!;
|
|
|
|
/// <summary>
|
|
/// Oggetto DB redis da impiegare x chiamate R/W
|
|
/// </summary>
|
|
private IDatabase redisDb = null!;
|
|
|
|
private int redisLongTimeCache = 5;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Methods
|
|
|
|
/// <summary>
|
|
/// Esegue flush memoria redis dato pat2Flush
|
|
/// </summary>
|
|
/// <param name="pat2Flush"></param>
|
|
/// <returns></returns>
|
|
private async Task<bool> ExecFlushRedisPattern(RedisValue pat2Flush)
|
|
{
|
|
bool answ = false;
|
|
var masterEndpoint = redisConn.GetEndPoints()
|
|
.Where(ep => redisConn.GetServer(ep).IsConnected && !redisConn.GetServer(ep).IsReplica)
|
|
.FirstOrDefault();
|
|
|
|
// sepattern è "*" elimino intero DB...
|
|
if (masterEndpoint != null && (pat2Flush.Equals(new RedisValue("*")) || pat2Flush == RedisValue.Null))
|
|
{
|
|
redisConn.GetServer(masterEndpoint).FlushDatabase(database: redisDb.Database);
|
|
}
|
|
else
|
|
{
|
|
var server = redisConn.GetServer(masterEndpoint);
|
|
var keys = server.Keys(database: redisDb.Database, pattern: pat2Flush, pageSize: 1000);
|
|
|
|
var deleteTasks = new List<Task>();
|
|
foreach (var key in keys)
|
|
{
|
|
deleteTasks.Add(redisDb.KeyDeleteAsync(key));
|
|
if (deleteTasks.Count >= 1000)
|
|
{
|
|
await Task.WhenAll(deleteTasks);
|
|
deleteTasks.Clear();
|
|
}
|
|
}
|
|
if (deleteTasks.Count > 0)
|
|
{
|
|
await Task.WhenAll(deleteTasks);
|
|
}
|
|
}
|
|
answ = true;
|
|
#if false
|
|
var listEndpoints = redisConnAdmin.GetEndPoints();
|
|
foreach (var endPoint in listEndpoints)
|
|
{
|
|
//var server = redisConnAdmin.GetServer(listEndpoints[0]);
|
|
var server = redisConnAdmin.GetServer(endPoint);
|
|
if (server != null)
|
|
{
|
|
var keyList = server.Keys(redisDb.Database, pattern);
|
|
foreach (var item in keyList)
|
|
{
|
|
await redisDb.KeyDeleteAsync(item);
|
|
}
|
|
// brutalmente rimuovo intero contenuto DB... DANGER
|
|
//await server.FlushDatabaseAsync();
|
|
answ = true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return answ;
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |