Samuele Locatelli
1021 lines
42 KiB
C#
1021 lines
42 KiB
C#
using MP.MONO.Core;
|
|
using MP.MONO.Core.CONF;
|
|
using MP.MONO.Core.DTO;
|
|
using MP.MONO.Data;
|
|
using MP.MONO.Data.Controllers;
|
|
using MP.MONO.Data.DbModels;
|
|
using MP.MONO.Data.DTO;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using StackExchange.Redis;
|
|
using System.Diagnostics;
|
|
using System.Reflection.PortableExecutable;
|
|
using static MP.MONO.Core.Enums;
|
|
|
|
namespace MP.MONO.UI.Data
|
|
{
|
|
public class CurrentDataService : IDisposable
|
|
{
|
|
#region Public Fields
|
|
|
|
/// <summary>
|
|
/// Controller dati da DB
|
|
/// </summary>
|
|
public static MpDbController dbController = null!;
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Public Constructors
|
|
|
|
public CurrentDataService(IConfiguration configuration, ILogger<CurrentDataService> logger, IConnectionMultiplexer redisConn)
|
|
{
|
|
_logger = logger;
|
|
_configuration = configuration;
|
|
|
|
// setup compoenti REDIS
|
|
this.redisConn = ConnectionMultiplexer.Connect(_configuration.GetConnectionString("Redis"));
|
|
this.redisDb = this.redisConn.GetDatabase();
|
|
// setup canali pub/sub
|
|
actLogPipe = new MessagePipe(redisConn, Constants.ACT_LOG_M_QUEUE);
|
|
alarmPipe = new MessagePipe(redisConn, Constants.ALARM_M_QUEUE);
|
|
machEvPipe = new MessagePipe(redisConn, Constants.EVENT_LOG_M_QUEUE);
|
|
parametersPipe = new MessagePipe(redisConn, Constants.PARAMS_M_QUEUE);
|
|
productionPipe = new MessagePipe(redisConn, Constants.PROD_M_QUEUE);
|
|
machStatsPipe = new MessagePipe(redisConn, Constants.MACH_STATS_M_QUEUE);
|
|
maintPipe = new MessagePipe(redisConn, Constants.MAINT_STATS_M_QUEUE);
|
|
statusPipe = new MessagePipe(redisConn, Constants.STATUS_M_QUEUE);
|
|
toolsPipe = new MessagePipe(redisConn, Constants.TOOLS_M_QUEUE);
|
|
|
|
// conf DB
|
|
string connStr = _configuration.GetConnectionString("MP.MONO.Data");
|
|
if (string.IsNullOrEmpty(connStr))
|
|
{
|
|
_logger.LogError("ConnString empty!");
|
|
}
|
|
else
|
|
{
|
|
dbController = new MpDbController(configuration);
|
|
_logger.LogInformation("DbController OK");
|
|
}
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Properties
|
|
|
|
public MessagePipe actLogPipe { get; set; } = null!;
|
|
|
|
/// <summary>
|
|
/// Verifica se gli AlarmLog sia attivi/da mostrare
|
|
/// </summary>
|
|
public bool AlarmLogActive
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
var rawVal = redisDb.StringGet(Constants.ALARM_LOG_ENABLED);
|
|
if (!string.IsNullOrEmpty(rawVal))
|
|
{
|
|
bool.TryParse(rawVal, out answ);
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
public MessagePipe alarmPipe { get; set; } = null!;
|
|
public MessagePipe machEvPipe { get; set; } = null!;
|
|
public MessagePipe machStatsPipe { get; set; } = null!;
|
|
public MessagePipe maintPipe { get; set; } = null!;
|
|
public MessagePipe parametersPipe { get; set; } = null!;
|
|
public MessagePipe productionPipe { get; set; } = null!;
|
|
public MessagePipe statusPipe { get; set; } = null!;
|
|
public MessagePipe toolsPipe { get; set; } = null!;
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Elenco records anagrafica allarmi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<AlarmListModel>> AlarmListGetAll()
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var dbResult = dbController.AlarmListGetAll();
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB AlarmListGetAll: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserisce nuovo record in anagrafica allarmi dato testo (o restituisce se esistente)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<AlarmListModel?> AlarmListInsert(string AlarmText)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var dbResult = dbController.AlarmListInsert(AlarmText);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB AlarmListInsert: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary> restituisce lista di allarmi (ultimi dati "skip") </summary> </summary> <param
|
|
/// name="machineId"></param> <param name="skipRec"></param> <param name="numRec"></param> <returns></returns>
|
|
public async Task<List<AlarmLogModel>> AlarmLogGetFilt(int machineId, int skipRec, int numRec)
|
|
{
|
|
string source = "DB";
|
|
List<AlarmLogModel> dbResult = new List<AlarmLogModel>();
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
string currKey = $"{Constants.ALARM_LOG}:{machineId}:{skipRec}:{numRec}";
|
|
stopWatch.Start();
|
|
var rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
source = "REDIS";
|
|
var tempResult = JsonConvert.DeserializeObject<List<AlarmLogModel>>($"{rawData}");
|
|
if (tempResult == null)
|
|
{
|
|
dbResult = new List<AlarmLogModel>();
|
|
}
|
|
else
|
|
{
|
|
dbResult = tempResult;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dbResult = await dbController.AlarmLogGetFilt(machineId, skipRec, numRec);
|
|
rawData = JsonConvert.SerializeObject(dbResult);
|
|
await redisDb.StringSetAsync(currKey, rawData, TimeSpan.FromMilliseconds(250));
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Debug($"AlarmLogGetFilt | {source} in : {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary> Recupero elenco allarmi con data <= alla data di riferimento (ultimi dati
|
|
/// "skip") </summary> <param name="machineId"></param> <param name="dtRif"></param> <param
|
|
/// name="skipRec"></param> <param name="numRec"></param> <returns></returns>
|
|
public async Task<List<AlarmLogModel>> AlarmLogGetFiltByDate(int machineId, DateTime dtRif, int skipRec, int numRec)
|
|
{
|
|
string source = "DB";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
List<AlarmLogModel> dbResult = new List<AlarmLogModel>();
|
|
string currKey = $"{Constants.ALARM_LOG}";
|
|
stopWatch.Start();
|
|
stopWatch.Stop();
|
|
var rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
source = "REDIS";
|
|
var tempResult = JsonConvert.DeserializeObject<List<AlarmLogModel>>($"{rawData}");
|
|
if (tempResult == null)
|
|
{
|
|
dbResult = new List<AlarmLogModel>();
|
|
}
|
|
else
|
|
{
|
|
dbResult = tempResult;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dbResult = dbController.AlarmLogGetFiltByDate(machineId, dtRif, skipRec, numRec);
|
|
rawData = JsonConvert.SerializeObject(dbResult);
|
|
await redisDb.StringSetAsync(currKey, rawData, TimeSpan.FromMilliseconds(30000));
|
|
}
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da {source} AlarmLogGetFilt: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chiude ultimo record dato Id (se fossero + di 1 chiude tutti...)
|
|
/// </summary>
|
|
/// <param name="AlarmId">Id Allarme</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> AlarmRecCloseActive(int AlarmId)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var dbResult = await dbController.AlarmRecCloseActive(AlarmId);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB AlarmRecCloseActive: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero elenco allarmi Rec (ultimi dato "skip")
|
|
/// </summary>
|
|
/// <param name="MachineId"></param>
|
|
/// <param name="skipRec"></param>
|
|
/// <param name="numRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<AlarmRecModel>> AlarmRecGetFilt(int MachineId, int skipRec, int numRec)
|
|
{
|
|
string source = "DB";
|
|
List<AlarmRecModel> dbResult = new List<AlarmRecModel>();
|
|
string currKey = $"{Constants.ALARM_REC}:{MachineId}:{skipRec}:{numRec}";
|
|
string currKeyLog = $"{Constants.ALARM_LOG}";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
source = "REDIS";
|
|
var tempResult = JsonConvert.DeserializeObject<List<AlarmRecModel>>($"{rawData}");
|
|
if (tempResult == null)
|
|
{
|
|
dbResult = new List<AlarmRecModel>();
|
|
}
|
|
else
|
|
{
|
|
dbResult = tempResult;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dbResult = await dbController.AlarmRecGetFilt(MachineId, skipRec, numRec);
|
|
rawData = JsonConvert.SerializeObject(dbResult);
|
|
await redisDb.StringSetAsync(currKey, rawData, TimeSpan.FromMilliseconds(5000));
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
//Log.Trace($"Effettuata lettura da DB AlarmRecGetFilt: {ts.TotalMilliseconds} ms");
|
|
Log.Debug($"AlarmRecGetFilt | {source} in: {ts.TotalMilliseconds} ms");
|
|
//return await Task.FromResult(dbResult);
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary> Recupero elenco allarmi Rec con data <= alla data di riferimento (ultimi dato
|
|
/// "skip") </summary> <param name="MachineId"></param> <param name="dtRif"></param> <param
|
|
/// name="skipRec"></param> <param name="numRec"></param> <returns></returns>
|
|
public async Task<List<AlarmRecModel>> AlarmRecGetFiltByDate(int MachineId, DateTime dtRif, int skipRec, int numRec)
|
|
{
|
|
string source = "DB";
|
|
List<AlarmRecModel> dbResult = new List<AlarmRecModel>();
|
|
string currKeyLog = $"{Constants.ALARM_LOG}";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var rawData = await redisDb.StringGetAsync(currKeyLog);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
source = "REDIS";
|
|
var tempResult = JsonConvert.DeserializeObject<List<AlarmRecModel>>($"{rawData}");
|
|
if (tempResult == null)
|
|
{
|
|
dbResult = new List<AlarmRecModel>();
|
|
}
|
|
else
|
|
{
|
|
dbResult = tempResult;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dbResult = dbController.AlarmRecGetFiltByDate(MachineId, dtRif, skipRec, numRec);
|
|
rawData = JsonConvert.SerializeObject(dbResult);
|
|
await redisDb.StringSetAsync(currKeyLog, rawData, TimeSpan.FromMilliseconds(30000));
|
|
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da {source} AlarmRecGetFilt: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero lista sommatoria durata eventi allarme per analisi, ordinati in logica di
|
|
/// pareto (Max-min)
|
|
/// </summary>
|
|
/// <param name="machineId">Id Macchina</param>
|
|
/// <param name="dtFrom">inizio analisi (evento deve iniziare/finire entro periodo)</param>
|
|
/// <param name="dtTo">fine analisi (evento deve iniziare/finire entro periodo)</param>
|
|
/// <param name="minDur">durata minima evento per venire considerato, -1 = tutti</param>
|
|
/// <param name="maxDur">durata massima evento per venire considerato, -1 = tutti</param>
|
|
/// <returns></returns>
|
|
public async Task<List<AlarmDurationDTO>> AlarmRecGetParetoDur(int machineId, DateTime dtFrom, DateTime dtTo, int minDur = -1, int maxDur = -1)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var dbResult = dbController.AlarmRecGetParetoDur(machineId, dtFrom, dtTo, minDur, maxDur);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB AlarmRecGetParetoDur: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero lista di conteggio eventi allarme per analisi, ordinati in logica di pareto (Max-min)
|
|
/// </summary>
|
|
/// <param name="machineId">Id Macchina</param>
|
|
/// <param name="dtFrom">inizio analisi (evento deve iniziare DOPO questa data)</param>
|
|
/// <param name="dtTo">fine analisi (evento deve iniziare prima di questa data)</param>
|
|
/// <param name="minDur">durata minima evento per venire considerato, -1 = tutti</param>
|
|
/// <param name="maxDur">durata massima evento per venire considerato, -1 = tutti</param>
|
|
public async Task<List<AlarmFreqDTO>> AlarmRecGetParetoFreq(int machineId, DateTime dtFrom, DateTime dtTo, int minDur = -1, int maxDur = -1)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var dbResult = dbController.AlarmRecGetParetoFreq(machineId, dtFrom, dtTo, minDur, maxDur);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB AlarmRecGetParetoFreq: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// TimeSearie in formato DataLogDTO
|
|
/// </summary>
|
|
/// <param name="machineId">ID macchina</param>
|
|
/// <param name="dataType">Tipologia di dato richiesto da enum</param>
|
|
/// <param name="fluxType">Tipo di Flusso</param>
|
|
/// <param name="inizio">DT Inizio estrazione</param>
|
|
/// <param name="fine">DT Fine estrazione</param>
|
|
/// <returns></returns>
|
|
public async Task<List<DataLogDTO>> DataLogDtoGetFilt(int machineId, DataLogType dataType, string fluxType, DateTime inizio, DateTime fine)
|
|
{
|
|
string source = "DB";
|
|
List<DataLogDTO> dbResult = new List<DataLogDTO>();
|
|
string currKey = $"{Constants.DATA_LOG_DTO_KEY}:{machineId}:{dataType}:{fluxType.Replace(" ", "_")}:{inizio:yyyyMMdd}:{fine:yyyyMMdd}";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
source = "REDIS";
|
|
var tempResult = JsonConvert.DeserializeObject<List<DataLogDTO>>($"{rawData}");
|
|
if (tempResult == null)
|
|
{
|
|
dbResult = new List<DataLogDTO>();
|
|
}
|
|
else
|
|
{
|
|
dbResult = tempResult;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dbResult = await dbController.DataLogDtoGetFilt(machineId, dataType, fluxType, inizio, fine);
|
|
// salvo per 2 min...
|
|
rawData = JsonConvert.SerializeObject(dbResult);
|
|
await redisDb.StringSetAsync(currKey, rawData, TimeSpan.FromSeconds(120));
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
int sizeKb = rawData.HasValue ? $"{rawData}".Length / 1024 : 0;
|
|
Log.Info($"DataLogDtoGetFilt | {machineId} | {dataType} | {fluxType} | {inizio:yyyyMMdd}-{fine:yyyyMMdd} | {source} | {ts.TotalMilliseconds} ms | {sizeKb} kb");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// TimeSearie in formato DataLogModel
|
|
/// </summary>
|
|
/// <param name="dataType">Tipologia di dato richiesto da enum</param>
|
|
/// <param name="inizio">DT Inizio estrazione</param>
|
|
/// <param name="fine">DT Fine estrazione</param>
|
|
/// <param name="machineId">ID macchina</param>
|
|
/// <param name="fluxType">Tipo di Flusso</param>
|
|
/// <returns></returns>
|
|
public async Task<List<DataLogModel>> DataLogGetFilt(DataLogType dataType, DateTime inizio, DateTime fine, int machineId, string fluxType)
|
|
{
|
|
string source = "DB";
|
|
List<DataLogModel> dbResult = new List<DataLogModel>();
|
|
string currKey = $"{Constants.DATA_LOG_KEY}:{dataType}:{machineId}:{fluxType.Replace(" ", "_")}:{inizio:yyyyMMdd}:{fine:yyyyMMdd}";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
source = "REDIS";
|
|
var tempResult = JsonConvert.DeserializeObject<List<DataLogModel>>($"{rawData}");
|
|
if (tempResult == null)
|
|
{
|
|
dbResult = new List<DataLogModel>();
|
|
}
|
|
else
|
|
{
|
|
dbResult = tempResult;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dbResult = await dbController.DataLogGetFilt(dataType, inizio, fine, machineId, fluxType);
|
|
// salvo per 2 min...
|
|
rawData = JsonConvert.SerializeObject(dbResult);
|
|
await redisDb.StringSetAsync(currKey, rawData, TimeSpan.FromSeconds(120));
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
int sizeKb = rawData.HasValue ? $"{rawData}".Length / 1024 : 0;
|
|
Log.Info($"DataLogGetFilt | {source} | dataType: {dataType} | machineId: {machineId} | fluxType: {fluxType} | {inizio:yyyyMMdd}-{fine:yyyyMMdd} | {ts.TotalMilliseconds} ms | {sizeKb} kb");
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// TimeSearie in formato DataLogModel
|
|
/// </summary>
|
|
/// <param name="dataType">Tipologia di dato richiesto da enum</param>
|
|
/// <param name="inizio">DT Inizio estrazione</param>
|
|
/// <param name="fine">DT Fine estrazione</param>
|
|
/// <returns></returns>
|
|
public async Task<List<DataLogModel>> DataLogGetFilt(DataLogType dataType, DateTime inizio, DateTime fine)
|
|
{
|
|
string source = "DB";
|
|
List<DataLogModel> dbResult = new List<DataLogModel>();
|
|
string currKey = $"{Constants.DATA_LOG_KEY}:{dataType}:ALL:{inizio:yyyyMMdd}:{fine:yyyyMMdd}";
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var rawData = await redisDb.StringGetAsync(currKey);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
source = "REDIS";
|
|
var tempResult = JsonConvert.DeserializeObject<List<DataLogModel>>($"{rawData}");
|
|
if (tempResult == null)
|
|
{
|
|
dbResult = new List<DataLogModel>();
|
|
}
|
|
else
|
|
{
|
|
dbResult = tempResult;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dbResult = await dbController.DataLogGetFilt(dataType, inizio, fine);
|
|
// salvo per 2 min...
|
|
rawData = JsonConvert.SerializeObject(dbResult);
|
|
await redisDb.StringSetAsync(currKey, rawData, TimeSpan.FromSeconds(120));
|
|
}
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
int sizeKb = rawData.HasValue ? $"{rawData}".Length / 1024 : 0;
|
|
Log.Info($"DataLogGetFilt | {source} | dataType: {dataType} | ALL | {inizio:yyyyMMdd}-{fine:yyyyMMdd} | {ts.TotalMilliseconds} ms | {sizeKb} kb");
|
|
return dbResult;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
// Clear database controller
|
|
dbController.Dispose();
|
|
}
|
|
|
|
public async Task<bool> FlushRedisCache()
|
|
{
|
|
await Task.Delay(1);
|
|
RedisValue pattern = new RedisValue($"{Constants.BASE_HASH}:Cache*");
|
|
bool answ = await ExecFlushRedisPattern(pattern);
|
|
return answ;
|
|
}
|
|
|
|
public async Task<List<DisplayDataDTO>> getActLog()
|
|
{
|
|
List<DisplayDataDTO>? answ = new List<DisplayDataDTO>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.ACT_LOG_CURR_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
answ = JsonConvert.DeserializeObject<List<DisplayDataDTO>>($"{rawData}");
|
|
}
|
|
if (answ == null)
|
|
{
|
|
answ = new List<DisplayDataDTO>();
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Conf allarmi (BankBit) IMPOSTATA con valori silenziati
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<BaseAlarmBankConf>> getAlarmBankBitSetup()
|
|
{
|
|
List<BaseAlarmBankConf>? redResult = new List<BaseAlarmBankConf>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.ALARMS_SETT_BBIT_KEY);
|
|
//se non avessi trovato valori cerco quelli di setup...
|
|
if (string.IsNullOrEmpty(rawData))
|
|
{
|
|
rawData = await redisDb.StringGetAsync(Constants.ALARMS_CONF_KEY);
|
|
}
|
|
// ora provo a deserializzare
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
redResult = JsonConvert.DeserializeObject<List<BaseAlarmBankConf>>($"{rawData}");
|
|
}
|
|
// altrimenti imposto vuoto
|
|
if (redResult == null)
|
|
{
|
|
redResult = new List<BaseAlarmBankConf>();
|
|
}
|
|
return await Task.FromResult(redResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Conf allarmi (da ADAPTER) tipo BankBit senza valori silenziati da app
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<BaseAlarmBankConf>> getAlarmBBConfig()
|
|
{
|
|
List<BaseAlarmBankConf>? dbResult = new List<BaseAlarmBankConf>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.ALARMS_CONF_BBIT_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
dbResult = JsonConvert.DeserializeObject<List<BaseAlarmBankConf>>($"{rawData}");
|
|
}
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new List<BaseAlarmBankConf>();
|
|
}
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
public async Task<AlarmReportingMode> getAlarmMode()
|
|
{
|
|
AlarmReportingMode answ = AlarmReportingMode.ND;
|
|
var rawData = await redisDb.StringGetAsync(Constants.ALARMS_MODE_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
answ = JsonConvert.DeserializeObject<AlarmReportingMode>($"{rawData}");
|
|
}
|
|
if (answ == AlarmReportingMode.ND)
|
|
{
|
|
answ = AlarmReportingMode.RawList;
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ID allarmi (RawList) x gestione stato silenziati
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<AlarmListModel>> getAlarmRawSetup()
|
|
{
|
|
List<AlarmListModel>? mutedList = new List<AlarmListModel>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.ALARMS_SETT_RLIST_KEY);
|
|
// ora provo a deserializzare
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
mutedList = JsonConvert.DeserializeObject<List<AlarmListModel>>($"{rawData}");
|
|
}
|
|
// altrimenti imposto vuoto
|
|
if (mutedList == null)
|
|
{
|
|
mutedList = dbController.AlarmListGetAll();
|
|
}
|
|
return await Task.FromResult(mutedList);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Conf allarmi (da ADAPTER) tipo RawList senza valori silenziati da app
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<AlarmListModel>> getAlarmRLConfig()
|
|
{
|
|
List<AlarmListModel>? redResult = dbController.AlarmListGetAll();
|
|
return await Task.FromResult(redResult);
|
|
}
|
|
|
|
public async Task<List<string>> getAlarms()
|
|
{
|
|
List<string>? dbResult = new List<string>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.ALARM_CURR_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
dbResult = JsonConvert.DeserializeObject<List<string>>($"{rawData}");
|
|
}
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new List<string>();
|
|
}
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
public async Task<List<DisplayDataDTO>> getEventHist()
|
|
{
|
|
List<DisplayDataDTO>? dbResult = new List<DisplayDataDTO>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.EVENT_LOG_CURR_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
dbResult = JsonConvert.DeserializeObject<List<DisplayDataDTO>>($"{rawData}");
|
|
}
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new List<DisplayDataDTO>();
|
|
}
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
public async Task<List<DisplayDataDTO>> getMaintenance()
|
|
{
|
|
List<DisplayDataDTO>? dbResult = new List<DisplayDataDTO>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.MAINT_STATS_CURR_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
dbResult = JsonConvert.DeserializeObject<List<DisplayDataDTO>>($"{rawData}");
|
|
}
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new List<DisplayDataDTO>();
|
|
}
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
public async Task<List<MachineMode>> getModesList()
|
|
{
|
|
List<MachineMode>? dbResult = new List<MachineMode>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.MODE_CONF_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
dbResult = JsonConvert.DeserializeObject<List<MachineMode>>($"{rawData}");
|
|
}
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new List<MachineMode>();
|
|
}
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
public async Task<List<DisplayDataDTO>> getParameters()
|
|
{
|
|
List<DisplayDataDTO>? dbResult = new List<DisplayDataDTO>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.PARAMS_CURR_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
dbResult = JsonConvert.DeserializeObject<List<DisplayDataDTO>>($"{rawData}");
|
|
}
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new List<DisplayDataDTO>();
|
|
}
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
public async Task<ProductionDTO> getProd()
|
|
{
|
|
ProductionDTO? dbResult = new ProductionDTO();
|
|
var rawData = await redisDb.StringGetAsync(Constants.PROD_CURR_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
dbResult = JsonConvert.DeserializeObject<ProductionDTO>($"{rawData}");
|
|
}
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new ProductionDTO();
|
|
}
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
public async Task<List<DisplayDataDTO>> getStats()
|
|
{
|
|
List<DisplayDataDTO>? dbResult = new List<DisplayDataDTO>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.MACH_STATS_CURR_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
dbResult = JsonConvert.DeserializeObject<List<DisplayDataDTO>>($"{rawData}");
|
|
}
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new List<DisplayDataDTO>();
|
|
}
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
public async Task<MachineDTO> getStatus()
|
|
{
|
|
MachineDTO? dbResult = new MachineDTO();
|
|
var rawData = await redisDb.StringGetAsync(Constants.STATUS_CURR_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
dbResult = JsonConvert.DeserializeObject<MachineDTO>($"{rawData}");
|
|
}
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new MachineDTO();
|
|
}
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
public async Task<List<MachineStatus>> getStatusList()
|
|
{
|
|
List<MachineStatus>? dbResult = new List<MachineStatus>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.DISPLSTATUS_CONF_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
dbResult = JsonConvert.DeserializeObject<List<MachineStatus>>($"{rawData}");
|
|
}
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new List<MachineStatus>();
|
|
}
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
public async Task<List<DisplayDataDTO>> getTools()
|
|
{
|
|
List<DisplayDataDTO>? dbResult = new List<DisplayDataDTO>();
|
|
var rawData = await redisDb.StringGetAsync(Constants.TOOLS_CURR_KEY);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
dbResult = JsonConvert.DeserializeObject<List<DisplayDataDTO>>($"{rawData}");
|
|
}
|
|
if (dbResult == null)
|
|
{
|
|
dbResult = new List<DisplayDataDTO>();
|
|
}
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco contatori ammessi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<CounterModel>> PMCounterModelGetAll()
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var dbResult = dbController.PMCounterModelGetAll();
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB PMCounterModelGetAll: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco Gruppi Macchina PM ammessi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<PMMGroupModel>> PMMachGroupGetAll()
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var dbResult = dbController.PMMachGroupGetAll();
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB PMMachGroupGetAll: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Eliminazione Record
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <param name="forceDelete"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> PMTaskDeleteRecord(PrevMaintTaskModel currRec, bool forceDelete)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
bool answ = await dbController.PMTaskDeleteRecord(currRec, forceDelete);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata chiamata a PMTaskDeleteRecord: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ri-abilita un record PM disabilitato
|
|
/// </summary>
|
|
/// <param name="currRec"></param>
|
|
/// <param name="forceDelete"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> PMTaskEnableRecord(PrevMaintTaskModel currRec)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
bool answ = await dbController.PMTaskEnableRecord(currRec);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata chiamata a PMTaskEnableRecord: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco Topics PM ammessi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<PMTaskTopicModel>> PMTaskTopicGetAll()
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var dbResult = dbController.PMTaskTopicGetAll();
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB PMTaskTopicGetAll: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco User Team PM ammessi
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<List<PMUTModel>> PMUTeamGetAll()
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
var dbResult = dbController.PMUTeamGetAll();
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB PMUTeamGetAll: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco task Schedulati
|
|
/// </summary>
|
|
/// <param name="machineId"></param>
|
|
/// <param name="skipRec"></param>
|
|
/// <param name="numRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<PrevMaintTaskModel>> PrevMaintTaskGetFilt(int machineId, int skipRec, int numRec)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
List<PrevMaintTaskModel>? dbResult = dbController.PrevMaintTaskGetFilt(machineId, skipRec, numRec);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB PrevMaintTaskGetFilt: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua upsert del record di manutenzione
|
|
/// </summary>
|
|
/// <param name="editRec"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> PrevMaintTaskUpdate(PrevMaintTaskModel editRec)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
bool dbResult = await dbController.PrevMaintTaskUpdate(editRec);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata upsert DB per PrevMaintTaskUpdate: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco task pending
|
|
/// </summary>
|
|
/// <param name="machineId"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> SchedMaintTaskCreateMissing(int machineId)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
bool answ = await dbController.SchedMaintTaskCreateMissing(machineId);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata chiamata a createMissingSchedTask: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero elenco Task Schedulati dati Macchina ed intervento "master"
|
|
/// </summary>
|
|
/// <param name="MachineId">Macchina selezionata</param>
|
|
/// <param name="PMTaskId">ID del PMTask parent</param>
|
|
/// <param name="skipRec">Num record da saltare</param>
|
|
/// <param name="numRec">num rec da recuperare</param>
|
|
/// <returns></returns>
|
|
public async Task<List<PendingMaintModel>> SchedMaintTaskGetByPMTask(int MachineId, int PMTaskId, int skipRec, int numRec)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
// ricerca sul DB "raw"
|
|
List<PendingMaintModel>? dbResult = dbController.SchedMaintTaskGetByPMTask(MachineId, PMTaskId, skipRec, numRec);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB SchedMaintTaskGetByPMTask: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero elenco Task Schedulati (ultimi dato "skip")
|
|
/// </summary>
|
|
/// <param name="MachineId">Macchina selezionata</param>
|
|
/// <param name="skipRec">Num record da saltare</param>
|
|
/// <param name="numRec">num rec da recuperare</param>
|
|
/// <returns></returns>
|
|
public async Task<List<PendingMaintModel>> SchedMaintTaskGetFilt(int machineId, int maxRemain, int skipRec, int numRec)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
// ricerca sul DB "raw"
|
|
List<PendingMaintModel>? rawResult = dbController.SchedMaintTaskGetFilt(machineId, skipRec, numRec);
|
|
// filtro ulteriormente ora...
|
|
var dbResult = rawResult.Where(x => x.CountRemainVal <= maxRemain || maxRemain == 0).ToList();
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata lettura da DB SchedMaintTaskGetFilt: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(dbResult);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Registro esecuzione task schedualto
|
|
/// </summary>
|
|
/// <param name="MachineId"></param>
|
|
/// <param name="SMTaskId"></param>
|
|
/// <param name="ExecDT"></param>
|
|
/// <param name="ExecUser"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> SchedMaintTaskSetDone(int MachineId, int SMTaskId, DateTime ExecDT, string ExecUser)
|
|
{
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
bool answ = await dbController.SchedMaintTaskSetDone(MachineId, SMTaskId, ExecDT, ExecUser);
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
Log.Trace($"Effettuata chiamata a SchedMaintTaskSetDone: {ts.TotalMilliseconds} ms");
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salva in settings la conf allarmi tipo BankBit
|
|
/// </summary>
|
|
/// <param name="alarmConf"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> setAlarmSetupBankBit(List<BaseAlarmBankConf> alarmConf)
|
|
{
|
|
bool answ = false;
|
|
string rawData = JsonConvert.SerializeObject(alarmConf);
|
|
await redisDb.StringSetAsync(Constants.ALARMS_SETT_BBIT_KEY, rawData);
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salva in settings la conf allarmi tipo RawList
|
|
/// </summary>
|
|
/// <param name="alarmConf"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> setAlarmSetupRawList(List<AlarmListModel> alarmConf)
|
|
{
|
|
bool answ = false;
|
|
string rawData = JsonConvert.SerializeObject(alarmConf);
|
|
await redisDb.StringSetAsync(Constants.ALARMS_SETT_RLIST_KEY, rawData);
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Private Fields
|
|
|
|
private static IConfiguration _configuration = null!;
|
|
|
|
private static ILogger<CurrentDataService> _logger = null!;
|
|
|
|
private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
/// <summary>
|
|
/// Oggetto per connessione a REDIS
|
|
/// </summary>
|
|
private ConnectionMultiplexer redisConn = null!;
|
|
|
|
//ISubscriber sub = redis.GetSubscriber();
|
|
/// <summary>
|
|
/// Oggetto DB redis da impiegare x chiamate R/W
|
|
/// </summary>
|
|
private IDatabase redisDb = null!;
|
|
|
|
#endregion Private Fields
|
|
|
|
#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);
|
|
}
|
|
// brutalmente rimuovo intero contenuto DB... DANGER
|
|
//await server.FlushDatabaseAsync();
|
|
answ = true;
|
|
}
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |