init

Common/DTS.Common.Import/.svn/pristine/66/662daab0011e30450c9b2d332d7b4dd01e862453.svn-base

@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Xml.Linq;
+using DataPROWin7.DataModel;
+using DTS.Common.Import.ImportOptions;
+using DTS.Common.Import.Parsers;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.SharedResource.Strings;
+using DTS.Common.Utilities.Logging;
+using DTS.Common.Utils;
+using DTS.SensorDB;
+
+namespace DTS.Common.Import
+{
+    public class EQXTestSetupParser : ParseVariantBase
+    {
+        private readonly IImportNotification _importNotification;
+        private readonly EqxImportOptions _eqxImportOptions;
+        private readonly IGroupImport _groupImport;
+        private readonly EquipmentExchange.EQXSensorDatabase _eqxSensorDatabase;
+        private readonly bool _createDynamicGroups;
+        public EQXTestSetupParser(IImportNotification importNotification, EqxImportOptions eqxImportOptions,
+             IGroupImport groupImport, EquipmentExchange.EQXSensorDatabase eqxSensorDatabase, bool createDynamicGroups)
+        {
+            _eqxImportOptions = eqxImportOptions;
+            _importNotification = importNotification;
+            _groupImport = groupImport;
+            _eqxSensorDatabase = eqxSensorDatabase;
+            _createDynamicGroups = createDynamicGroups;
+        }
+        private void FixCalibrations(ImportObject importObject)
+        {
+            try
+            {
+                var sensors = importObject.Sensors().ToArray();
+                foreach (var sensor in sensors)
+                {
+                    if (null == sensor) { continue; }
+                    var cals = importObject.CalibrationLookup(sensor.SerialNumber);
+                    if (null != cals && cals.Count > 0)
+                    {
+                        cals.Sort();
+                        sensor.Calibration = cals[0];
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                APILogger.Log("EQXTestSetupParser.FixCalibrations failed to fix calibrations", ex);
+            }
+        }
+        public override void Parse(ref ImportObject importObject)
+        {
+            if (string.IsNullOrEmpty(FileName))
+            {
+                return;
+            }
+
+            if (importObject == null)
+            {
+                throw new ArgumentNullException("importObject", "importObject can't be null or empty");
+            }
+
+            var sensorImportData = _eqxSensorDatabase.GetImportData();
+            //FB 40750 if there is not Group name test then the eqx file does not have any test setup
+            if (sensorImportData.GroupNameTestObjectLookup == null || !sensorImportData.GroupNameTestObjectLookup.Any())
+            {
+                //abort the import process 
+                importObject.AddError(new ImportError { ContinueImportOnError = false, Message = StringResources.Import_EQXFileNotForTestSetup, Severity = ImportSeverityError.Critical });
+                return;
+            }
+
+            importObject.AssignGroupNameTestObjectLookup(sensorImportData.GroupNameTestObjectLookup);
+            importObject.AssignGroupNameSensorsLookup(sensorImportData.GroupNameSensorListLookup);
+
+            var testTemplate = new TestTemplate();
+            var setupName = ParseSetupName(FileName);
+            testTemplate.Name = setupName == string.Empty ? Path.GetFileNameWithoutExtension(FileName) : setupName;
+
+            if (importObject.TestSetups().Any(p => p.Name == testTemplate.Name))
+            {
+                return;
+            }
+
+            FixCalibrations(importObject);
+
+            var res = AssignGroupsToTestSetup(testTemplate, importObject, sensorImportData.GroupNameSensorListLookup,
+                _groupImport, _importNotification);
+
+            var sensors = res.Item3;
+            var testSetup = res.Item1;
+            var staticGroups = res.Item2;
+
+            if (staticGroups != null)
+            {
+                importObject.AddStaticGroups(staticGroups);
+            }
+            var cleanedSensors = GroupHelper.CleanUneededSensorDataPlaceHolder(importObject.CalibrationsLookup(), sensors);
+
+            importObject.ClearSensors();
+            importObject.AddSensors(cleanedSensors);
+
+            importObject.AddTestSetup(testSetup);
+            //FB 38039,40758 Identify single test setup in import file
+            importObject.TestSetupImportFileFormat = importObject.GetImportFileFormat();
+        }
+        
+        //FB 36879 Single repsposibility principle , moved the method to this class
+        private Tuple<TestTemplate, List<IGroup>, List<SensorData>> AssignGroupsToTestSetup(TestTemplate testTemplate, ImportObject importObject, Dictionary<string, List<string>> groupNameSensorListLookup,
+           IGroupImport groupImport, IImportNotification importNotification)
+        {
+            var sensorGroupNameLookup = importObject.SensorGroupNamesLookup();
+            var existingStaticGroups = importObject.StaticGroups().ToList();
+            var sensors = importObject.Sensors().ToList();
+            try
+            {
+                _ = GroupHelper.ReverseChannelOrder(testTemplate, sensorGroupNameLookup, sensors);
+
+                var groupSensorLookup = groupImport.GetGroupSensorLookup(sensors, sensorGroupNameLookup, groupNameSensorListLookup);
+
+                sensors = GroupHelper.NormalizeSensorIds(sensors);
+                //http://manuscript.dts.local/f/cases/44105/EQX-Import-does-not-overwrite-zero-method-consistently-in-the-parameters-of-test-setup-but-consistently-for-sensor-database
+                //normalizesensorids above can reset the calibrations for sensors - revert back to the calibration in the import ...
+                FixCalibrations(importObject);
+                //FB 36905
+                var testAndGroups = groupImport.CreateGroups(sensors, groupSensorLookup, testTemplate, _createDynamicGroups, existingStaticGroups, importNotification.SetProgress);
+
+                if (testAndGroups == null)
+                {
+                    TestTemplate noTestSetup = null;
+                    List<IGroup> noGroup = null;
+                    return Tuple.Create(noTestSetup, noGroup, sensors);
+                }
+                return Tuple.Create(testAndGroups.Item1, testAndGroups.Item2, sensors);
+            }
+            catch (Exception ex)
+            {
+                importNotification.ReportErrors(new List<string> { ex.Message });
+                return null;
+            }
+        }
+
+        //FB 39054 parse setup name from eqx
+        private string ParseSetupName(string filename)
+        {
+            XDocument xDoc = null;
+            try
+            {
+                xDoc = XDocument.Load(filename);
+                var fields = xDoc.Elements("Sensors").Select(x => x.Elements("Fields")).FirstOrDefault();
+                if (fields.Any())
+                {
+                    var setupName = fields.Select(x => x.Element("SetupName").Value).FirstOrDefault();
+                    return setupName;
+                }
+            }
+            catch
+            {
+                return string.Empty;
+            }
+            return string.Empty;
+        }
+    }
+}