refresh codice

2022-10-23 15:04:26 +02:00
parent 32efb52d9d
commit 9bb67a368e
21 changed files with 373 additions and 43 deletions
@@ -6,7 +6,7 @@
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <Platforms>AnyCPU;x86;x64</Platforms>
-    <Version>1.2.2210.2223</Version>
+    <Version>1.2.2210.2315</Version>
  </PropertyGroup>

  <ItemGroup>
@@ -1,6 +1,6 @@
 <body>
    <i>MAPO-MONO</i>
-    <h4>Version: 1.2.2210.2223</h4>
+    <h4>Version: 1.2.2210.2315</h4>
    <br /> Release Note:
    <ul>
        <li>
@@ -1 +1 @@
-1.2.2210.2223
+1.2.2210.2315
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.2.2210.2223</version>
+  <version>1.2.2210.2315</version>
  <url>http://nexus.steamware.net/repository/SWS/MP.MONO.ANALYZER/stable/LAST/MP.Mon.zip</url>
  <changelog>http://nexus.steamware.net/repository/SWS/MP.MONO.ANALYZER/stable/LAST/ChangeLog.html</changelog>
  <mandatory>false</mandatory>
@@ -10,7 +10,8 @@ namespace MP.MONO.Core.CONF
        #region Public Constructors

        public MachDataItem()
-        { }
+        {
+        }

        #endregion Public Constructors

@@ -19,32 +20,32 @@ namespace MP.MONO.Core.CONF
        /// <summary>
        /// Categoria oggetto
        /// </summary>
-        public DataItemCategory Category { get; set; }
+        public DataItemCategory Category { get; set; } = DataItemCategory.EVENT;

        /// <summary>
        /// Nome / descrizione
        /// </summary>
-        public string Name { get; set; }
+        public string Name { get; set; } = "";

        /// <summary>
        /// Tipologia specifica
        /// </summary>
-        public string SubType { get; set; }
+        public string SubType { get; set; } = "";

        /// <summary>
        /// Tipologia principale
        /// </summary>
-        public string Type { get; set; }
+        public string Type { get; set; } = "";

        /// <summary>
        /// Unità di misura
        /// </summary>
-        public string Units { get; set; }
+        public string Units { get; set; } = "";

        /// <summary>
        /// ID generico
        /// </summary>
-        public string uuid { get; set; }
+        public string uuid { get; set; } = "";

        #endregion Public Properties
    }
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
@@ -0,0 +1,323 @@
+using Microsoft.Extensions.Configuration;
+using MP.MONO.Core;
+using Newtonsoft.Json;
+using NLog;
+using StackExchange.Redis;
+
+namespace MP.MONO.DECODER
+{
+    public class AlarmsBlinkManager
+    {
+        #region Protected Fields
+
+        protected static Logger Log = LogManager.GetCurrentClassLogger();
+
+        #endregion Protected Fields
+
+        #region Private Fields
+
+        private static ConnectionMultiplexer? redisConn = null;
+        private static IDatabase? redisDb = null;
+
+        #endregion Private Fields
+
+        #region Public Constructors
+
+        public AlarmsBlinkManager()
+        {
+            var env = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+            var builder = new ConfigurationBuilder()
+                .AddJsonFile($"appsettings.json", true, true)
+                .AddJsonFile($"appsettings.{env}.json", true, true)
+                .AddEnvironmentVariables();
+            var config = builder.Build();
+
+            redisConn = ConnectionMultiplexer.Connect(config.GetConnectionString("Redis"));
+            redisDb = redisConn.GetDatabase();
+
+            Log.Info("AlarmsBlinkManager OK");
+            Console.WriteLine("AlarmsBlinkManager OK");
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        /// <summary>
+        /// Funzione chiamata x verifica allarmi:
+        /// - fornisce elenco dei NUOVI come ref
+        /// - fornisce elenco dei CESSATI come ref
+        /// </summary>
+        /// <param name="alarmListReceived"></param>
+        /// <param name="alarmListAdded"></param>
+        /// <param name="alarmListCeased"></param>
+        /// <returns>Boolean che indica se ci siano state variazioni</returns>
+        public static bool processData(List<string> alarmListReceived, ref List<string> alarmListAdded, ref List<string> alarmListCeased)
+        {
+            bool answ = false;
+            // primo step: verifico gli allarmi ricevuti siano > 0 e NON contengano duplicati...
+            List<string> alarmListReceivedOk = new List<string>();
+            if (alarmListReceived.Count > 0)
+            {
+                alarmListReceivedOk = alarmListReceived
+                                .GroupBy(x => x)
+                                .Select(grp => grp.First())
+                                .OrderBy(x => x)
+                                .ToList();
+                Log.Info($"Ricezione update allarmi | {alarmListReceived.Count} --> {alarmListReceivedOk.Count} distinct");
+            }
+            else
+            {
+                Log.Info($"Ricezione ZERO allarmi | {alarmListReceived.Count}");
+            }
+
+            // salvo set allarmi ricevuti...
+            setAlarms("LastReceived", alarmListReceivedOk);
+            Log.Debug($"Salvataggio LastReceived | count {alarmListReceivedOk.Count}");
+
+            // recupero allarmi correnti...
+            List<string> alarmListCurrent = getAlarms("Current");
+
+            // elenco allarmi confermati
+            var alarmListConf = alarmListCurrent.Intersect(alarmListReceivedOk);
+
+            // copio oggetti x allarmi NUOVI e cessati
+            alarmListAdded = new List<string>(alarmListReceivedOk);
+            alarmListCeased = new List<string>(alarmListCurrent);
+            foreach (var item in alarmListConf)
+            {
+                // calcolo allarmi nuovi/cessati eliminando eventuali elementi comuni
+                alarmListAdded.Remove(item);
+                alarmListCeased.Remove(item);
+            }
+
+            // aggiungo i nuovi a current
+            alarmListCurrent.AddRange(alarmListAdded);
+            // riordino
+            alarmListCurrent = alarmListCurrent.OrderBy(x => x).ToList();
+            // ...e salvo
+            setAlarms("Current", alarmListCurrent);
+
+            // loggo controllo
+            Log.Debug($"Esito controllo | {alarmListReceivedOk.Count} ricevuti | {alarmListAdded.Count} aggiunti | {alarmListCeased.Count} cessati");
+#if false
+              // gestione allarmi muted
+                List<AlarmListModel>? mutedAlarmsList = new List<AlarmListModel>();
+                string rawData = redisDb.StringGet(Constants.ALARMS_SETT_RLIST_KEY);
+                if (!string.IsNullOrEmpty(rawData))
+                {
+                    mutedAlarmsList = JsonConvert.DeserializeObject<List<AlarmListModel>>(rawData);
+                }
+                if (mutedAlarmsList == null)
+                {
+                    mutedAlarmsList = dbController.AlarmListGetAll();
+                }
+
+                // rileggo da REDIS la conf attuale allarmi già attivi da area ALARM_CURR_KEY
+
+                // FIXME TODO !!! usare una lista thread safe?!?!?
+                List<string> lastAlarms = getAlarms("Current");
+                List<string> startedAlarms = new List<string>();
+                List<string> ceasedAlarms = new List<string>();
+                string serAlarms = "";
+
+                // ciclo x ogni allarme ricevuto x vedere se sia INIZIATO o vada filtrato x muted
+                if (alarmList != null)
+                {
+                    // ciclo x ogni allarme attivo x verificare se si sia CHIUSO
+                    foreach (var newAlarm in alarmList)
+                    {
+                        var currNewAlarm = newAlarm;
+                        // se ho valori trim pre/post li applica...
+                        if (!string.IsNullOrEmpty(AlarmCleanPre))
+                        {
+                            currNewAlarm = currNewAlarm.Replace(AlarmCleanPre, "");
+                        }
+                        if (!string.IsNullOrEmpty(AlarmCleanPost))
+                        {
+                            currNewAlarm = currNewAlarm.Replace(AlarmCleanPost, "");
+                        }
+                        // se AlarmIgnoreEmpty=true + vuoto --> salto
+                        if (AlarmIgnoreEmpty && string.IsNullOrWhiteSpace(currNewAlarm))
+                        {
+                            alarmList.Remove(currNewAlarm);
+                            alarmList.Remove(newAlarm);
+                        }
+                        else
+                        {
+                            // in primis... se è muted --> lo escludo...
+                            bool isMuted = false;
+                            var maybeMuted = mutedAlarmsList.Where(x => x.FullValue == currNewAlarm).FirstOrDefault();
+                            if (maybeMuted != null)
+                            {
+                                isMuted = maybeMuted.Muted;
+                            }
+                            // cerco l'allarme nell'elenco degli allarmi dal DB
+                            AlarmListModel? foundAlarm = getAlarmModel(currNewAlarm);
+
+                            if (!isMuted)
+                            {
+                                if (!lastAlarms.Contains(currNewAlarm))
+                                {
+                                    if (foundAlarm != null)
+                                    {
+                                        // segno come iniziato...
+                                        AlarmRecModel newAlarmRec = new AlarmRecModel()
+                                        {
+                                            MachineId = MachineId,
+                                            DtStart = adesso,
+                                            DtEnd = adesso.AddMinutes(-1),
+                                            AlarmId = foundAlarm.AlarmId
+                                        };
+                                        alarmRecList.Add(newAlarmRec);
+                                        startedAlarms.Add(currNewAlarm);
+                                        lastAlarms.Add(currNewAlarm);
+                                        needsWrite = true;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                // rimuovo da alarmList perché muted...
+                                alarmList.Remove(currNewAlarm);
+                                alarmList.Remove(newAlarm);
+                            }
+                        }
+                    }
+                }
+
+                // salvo
+                serAlarms = JsonConvert.SerializeObject(lastAlarms);
+                // invio sulla message pipeline corretta TUTTI gli allarmi serializzati
+                alarmsSendPipe.saveAndSendMessage(Constants.ALARM_CURR_KEY, serAlarms);
+
+                // calcolo allarmi cessati...
+                if (lastAlarms != null)
+                {
+                    // ciclo x ogni allarme attivo x verificare se si sia CHIUSO
+                    foreach (var oldData in lastAlarms)
+                    {
+                        bool trovato = false;
+                        if (alarmList != null)
+                        {
+                            trovato = alarmList.Contains(oldData);
+                        }
+                        // se non c'è... segno cessato
+                        if (!trovato)
+                        {
+                            ceasedAlarms.Add(oldData);
+                            await Task.Run(async () =>
+                            {
+                                await checkCeasedAlarm(oldData);
+                            });
+                        }
+                    }
+                }
+
+                Log.Debug($"Stato lastAlarms | count {lastAlarms.Count}");
+
+                // gli allarmi cessati avvio un task di verifica dopo periodo di blink
+                if (needsWrite)
+                {
+                    Log.Debug($"Preparazione AlarmLogRecord | count {lastAlarms.Count}");
+
+                    // preparo dati x alarmLog
+                    AlarmLogModel newAlarmLog = new AlarmLogModel()
+                    {
+                        MachineId = MachineId,
+                        DtRif = adesso,
+                        MemAddress = "ND",
+                        Index = 0,
+                        // usare alarmList o lastAlarms
+                        Status = (uint)alarmList.Count,
+                        ValDecoded = alarmList.Count > 0 ? string.Join(", ", alarmList) : "All OK"
+                    };
+                    alarmLogList.Add(newAlarmLog);
+                }
+
+                if (lastAlarms != null)
+                {
+                    lastAlarms = lastAlarms.OrderBy(x => x).ToList();
+                    // serializzo l'elenco allarmi...
+                    serAlarms = JsonConvert.SerializeObject(lastAlarms);
+
+                    // se vuoto metto controllo x chiusura
+                    if (lastAlarms.Count() == 0)
+                    {
+                        await Task.Run(async () =>
+                        {
+                            await checkCloseAllAlarm();
+                        });
+                    }
+
+                    // invio sulla message pipeline corretta TUTTI gli allarmi serializzati
+                    alarmsSendPipe.saveAndSendMessage(Constants.ALARM_CURR_KEY, serAlarms);
+
+                    Log.Debug($"Salvataggio/invio allarmi | serAlarms | count {lastAlarms.Count}");
+                }
+#endif
+            // restituisco esito esecuzione
+            return answ;
+        }
+
+        #endregion Public Methods
+
+        #region Private Methods
+
+        /// <summary>
+        /// Recupero da redis gli allarmi secondo tipo LastReceived / Current
+        /// </summary>
+        private static List<string> getAlarms(string tipo)
+        {
+            // rileggo da REDIS la conf attuale allarmi già attivi da area ALARM_CURR_KEY
+            List<string> lastAlarms = new List<string>();
+            // in base al tipo leggo una chiave redis o l'altra...
+            string rawData = "";
+            if (redisDb != null)
+            {
+                if (tipo == "LastReceived")
+                {
+                    rawData = redisDb.StringGet(Constants.ALARM_RECEIV_KEY);
+                }
+                else
+                {
+                    rawData = redisDb.StringGet(Constants.ALARM_CURR_KEY);
+                }
+            }
+            // se trovati uso questi...
+            if (!string.IsNullOrEmpty(rawData))
+            {
+                var rawLastAlarms = JsonConvert.DeserializeObject<List<string>>(rawData);
+                lastAlarms = rawLastAlarms != null ? rawLastAlarms : new List<string>();
+                Log.Debug($"Lettura allarmi | tipo: {tipo} | num: {lastAlarms.Count}");
+            }
+            return lastAlarms;
+        }
+
+        /// <summary>
+        /// Salvo in redis gli allarmi secondo tipo LastReceived / Sent
+        /// </summary>
+        private static bool setAlarms(string tipo, List<string> listAlarm)
+        {
+            bool fatto = false;
+            string rawData = JsonConvert.SerializeObject(listAlarm);
+
+            if (redisDb != null)
+            {
+                if (tipo == "LastReceived")
+                {
+                    fatto = redisDb.StringSet(Constants.ALARM_RECEIV_KEY, rawData);
+                }
+                else
+                {
+                    fatto = redisDb.StringSet(Constants.ALARM_CURR_KEY, rawData);
+                }
+            }
+
+            Log.Debug($"Scrittura allarmi | tipo: {tipo} | num: {listAlarm.Count}");
+            return fatto;
+        }
+
+        #endregion Private Methods
+    }
+}
@@ -6,7 +6,7 @@
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <Platforms>AnyCPU;x86;x64</Platforms>
-    <Version>1.2.2210.2223</Version>
+    <Version>1.2.2210.2315</Version>
  </PropertyGroup>

  <ItemGroup>
@@ -174,7 +174,7 @@ void setupAlarmState()
 {
    // setup preliminare allarmi da DB
    var actAlarmsList = dbController.AlarmRecGetActive().Select(x => x.AlarmListNav.FullValue).Distinct().ToList();
-    setAlarms("Sent", actAlarmsList);
+    setAlarms("Current", actAlarmsList);
    setAlarms("LastReceived", new List<string>());
    Log.Debug($"Setup Stato allarmi | act: {actAlarmsList.Count}");
 }
@@ -291,7 +291,7 @@ async Task<bool> checkCeasedAlarm(string alarmFullCode)
                Log.Debug($"checkCeasedAlarm 03 | Chiusura allarme | cod: {alarmFullCode} | Id: {foundAlarm.AlarmId}");
            }
            // --> rimuovo da elenco attivi!
-            var alarmListSent = getAlarms("Sent");
+            var alarmListSent = getAlarms("Current");
            int numPre = alarmListSent.Count();
            alarmListSent.Remove(alarmFullCode);
            int numPost = alarmListSent.Count();
@@ -314,7 +314,7 @@ async Task<bool> checkCloseAllAlarm()
    bool answ = false;
    Log.Debug($"Verifica checkCloseAllAlarm");
    // cerco allarme da valore REDIS ultimi ricevuti
-    var alarmSent = getAlarms("Sent");
+    var alarmSent = getAlarms("Current");
    if (alarmSent != null)
    {
        bool isZero = alarmSent.Count() == 0;
@@ -324,7 +324,7 @@ async Task<bool> checkCloseAllAlarm()
            // attendo periodo pausa...
            await Task.Delay(BlinkPeriodMSec * 2);
            // rileggo stato
-            alarmSent = getAlarms("Sent");
+            alarmSent = getAlarms("Current");
            isZero = alarmSent.Count() == 0;
            // ...SE fossero sempre zero
            if (isZero)
@@ -700,7 +700,7 @@ async void AlarmsValPipe_EA_NewMessage(object? sender, EventArgs e)
                // rileggo da REDIS la conf attuale allarmi già attivi da area ALARM_CURR_KEY

                // FIXME TODO !!! usare una lista thread safe?!?!?
-                List<string> lastAlarms = getAlarms("Sent");
+                List<string> lastAlarms = getAlarms("Current");
                List<string> startedAlarms = new List<string>();
                List<string> ceasedAlarms = new List<string>();
                string serAlarms = "";
@@ -1,6 +1,6 @@
 <body>
    <i>MAPO-MONO</i>
-    <h4>Version: 1.2.2210.2223</h4>
+    <h4>Version: 1.2.2210.2315</h4>
    <br /> Release Note:
    <ul>
        <li>
@@ -1 +1 @@
-1.2.2210.2223
+1.2.2210.2315
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.2.2210.2223</version>
+  <version>1.2.2210.2315</version>
  <url>http://nexus.steamware.net/repository/SWS/MP.MONO.DECODER/stable/LAST/MP.Mon.zip</url>
  <changelog>http://nexus.steamware.net/repository/SWS/MP.MONO.DECODER/stable/LAST/ChangeLog.html</changelog>
  <mandatory>false</mandatory>
@@ -942,18 +942,21 @@ namespace MP.MONO.Data.Controllers
                                    .DbSetPMTask
                                    .Where(x => x.PMTaskId == currRec.PMTaskId)
                                    .FirstOrDefault();
-                    // se effettivo delete
-                    if (forceDelete)
+                    if (currVal != null)
                    {
-                        localDbCtx
-                            .DbSetPMTask
-                            .Remove(currVal);
+                        // se effettivo delete
+                        if (forceDelete)
+                        {
+                            localDbCtx
+                                .DbSetPMTask
+                                .Remove(currVal);
+                        }
+                        else
+                        {
+                            currVal.IsDisabled = true;
+                        }
+                        await localDbCtx.SaveChangesAsync();
                    }
-                    else
-                    {
-                        currVal.IsDisabled = true;
-                    }
-                    await localDbCtx.SaveChangesAsync();
                    fatto = true;
                }
                catch (Exception exc)
@@ -980,12 +983,15 @@ namespace MP.MONO.Data.Controllers
                                    .DbSetPMTask
                                    .Where(x => x.PMTaskId == currRec.PMTaskId)
                                    .FirstOrDefault();
-                    // se effettivo delete
-                    if (currRec.IsDisabled)
+                    if (currVal != null)
                    {
-                        currVal.IsDisabled = false;
+                        // se effettivo delete
+                        if (currRec.IsDisabled)
+                        {
+                            currVal.IsDisabled = false;
+                        }
+                        await localDbCtx.SaveChangesAsync();
                    }
-                    await localDbCtx.SaveChangesAsync();
                    fatto = true;
                }
                catch (Exception exc)
@@ -6,7 +6,7 @@
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <Platforms>AnyCPU;x86;x64</Platforms>
-    <Version>1.2.2210.2223</Version>
+    <Version>1.2.2210.2315</Version>
  </PropertyGroup>

  <ItemGroup>
@@ -1,6 +1,6 @@
 <body>
    <i>MAPO-MONO</i>
-    <h4>Version: 1.2.2210.2223</h4>
+    <h4>Version: 1.2.2210.2315</h4>
    <br /> Release Note:
    <ul>
        <li>
@@ -1 +1 @@
-1.2.2210.2223
+1.2.2210.2315
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.2.2210.2223</version>
+  <version>1.2.2210.2315</version>
  <url>http://nexus.steamware.net/repository/SWS/MP.MONO.SIM/stable/LAST/MP.Mon.zip</url>
  <changelog>http://nexus.steamware.net/repository/SWS/MP.MONO.SIM/stable/LAST/ChangeLog.html</changelog>
  <mandatory>false</mandatory>
@@ -5,7 +5,7 @@
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <Platforms>AnyCPU;x86;x64</Platforms>
-    <Version>1.2.2210.2223</Version>
+    <Version>1.2.2210.2315</Version>
  </PropertyGroup>

  <ItemGroup>
@@ -1,6 +1,6 @@
 <body>
    <i>MAPO-MONO</i>
-    <h4>Version: 1.2.2210.2223</h4>
+    <h4>Version: 1.2.2210.2315</h4>
    <br /> Release Note:
    <ul>
        <li>
@@ -1 +1 @@
-1.2.2210.2223
+1.2.2210.2315
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.2.2210.2223</version>
+  <version>1.2.2210.2315</version>
  <url>http://nexus.steamware.net/repository/SWS/MP.MONO.UI/stable/LAST/MP.Mon.zip</url>
  <changelog>http://nexus.steamware.net/repository/SWS/MP.MONO.UI/stable/LAST/ChangeLog.html</changelog>
  <mandatory>false</mandatory>