init

Common/DTS.Common.Import/Persist/SaveTestSetup.cs

@@ -0,0 +1,222 @@
+using DataPROWin7.DataModel;
+using DataPROWin7.DataModel.Classes.Hardware;
+using DTS.Common.Import.Enums;
+using DTS.SensorDB;
+using DTS.Slice.Users;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static System.Net.Mime.MediaTypeNames;
+
+namespace DTS.Common.Import.Persist
+{
+    public class SaveTestSetup : SaveVariantBase
+    {
+        private readonly SaveCustomChannels _saveCustomChannels;
+        private readonly SaveHardware _saveHardware;
+        private readonly SaveGroups _saveGroups;
+        public User CurrentUser { get; set; }
+        //FB 38039 Get/ Set setup name used in run test 
+        public string TestSetupName { get; set; }
+        public SaveTestSetup(ImportObject importObject, IPersistCalculator persistCalculator, IImportNotification importNotification,
+            SaveCustomChannels saveCustomChannels, SaveHardware saveHardware, SaveGroups saveGroups,
+            Func<bool> isCancelled = null) :
+            base(importObject, persistCalculator, importNotification, isCancelled)
+        {
+            _saveCustomChannels = saveCustomChannels;
+            _saveHardware = saveHardware;
+            _saveGroups = saveGroups;
+        }
+        //FB 38039 Default used for run test 
+        private void ConfigureDefaultRunTestTestSetup(TestTemplate testSetup)
+        {
+            testSetup.DoROIDownload = true;
+
+            testSetup.ViewROIDownload = true;
+
+            testSetup.DownloadAll = true;
+
+            testSetup.ViewDownloadAll = true;
+
+            testSetup.RequireUserConfirmationOnErrors = true;
+
+            //FB 43757, 43817 keep the default from testsetup default setting for upload data
+
+            testSetup.ViewDiagnostics = true;
+
+            testSetup.VerifyChannels = true;
+
+            testSetup.ViewExport = true;
+
+            testSetup.DefaultNumberRealtimeGraphs = 1;
+
+            testSetup.ExportFormats = DTS.Common.Enums.SupportedExportFormatBitFlags.rdfadc;
+
+            testSetup.AllowMissingSensors = false;
+
+            testSetup.StrictDiagnostics = true;
+
+            testSetup.AutomaticProgression = true;
+
+            testSetup.DoAutoArm = false;
+
+            testSetup.DoEnableRepeat = false;
+
+            testSetup.DoStreaming = false;
+
+            testSetup.AllowSensorIdToBlankChannel = false;
+            testSetup.AllowMissingSensors = false;
+            testSetup.SuppressMissingSensorsWarning = false;
+            testSetup.CheckListRequirePass = true;
+        }
+
+        public override void Save()
+        {
+            var testSetups = _importObject.TestSetups();
+
+            if (_importObject.TestSetupImportFileFormat == ImportFileFormat.SingleTestSetup && !string.IsNullOrEmpty(TestSetupName))
+            {
+                //FB 38039 this test is used for run test 
+                var testSetup = testSetups.FirstOrDefault();
+                if (testSetup == null)
+                {
+                    return;
+                }
+
+                testSetup.Name = TestSetupName;
+                testSetup.TestId = TestSetupName;
+                ConfigureDefaultRunTestTestSetup(testSetup);
+            }
+
+            Dictionary<string, string> oldIdToNewIdLookup = new Dictionary<string, string>();
+
+            SaveTestSetupHelper.UpdateLevelTriggers(ref oldIdToNewIdLookup, _saveCustomChannels, testSetups);
+
+            SaveTestSetupHelper.DeleteExistingTestSetups(testSetups, CurrentUser.UserName);
+
+            Dictionary<string, DASHardware> hardwareLookup = SaveTestSetupHelper.PopulateHarwareLookup();
+
+            _importNotification.SetStatus.Invoke(new ImportStatus { ExtraStatus = ImportExtraStatus.ReadingTestSetups, PossibleStatus = PossibleStatus.Importing });
+
+            foreach (var t in testSetups)
+            {
+                SaveTestSetupHelper.FixDasAff(hardwareLookup, t);
+                //keep track of test id prior to commit, so that we can correct das.TestId
+                //if we need to
+                var idPriorToCommit = t.Id;
+                t.Id = 0;
+
+                var allSensorsInDb = SensorsCollection.SensorsList.GetAllSensors(true);
+
+                foreach (var channels in t.ChannelsForGroup)
+                {
+                    foreach (var ch in channels.Value)
+                    {
+                        if (_importObject.OldSensorDatabaseIdsToNew().ContainsKey(ch.SensorId))
+                        {
+                            ch.SensorId = _importObject.OldSensorDatabaseIdToNew(ch.SensorId);
+                            var match = allSensorsInDb?.FirstOrDefault(s => s.DatabaseId == ch.SensorId);
+                            if (null != match)
+                            {
+                                ch.SetSensorData(match, null, false);
+                            }
+                        }
+
+                        if (_saveHardware.OldDASIdToNewDASId.ContainsKey(ch.DASId))
+                        {
+                            ch.DASId = _saveHardware.OldDASIdToNewDASId[ch.DASId];
+                        }
+                        //15262 Absolute zero sensors in test setup change to ave over time after import.
+                        //zero method may be undefined on older imports
+                        //make sure we set the zero method before embedded group is committed ...
+                        SaveSensor.FixMissingZeroMethodParameter(ch, _saveGroups.DefaultZeroMethod, _saveGroups.DefaultZeroStart, _saveGroups.DefaultZeroEnd);
+                        SaveSensor.FixMissingInitialOffset(ch, _saveGroups.DefaultInitialOffset);
+                    }
+                }
+
+                var hardwareIncluded = t.AddedHardware.ToList();
+                var hardwareRemoved = t.RemovedHardware.ToList();
+
+                var listToProcess = new List<Tuple<int, int>>();
+                foreach (var e in _saveHardware.OldDASIdToNewDASId)
+                {
+                    listToProcess.Add(new Tuple<int, int>(e.Key, e.Value));
+                }
+                //arrange the to process by the largest new id
+                listToProcess.Sort((a, b) =>
+                {
+                    if (a == b)
+                    {
+                        return 0;
+                    }
+
+                    return b.Item2.CompareTo(a.Item2);
+                });
+
+                foreach (var tuple in listToProcess)
+                {
+                    if (tuple.Item1 == tuple.Item2)
+                    {
+                        continue;
+                    }
+                    if (hardwareIncluded.Contains(tuple.Item2))
+                    {
+                        throw new Exception("Panic, new id already in list");
+                    }
+
+                    if (hardwareRemoved.Contains(tuple.Item2))
+                    {
+                        throw new Exception("Panic, new id already in list");
+                    }
+
+                    if (hardwareIncluded.Contains(tuple.Item1))
+                    {
+                        hardwareIncluded.Remove(tuple.Item1);
+                        hardwareIncluded.Add(tuple.Item2);
+                    }
+
+                    if (hardwareRemoved.Contains(tuple.Item1))
+                    {
+                        hardwareRemoved.Remove(tuple.Item1);
+                        hardwareRemoved.Add(tuple.Item2);
+                    }
+                }
+
+                SaveTestSetupHelper.AddHardwareFromEmbeddedGroups(t, _saveGroups, hardwareRemoved, hardwareIncluded);
+
+                t.ReplaceCalculatedChannel(oldIdToNewIdLookup);
+                if (IsCancelled())
+                {
+                    return;
+                }
+                if (t.TestSetupUniqueId == null)
+                {
+                    t.TestSetupUniqueId = Guid.NewGuid().ToString();
+                }
+                TestTemplateList.TestTemplatesList.Commit(t, false);
+                if (idPriorToCommit > 0 && _saveHardware.TestIdToHardware.ContainsKey(idPriorToCommit))
+                {
+                    foreach (var enumH in _saveHardware.TestIdToHardware[idPriorToCommit])
+                    {
+                        enumH.TestId = t.Id;
+                        enumH.Update();
+                    }
+                }
+                _persistCalculator.AddDone();
+                _importNotification.SetProgress(_persistCalculator.ProgressValue);
+            }
+
+            oldIdToNewIdLookup.Clear();
+
+            if (_importObject.Errors().Any())
+            {
+                //report errors
+            }
+            //FB 36879 Still parsing it should report as Working status
+            _importNotification.SetStatus.Invoke(new ImportStatus { ExtraStatus = ImportExtraStatus.None, PossibleStatus = PossibleStatus.Working });
+        }
+
+    }
+}