Samuele Locatelli
785 lines
31 KiB
C#
785 lines
31 KiB
C#
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Configuration;
|
|
using MP.Data.DatabaseModels;
|
|
using MP.Data.Objects;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using StackExchange.Redis;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using static MP.Data.Objects.Enums;
|
|
|
|
namespace MP.Data.Services
|
|
{
|
|
public class TabDataService : BaseServ, IDisposable
|
|
{
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// Init servizio TAB
|
|
/// </summary>
|
|
/// <param name="configuration"></param>
|
|
public TabDataService(IConfiguration configuration)
|
|
{
|
|
_configuration = configuration;
|
|
|
|
// setup compoenti REDIS
|
|
redisConn = ConnectionMultiplexer.Connect(_configuration.GetConnectionString("Redis"));
|
|
redisDb = redisConn.GetDatabase();
|
|
|
|
// conf DB
|
|
ConnStr = _configuration.GetConnectionString("Mp.All");
|
|
if (string.IsNullOrEmpty(ConnStr))
|
|
{
|
|
Log.Error("ConnString empty!");
|
|
}
|
|
else
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
dbTabController = new Controllers.MpTabController(configuration);
|
|
sb.AppendLine($"TabDataService | MpTabController OK");
|
|
dbIocController = new Controllers.MpIocController(configuration);
|
|
sb.AppendLine($"TabDataService | MpIocController OK");
|
|
Log.Info(sb.ToString());
|
|
// sistemo i parametri x redHas...
|
|
CodModulo = _configuration.GetValue<string>("OptConf:CodModulo");
|
|
var cstringArray = ConnStr.Split(";");
|
|
foreach (var item in cstringArray)
|
|
{
|
|
var cData = item.Trim().Split("=");
|
|
if (cData.Length == 2)
|
|
{
|
|
if (!connStrParams.ContainsKey(cData[0]))
|
|
{
|
|
connStrParams.Add(cData[0], cData[1]);
|
|
}
|
|
}
|
|
}
|
|
// sistemo
|
|
DataSource = connStrParams["Server"];
|
|
DataBase = connStrParams["Database"];
|
|
}
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Elenco completo EVENTI
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<AnagEventiModel>> AnagEventiGetAll()
|
|
{
|
|
// setup parametri costanti
|
|
DateTime startDate = new DateTime(2000, 1, 1);
|
|
DateTime endDate = DateTime.Today.AddDays(1);
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
List<AnagEventiModel>? result = new List<AnagEventiModel>();
|
|
// cerco in redis...
|
|
string currKey = $"{redisBaseKey}:AnagEventi:ALL";
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<AnagEventiModel>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbTabController.AnagEventiGetAll();
|
|
// serializzp e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(currKey, rawData, LongCache);
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<AnagEventiModel>();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"AnagEventiGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco EVENTI validi x macchina
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<AnagEventiModel>> AnagEventiGetByMacch(string IdxMacch)
|
|
{
|
|
// setup parametri costanti
|
|
DateTime startDate = new DateTime(2000, 1, 1);
|
|
DateTime endDate = DateTime.Today.AddDays(1);
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
List<AnagEventiModel>? result = new List<AnagEventiModel>();
|
|
// cerco in redis...
|
|
string currKey = $"{redisBaseKey}:AnagEventi:{IdxMacch}";
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<AnagEventiModel>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbTabController.AnagEventiGetByMacc(IdxMacch);
|
|
// serializzp e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(currKey, rawData, LongCache);
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<AnagEventiModel>();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"AnagEventiGetByMacch | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco completo STATI
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<AnagStatiModel>> AnaStatiGetAll()
|
|
{
|
|
// setup parametri costanti
|
|
DateTime startDate = new DateTime(2000, 1, 1);
|
|
DateTime endDate = DateTime.Today.AddDays(1);
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
List<AnagStatiModel>? result = new List<AnagStatiModel>();
|
|
// cerco in redis...
|
|
string currKey = $"{redisBaseKey}:AnagStati";
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<AnagStatiModel>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbTabController.AnagStatiGetAll();
|
|
// serializzp e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(currKey, rawData, LongCache);
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<AnagStatiModel>();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"AnaStatiGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua conferma prod macchina dell'intero periodo da confermare (ultima conferma
|
|
/// --> dtEvent)
|
|
/// </summary>
|
|
/// <param name="idxMacchina">idx macchina da confermare</param>
|
|
/// <param name="modoConfProd">0=periodo, 1 = giorno, 2 = turno</param>
|
|
/// <param name="numPzConfermati">qta pezzi BUONI da confermare</param>
|
|
/// <param name="numPzScarto">qta pezzi SCARTO da confermare</param>
|
|
/// <param name="DataOraApp">DataOra in cui registrare approvazione</param>
|
|
/// <param name="MatrOpr">Matricola operatore</param>
|
|
/// <returns></returns>
|
|
public bool ConfermaProdMacchina(string idxMacchina, int modoConfProd, int numPzConfermati, int numPzScarto, DateTime DataOraApp, int MatrOpr)
|
|
{
|
|
bool answ = false;
|
|
answ = dbTabController.ConfermaProdMacchina(idxMacchina, modoConfProd, numPzConfermati, numPzScarto, DataOraApp, MatrOpr);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua conferma prod macchina dell'intero periodo da confermare (ultima conferma
|
|
/// --> dtEvent)
|
|
/// </summary>
|
|
/// <param name="idxMacchina">idx macchina da confermare</param>
|
|
/// <param name="modoConfProd">0=periodo, 1 = giorno, 2 = turno</param>
|
|
/// <param name="numPzConfermati">qta pezzi BUONI da confermare</param>
|
|
/// <param name="numPzLasciati">
|
|
/// qta pezzi LASCIATI alla macchina da confermare (2 eventi 121 rettifica neg/pos)
|
|
/// </param>
|
|
/// <param name="numPzScarto">qta pezzi SCARTO da confermare</param>
|
|
/// <param name="DataOraApp">DataOra in cui registrare approvazione</param>
|
|
/// <param name="MatrOpr">Matricola operatore</param>
|
|
/// <returns></returns>
|
|
public bool ConfermaProdMacchinaFull(string idxMacchina, int modoConfProd, int numPzConfermati, int numPzLasciati, int numPzScarto, DateTime DataOraApp, int MatrOpr)
|
|
{
|
|
bool answ = false;
|
|
answ = dbTabController.ConfermaProdMacchinaFull(idxMacchina, modoConfProd, numPzConfermati, numPzLasciati, numPzScarto, DataOraApp, MatrOpr);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Config values attivi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<ConfigModel>> ConfigGetAll()
|
|
{
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
List<ConfigModel>? result = new List<ConfigModel>();
|
|
// cerco in redis...
|
|
string currKey = $"{redisBaseKey}:Conf";
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<ConfigModel>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = await Task.FromResult(dbTabController.ConfigGetAll());
|
|
// serializzp e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(currKey, rawData, LongCache);
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<ConfigModel>();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"ConfigGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
// Clear database controller
|
|
dbTabController.Dispose();
|
|
dbIocController.Dispose();
|
|
}
|
|
/// <summary>
|
|
/// Recupero info IOB x TAB (da info registrate IOB-WIN--> MP-IO)
|
|
/// </summary>
|
|
/// <param name="IdxMacchina"></param>
|
|
/// <returns></returns>
|
|
public async Task<IOB_data> IobInfo(string IdxMacchina)
|
|
{
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
IOB_data? result = new IOB_data();
|
|
// cerco in redis...
|
|
string currKey = redHash($"hM2IOB:{IdxMacchina}");
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<IOB_data>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new IOB_data();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"IobInfo | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resetta (rileggendo) i dati della macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public Dictionary<string, string> resetDatiMacchina(string idxMacchina)
|
|
{
|
|
Dictionary<string, string> answ = new Dictionary<string, string>();
|
|
#if false
|
|
string currHash = dtMaccHash(idxMacchina);
|
|
// inizio con un bel reset...
|
|
memLayer.ML.redFlushKey(currHash);
|
|
DS_applicazione.MSFDDataTable tabMSFD = new DS_applicazione.MSFDDataTable();
|
|
// 2018.01.08 SEMPRE senza singleton: instanzio un nuovo oggetto MapoDb
|
|
MapoDb connDb = new MapoDb();
|
|
tabMSFD = connDb.taMSFD.getByIdxMacc(idxMacchina);
|
|
bool trovato = false;
|
|
// se ho righe...
|
|
DS_applicazione.MSFDDataTable tab = new DS_applicazione.MSFDDataTable();
|
|
DS_applicazione.MSFDRow rigaMSFD;
|
|
if (tabMSFD.Rows.Count > 0)
|
|
{
|
|
try
|
|
{
|
|
rigaMSFD = tabMSFD[0];
|
|
trovato = true;
|
|
}
|
|
catch
|
|
{
|
|
rigaMSFD = tab.NewMSFDRow();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rigaMSFD = tab.NewMSFDRow();
|
|
}
|
|
if (trovato)
|
|
{
|
|
// ora provo a compilare...
|
|
try
|
|
{
|
|
// salvo 1:1 i valori... STATO
|
|
answ.Add("IdxMicroStato", rigaMSFD.IdxMicroStato.ToString());
|
|
answ.Add("IdxStato", rigaMSFD.IdxStato.ToString());
|
|
answ.Add("CodArticolo", rigaMSFD.CodArticolo);
|
|
answ.Add("insEnabled", rigaMSFD.insEnabled.ToString());
|
|
answ.Add("sLogEnabled", rigaMSFD.sLogEnabled.ToString());
|
|
answ.Add("pallet", rigaMSFD.pallet);
|
|
answ.Add("CodArticolo_A", rigaMSFD.CodArticolo_A);
|
|
answ.Add("CodArticolo_B", rigaMSFD.CodArticolo_B);
|
|
answ.Add("TempoCicloBase", rigaMSFD.TempoCicloBase.ToString());
|
|
answ.Add("PzPalletProd", rigaMSFD.PzPalletProd.ToString());
|
|
answ.Add("MatrOpr", rigaMSFD.MatrOpr.ToString());
|
|
answ.Add("lastVal", rigaMSFD.lastVal);
|
|
answ.Add("TCBase", rigaMSFD.TempoCicloBase.ToString());
|
|
|
|
//...e SETUP
|
|
answ.Add("CodMacc", rigaMSFD.codmacchina);
|
|
answ.Add("IdxFamIn", rigaMSFD.IdxFamigliaIngresso.ToString());
|
|
answ.Add("Multi", rigaMSFD.Multi.ToString());
|
|
answ.Add("BitFilt", rigaMSFD.BitFilt.ToString());
|
|
answ.Add("MaxVal", rigaMSFD.MaxVal.ToString());
|
|
answ.Add("BSR", rigaMSFD.BSR.ToString());
|
|
answ.Add("ExplodeBit", rigaMSFD.ExplodeBit.ToString());
|
|
answ.Add("NumBit", rigaMSFD.NumBit.ToString());
|
|
answ.Add("IdxFamMacc", rigaMSFD.IdxFamiglia.ToString());
|
|
answ.Add("simplePallet", rigaMSFD.simplePallet.ToString());
|
|
answ.Add("palletChange", rigaMSFD.palletChange.ToString());
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info(string.Format("Errore in compilazione dati MSFD:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
// cerco dati master/slave...
|
|
string isMaster = connDb.taM2S.getByMaster(idxMacchina).Count > 0 ? "1" : "0";
|
|
string isSlave = connDb.taM2S.getBySlave(idxMacchina).Count > 0 ? "1" : "0";
|
|
answ.Add("Master", isMaster);
|
|
answ.Add("Slave", isSlave);
|
|
|
|
// verifico il timeout che cambia a seconda che sia vero o falso insEnabled...
|
|
int tOutShort = memLayer.ML.cdvi("TmOut.MS.S");
|
|
int tOutLong = memLayer.ML.cdvi("TmOut.MS.L");
|
|
int redDtMacTOut = tOutLong;
|
|
try
|
|
{
|
|
redDtMacTOut = (answ["insEnabled"].ToLower() == "true") ? tOutShort : tOutLong;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Info($"Eccezione in calcolo timeout dati macchina: idxMacchina{idxMacchina} | TShort: {tOutShort} | TLong {tOutLong}{Environment.NewLine}{exc}");
|
|
}
|
|
// salvo in redis!
|
|
memLayer.ML.redSaveHashDict(currHash, answ, redDtMacTOut);
|
|
}
|
|
else
|
|
{
|
|
Log.Info("Errore in chiamata stp_MSFD_getMacc (connDb.taMSFD.getByIdxMacc(idxMacchina))");
|
|
}
|
|
#endif
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua reset microstato macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
public void resetMicrostatoMacchina(string idxMacchina)
|
|
{
|
|
// salvo microstato 0...
|
|
MicroStatoMacchinaModel newRecMS = new MicroStatoMacchinaModel()
|
|
{
|
|
IdxMacchina = idxMacchina,
|
|
InizioStato = DateTime.Now,
|
|
IdxMicroStato = 0,
|
|
Value = "FER"
|
|
};
|
|
var result = dbTabController.MicroStatoMacchinaUpsert(newRecMS);
|
|
// reset in redis
|
|
resetDatiMacchina(idxMacchina);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua ricalcolo MSE x macchina indicata
|
|
/// </summary>
|
|
/// <param name="idxMacchina">idx macchina da confermare</param>
|
|
/// <param name="maxAgeSec">Num massimo secondi di "vecchiaia" del dato</param>
|
|
/// <returns></returns>
|
|
public bool RicalcMse(string idxMacchina, int maxAgeSec)
|
|
{
|
|
bool answ = false;
|
|
answ = dbTabController.RicalcMse(idxMacchina, maxAgeSec);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// scrive una riga di evento inviato da Barcode nel db
|
|
/// </summary>
|
|
/// <param name="idxMacchina">codice macchina</param>
|
|
/// <param name="idxTipo">idx evento</param>
|
|
/// <param name="codArticolo">Codice Articolo</param>
|
|
/// <param name="value">valore</param>
|
|
/// <param name="matrOpr">matricola operatore</param>
|
|
/// <param name="pallet">pallet (vuoto se nd)</param>
|
|
/// <returns></returns>
|
|
public async Task<inputComandoMapo> scriviRigaEventoBarcode(string idxMacchina, int idxTipo, string codArticolo, string value, int matrOpr, string pallet)
|
|
{
|
|
bool inserito = false;
|
|
DateTime adesso = DateTime.Now;
|
|
EventListModel newRec = new EventListModel()
|
|
{
|
|
IdxMacchina = idxMacchina,
|
|
InizioStato = adesso,
|
|
IdxTipo = idxTipo,
|
|
CodArticolo = codArticolo,
|
|
Value = value,
|
|
MatrOpr = matrOpr,
|
|
pallet = pallet
|
|
};
|
|
try
|
|
{
|
|
// inserisco evento
|
|
inserito = await dbTabController.EvListInsert(newRec);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
string logMsg = $"Eccezione in fase di scrittura evento con i seguenti dati | macchina: {idxMacchina} | IdxTipo: {idxTipo} | CodArticolo: {codArticolo} | Value {value} | MatrOpr {matrOpr} | Pallet {pallet}{Environment.NewLine}{exc}";
|
|
Log.Error(logMsg);
|
|
}
|
|
try
|
|
{
|
|
// faccio controllo per eventuale cambio stato da tab transizioni...
|
|
dbTabController.CheckCambiaStatoBatch(tipoInputEvento.barcode, idxMacchina, adesso, idxTipo, codArticolo, value, matrOpr, pallet);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
string logMsg = $"Eccezione in checkCambiaStatoBatch(6) | tipoInputEvento: {tipoInputEvento.barcode} | macchina: {idxMacchina} | dataOra: {adesso} | IdxTipo: {idxTipo} | CodArticolo: {codArticolo} | Value {value} | MatrOpr {matrOpr} | Pallet {pallet}{Environment.NewLine}{exc}";
|
|
Log.Error(logMsg);
|
|
}
|
|
// formatto output
|
|
inputComandoMapo answ = new inputComandoMapo();
|
|
answ.outValue = inserito.ToString();
|
|
answ.needStatusRefresh = true;
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero Righe (Actual) della scheda tecnica da GRUPPO + ODL
|
|
/// </summary>
|
|
/// <param name="codGruppo"></param>
|
|
/// <param name="idxODL"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<ST_ActRow>> STAR_byGrpOdl(string codGruppo, int idxODL)
|
|
{
|
|
// setup parametri costanti
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
List<ST_ActRow>? result = new List<ST_ActRow>();
|
|
// cerco in redis...
|
|
string currKey = $"{redisBaseKey}:START:{codGruppo}:{idxODL}";
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<ST_ActRow>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbTabController.STAR_byGrpOdl(codGruppo, idxODL);
|
|
// serializzp e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(currKey, rawData, LongCache);
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<ST_ActRow>();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"STAR_byGrpOdl | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero Righe (Actual) della scheda tecnica da GRUPPO + ODL
|
|
/// </summary>
|
|
/// <param name="codGruppo"></param>
|
|
/// <param name="label"></param>
|
|
/// <param name="idxODL"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<ST_ActRow>> STAR_byGrpOdlLbl(string codGruppo, string label, int idxODL)
|
|
{
|
|
// setup parametri costanti
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
List<ST_ActRow>? result = new List<ST_ActRow>();
|
|
// cerco in redis...
|
|
string currKey = $"{redisBaseKey}:START:{codGruppo}:{label}:{idxODL}";
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<ST_ActRow>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbTabController.STAR_byGrpOdlLbl(codGruppo, label, idxODL);
|
|
// serializzp e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(currKey, rawData, LongCache);
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<ST_ActRow>();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"STAR_byGrpOdlLbl | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stato macchina
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <returns></returns>
|
|
public async Task<StatoMacchineModel> StatoMacchina(string idxMacchina)
|
|
{
|
|
// setup parametri costanti
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
StatoMacchineModel? result = new StatoMacchineModel();
|
|
// cerco in redis...
|
|
string currKey = $"{redisBaseKey}:StatoMacc:{idxMacchina}";
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<StatoMacchineModel>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbTabController.StatoMacchina(idxMacchina);
|
|
// serializzp e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(currKey, rawData, TimeSpan.FromSeconds(2));
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new StatoMacchineModel();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"StatoMacchina | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stato prod macchina (completo)
|
|
/// </summary>
|
|
/// <param name="idxMacchina"></param>
|
|
/// <param name="dtReq"></param>
|
|
/// <returns></returns>
|
|
public async Task<StatoProdModel> StatoProdMacchina(string idxMacchina, DateTime dtReq)
|
|
{
|
|
// setup parametri costanti
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
StatoProdModel? result = new StatoProdModel();
|
|
// cerco in redis...
|
|
string currKey = $"{redisBaseKey}:StatoProd:{idxMacchina}:{dtReq:HHmmss}";
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<StatoProdModel>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbTabController.StatoProdMacchina(idxMacchina, dtReq);
|
|
// serializzp e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new StatoProdModel();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"StatoProdMacchina | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Intera vista v_MSFD
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<VMSFDModel>> VMSFDGetAll()
|
|
{
|
|
// setup parametri costanti
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
List<VMSFDModel> result = new List<VMSFDModel>();
|
|
// cerco in redis...
|
|
string currKey = $"{redisBaseKey}:MSFD:ALL";
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<VMSFDModel>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbIocController.VMSFDGetAll();
|
|
// serializzp e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<VMSFDModel>();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"VMSFDGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Vista v_MSFD x singola macchina (da stored) - singolo record
|
|
/// </summary>
|
|
/// <param name="idxMacc"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<VMSFDModel>> VMSFDGetByMacc(string idxMacc)
|
|
{
|
|
// setup parametri costanti
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
List<VMSFDModel>? result = new List<VMSFDModel>();
|
|
// cerco in redis...
|
|
string currKey = $"{redisBaseKey}:MSFD:MACCH:{idxMacc}";
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<VMSFDModel>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbIocController.VMSFDGetByMacc(idxMacc);
|
|
// serializzp e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<VMSFDModel>();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"VMSFDGetByMacc | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Vista v_MSFD delle machine MULTI filtrato x macchina (da stored)
|
|
/// </summary>
|
|
/// <param name="idxMacc"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<VMSFDModel>> VMSFDGetMultiByMacc(string idxMacc)
|
|
{
|
|
// setup parametri costanti
|
|
string source = "DB";
|
|
Stopwatch sw = new Stopwatch();
|
|
sw.Start();
|
|
List<VMSFDModel>? result = new List<VMSFDModel>();
|
|
// cerco in redis...
|
|
string currKey = $"{redisBaseKey}:MSFD:MULTI:{idxMacc}";
|
|
RedisValue rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty($"{rawData}"))
|
|
{
|
|
result = JsonConvert.DeserializeObject<List<VMSFDModel>>($"{rawData}");
|
|
source = "REDIS";
|
|
}
|
|
else
|
|
{
|
|
result = dbIocController.VMSFDGetByMacc(idxMacc);
|
|
// serializzp e salvo...
|
|
rawData = JsonConvert.SerializeObject(result);
|
|
await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new List<VMSFDModel>();
|
|
}
|
|
sw.Stop();
|
|
Log.Debug($"VMSFDGetMultiByMacc | {source} | {sw.Elapsed.TotalMilliseconds}ms");
|
|
return result;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Fields
|
|
|
|
/// <summary>
|
|
/// Oggetto per connessione a REDIS
|
|
/// </summary>
|
|
protected ConnectionMultiplexer redisConn = null!;
|
|
|
|
/// <summary>
|
|
/// Oggetto DB redis da impiegare x chiamate R/W
|
|
/// </summary>
|
|
protected IDatabase redisDb = null!;
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Private Fields
|
|
|
|
private static Logger Log = LogManager.GetCurrentClassLogger();
|
|
private string CodModulo = "";
|
|
private string ConnStr = "";
|
|
private Dictionary<string, string> connStrParams = new Dictionary<string, string>();
|
|
private string DataBase = "";
|
|
private string DataSource = "";
|
|
|
|
private string redisBaseKey = "MP:TAB:Cache";
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Properties
|
|
|
|
private static Controllers.MpIocController dbIocController { get; set; } = null!;
|
|
|
|
private static Controllers.MpTabController dbTabController { get; set; } = null!;
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Private Methods
|
|
|
|
private string redHash(string keyName)
|
|
{
|
|
string result = keyName;
|
|
try
|
|
{
|
|
result = $"{CodModulo}:{DataSource}:{DataBase}:{keyName}".Replace("\\", "_");
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Errore in redHash{Environment.NewLine}{exc}");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |