Implemented Jobs, JobRuns & Machine Events Synchronization.

Added synchronizations to Updates view on Machine Designer.
Removed request response events logging from machine studio.
Fixed issue with exception throwing from machine service.
Implemented "New jobs synchronized" notification item to PPC.
Added synchronization to PPC settings.
Added Synchronization view to technician module.
Implemented PPC Schema synchronizer utility.
Added custom query support to EntityCollectionBuilder.
Added synchronization status to TangoUpdate.
Removed FK from Jobs and Job runs.

1 files changed, 272 insertions, 5 deletions

diff --git a/Software/Visual_Studio/Web/Tango.MachineService/Controllers/PPCController.cs b/Software/Visual_Studio/Web/Tango.MachineService/Controllers/PPCController.cs
index 0d9a2993b..b2a1da980 100644
--- a/Software/Visual_Studio/Web/Tango.MachineService/Controllers/PPCController.cs
+++ b/Software/Visual_Studio/Web/Tango.MachineService/Controllers/PPCController.cs
@@ -398,12 +398,9 @@ namespace Tango.MachineService.Controllers
                     Type = DataSourceType.SQLServer,
                 };
 
-                var machine_version = db.MachineVersions.SingleOrDefault(x => x.Guid == machine.MachineVersionGuid);
-                var latest_machine_version = db.TangoVersions.Where(x => x.MachineVersionGuid == machine_version.Guid).ToList().OrderByDescending(x => Version.Parse(x.Version)).FirstOrDefault();
-
                 TangoUpdate tangoUpdate = new TangoUpdate();
-                tangoUpdate.ApplicationVersion = latest_machine_version.Version;
-                tangoUpdate.FirmwareVersion = latest_machine_version.FirmwareVersion;
+                tangoUpdate.ApplicationVersion = request.ApplicationVersion;
+                tangoUpdate.FirmwareVersion = request.FirmwareVersion;
                 tangoUpdate.MachineGuid = machine.Guid;
                 tangoUpdate.StartDate = DateTime.UtcNow;
                 tangoUpdate.UpdateStatus = TangoUpdateStatuses.DatabaseStarted;
@@ -423,6 +420,276 @@ namespace Tango.MachineService.Controllers
 
         #endregion
 
