Merge branch 'develop' of https://bitbucket.org/ncarminati/cms_step into develop

Step.Model/DTOModels/DTOAlarmsModel.cs

@@ -25,16 +25,127 @@ namespace Step.Model.DTOModels
             PlcAlarms.Clear();
             ProcessAlarms.Clear();
         }
+
+        public override bool Equals(object obj)
+        {
+            var item = obj as DTOAlarmsModel;
+
+            if(item == null)
+                return false;
+
+            if (item.NcAlarms.Count != NcAlarms.Count || item.PlcAlarms.Count != this.PlcAlarms.Count || item.ProcessAlarms.Count != this.ProcessAlarms.Count)
+                return false;
+
+            bool isEqual = item.NcAlarms.All(NcAlarms.Contains);
+            if (!isEqual)
+                return false;
+
+            isEqual = item.PlcAlarms.All(PlcAlarms.Contains);
+            if (!isEqual)
+                return false;
+
+            isEqual = item.ProcessAlarms.All(ProcessAlarms.Contains);
+            if (!isEqual)
+                return false;
+
+            return true;
+        }
+
+        public DTOAlarmsModel IntersectModels(DTOAlarmsModel newAlarms)
+        {
+            DTOAlarmsModel result = new DTOAlarmsModel();
+            // Get common data 
+            result.NcAlarms = NcAlarms.Where(x => newAlarms.NcAlarms.Contains(x as GenericAlarmModel)).ToList();
+            // Concat common data + new data
+            result.NcAlarms = result.NcAlarms.Concat(
+                newAlarms.NcAlarms.Where(x => !NcAlarms.Contains(x as GenericAlarmModel)).ToList() // Find not contained data in the old list
+                ).ToList();
+
+            // Get common data 
+            result.PlcAlarms = PlcAlarms.Where(x => newAlarms.PlcAlarms.Contains(x as GenericAlarmModel)).ToList();
+            // Concat common data + new data
+            result.PlcAlarms = result.PlcAlarms.Concat(
+                newAlarms.PlcAlarms.Where(x => !PlcAlarms.Contains(x as GenericAlarmModel)).ToList() // Find not contained data in the old list
+                ).ToList();
+
+            // Get common data
+            result.ProcessAlarms = ProcessAlarms.Where(x => newAlarms.ProcessAlarms.Contains(x as ProcessAlarmModel)).ToList();
+
+            // Concat common data + new data in the list
+            result.ProcessAlarms = result.ProcessAlarms.Concat( 
+                newAlarms.ProcessAlarms.Where(x => !ProcessAlarms.Contains(x as ProcessAlarmModel)).ToList()  // Find not contained data in the old list
+                ).ToList();
+
+            return result;
+        }
     }
 
-    public struct GenericAlarmModel
+    public class GenericAlarmModel
     {
         public string alarmMessage;
+        public DateTime dateTime;
+
+        public override bool Equals(object obj)
+        {
+            var item = obj as GenericAlarmModel;
+
+            if (item == null)
+                return false;
+
+            if (item.alarmMessage == alarmMessage)
+                return true;
+            else
+                return false;
+        }
     }
 
-    public struct ProcessAlarmModel
+    public class ProcessAlarmModel
     {
         public string alarmMessage;
         public ushort process;
+        public DateTime dateTime;
+
+        public override bool Equals(object obj)
+        {
+            var item = obj as ProcessAlarmModel;
+
+            if (item == null)
+                return false;
+
+            if (item.process == process && item.alarmMessage == alarmMessage )
+                return true;
+            else
+                return false;
+        }
+    }
+    class DTOAlarmsModelComparer : IEqualityComparer<DTOAlarmsModel>
+    {
+        public  bool Equals(DTOAlarmsModel x, DTOAlarmsModel y)
+        {
+            if (x == null)
+                return false;
+
+            if (x.NcAlarms.Count != y.NcAlarms.Count || x.PlcAlarms.Count != y.PlcAlarms.Count || x.ProcessAlarms.Count != y.ProcessAlarms.Count)
+                return false;
+
+            bool isEqual = x.NcAlarms.All(y.NcAlarms.Contains);
+            if (!isEqual)
+                return false;
+
+            isEqual = x.PlcAlarms.All(y.PlcAlarms.Contains);
+            if (!isEqual)
+                return false;
+
+            isEqual = x.ProcessAlarms.All(y.ProcessAlarms.Contains);
+            if (!isEqual)
+                return false;
+
+            return true;
+        }
+
+        public int GetHashCode(DTOAlarmsModel obj)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

Step.Model/DTOModels/DTOAxesModel.cs

@@ -23,11 +23,20 @@ namespace Step.Model.DTOModels
             followingErr = new Dictionary<string, double>();
         }
 
-
         public struct AxisModel
         {
             public string name;
             public double value;
         }
+
+        public override bool Equals(object obj)
+        {
+            var item = obj as DTOAxesModel;
+            if (item == null)
+                return false;
+
+
+            return base.Equals(obj);
+        }
     }
 }

Step.NC/NcHandler.cs

@@ -127,6 +127,7 @@ namespace Step.NC
                 alarms.NcAlarms.Add(new GenericAlarmModel()
                 {
                     alarmMessage = alarmMessage,
+                    dateTime = DateTime.Now
                 });
             }
 
@@ -147,7 +148,8 @@ namespace Step.NC
                     alarms.ProcessAlarms.Add(new ProcessAlarmModel()
                     {
                         alarmMessage = alarmMessage,
-                        process = i
+                        process = i,
+                        dateTime = DateTime.Now
                     });
                 }
             }
@@ -163,6 +165,7 @@ namespace Step.NC
                 alarms.PlcAlarms.Add(new GenericAlarmModel()
                 {
                     alarmMessage = alarmMessage,
+                    dateTime = DateTime.Now
                 });
             }
 

Step.Tasks/ThreadsFunctions.cs

@@ -30,6 +30,7 @@ public static class ThreadsFunctions
             while (true)
             {
                 sw.Restart();
+                // Check if client is connected
                 if (ncHandler.numericalControl.NC_IsConnected())
                 {
                     // Get Alarms from NC
@@ -45,6 +46,7 @@ public static class ThreadsFunctions
                 ReadAlarmsTimer += sw.ElapsedMilliseconds;
                 ReadAlarmsTimes++;
 
+                // Wait
                 Thread.Sleep(200);
             }
         }

Step/Controllers/SignalR/NcHub.cs

@@ -9,6 +9,24 @@ namespace Step.Controllers.SignalR
 {
     public class NcHub : Hub
     {
+        public static List<string> ConnectedClients = new List<string>();
+        public static bool NewConnectedClients = false;
 
+        public override Task OnConnected()
+        {
+            Groups.Add(Context.ConnectionId, "ncData");
+            NewConnectedClients = true;
+            ConnectedClients.Add(Context.ConnectionId);
+
+            return base.OnConnected();
+        }
+
+        public override Task OnDisconnected(bool stopCalled)
+        {
+            Groups.Remove(Context.ConnectionId, "ncData");
+            ConnectedClients.Remove(Context.ConnectionId);
+
+            return base.OnDisconnected(stopCalled);
+        }
     }
 }

Step/Listeners/SignalR/SignalRListener.cs

@@ -3,26 +3,38 @@ using System.Diagnostics;
 using System.Threading;
 using Microsoft.AspNet.SignalR;
 using Step.Controllers.SignalR;
+using Step.Model.DTOModels;
 using TeamDev.SDK.MVVM;
 
 namespace Step.Listeners.SignalR
 {
     public static class SignalRListener
     {
+        private static DTOAlarmsModel alarms = new DTOAlarmsModel();
+        private static DTOAxesModel axes = new DTOAxesModel();
+
         public static void SendNcInfoToClient(object taskName)
         {
-            var context = GlobalHost.ConnectionManager.GetHubContext<DataHub>();
-            context.Clients.All.machineInfo(taskName);
+            var context = GlobalHost.ConnectionManager.GetHubContext<NcHub>();
+            context.Clients.Group("ncData").machineInfo(taskName);
         }
-        public static void SendAlarmsToClient(object taskName)
+
+        public static void SendAlarmsToClient(object newAlarmsData)
         {
-            var context = GlobalHost.ConnectionManager.GetHubContext<DataHub>();
-            context.Clients.All.alarms(taskName);
+            var context = GlobalHost.ConnectionManager.GetHubContext<NcHub>();
+
+            //if (!alarms.Equals(newAlarmsData))
+            //{
+            // Intersect old alarms data with new data
+                alarms = alarms.IntersectModels(newAlarmsData as DTOAlarmsModel);
+                context.Clients.Group("ncData").alarms(alarms);
+            //}
         }
-        public static void SendAxesToClient(object taskName)
+
+        public static void SendAxesToClient(object newAxesData)
         {
-            var context = GlobalHost.ConnectionManager.GetHubContext<DataHub>();
-            context.Clients.All.axes(taskName);
+            var context = GlobalHost.ConnectionManager.GetHubContext<NcHub>();
+            context.Clients.Group("ncData").axes(newAxesData);
         }
 
     }