From 80a5d40897d68b32fc8628f6c14ab3cf3064c864 Mon Sep 17 00:00:00 2001
From: Samuele Locatelli <samuele@steamware.net>
Date: Tue, 28 Apr 2026 08:59:48 +0200
Subject: [PATCH] test fix input

---
 MP.IOC/Controllers/IOBController.cs |  1 -
 MP.IOC/Data/MpDataService.cs        | 73 +++++++++++++++++++++++++----
 2 files changed, 65 insertions(+), 9 deletions(-)

diff --git a/MP.IOC/Controllers/IOBController.cs b/MP.IOC/Controllers/IOBController.cs
index 106c33ff..21ef2c34 100644
--- a/MP.IOC/Controllers/IOBController.cs
+++ b/MP.IOC/Controllers/IOBController.cs
@@ -1186,7 +1186,6 @@ namespace MP.IOC.Controllers
                 Log.Error($"Errore in sendReboot{Environment.NewLine}{exc}");
                 return StatusCode(StatusCodes.Status500InternalServerError, "NO");
             }
-            return Ok(answ);
         }
 
         /// <summary>
diff --git a/MP.IOC/Data/MpDataService.cs b/MP.IOC/Data/MpDataService.cs
index e425fbf9..1928613d 100644
--- a/MP.IOC/Data/MpDataService.cs
+++ b/MP.IOC/Data/MpDataService.cs
@@ -2945,6 +2945,25 @@ namespace MP.IOC.Data
             return answ;
         }
 
+        /// <summary>
+        /// Formato dataora standard x parsing
+        /// </summary>
+        private string dtFormat = "yyyyMMddHHmmssfff";
+        /// <summary>
+        /// Provider CultureInfo x parse valori (es dataora)
+        /// </summary>
+        private CultureInfo ciProvider = CultureInfo.InvariantCulture;
+
+        /// <summary>
+        /// Helper standardizzazione valore dataora ricevuto da IOB remoti
+        /// </summary>
+        /// <param name="s"></param>
+        /// <returns></returns>
+        private string dtFormStd(string? s)
+        {
+            return s?.Length > 17 ? s[..17] : s?.PadRight(17, '0') ?? string.Empty;
+        }
+
         /// <summary>
         /// Processa input da IOB eventualmente registrando i segnali inviati
         /// </summary>
@@ -2968,11 +2987,48 @@ namespace MP.IOC.Data
             }
             else
             {
+                DateTime dataOraEvento = DateTime.Now;
+
+                // fix formato dataora in ingresso
+                string stdEve = dtFormStd(dtEve);
+                string stdCurr = dtFormStd(dtCurr);
+
+                // 2. Se le stringhe normalizzate coincidono, skip dei calcoli
+                if (stdEve != stdCurr)
+                {
+
+                    // 3. Parsing sicuro
+                    if (DateTime.TryParseExact(stdEve, dtFormat, ciProvider, DateTimeStyles.None, out DateTime dtEvento) &&
+                        DateTime.TryParseExact(stdCurr, dtFormat, ciProvider, DateTimeStyles.None, out DateTime dtCorrente))
+                    {
+                        TimeSpan diff = dtCorrente - dtEvento;
+                        double ms = Math.Abs(diff.TotalMilliseconds);
+
+                        // 4. Classificazione delta con switch expression (più leggibile e performante)
+                        string deltaClass = ms switch
+                        {
+                            <= 10 => "0-10 ms",
+                            <= 100 => "10-100 ms",
+                            <= 1000 => "100-1000 ms",
+                            <= 10000 => "1-10 sec",
+                            _ => "> 10 sec"
+                        };
+
+                        Log.Debug($"Correzione delta {deltaClass}");
+
+                        // 5. Correzione data/ora server: sottrao lo scarto calcolato
+                        dataOraEvento = dataOraEvento.Subtract(diff);
+                    }
+                    else
+                    {
+                        Log.Error($"Errore parsing date: {stdEve} | {stdCurr}");
+                    }
+                }
+#if false
                 // 2017.09.14 trimmo eventualmente lo zero finale dalle date SE supera i millisecondi...
                 dtEve = dtEve.Length > 17 ? dtEve.Substring(0, 17) : dtEve;
                 dtCurr = dtCurr.Length > 17 ? dtCurr.Substring(0, 17) : dtCurr;
 
-                DateTime dataOraEvento = DateTime.Now;
                 DateTime dtEvento, dtCorrente;
                 // controllo: se ho valori dt x evento e orario DIVERSI per acquisitore IOB calcolo
                 // dataOraEvento corretto
@@ -2992,10 +3048,8 @@ namespace MP.IOC.Data
                         // log della classe del delta (1-10, 10-100, 100-1k, 1k-10k, > 10k ms)
                         string deltaClass = "";
                         // faccio SEMPRE calcolo esatto sennò sbaglia...
-                        CultureInfo provider = CultureInfo.InvariantCulture;
-                        string format = "yyyyMMddHHmmssfff";
-                        dtEvento = DateTime.ParseExact(dtEve, format, provider);
-                        dtCorrente = DateTime.ParseExact(dtCurr, format, provider);
+                        dtEvento = DateTime.ParseExact(dtEve, dtFormat, ciProvider);
+                        dtCorrente = DateTime.ParseExact(dtCurr, dtFormat, ciProvider);
                         Int64 tiks = dtCorrente.Ticks - dtEvento.Ticks;
                         TimeSpan ts = new TimeSpan(tiks);
                         double ms = Math.Abs(ts.TotalMilliseconds);
@@ -3031,7 +3085,8 @@ namespace MP.IOC.Data
                     {
                         Log.Error($"Errore calcolo ms evento/ora corrente da device remoto | dtEve:  {dtEve} | dtCurr: {dtCurr}{Environment.NewLine}{exc}");
                     }
-                }
+                } 
+#endif
                 // inizio processing vero e proprio INPUT...
                 if (string.IsNullOrEmpty(idxMacchina))
                 {
@@ -4563,8 +4618,10 @@ namespace MP.IOC.Data
                 int.TryParse(datiMacc.ContainsKey("BitFilt") ? datiMacc["BitFilt"] : "0", out BitFilt);
                 int.TryParse(datiMacc.ContainsKey("BSR") ? datiMacc["BSR"] : "0", out BSR);
                 Boolean.TryParse(datiMacc.ContainsKey("ExplodeBit") ? datiMacc["ExplodeBit"] : "false", out ExplodeBit);
-                int.TryParse(datiMacc.ContainsKey("NumBit") ? datiMacc["NumBit"] : "0", out NumBit); // non usato (x ora)
-                                                                                                     // recupero valore
+                // non usato (x ora)
+                int.TryParse(datiMacc.ContainsKey("NumBit") ? datiMacc["NumBit"] : "0", out NumBit);
+
+                // recupero valore
                 valINT = int.Parse(valore, NumberStyles.HexNumber);
                 // filtro
                 newValInt = MP.Core.Utils.bMaskInt(valINT, BitFilt);