458 lines
27 KiB
C#
458 lines
27 KiB
C#
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Xml;
|
|
using DataPROWin7.DataModel;
|
|
using DTS.Common.Classes.Groups.ChannelSettings;
|
|
using DTS.Common.Classes.Groups;
|
|
using DTS.Common.Enums.Sensors;
|
|
using DTS.Common.Interface.Channels;
|
|
using DTS.Common.Interface.Groups.GroupList;
|
|
using DTS.Common.SharedResource.Strings;
|
|
using DTS.SensorDB;
|
|
using DTS.Common.Classes.Sensors;
|
|
using DTS.Common.Enums;
|
|
using DTS.Common.Enums.DBExport;
|
|
using DTS.Common.Utils;
|
|
|
|
namespace DTS.Common.Import.XML
|
|
{
|
|
|
|
public class XMLPre20ParseTestSetups : XMLParseBase
|
|
{
|
|
private readonly IsoViewMode _isoViewMode;
|
|
private readonly XMLParseTestSetups _xmlParseTestSetups;
|
|
public XMLPre20ParseTestSetups(XmlElement root, double importedVersion, IsoViewMode isoViewMode, XMLParseTestSetups xmlParseTestSetups, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
|
|
{
|
|
_isoViewMode = isoViewMode;
|
|
_xmlParseTestSetups = xmlParseTestSetups;
|
|
}
|
|
|
|
private XmlElement MigratePre20TestTemplate(IEnumerable<TestTemplate> testTemplates, ImportObject importObject)
|
|
{
|
|
|
|
_writer.WriteStartElement(TopLevelFields.TestSetups.ToString());
|
|
foreach (var t in testTemplates)
|
|
{
|
|
//Migrate HardwareOverrides to HardwareIncludes and HardwareRemoves
|
|
|
|
//Since we're migrating an earlier version of a Test Setup export which does not have
|
|
//a <DASList> within the <TestSetup>, change this Test Setup's <DASList><SamplesPerSecond>
|
|
//from the Test Setup default to this Test Setup's aggregate sample rate
|
|
//Also, initialize all DAS in the DASClockMasterList to false.
|
|
var testSetupDAS = importObject.Hardware();
|
|
foreach (var das in testSetupDAS)
|
|
{
|
|
t.DASSampleRateList[das.SerialNumber] = t.SamplesPerSecondAggregate;
|
|
t.DASAAFRateList[das.SerialNumber] = TestTemplate.GetAAFForHardware(das, (int)t.SamplesPerSecondAggregate);
|
|
t.DASClockMasterList[das.SerialNumber] = false;
|
|
t.DASPTPDomainIDList[das.SerialNumber] = 0;
|
|
}
|
|
|
|
//Migrate Groups
|
|
var count = -1;
|
|
var oldToNewChannelIds = new Dictionary<string, int>();
|
|
|
|
foreach (var testObject in t.TestObjectsAndAddedGroupsList)
|
|
{
|
|
//FB14086: Don't import channel-less groups
|
|
if (!t.SensorLookup.ContainsKey(testObject.SerialNumber)) continue;
|
|
IGroup newGroup = GroupHelper.CreateEmptyGroup();
|
|
|
|
|
|
newGroup.StaticGroupId = GroupHelper.GetGroupId(testObject, _groupIdMapping, importObject.Groups()?.ToList());
|
|
|
|
newGroup.Name = testObject.SerialNumber;
|
|
newGroup.DisplayName = testObject.DisplaySerialNumber == TestTemplate.NON_ISO_INTERNAL_GROUP_NAME
|
|
? StringResources.TestChannels
|
|
: testObject.DisplaySerialNumber;
|
|
newGroup.DisplayOrder = testObject.DisplayOrder;
|
|
newGroup.Position = testObject.Position.Position;
|
|
newGroup.TestObject = testObject.TestObjectType;
|
|
|
|
//13203 DataPRO failed on XML test setup import
|
|
//13558 Imported test setup missing included hardware.
|
|
//Get the embedded Group's hardware
|
|
var hardwareStringList = new List<string>();
|
|
foreach (var serialNumber in testObject.Hardware.Select(s => s.SerialNumber))
|
|
{
|
|
if (!hardwareStringList.Contains(serialNumber))
|
|
{
|
|
hardwareStringList.Add(serialNumber);
|
|
}
|
|
}
|
|
newGroup.IncludedHardwareStringList = hardwareStringList.ToArray();
|
|
|
|
t.Groups.Add(newGroup);
|
|
|
|
var groupChannelsList = new List<IGroupChannel>();
|
|
foreach (var groupName in t.SensorLookup.Keys)
|
|
{
|
|
if (groupName == newGroup.Name)
|
|
{
|
|
var channels = t.SensorLookup[groupName];
|
|
foreach (var channelName in channels.Keys)
|
|
{
|
|
var sensors = channels[channelName];
|
|
foreach (var sensorName in sensors.Keys) //Really only 1
|
|
{
|
|
var groupChannel = new GroupChannel(true, newGroup.DisplayName, newGroup, new IChannelSetting[0]);
|
|
groupChannel.IsoChannelName = channelName.StartsWith("TSD_")
|
|
? StringResources.SensorTableControl_DigitalOutputSetting
|
|
: channelName;
|
|
var isoCode = sensors[sensorName].ISOCode;
|
|
isoCode = isoCode.Remove(12, 2).Insert(12, sensors[sensorName].PhysicalDimension);
|
|
isoCode = isoCode.Remove(14, 1).Insert(14, sensors[sensorName].Direction);
|
|
groupChannel.IsoCode = isoCode;
|
|
groupChannel.UserChannelName = channelName.StartsWith("TSD_")
|
|
? StringResources.SensorTableControl_DigitalOutputSetting
|
|
: channelName;
|
|
groupChannel.UserCode = string.Empty;
|
|
groupChannel.IsDisabled = false;
|
|
|
|
//Migrate the Settings string from the XML (0=2400,1=A, etc.)
|
|
var settings = new List<IChannelSetting>();
|
|
|
|
|
|
switch (sensors[sensorName].Bridge)
|
|
{
|
|
case SensorConstants.BridgeType.IEPE:
|
|
case SensorConstants.BridgeType.QuarterBridge:
|
|
case SensorConstants.BridgeType.HalfBridge:
|
|
case SensorConstants.BridgeType.FullBridge:
|
|
case SensorConstants.BridgeType.HalfBridge_SigPlus:
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.Range + 1, ChannelSettingBase.RANGE, "2400")
|
|
{ DoubleValue = sensors[sensorName].Capacity });
|
|
//FB 15574 use filter class instead of cfc
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.FilterClass + 1, ChannelSettingBase.FilterClass, "None,0")
|
|
{ Value = FilterClass.GetFilterClassSettingFromFilterClass(sensors[sensorName].FilterClass) });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.Polarity + 1, ChannelSettingBase.POLARITY, "+")
|
|
{ Value = sensors[sensorName].Invert ? "-" : "+" });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.Position + 1, ChannelSettingBase.POSITION, "?")
|
|
{ Value = sensors[sensorName].Position });
|
|
|
|
//18861 When migrating from pre-2.0 add these settings
|
|
ZeroMethod zeroMethod = sensors[sensorName].Calibration.ZeroMethods.Methods.LastOrDefault();
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.ZeroMethod + 1, ChannelSettingBase.ZEROMETHOD, "AverageOverTime")
|
|
{ Value = zeroMethod.Method.ToString() });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.ZeroMethodStart + 1, ChannelSettingBase.ZEROMETHODSTART, "-0.05")
|
|
{ DoubleValue = zeroMethod.Start });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.ZeroMethodEnd + 1, ChannelSettingBase.ZEROMETHODEND, "-0.02")
|
|
{ DoubleValue = zeroMethod.End });
|
|
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UserValue1 + 1, ChannelSettingBase.USERVALUE1, "")
|
|
{ Value = sensors[sensorName].UserValue1 });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UserValue2 + 1, ChannelSettingBase.USERVALUE2, "")
|
|
{ Value = sensors[sensorName].UserValue2 });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UserValue3 + 1, ChannelSettingBase.USERVALUE3, "")
|
|
{ Value = sensors[sensorName].UserValue3 });
|
|
|
|
InitialOffset initialOffset = sensors[sensorName].Calibration.InitialOffsets.Offsets.LastOrDefault();
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.InitialOffset + 1, ChannelSettingBase.INITIAL_OFFSET, "None,0,0")
|
|
{ Value = $"{initialOffset.Form},{initialOffset.EU},{initialOffset.MV}" });
|
|
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.ACCouplingEnabled + 1, ChannelSettingBase.ACCouplingEnabled, "0")
|
|
{
|
|
Value = "FALSE"
|
|
});
|
|
break;
|
|
|
|
case SensorConstants.BridgeType.DigitalInput:
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.DefaultValue + 1, ChannelSettingBase.DEFAULT_VALUE, "0")
|
|
{ DoubleValue = sensors[sensorName].ScaleMultiplier.DefaultValue });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.ActiveValue + 1, ChannelSettingBase.ACTIVE_VALUE, "1")
|
|
{ DoubleValue = sensors[sensorName].ScaleMultiplier.ActiveValue });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.DIMode + 1, ChannelSettingBase.DIMODE, "8")
|
|
{ IntValue = (int)sensors[sensorName].InputMode });
|
|
break;
|
|
|
|
case SensorConstants.BridgeType.SQUIB:
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.SQMode + 1, ChannelSettingBase.SQMODE, "1")
|
|
{ IntValue = (int)sensors[sensorName].SquibFireMode });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.SquibDelay + 1, ChannelSettingBase.SQUIB_DELAY, "0")
|
|
{ DoubleValue = sensors[sensorName].SquibFireDelayMS });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.SquibDuration + 1, ChannelSettingBase.SQUIB_DURATION, "100")
|
|
{ DoubleValue = sensors[sensorName].SquibFireDurationMS });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.SquibLimitDuration + 1, ChannelSettingBase.SQUIB_LIMIT_DURATION, "1")
|
|
{ BoolValue = sensors[sensorName].LimitSquibFireDuration });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.SquibCurrent + 1, ChannelSettingBase.SQUIB_CURRENT, "1.5")
|
|
{ DoubleValue = sensors[sensorName].SquibOutputCurrent });
|
|
break;
|
|
|
|
case SensorConstants.BridgeType.TOMDigital:
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.OutputMode + 1, ChannelSettingBase.OUTPUT_MODE, "1")
|
|
{ IntValue = (int)sensors[sensorName].DigitalOutputMode });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.DigitalOutLimitDuration + 1, ChannelSettingBase.DIGITALOUT_LIMIT_DURATION, "1")
|
|
{ BoolValue = sensors[sensorName].DigitalOutputLimitDuration });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.DigitalOutDuration + 1, ChannelSettingBase.DIGITALOUT_DURATION, "100")
|
|
{ DoubleValue = sensors[sensorName].DigitalOutputDurationMS });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.DigitalOutDelay + 1, ChannelSettingBase.DIGITALOUT_DELAY, "0")
|
|
{ DoubleValue = sensors[sensorName].DigitalOutputDelayMS });
|
|
break;
|
|
|
|
case SensorConstants.BridgeType.UART:
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartBaudRate + 1, ChannelSettingBase.BAUD_RATE, "57600")
|
|
{ IntValue = (int)sensors[sensorName].UartBaudRate });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartDataBits + 1, ChannelSettingBase.DATA_BITS, "8")
|
|
{ IntValue = (int)sensors[sensorName].UartDataBits });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartStopBits + 1, ChannelSettingBase.STOP_BITS, "None")
|
|
{ Value = sensors[sensorName].UartStopBits.ToString() });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartParity + 1, ChannelSettingBase.PARITY, "None")
|
|
{ Value = sensors[sensorName].UartParity.ToString() });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartFlowControl + 1, ChannelSettingBase.FLOW_CONTROL, "None")
|
|
{ Value = sensors[sensorName].UartFlowControl.ToString() });
|
|
settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartDataFormat + 1, ChannelSettingBase.DATA_FORMAT, "Binary")
|
|
{ Value = sensors[sensorName].UartDataFormat.ToString() });
|
|
break;
|
|
}
|
|
|
|
groupChannel.ChannelSettings = settings.ToArray();
|
|
|
|
foreach (var sensor in importObject.Sensors())
|
|
{
|
|
if (sensor.SerialNumber == sensors[sensorName].SerialNumber)
|
|
{
|
|
groupChannel.SetSensorData(sensors[sensorName], null);
|
|
groupChannel.SensorId = sensor.DatabaseId;
|
|
break;
|
|
}
|
|
}
|
|
foreach (var hardware in importObject.Hardware())
|
|
{
|
|
foreach (var group in importObject.Groups())
|
|
{
|
|
foreach (var channel in group.GetISOTestObject().AllChannels)
|
|
{
|
|
var hardwareUnderscoreSplit = channel.HardwareId.Split('_');
|
|
|
|
if (hardwareUnderscoreSplit[0] == hardware.SerialNumber &&
|
|
group.SerialNumber == groupChannel.Group.Name &&
|
|
sensorName == channel.SensorSerialNumber)
|
|
{
|
|
groupChannel.DASId = hardware.DASId;
|
|
var hardwareXSplit = channel.HardwareId.Split('x');
|
|
groupChannel.DASChannelIndex = Convert.ToInt32(hardwareXSplit[1]) - 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var g in importObject.Groups())
|
|
{
|
|
if (g.SerialNumber == groupName)
|
|
{
|
|
foreach (var ch in g.GetISOTestObject().AllChannels)
|
|
{
|
|
if (ch.Name == channelName)
|
|
{
|
|
groupChannel.Id = count;
|
|
var channelParts = ch.GetId().Split('_');
|
|
groupChannel.GroupChannelOrder = Convert.ToInt32(channelParts[channelParts.Length - 1]);
|
|
oldToNewChannelIds[ch.GetId()] = count;
|
|
count--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
groupChannelsList.Add(groupChannel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
t.ChannelsForGroup[newGroup] = groupChannelsList.ToArray();
|
|
}
|
|
|
|
//Migrate Graphs
|
|
foreach (var testGraph in t.TestGraphs)
|
|
{
|
|
foreach (var testGraphChannel in testGraph.Channels)
|
|
{
|
|
foreach (var group in t.Groups)
|
|
{
|
|
foreach (var channel in t.ChannelsForGroup[group])
|
|
{
|
|
if (channel.GetChannelName(_isoViewMode) == testGraphChannel.Name)
|
|
{
|
|
testGraph.AddChannel(channel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Migrate CalculatedChannels
|
|
foreach (var calculatedChannel in t.CalculatedChannels)
|
|
{
|
|
var groupChannelsList = new List<IGroupChannel>();
|
|
foreach (var calculatedChannelInputChannel in calculatedChannel.TestObjectChannels)
|
|
{
|
|
foreach (var group in t.Groups)
|
|
{
|
|
foreach (var channel in t.ChannelsForGroup[group])
|
|
{
|
|
//15242 Sensors swapped on calculated channel when importing test setup.
|
|
//use name of the channel to match between test channels and calculated input channel ...
|
|
if (channel.GetChannelName(_isoViewMode) == calculatedChannelInputChannel.NameOfTheChannel)
|
|
{
|
|
groupChannelsList.Add(channel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
calculatedChannel.SetChannels(groupChannelsList.ToArray());
|
|
}
|
|
|
|
//Migrate LevelTriggers
|
|
foreach (var levelTrigger in t.LevelTriggerChannels.Select(l => l.Value))
|
|
{
|
|
foreach (var group in t.Groups)
|
|
{
|
|
foreach (var channel in t.ChannelsForGroup[group])
|
|
{
|
|
if ((channel.SensorData != null) && (channel.SensorData.SerialNumber == levelTrigger.SensorSerialNumber))
|
|
{
|
|
levelTrigger.GroupChannelId = channel.Id.ToString(CultureInfo.InvariantCulture);
|
|
levelTrigger.GroupChannel = channel;
|
|
channel.HardwareId = levelTrigger.HardwareChannelId;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//first go through all groups, add any hardware from any groups in the test setup
|
|
var addedHardwareList = new List<int>();
|
|
var removedHardwareList = new List<int>();
|
|
foreach (var group in t.Groups)
|
|
{
|
|
foreach (var h in group.IncludedHardwareStringList)
|
|
{
|
|
var matches = from hw in importObject.Hardware() where hw.SerialNumber == h select hw;
|
|
if (matches.Any())
|
|
{
|
|
foreach (var match in matches)
|
|
{
|
|
if (!addedHardwareList.Contains(match.DASId))
|
|
{
|
|
addedHardwareList.Add(match.DASId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//finally add any hardware add/remove specific instructions
|
|
foreach (var hardwareOverride in t.HardwareOverrides.Select(p => p.Value))
|
|
{
|
|
var dasId = 0;
|
|
var dasParts = hardwareOverride.HardwareId.Split('_');
|
|
foreach (var hardware in importObject.Hardware())
|
|
{
|
|
if (hardware.SerialNumber == dasParts[0])
|
|
{
|
|
dasId = hardware.DASId;
|
|
if (hardwareOverride.Action == HardwareInclusionInstruction.Actions.Add)
|
|
{
|
|
addedHardwareList.Add(dasId);
|
|
}
|
|
else if (hardwareOverride.Action == HardwareInclusionInstruction.Actions.Remove)
|
|
{
|
|
if (addedHardwareList.Contains(dasId))
|
|
{
|
|
addedHardwareList.Remove(dasId);
|
|
}
|
|
|
|
removedHardwareList.Add(dasId);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
t.AddedHardware = addedHardwareList.ToArray();
|
|
t.RemovedHardware = removedHardwareList.ToArray();
|
|
t.HardwareOverrides.Clear();
|
|
|
|
_writer.Flush();
|
|
t.WriteXML(ref _writer);
|
|
_writer.Flush();
|
|
}
|
|
_writer.WriteEndElement();
|
|
return GetXmlElement();
|
|
}
|
|
private IEnumerable<TestTemplate> ParsePre20TestTemplate(ImportObject importObject)
|
|
{
|
|
List<TestTemplate> testTemplates = new List<TestTemplate>();
|
|
|
|
var testobjectLookup = new Dictionary<string, TestObject>();
|
|
|
|
foreach (var to in importObject.Groups())
|
|
{
|
|
if (IsCancelled()) { return testTemplates; }
|
|
testobjectLookup[to.SerialNumber] = to;
|
|
}
|
|
|
|
var customerDetailsLookup = new Dictionary<string, ISO.CustomerDetails>();
|
|
foreach (var c in importObject.CustomerDetails())
|
|
{
|
|
if (IsCancelled()) { return testTemplates; }
|
|
customerDetailsLookup[c.Name] = c;
|
|
}
|
|
|
|
var testEngineerDetailsLookup = new Dictionary<string, ISO.TestEngineerDetails>();
|
|
foreach (var t in importObject.TestEngineerDetails())
|
|
{
|
|
if (IsCancelled()) { return testTemplates; }
|
|
testEngineerDetailsLookup[t.Name] = t;
|
|
}
|
|
|
|
var labDetailsLookup = new Dictionary<string, ISO.LabratoryDetails>();
|
|
foreach (var l in importObject.LabDetails())
|
|
{
|
|
if (IsCancelled()) { return testTemplates; }
|
|
labDetailsLookup[l.Name] = l;
|
|
}
|
|
|
|
var sensorLookup = new Dictionary<string, SensorData>();
|
|
foreach (var s in importObject.Sensors())
|
|
{
|
|
if (IsCancelled()) { return testTemplates; }
|
|
sensorLookup[s.SerialNumber] = s;
|
|
}
|
|
|
|
foreach (var node in _root.ChildNodes)
|
|
{
|
|
if (IsCancelled()) { return testTemplates; }
|
|
if (node is XmlElement)
|
|
{
|
|
var d = new TestTemplate();
|
|
d.ReadXMLPre20(node as XmlElement, testobjectLookup, labDetailsLookup, customerDetailsLookup, testEngineerDetailsLookup, sensorLookup, importObject.Hardware()?.ToList());
|
|
testTemplates.Add(d);
|
|
|
|
}
|
|
}
|
|
|
|
return testTemplates;
|
|
}
|
|
|
|
|
|
public override void Parse(ref ImportObject importObject)
|
|
{
|
|
var testTemplates = ParsePre20TestTemplate(importObject);
|
|
if (!testTemplates.Any())
|
|
{
|
|
return;
|
|
}
|
|
XmlElement newRoot = MigratePre20TestTemplate(testTemplates, importObject);
|
|
if (newRoot == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
importObject.AddTestSetups(_xmlParseTestSetups.ParseTestTemplate(importObject, newRoot));
|
|
//FB 38039,40758 Identify test setup type
|
|
importObject.TestSetupImportFileFormat = importObject.GetImportFileFormat();
|
|
|
|
}
|
|
}
|
|
}
|