init

Common/DTS.Common.Import/Factories/CSVSensorParserFactory.cs

@@ -0,0 +1,39 @@
+using DTS.Common.Import.ImportOptions;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Import.Parsers.CSV;
+using System.Collections.Generic;
+
+namespace DTS.Common.Import.Factories
+{
+    public class CSVSensorParserFactory
+    {
+        public static IReadOnlyDictionary<int, IParseCSVSensor> CreateCSVParsers(ICalibrationImport import, ZeroMethodOptions zmOptions,
+            IImportNotification importNotification, bool importCreateDynamicGroups,
+            bool useISOCodeFilterMapping, bool useZeroForUnfiltered)
+        {
+            var parsers = new Dictionary<int, IParseCSVSensor>();
+
+            var v0 = new Version0CSVSensorParser();
+            v0.Initialize(import, zmOptions, importNotification, importCreateDynamicGroups, useISOCodeFilterMapping,
+                useZeroForUnfiltered);
+            parsers[v0.Version] = v0;
+
+            var v2 = new Version2CSVSensorParser();
+            v2.Initialize(import, zmOptions, importNotification, importCreateDynamicGroups, useISOCodeFilterMapping,
+                useZeroForUnfiltered);
+            parsers[v2.Version] = v2;
+
+            var v3 = new Version3CSVSensorParser();
+            v3.Initialize(import, zmOptions, importNotification, importCreateDynamicGroups, useISOCodeFilterMapping,
+                useZeroForUnfiltered);
+            parsers[v3.Version] = v3;
+
+            var v4 = new Version4CSVSensorParser();
+            v4.Initialize(import, zmOptions, importNotification, importCreateDynamicGroups, useISOCodeFilterMapping,
+                useZeroForUnfiltered);
+            parsers[v4.Version] = v4;
+
+            return parsers;
+        }
+    }
+}

Common/DTS.Common.Import/Factories/CSVTestParserFactory.cs

@@ -0,0 +1,25 @@
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Import.Parsers.CSV;
+using System.Collections.Generic;
+
+namespace DTS.Common.Import.Factories
+{
+    public class CSVTestParserFactory
+    {
+        public static IParseCSVTest[] CreateCSVParsers()
+        {
+            var parsers = new List<IParseCSVTest>();
+
+            var v0 = new Version0CSVTestParser();
+            parsers.Add(v0);
+
+            var v5 = new Version5CSVTestParser();
+            parsers.Add(v5);
+
+            var v6 = new Version6CSVTestParser();
+            parsers.Add(v6);
+
+            return parsers.ToArray();
+        }
+    }
+}

Common/DTS.Common.Import/Factories/DatabaseLocksFactory.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DTS.Common.Import.Interfaces;
+using DTS.Slice.Users;
+using DTS.Common.Import.DatabaseLocks;
+namespace DTS.Common.Import.Factories
+{
+    public static class DatabaseLocksFactory
+    {
+        //FB 36740 Factory to build objects which implement ILockImport
+        public static List<ILockImport> Create(ImportObject importObject, User user, double strandedLockTimeoutMinutes)
+        {
+            List<ILockImport> lockImports = new List<ILockImport>();
+
+            if (importObject.TestSetups().Any())
+            {
+                var testSetupsLock = new LockImportTestSetups(user, strandedLockTimeoutMinutes);
+                lockImports.Add(testSetupsLock);
+            }
+
+            if (importObject.Sensors().Any())
+            {
+                var sensorsLock = new LockImportSensors(user, strandedLockTimeoutMinutes);
+                lockImports.Add(sensorsLock);
+            }
+
+            if (importObject.StaticGroups().Any())
+            {
+                var groupsLock = new LockImportGroups(user, strandedLockTimeoutMinutes);
+                lockImports.Add(groupsLock);
+            }
+
+            return lockImports;
+        }
+    }
+}

Common/DTS.Common.Import/Factories/SaveVariantFactory.cs

