Egalware/mapo-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Aggiunta metodi processin FLog

Browse Source
This commit is contained in:
Samuele Locatelli
2026-04-14 09:00:41 +02:00
parent 683b326194
commit 1b48ee24fa
7 changed files with 578 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MP.Core/DTO/EvDataDto.cs
+33
View File
@@ -0,0 +1,33 @@
namespace MP.Core.DTO
{
/// <summary>
/// Tracciato InputEvents in formato JSON valido
/// Derivato da input realtime valore=3&dtEve=20181206180600000&dtCurr=20181206180600000&cnt=999
/// </summary>
public class EvDataDto
{
#region Public Properties
/// <summary>
/// Contatore incrementale x riordino invio (opzionale)
/// </summary>
public int cnt { get; set; } = 0;
/// <summary>
/// DataOra corrente della trasmissione
/// </summary>
public DateTime dtCurr { get; set; } = DateTime.Now;
/// <summary>
/// DataOra evento
/// </summary>
public DateTime dtEve { get; set; } = DateTime.Now;
/// <summary>
/// Valore del dato di flusso registrato
/// </summary>
public string valore { get; set; } = "-";
#endregion Public Properties
}
}
MP.Core/DTO/FLogDataDto.cs
+13
View File
@@ -0,0 +1,13 @@
namespace MP.Core.DTO
{
/// <summary>
/// Tracciato FluxLog in formato JSON valido
/// </summary>
public class FLogDataDto : EvDataDto
{
/// <summary>
/// nome del flusso
/// </summary>
public string flux { get; set; } = "ND";
}
}
MP.Core/DTO/FLogJsonPayloadDto.cs
+14
View File
@@ -0,0 +1,14 @@
namespace MP.Core.DTO
{
/// <summary>
/// Array valori tipo flogData inviati come JSon
/// </summary>
public class FLogJsonPayloadDto
{
#region Public Properties
public List<FLogDataDto> fluxData { get; set; } = new();
#endregion Public Properties
}
}
MP.Core/Utils.cs
+26 -1
View File
@@ -257,7 +257,19 @@ namespace MP.Core
}
/// <summary>
/// Hash dati Task2Exe x la macchina specificata
/// Hash dati SAVED (EXE) TASK x la macchina specificata x poter ripristinare in caso di
/// perdita valore WRITE (ex savedTaskHash)
/// </summary>
/// <param name="idxMacchina"></param>
/// <returns></returns>
public static RedisKey RedKeySavedTask2ExeMacc(string idxMacchina, string baseAddr = null)
{
var prefix = (baseAddr ?? redisBaseAddr).TrimEnd(':');
return (RedisKey)$"{prefix}:SavedTask:{idxMacchina}";
}
/// <summary>
/// Hash dati Task2Exe x la macchina specificata (ex exeTaskHash)
/// </summary>
/// <param name="idxMacchina"></param>
/// <param name="baseAddr">Chiave override per i valori in caso di dati che accedono al dominio dati di un altra app (es: baseAddr x IO legacy)</param>
@@ -268,6 +280,19 @@ namespace MP.Core
return (RedisKey)$"{prefix}:ExeTask:{idxMacchina}";
}
/// <summary>
/// Hash dati ultimo FluxLog ricevuto (ex LiveFLogKeyHash)
/// </summary>
/// <param name="idxMacchina"></param>
/// <param name="flog"></param>
/// <param name="baseAddr">Chiave override per i valori in caso di dati che accedono al dominio dati di un altra app (es: baseAddr x IO legacy)</param>
/// <returns></returns>
public static RedisKey RedKeyLastFLog(string idxMacchina, string flog, string baseAddr = null)
{
var prefix = (baseAddr ?? redisBaseAddr).TrimEnd(':');
return (RedisKey)$"{prefix}:FLOG:{idxMacchina}:{flog}";
}
/// <summary>
/// Formato RedisValue delal chaive richeista (completa)
/// </summary>
MP.Data/Controllers/MpIocController.cs
+50
View File
@@ -199,6 +199,56 @@ namespace MP.Data.Controllers
return dbResult;
}
/// <summary>
/// Aggiunta record FluxLog
/// </summary>
/// <param name="newRec"></param>
/// <returns></returns>
public bool FluxLogInsert(FluxLogModel newRec)
{
bool fatto = false;
using (var dbCtx = new MoonPro_FluxContext(_configuration))
{
try
{
var currRec = dbCtx
.DbSetFluxLog
.Add(newRec);
dbCtx.SaveChanges();
}
catch (Exception exc)
{
Log.Error($"Eccezione durante FluxLogInsert{Environment.NewLine}{exc}");
}
}
return fatto;
}
/// <summary>
/// Aggiunta record FluxLog Async
/// </summary>
/// <param name="newRec"></param>
/// <returns></returns>
public async Task<bool> FluxLogInsertAsync(FluxLogModel newRec)
{
bool fatto = false;
using (var dbCtx = new MoonPro_FluxContext(_configuration))
{
try
{
var currRec = dbCtx
.DbSetFluxLog
.Add(newRec);
await dbCtx.SaveChangesAsync();
}
catch (Exception exc)
{
Log.Error($"Eccezione durante FluxLogInsertAsync{Environment.NewLine}{exc}");
}
}
return fatto;
}
public bool KeepAliveUpsert(string IdxMacc, DateTime OraServer, DateTime OraMacc)
{
bool fatto = false;
MP.IOC/Controllers/IOBController.cs
+189 -2
View File
@@ -74,6 +74,78 @@ namespace MP.IOC.Controllers
}
}
/// <summary>
/// Invio record flog direttamente via URL GET
/// GET: IOB/flog/SIMUL_03?flux=PROG&valore=P0001&dtEve=20161223180600000&dtCurr=20161223180600000&cnt=999&disabKA=false
/// </summary>
/// <param name="id">IdxMacchina</param>
/// <param name="flux">CodFlux</param>
/// <param name="valore">Valore da registrare</param>
/// <param name="dtEve">DataOra evento (IOB time)</param>
/// <param name="dtCurr">DataOra corrente (IOB time)</param>
/// <param name="cnt">Contatore eventi (IOB)</param>
/// <param name="disabKA">Disabilitazione scrittura record KeepAlive</param>
/// <returns></returns>
[HttpGet("flog/{id}")]
public async Task<IActionResult> Flog(string id, string flux, string valore, string dtEve, string dtCurr, string cnt = "0", string disabKA = "false")
{
if (string.IsNullOrEmpty(id)) return BadRequest("Missing ID");
// Multi: gestione carattere "|" trasformato in "#"
id = id.Replace("|", "#");
string answ = "";
// formato yyyymmddHHMMSSnnn ovvero da anno a millisecondi
DateTime dataOraEvento = DateTime.Now;
Log.Trace($"Valori letti: id: {id} | flux: {flux} valore: {valore}");
try
{
int count = 0;
Int32.TryParse(cnt, out count);
bool disKa = false;
bool.TryParse(disabKA, out disKa);
answ = await DService.ProcessFluxLogAsync(id, flux, valore, dtEve, dtCurr, count, disKa);
return Ok(answ);
}
catch (Exception exc)
{
Log.Error($"Errore in flog{Environment.NewLine}{exc}");
return StatusCode(StatusCodes.Status500InternalServerError, "NO");
}
}
/// <summary>
/// Processa una chiamata POST per l'invio di un array Json di oggetti fluxLog
/// PUT: IOB/flogJson/SIMUL_03
/// </summary>
/// <param name="id">ID dell'IOB</param>
/// <param name="disabKA">Disabilitazione della scrittura del record KeepAlive</param>
/// <returns></returns>
[HttpPost("flogJson/{id}")]
public async Task<IActionResult> FlogJson(string id, string disabKA = "false", [FromBody] string content = "")
{
if (string.IsNullOrEmpty(id)) return BadRequest("Missing ID");
// Multi: gestione carattere "|" trasformato in "#"
id = id.Replace("|", "#");
bool disableKa = false;
bool.TryParse(disabKA, out disableKa);
string answ = "-";
// se ho dati...
if (content != "")
{
answ = await processFLogJsonAsync(id, disableKa, content);
return Ok(answ);
}
else
{
Log.Error($"Errore in FlogJson - no content");
return StatusCode(StatusCodes.Status500InternalServerError, "NO");
}
}
/// <summary>
/// Recupera COUNTER x macchina:
/// GET: IOB/getCounter/SIMUL_03
@@ -326,7 +398,6 @@ namespace MP.IOC.Controllers
/// </summary>
/// <param name="id">ID dell'IOB</param>
/// <returns></returns>
[HttpPost]
[HttpPost("saveMachineIobConf/{id}")]
public async Task<IActionResult> SaveMachineIobConf(string id, [FromBody] Dictionary<string, string> currDict)
{
@@ -334,8 +405,8 @@ namespace MP.IOC.Controllers
// Multi: gestione carattere "|" trasformato in "#"
id = id.Replace("|", "#");
string answ = "NA";
string answ = "NA";
try
{
bool fatto = await DService.SaveMachineIobConf(id, currDict);
@@ -530,5 +601,121 @@ namespace MP.IOC.Controllers
private MpDataService DService { get; set; }
#endregion Private Properties
#region Private Methods
/// <summary>
/// Effettivo processing FLogJson
/// </summary>
/// <param name="idxMacc"></param>
/// <param name="disabKA"></param>
/// <param name="insDone"></param>
/// <param name="content"></param>
/// <returns></returns>
private async Task<string> processFLogJsonAsync(string idxMacc, bool disabKA, string content)
{
string answ = "";
int insDone = 0;
// procedo a deserializzare in blocco l'oggetto...
FLogJsonPayloadDto receivedData = new FLogJsonPayloadDto();
try
{
// deserializzo.
receivedData = JsonConvert.DeserializeObject<FLogJsonPayloadDto>(content) ?? new();
}
catch (Exception exc)
{
Log.Error($"Errore in fase deserializzazione flogJson{Environment.NewLine}{exc}");
answ = "NO";
}
// se ho qualcosa da processare...
if (receivedData != null)
{
// per ogni valore --> salvo!
try
{
foreach (var item in receivedData.fluxData)
{
// formato datetime come yyyyMMddHHmmssfff -->es: 20181223180600000
answ = await DService.ProcessFluxLogAsync(idxMacc, item.flux, item.valore, item.dtEve.ToString("yyyyMMddHHmmssfff"), item.dtCurr.ToString("yyyyMMddHHmmssfff"), item.cnt, disabKA);
}
// se vuoto --> OK!
if (string.IsNullOrEmpty(answ))
{
answ = $"OK {insDone} processed";
}
}
catch (Exception exc)
{
Log.Error($"Errore in fase invio valori flogJson{Environment.NewLine}{exc}");
answ = "NO";
}
// leggo parametri correnti...
DateTime adesso = DateTime.Now;
try
{
List<ObjItemDTO> currParams = DService.MachineParamList(idxMacc);
// ora per ogni valore RICEVUTO costruisco un oggetto in innovazioni da
// inviare...x salvare in stato parametri...
List<ObjItemDTO> innovazioni = new List<ObjItemDTO>();
foreach (var item in receivedData.fluxData)
{
// flux = uuid del parametro
ObjItemDTO? trovato = currParams.Find(obj => obj.uid == item.flux);
// se lo trovo aggiorno...
if (trovato != null)
{
// aggiorno valore e data
trovato.value = item.valore;
trovato.lastRead = adesso;
trovato.lastMessage = item.valore;
// se fosse un valore WRITE
if (trovato.writable)
{
// ...e mi ha dato un valore vuoto --> mando un fix x riscrittura
if (string.IsNullOrEmpty(item.valore))
{
Log.Debug($"flogJson | verifica parametri | {trovato.uid} | reqVal: {trovato.reqValue}");
taskType currTask = (taskType)Enum.Parse(typeof(taskType), trovato.uid);
DService.AddCheckTask4Machine(idxMacc, currTask, item.valore);
}
}
else
{
// richiesto 10 sec prima...
trovato.lastRequest = adesso.AddSeconds(-10);
}
}
// altrimenti AGGIUNGO (READ ONLY)...
else
{
trovato = new ObjItemDTO
{
uid = item.flux,
name = item.flux,
value = item.valore,
lastRead = adesso,
lastRequest = adesso.AddSeconds(-10),
writable = false
};
}
// lo carico in innovation
innovazioni.Add(trovato);
}
// faccio upsert innovations!
DService.UpsertCurrObjItems(idxMacc, innovazioni);
Log.Info($"processFLogJsonAsync | {idxMacc} | Updated {innovazioni.Count} par");
}
catch (Exception exc)
{
Log.Error($"Errore in fase salvataggio innovazioni parametri correnti da flogJson{Environment.NewLine}{exc}");
answ = "NO";
}
}
return answ;
}
#endregion Private Methods
}
}
MP.IOC/Data/MpDataService.cs
+253 -14
View File
@@ -127,6 +127,43 @@ namespace MP.IOC.Data
return fatto;
}
/// <summary>
/// Verifica se sia da reinviare un task alla macchina dall'elenco di quelli salvati (in
/// modalità upsert) se non scaduti
/// </summary>
/// <param name="idxMacchina"></param>
/// <param name="taskKey"></param>
/// <param name="taskVal"></param>
/// <returns></returns>
public bool AddCheckTask4Machine(string idxMacchina, taskType taskKey, string taskVal)
{
bool answ = false;
var currHash = Utils.RedKeyTask2ExeMacc(idxMacchina, MpIoNS);
Log.Info($"addCheckTask4Machine idxMacchina: {idxMacchina} | taskKey: {taskKey} | taskVal: {taskVal}");
try
{
Dictionary<string, string> savedTask = mSavedTaskMacchina(idxMacchina);
// cerco valore saved
string savedVal = savedTask[taskKey.ToString()];
// se ho un valore != "" --> rimetto in coda di invio...
if (!string.IsNullOrEmpty(savedVal) && (savedVal != taskVal))
{
// leggo task attuali...
Dictionary<string, string> currTask = mTaskMacchina(idxMacchina);
// rimetto in task da eseguire...
currTask[taskKey.ToString()] = savedVal;
answ = RedisSetHashDict(currHash, currTask);
Log.Info($"re-issued task4machine: idxMacchina: {idxMacchina} | taskKey: {taskKey} | savedVal: {savedVal}");
}
}
catch (Exception exc)
{
Log.Error($"Eccezione in AddCheckTask4Machine{Environment.NewLine}{exc}");
}
return answ;
}
/// <summary>
/// Aggiunge un PARAMETRO OPZIONALE all'elenco di quelli salvati (in modalità upsert)
/// </summary>
@@ -152,6 +189,61 @@ namespace MP.IOC.Data
return answ;
}
/// <summary>
/// Aggiunge un task all'elenco di quelli salvati (in modalità upsert)
/// </summary>
/// <param name="idxMacchina"></param>
/// <param name="taskKey"></param>
/// <param name="taskVal"></param>
/// <returns></returns>
public bool AddTask4Machine(string idxMacchina, Enums.taskType taskKey, string taskVal)
{
bool answ = false;
var currHash = Utils.RedKeyTask2ExeMacc(idxMacchina, MpIoNS);
var currSavedParHash = Utils.RedKeySavedTask2ExeMacc(idxMacchina, MpIoNS);
Dictionary<string, string> currTask = new Dictionary<string, string>();
Dictionary<string, string> savedTask = new Dictionary<string, string>();
try
{
// leggo task attuali...
currTask = mTaskMacchina(idxMacchina);
if (currTask.ContainsKey($"{taskKey}"))
{
currTask[$"{taskKey}"] = taskVal;
}
else
{
currTask.Add($"{taskKey}", taskVal);
}
answ = RedisSetHashDict(currHash, currTask);
Log.Info($"Task ADD | hash: {currHash} | idxMacchina: {idxMacchina} | taskKey: {taskKey} | taskVal: {taskVal}");
}
catch { }
// verifico in base al tipo di task se fare backup...
switch (taskKey)
{
case Enums.taskType.setArt:
case Enums.taskType.setComm:
case Enums.taskType.setPzComm:
case Enums.taskType.setProg:
// leggo task SALVATI attuali...
savedTask = mSavedTaskMacchina(idxMacchina);
savedTask[taskKey.ToString()] = taskVal;
answ = RedisSetHashDict(currSavedParHash, savedTask);
break;
case Enums.taskType.endProd:
// salvo un DICT vuoto x resettare
savedTask = new Dictionary<string, string>();
answ = RedisSetHashDict(currSavedParHash, savedTask);
break;
default:
break;
}
return answ;
}
public async Task<List<ListValuesModel>> AnagStatiComm()
{
Stopwatch stopWatch = new Stopwatch();
@@ -1240,7 +1332,7 @@ namespace MP.IOC.Data
}
/// <summary>
/// Lista parametri correnti (ObjItemDTO) della macchina
/// Lista parametri correnti (ObjItemDTO) della macchina (ex getCurrObjItems)
/// </summary>
/// <param name="idxMacchina"></param>
/// <returns></returns>
@@ -1275,7 +1367,7 @@ namespace MP.IOC.Data
}
/// <summary>
/// Lista parametri correnti (ObjItemDTO) della macchina
/// Lista parametri correnti (ObjItemDTO) della macchina (ex getCurrObjItems)
/// </summary>
/// <param name="idxMacchina"></param>
/// <returns></returns>
@@ -1309,6 +1401,34 @@ namespace MP.IOC.Data
return result;
}
/// <summary>
/// Esegue aggiornamento MachineParamList (ex CurrObjItems)
/// </summary>
/// <param name="idxMacchina"></param>
/// <param name="currData"></param>
/// <returns></returns>
public bool MachineParamListSet(string idxMacchina, List<ObjItemDTO> currData)
{
string serVal = JsonConvert.SerializeObject(currData);
var currKey = Utils.RedKeyCurrObjItems(idxMacchina, MpIoNS);
bool fatto = redisDb.StringSet(currKey, serVal);
return fatto;
}
/// <summary>
/// Esegue aggiornamento MachineParamList (ex CurrObjItems) Async
/// </summary>
/// <param name="idxMacchina"></param>
/// <param name="currData"></param>
/// <returns></returns>
public async Task<bool> MachineParamListSetAsync(string idxMacchina, List<ObjItemDTO> currData)
{
string serVal = JsonConvert.SerializeObject(currData);
var currKey = Utils.RedKeyCurrObjItems(idxMacchina, MpIoNS);
bool fatto = await redisDb.StringSetAsync(currKey, serVal);
return fatto;
}
/// <summary>
/// Effettua UPSERT elenco parametri correnti x IOB (se c'è UPDATE, se manca ADD)
/// </summary>
@@ -1344,9 +1464,7 @@ namespace MP.IOC.Data
}
}
// serializzo e salvo
string serVal = JsonConvert.SerializeObject(innovations);
var currKey = Utils.RedKeyCurrObjItems(idxMacchina, MpIoNS);
RedisValue rawData = redisDb.StringSet(currKey, serVal);
answ = MachineParamListSet(idxMacchina, innovations);
}
return answ;
}
@@ -1386,9 +1504,7 @@ namespace MP.IOC.Data
}
}
// serializzo e salvo
string serVal = JsonConvert.SerializeObject(innovations);
var currKey = Utils.RedKeyCurrObjItems(idxMacchina, MpIoNS);
RedisValue rawData = await redisDb.StringSetAsync(currKey, serVal);
answ = MachineParamListSet(idxMacchina, innovations);
}
return answ;
}
@@ -1459,9 +1575,31 @@ namespace MP.IOC.Data
return answ;
}
/// <summary>
/// Restitusice elenco KVP dei TASK SALVATI (da passare a IOB-WIN) per l'impianto indicato
/// </summary>
/// <param name="idxMacchina"></param>
/// <returns></returns>
public Dictionary<string, string> mSavedTaskMacchina(string idxMacchina)
{
// hard coded dimensione vettore DatiMacchine
Dictionary<string, string> answ = new Dictionary<string, string>();
// ORA recupero da memoria redis...
try
{
RedisKey currHash = Utils.RedKeySavedTask2ExeMacc(idxMacchina);
answ = RedisGetHashDict(currHash);
}
catch (Exception exc)
{
Log.Info($"Errore in recupero dati SAVED TASK x Redis mSavedTaskMacchina | idxMacchina {idxMacchina}{Environment.NewLine}{exc}");
}
return answ;
}
/// <summary>
/// Restitusice elenco KVP
/// key: IdxMacchina
/// currKey: IdxMacchina
/// value: IdxFamigliaIngresso
/// </summary>
/// <param name="idxMacchina"></param>
@@ -1955,6 +2093,65 @@ namespace MP.IOC.Data
return dbResult;
}
/// <summary>
/// Processa registrazione FL da IOB
/// </summary>
/// <param name="idxMacchina"></param>
/// <param name="flux"></param>
/// <param name="valore"></param>
/// <param name="dtEve"></param>
/// <param name="dtCurr"></param>
/// <param name="contatore"></param>
/// <param name="disabKA"></param>
/// <returns></returns>
public async Task<string> ProcessFluxLogAsync(string idxMacchina, string flux, string valore, string dtEve, string dtCurr, int contatore, bool disabKA)
{
// se non vietato...
if (!disabKA)
{
// scrivo keep alive!!! (se necessario, altrimenti è in cache...)
ScriviKeepAlive(idxMacchina, DateTime.Now);
}
string answ = "";
DateTime dataOraEvento = GetSrvDtEvent(dtEve, dtCurr);
// inizio processing vero e proprio INPUT...
if (idxMacchina != null && valore != null)
{
if (idxMacchina != "" && valore != "")
{
FluxLogModel newRec = new FluxLogModel()
{
IdxMacchina = idxMacchina,
dtEvento = dataOraEvento,
CodFlux = flux,
Valore = valore,
Cnt = contatore
};
await IocDbController.FluxLogInsertAsync(newRec);
// 2022.06.06 salvo su redis il valore ULTIMO del flux x recupero rapido ultimo valore
var currKey = Utils.RedKeyLastFLog(idxMacchina, flux, MpIoNS);
// 10 min cache max...
await redisDb.StringSetAsync(currKey, valore, TimeSpan.FromMinutes(10));
// registro in risposta che è andato tutto bene...
answ = "OK";
}
else
{
string errore = "processFluxLog | Errore: parametri macchina/valore vuoti";
Log.Error(errore);
answ = errore;
}
}
else
{
string errore = "processFluxLog | Errore: mancano parametri macchina/valore";
Log.Error(errore);
answ = errore;
}
return answ;
}
/// <summary>
/// Processa input da IOB eventualmente registrando i segnali inviati
/// </summary>
@@ -2361,7 +2558,7 @@ namespace MP.IOC.Data
}
catch (Exception arg)
{
Log.Error($"Errore in redHashPresent per la key {key}{Environment.NewLine}{arg}");
Log.Error($"Errore in redHashPresent per la currKey {key}{Environment.NewLine}{arg}");
}
return result;
@@ -2381,7 +2578,7 @@ namespace MP.IOC.Data
}
catch (Exception arg)
{
Log.Error($"Errore in redKeyPresent per la key {key}:{Environment.NewLine}{arg}");
Log.Error($"Errore in redKeyPresent per la currKey {key}:{Environment.NewLine}{arg}");
}
return result;
@@ -2453,7 +2650,7 @@ namespace MP.IOC.Data
/// <summary>
/// Resetta (rileggendo) i dati della State Machine multi ingressi nel formato
/// key: IdxMacchina
/// currKey: IdxMacchina
/// value: IdxFamigliaIngresso
/// </summary>
/// <param name="idxMacchina"></param>
@@ -2787,7 +2984,7 @@ namespace MP.IOC.Data
/// <summary>
/// Restitusice elenco KVP dei campi della State Machine ingressi nel formato
/// key: cState_nVal (current MICRO-STATE + "_" + new Value)
/// currKey: cState_nVal (current MICRO-STATE + "_" + new Value)
/// value: iTipoEv_nState (IdxTipoEv da trasmettere + New MICRO-STATE
/// </summary>
/// <param name="idxFamIn"></param>
@@ -2914,6 +3111,48 @@ namespace MP.IOC.Data
return answ;
}
/// <summary>
/// Effettua UPSERT elenco parametri correnti x IOB (se c'è UPDATE, se manca ADD)
/// </summary>
/// <param name="idxMacchina"></param>
/// <param name="innovations"></param>
/// <returns></returns>
public bool UpsertCurrObjItems(string idxMacchina, List<ObjItemDTO> innovations)
{
bool answ = false;
if (innovations != null)
{
Log.Info($"upsertCurrObjItems | idxMacchina: {idxMacchina} | {innovations.Count} innovations");
// leggo i valori attuali...
List<ObjItemDTO> actValues = MachineParamList(idxMacchina);
// per ogni valore passatomi faccio insert o update rispetto elenco valori correnti in REDIS
foreach (var item in actValues)
{
// cerco nelle innovazioni SE CI SIA il valore...
var trovato = innovations.Find(obj => obj.uid == item.uid);
// se non trovato nelle innovazioni...
if (trovato == null)
{
// lo ri-aggiungo x non perderlo
innovations.Add(item);
Log.Trace($"innovations | add | item.uid: {item.uid} | item.value: {item.value}");
}
else
// altrimenti aggiorno campo (non trasmesso) name e tengo il resto...
{
trovato.name = item.name;
Log.Info($"innovations | update | item.uid: {item.uid} | item.value: {item.value} --> {trovato.value} ");
}
}
// serializzo e salvo
string serVal = JsonConvert.SerializeObject(innovations);
var currKey = Utils.RedKeyCurrObjItems(idxMacchina, MpIoNS);
RedisValue rawData = redisDb.StringSet(currKey, serVal);
}
return answ;
}
/// <summary>
/// Restituisce il valore SPECIFICATO per la state machine ingressi
/// value: iTipoEv_nState (IdxTipoEv da trasmettere + New MICRO-STATE)
@@ -3278,7 +3517,7 @@ namespace MP.IOC.Data
/// <summary>
/// Resetta (rileggendo) i dati della State Machine ingressi nel formato
/// key: cState_nVal (current MICRO-STATE + "_" + new Value)
/// currKey: cState_nVal (current MICRO-STATE + "_" + new Value)
/// value: iTipoEv_nState (IdxTipoEv da trasmettere + New MICRO-STATE)
/// </summary>
/// <param name="idxFamIn"></param>