+        #region Synchronization
+
+        [HttpPost]
+        [JwtTokenFilter]
+        public UploadMachineDataResponse UploadMachineData(UploadMachineDataRequest request)
+        {
+            UploadMachineDataResponse response = new UploadMachineDataResponse();
+            response.NotifyCompletedToken = Guid.NewGuid().ToString();
+
+            using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+            {
+                var machine = db.Machines.SingleOrDefault(x => x.Guid == RequestToken.Object.MachineGuid);
+
+                if (machine == null)
+                {
+                    throw new AuthenticationException("The specified machine could not be found.");
+                }
+
+                TangoUpdate tangoUpdate = new TangoUpdate();
+                tangoUpdate.ApplicationVersion = request.ApplicationVersion;
+                tangoUpdate.FirmwareVersion = request.FirmwareVersion;
+                tangoUpdate.MachineGuid = machine.Guid;
+                tangoUpdate.StartDate = DateTime.UtcNow;
+                tangoUpdate.UpdateStatus = TangoUpdateStatuses.SynchronizationStarted;
+                db.TangoUpdates.Add(tangoUpdate);
+                db.SaveChanges();
+
+                _pendingUpdates.Add(new PPCPendingUpdate()
+                {
+                    Token = response.NotifyCompletedToken,
+                    TangoUpdateGuid = tangoUpdate.Guid,
+                });
+            }
+
+            User machineUser = null;
+
+            try
+            {
+                using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+                {
+                    var machine = db.Machines.SingleOrDefault(x => x.Guid == RequestToken.Object.MachineGuid);
+
+                    if (machine == null)
+                    {
+                        throw new AuthenticationException("The specified machine could not be found.");
+                    }
+
+                    machineUser = db.Users.Include(x => x.Contact).SingleOrDefault(x => x.Contact.FirstName == machine.Name);
+
+                    if (machineUser == null)
+                    {
+                        //No machine user then create one.
+                        machineUser = new User();
+                        machineUser.Email = machine.SerialNumber + "@twine-s.com";
+                        machineUser.Password = machine.SerialNumber;
+                        machineUser.OrganizationGuid = machine.OrganizationGuid;
+                        machineUser.Contact = new Contact();
+                        machineUser.Contact.Email = machineUser.Email;
+                        machineUser.Contact.FirstName = machine.Name;
+                        machineUser.Contact.LastName = machine.Name;
+                        machineUser.Contact.FullName = machine.Name;
+                        machineUser.Address = new Address();
+
+                        db.Users.Add(machineUser);
+                        db.SaveChanges();
+                    }
+                }
+
+                //Insert/Replace Jobs.
+                foreach (var dto in request.Jobs)
+                {
+                    using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+                    {
+                        try
+                        {
+                            var job = dto.ToObservable();
+
+                            job.ID = 0;
+                            job.UserGuid = machineUser.Guid;
+                            job.CustomerGuid = null;
+                            job.IsSynchronized = true;
+
+                            var existingJob = db.Jobs.SingleOrDefault(x => x.Guid == job.Guid);
+
+                            if (existingJob == null)
+                            {
+                                db.Jobs.Add(job);
+                                db.SaveChanges();
+                            }
+                            else if (job.LastUpdated > existingJob.LastUpdated)
+                            {
+                                existingJob.Delete(db);
+                                db.Jobs.Add(job);
+                                db.SaveChanges();
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            response.FailedJobs.Add(new SynchronizationFailedEntity()
+                            {
+                                Guid = dto.Guid,
+                                Reason = ex.FlattenMessage(),
+                            });
+                        }
+                    }
+                }
+
+                //Insert JobRuns.
+                foreach (var dto in request.JobRuns)
+                {
+                    using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+                    {
+                        try
+                        {
+                            var run = dto.ToObservable();
+                            run.ID = 0;
+                            run.IsSynchronized = true;
+
+                            if (db.JobRuns.SingleOrDefault(x => x.Guid == run.Guid) == null)
+                            {
+                                db.JobRuns.Add(run);
+                                db.SaveChanges();
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            response.FailedJobRuns.Add(new SynchronizationFailedEntity()
+                            {
+                                Guid = dto.Guid,
+                                Reason = ex.FlattenMessage(),
+                            });
+                        }
+                    }
+                }
+
+                //Insert MachineEvents.
+                foreach (var dto in request.MachineEvents)
+                {
+                    using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+                    {
+                        try
+                        {
+                            var ev = dto.ToObservable();
+                            ev.ID = 0;
+                            ev.UserGuid = machineUser.Guid;
+                            ev.IsSynchronized = true;
+
+                            if (db.MachinesEvents.SingleOrDefault(x => x.Guid == ev.Guid) == null)
+                            {
+                                db.MachinesEvents.Add(ev);
+                                db.SaveChanges();
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            response.FailedMachineEvents.Add(new SynchronizationFailedEntity()
+                            {
+                                Guid = dto.Guid,
+                                Reason = ex.FlattenMessage(),
+                            });
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                NotifyUpdateCompleted(new MachineUpdateCompletedRequest()
+                {
+                    Status = TangoUpdateStatuses.SynchronizationFailed,
+                    FailedReason = ex.FlattenMessage(),
+                    FailedLog = ex.FlattenException(),
+                    Token = response.NotifyCompletedToken,
+                });
+                throw ex;
+            }
+
+            return response;
+        }
+
+        [HttpPost]
+        [JwtTokenFilter]
+        public DownloadMachineDataResponse DownloadMachineData(DownloadMachineDataRequest request)
+        {
+            DownloadMachineDataResponse response = new DownloadMachineDataResponse();
+
+            using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+            {
+                var machine = db.Machines.SingleOrDefault(x => x.Guid == RequestToken.Object.MachineGuid);
+
+                if (machine == null)
+                {
+                    throw new AuthenticationException("The specified machine could not be found.");
+                }
+
+                //Send Jobs
+                if (request.RequestJobs)
+                {
+                    var jobs = new JobsCollectionBuilder(db).Set(x => x.MachineGuid == machine.Guid && !x.IsSynchronized).WithSegments().WithBrushStops().Query(x => x.Take(request.MaxJobs).OrderByDescending(z => z.LastUpdated)).BuildList();
+
+                    foreach (var job in jobs)
+                    {
+                        JobDTO dto = JobDTO.FromObservable(job);
+                        response.Jobs.Add(dto);
+                    }
+                }
+
+                //Send Job Runs
+                if (request.RequestJobRuns)
+                {
+                    var jobRuns = db.JobRuns.Where(x => x.MachineGuid == machine.Guid && !x.IsSynchronized).Take(request.MaxJobRuns).OrderByDescending(x => x.LastUpdated).ToList();
+
+                    foreach (var jobRun in jobRuns)
+                    {
+                        JobRunDTO dto = JobRunDTO.FromObservable(jobRun);
+                        response.JobRuns.Add(dto);
+                    }
+                }
+
+                //Send Machine Events
+                if (request.RequestMachineEvents)
+                {
+                    var machineEvents = db.MachinesEvents.Where(x => x.MachineGuid == machine.Guid && !x.IsSynchronized).Take(request.MaxMachinesEvents).OrderByDescending(x => x.LastUpdated).ToList();
+
+                    foreach (var machineEvent in machineEvents)
+                    {
+                        MachinesEventDTO dto = MachinesEventDTO.FromObservable(machineEvent);
+                        response.MachineEvents.Add(dto);
+                    }
+                }
+            }
+
+            return response;
+        }
+
+        [HttpPost]
+        [JwtTokenFilter]
+        public NotifyMachineDataDownloadCompletedResponse NotifyMachineDataDownloadCompleted(NotifyMachineDataDownloadCompletedRequest request)
+        {
+            var response = new NotifyMachineDataDownloadCompletedResponse();
+
+            using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+            {
+                var machine = db.Machines.SingleOrDefault(x => x.Guid == RequestToken.Object.MachineGuid);
+
+                if (machine == null)
+                {
+                    throw new AuthenticationException("The specified machine could not be found.");
+                }
+
+                if (request.SynchronizedJobs.Count > 0)
+                {
+                    db.Database.ExecuteSqlCommand($"UPDATE JOBS SET IS_SYNCHRONIZED = 1 WHERE GUID IN ({String.Join(",", request.SynchronizedJobs.Select(x => "'" + x + "'"))});");
+                }
+
+                if (request.SynchronizedJobRuns.Count > 0)
+                {
+                    db.Database.ExecuteSqlCommand($"UPDATE JOB_RUNS SET IS_SYNCHRONIZED = 1 WHERE GUID IN ({String.Join(",", request.SynchronizedJobRuns.Select(x => "'" + x + "'"))});");
+                }
+
+                if (request.SynchronizedMachineEvents.Count > 0)
+                {
+                    db.Database.ExecuteSqlCommand($"UPDATE MACHINES_EVENTS SET IS_SYNCHRONIZED = 1 WHERE GUID IN ({String.Join(",", request.SynchronizedMachineEvents.Select(x => "'" + x + "'"))});");
+                }
+            }
+
+            return response;
+        }
+
+        #endregion
+
         #region Version Upload
 
         [HttpPost]