@@ -0,0 +1,136 @@
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Import.Persist;
+using DTS.Slice.Users;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DTS.Common.Import.Factories
+{
+    public static class SaveVariantFactory
+    {
+        //FB 36854 Added cancel action
+        public static List<IPersistImport> CreateVariants(ImportObject importObject, ImportNotification importNotification, User user, Func<bool> isCanceled, bool showCheckoutButton)
+        {
+            List<IPersistImport> saveHandlers = new List<IPersistImport>();
+
+            IPersistCalculator persistCalculator = new PersistCalculator();
+
+            if (importObject.CustomerDetails().Any())
+            {
+                persistCalculator.AddToTotal(importObject.CustomerDetails().Count());
+                var saveCustomerDetails = new SaveCustomerDetails(importObject, persistCalculator, importNotification, isCanceled);
+                saveHandlers.Add(saveCustomerDetails);
+            }
+
+            if (importObject.TestEngineerDetails().Any())
+            {
+                persistCalculator.AddToTotal(importObject.TestEngineerDetails().Count());
+                var saveTestEngineerDetails = new SaveTestEngineerDetails(importObject, persistCalculator, importNotification, isCanceled);
+                saveHandlers.Add(saveTestEngineerDetails);
+            }
+
+            if (importObject.LabDetails().Any())
+            {
+                persistCalculator.AddToTotal(importObject.LabDetails().Count());
+                var saveLabDetails = new SaveLabDetails(importObject, persistCalculator, importNotification, isCanceled);
+                saveHandlers.Add(saveLabDetails);
+            }
+
+            if (importObject.SensorModels().Any())
+            {
+                persistCalculator.AddToTotal(importObject.SensorModels().Count());
+                var sensorModels = new SaveSensorModels(importObject, persistCalculator, importNotification, isCanceled);
+                saveHandlers.Add(sensorModels);
+            }
+
+            if (importObject.Sensors().Any())
+            {
+                persistCalculator.AddToTotal(importObject.Sensors().Count());
+                persistCalculator.AddToTotal(importObject.Calibrations().Count());
+
+                if (importObject.SourceFormat == Enums.ImportFormats.DTS_CSV)
+                {
+                    var saveCsvSourceSensor = new SaveCsvSourceSensor(importObject, persistCalculator, importNotification, isCanceled);
+                    saveCsvSourceSensor.CurrentUser = user;
+                    saveHandlers.Add(saveCsvSourceSensor);
+                }
+                else
+                {
+                    var saveNonCsvSourceSensor = new SaveNonCsvSourceSensor(importObject, persistCalculator, importNotification, isCanceled);
+                    saveNonCsvSourceSensor.CurrentUser = user;
+                    saveHandlers.Add(saveNonCsvSourceSensor);
+                }
+            }
+
+            if (importObject.Users().Any())
+            {
+                persistCalculator.AddToTotal(importObject.Users().Count());
+                var saveUsers = new SaveUsers(importObject, persistCalculator, importNotification, isCanceled);
+                saveHandlers.Add(saveUsers);
+            }
+
+            if (importObject.GlobalSettings().Any())
+            {
+                persistCalculator.AddToTotal(importObject.GlobalSettings().Count);
+                var saveGlobalSettings = new SaveGlobalSettings(importObject, persistCalculator, importNotification, isCanceled);
+                saveHandlers.Add(saveGlobalSettings);
+            }
+
+            SaveCustomChannels saveCustomChannels = new SaveCustomChannels(importObject, persistCalculator, importNotification, isCanceled);
+
+
+            var saveHardware = new SaveHardware(importObject, persistCalculator, importNotification, isCanceled);
+
+            if (importObject.Hardware().Any())
+            {
+                persistCalculator.AddToTotal(importObject.Hardware().Count());
+                persistCalculator.AddToTotal(importObject.Hardware().Sum(h => h?.Channels.Length ?? 0));
+
+                saveHandlers.Add(saveHardware);
+            }
+
+            if (importObject.GroupTemplates().Any())
+            {
+                persistCalculator.AddToTotal(importObject.GroupTemplates().Count());
+                SaveGroupTemplates saveGroupTemplates = new SaveGroupTemplates(importObject, persistCalculator, importNotification, isCanceled);
+                saveHandlers.Add(saveGroupTemplates);
+            }
+
+            SaveGroups saveGroups = new SaveGroups(importObject, persistCalculator, importNotification, saveHardware, isCanceled);
+
+            if (importObject.Groups().Any() || importObject.StaticGroups().Any())
+            {
+                persistCalculator.AddToTotal(importObject.Groups().Count());
+                persistCalculator.AddToTotal(importObject.StaticGroups().Count());
+
+                saveHandlers.Add(saveGroups);
+            }
+
+            if (importObject.TestSetups().Any())
+            {
+                persistCalculator.AddToTotal(importObject.TestSetups().Count());
+                SaveTestSetup saveTestSetup = new SaveTestSetup(importObject, persistCalculator, importNotification, saveCustomChannels, saveHardware, saveGroups, isCanceled);
+                if (showCheckoutButton)
+                {
+                    //FB 38039 For now the checkout setting specifies if we are in GM parse mode.
+                    //We concat Run Test at the end of file too
+                    //We might use manufacturer to set this name later
+                    saveTestSetup.TestSetupName = string.Concat(importObject.TestSetups()?.FirstOrDefault()?.Name, Serialization.RDF.File.SUFFIX_RUNTEST);
+                }
+                saveTestSetup.CurrentUser = user;
+                saveHandlers.Add(saveTestSetup);
+                if (showCheckoutButton)
+                {
+                    //FB 38039 create checkout test setup
+                    SaveCheckoutTestSetup saveTestSetupCheckout = new SaveCheckoutTestSetup(importObject, persistCalculator, importNotification,
+                        saveCustomChannels, saveHardware, saveGroups, isCanceled, string.Concat(importObject.TestSetups()?.FirstOrDefault()?.Name, Serialization.RDF.File.SUFFIX_CHECKOUT));
+                    saveTestSetupCheckout.CurrentUser = user;
+                    saveHandlers.Add(saveTestSetupCheckout);
+                }
+            }
+
+            return saveHandlers;
+        }
+    }
+}

Common/DTS.Common.Import/Factories/XmlParserFactory.cs

@@ -0,0 +1,166 @@
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Import.XML;
+using DTS.Common.Utils;
+using DTS.Slice.Users;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import
+{
+    public static class XmlParserFactory
+    {
+        public static List<IUIItems> UIItems { get; set; }
+        private static Func<bool> _isCancelled;
+        public static IImportNotification ImportNotification { get; set; }
+        private static List<IParseVariant> LessThan20XMLVersion(XmlElement node, double importVersion)
+        {
+            List<IParseVariant> parseVariants = new List<IParseVariant>();
+            //FB 36879 prevent exception if there is no node to process
+            if (node == null || node.ChildNodes == null)
+            {
+                return parseVariants;
+            }
+            foreach (var childNode in node.ChildNodes)
+            {
+                if (childNode is XmlElement)
+                {
+                    var root = childNode as XmlElement;
+                    var name = root.Name;
+                    if (Enum.TryParse(name, out TopLevelFields field))
+                    {
+                        switch (field)
+                        {
+                            case TopLevelFields.CustomChannels:
+                                var xmlCustomChannels = new XMLParseMMECustomChannels(root, importVersion, _isCancelled);
+                                parseVariants.Add(xmlCustomChannels);
+                                break;
+                            case TopLevelFields.CustomMainLocs:
+                                var xmlCustomMainLocs = new XMLParseMMECustomMainLocations(root, importVersion, _isCancelled);
+                                parseVariants.Add(xmlCustomMainLocs);
+                                break;
+                            case TopLevelFields.DASList:
+                                var xmlParseDasList = new XMLParseDASList(root, importVersion, _isCancelled);
+                                parseVariants.Add(new XMLPre20ParseDASList(root, importVersion, xmlParseDasList, _isCancelled));
+                                break;
+                            case TopLevelFields.Sensors:
+                                var xmlParseSensors = new XMLParseSensors(root, importVersion, _isCancelled);
+                                xmlParseSensors.ImportNotification = ImportNotification;
+                                parseVariants.Add(new XMLPre20ParseSensors(root, importVersion, xmlParseSensors, _isCancelled));
+                                break;
+                            case TopLevelFields.Calibrations:
+                                var xmlParseCalibrations = new XMLParseCalibrations(root, importVersion, _isCancelled);
+                                xmlParseCalibrations.ImportNotification = ImportNotification;
+                                parseVariants.Add(new XMLPre20ParseCalibrations(root, importVersion, xmlParseCalibrations, _isCancelled));
+                                break;
+                            case TopLevelFields.GroupTemplates:
+                                var xmlParseGroupTemplates = new XMLParseGroupTemplates(root, importVersion, null, _isCancelled);
+                                parseVariants.Add(new XMLPre20ParseGroupTemplates(root, importVersion, xmlParseGroupTemplates, _isCancelled));
+                                break;
+                            case TopLevelFields.Groups:
+                                var xmlParseGroups = new XMLParseGroups(root, importVersion);
+                                xmlParseGroups.ImportNotification = ImportNotification;
+                                parseVariants.Add(new XMLPre20ParseGroups(root, importVersion, null, xmlParseGroups, _isCancelled));
+                                break;
+                            case TopLevelFields.TestSetups:
+                                var xmlParseTestSetups = new XMLParseTestSetups(root, importVersion, _isCancelled);
+                                xmlParseTestSetups.ImportNotification = ImportNotification;
+                                parseVariants.Add(new XMLPre20ParseTestSetups(root, importVersion, DTS.Common.Enums.IsoViewMode.ISOOnly, xmlParseTestSetups, _isCancelled));
+                                break;
+                        }
+                    }
+                }
+            }
+            return parseVariants;
+        }
+
+
+        private static List<IParseVariant> GreaterOrEqual20XMLVersion(XmlElement node, double importVersion, bool skipNormalizing)
+        {
+            List<IParseVariant> parseVariants = new List<IParseVariant>();
+            foreach (var childNode in node.ChildNodes)
+            {
+                if (childNode is XmlElement)
+                {
+                    var root = childNode as XmlElement;
+                    var name = root.Name;
+                    if (Enum.TryParse(name, out TopLevelFields field))
+                    {
+                        switch (field)
+                        {
+
+                            case TopLevelFields.LabDetails:
+                                var xmlParseLab = new XMLParseLabDetails(root, importVersion, _isCancelled);
+                                xmlParseLab.ImportNotification = ImportNotification;
+                                parseVariants.Add(xmlParseLab);
+                                break;
+                            case TopLevelFields.CustomerDetails:
+                                var xmlParseCustomer = new XMLParseCustomerDetails(root, importVersion, _isCancelled);
+                                xmlParseCustomer.ImportNotification = ImportNotification;
+                                parseVariants.Add(xmlParseCustomer);
+                                break;
+                            case TopLevelFields.TestEngineerDetails:
+                                var xmlParseTestEngineer = new XMLParseTestEngineerDetails(root, importVersion, _isCancelled);
+                                xmlParseTestEngineer.ImportNotification = ImportNotification;
+                                parseVariants.Add(xmlParseTestEngineer);
+                                break;
+                            case TopLevelFields.DASList:
+                                var xmlParseDasList = new XMLParseDASList(root, importVersion, _isCancelled, skipNormalizing);
+                                xmlParseDasList.ImportNotification = ImportNotification;
+                                parseVariants.Add(xmlParseDasList);
+                                break;
+                            case TopLevelFields.Sensors:
+                                var xmlParseSensors = new XMLParseSensors(root, importVersion, _isCancelled, skipNormalizing);
+                                xmlParseSensors.ImportNotification = ImportNotification;
+                                parseVariants.Add(xmlParseSensors);
+                                break;
+                            case TopLevelFields.Calibrations:
+                                var xmlParseCalibrations = new XMLParseCalibrations(root, importVersion, _isCancelled);
+                                xmlParseCalibrations.ImportNotification = ImportNotification;
+                                parseVariants.Add(xmlParseCalibrations);
+                                break;
+                            case TopLevelFields.GroupTemplates:
+                                var xmlParseGroupTemplates = new XMLParseGroupTemplates(root, importVersion, null, _isCancelled);
+                                parseVariants.Add(xmlParseGroupTemplates);
+                                break;
+                            case TopLevelFields.Groups:
+                                var xmlParseGroups = new XMLParseGroups(root, importVersion, _isCancelled);
+                                xmlParseGroups.ImportNotification = ImportNotification;
+                                parseVariants.Add(xmlParseGroups);
+                                break;
+                            case TopLevelFields.TestSetups:
+                                var xmlParseTestSetups = new XMLParseTestSetups(root, importVersion, _isCancelled, skipNormalizing);
+                                xmlParseTestSetups.ImportNotification = ImportNotification;
+                                parseVariants.Add(xmlParseTestSetups);
+                                break;
+                            case TopLevelFields.Users:
+                                var xmlParseUsers = new XMLParseUsers(root, importVersion, UIItems, _isCancelled);
+                                parseVariants.Add(xmlParseUsers);
+                                break;
+                        }
+                    }
+                }
+            }
+            return parseVariants;
+        }
+
+        public static IEnumerable<IParseVariant> CreateXMLParsers(string fileName, IImportNotification importNotification, Func<bool> isCanceled, bool skipNormalizing)
+        {
+            double importVersion = -1;
+            _isCancelled = isCanceled;
+            ImportNotification = importNotification;
+            var node = FileUtils.GetImportXmlNode(fileName, null, out importVersion);
+
+            if (importVersion < FileUtils.DataPRO20XmlVersion)
+            {
+                return LessThan20XMLVersion(node, importVersion);
+            }
+            else
+            {
+                return GreaterOrEqual20XMLVersion(node, importVersion, skipNormalizing);
+            }
+        }
+
+    }
+}