752 lines
35 KiB
C#
752 lines
35 KiB
C#
using System.Collections.Generic;
|
|
using DTS.Common.Interface.Groups.GroupList;
|
|
using DTS.SensorDB;
|
|
using DTS.Common.Interface.Sensors;
|
|
using DTS.Common.Interface.Channels;
|
|
using System.Linq;
|
|
using System.Windows;
|
|
using System.Threading;
|
|
using System;
|
|
using DTS.Common.Interface.DataRecorders;
|
|
using DTS.Common.Storage;
|
|
using Prism.Ioc;
|
|
using DTS.Common.ISO;
|
|
using DTS.Common.Utils;
|
|
using DTS.Common.Utilities.Logging;
|
|
using DTS.Common.Enums.DBExport;
|
|
using System.Text;
|
|
using Unity;
|
|
|
|
namespace DataPROWin7.DataModel.Classes
|
|
{
|
|
public static class ExportTestSetup
|
|
{
|
|
public static void PrepareForExport(DataModel.TestTemplate t,
|
|
Dictionary<string, DataModel.TestTemplate> includedTests,
|
|
Dictionary<string, IGroup> includedGroups,
|
|
Dictionary<string, DataModel.DASHardware> includedDAS,
|
|
Dictionary<string, SensorData> includedSensors,
|
|
HashSet<int> sensorsAlreadyAdded,
|
|
Dictionary<string, SensorModel> includedSensorModels,
|
|
Dictionary<string, SensorCalibration[]> includedCalibration,
|
|
Dictionary<string, DTS.Common.ISO.CustomerDetails> includedCustomerDetails,
|
|
Dictionary<string, DTS.Common.ISO.TestEngineerDetails> includedTestEngineerDetails,
|
|
Dictionary<string, DTS.Common.ISO.LabratoryDetails> includedLabDetails,
|
|
bool savingRunningTest,
|
|
// ReSharper disable once InconsistentNaming
|
|
bool savingTTSImport
|
|
)
|
|
{
|
|
if (!includedTests.ContainsKey(t.Name)) { includedTests[t.Name] = t; }
|
|
|
|
if (!string.IsNullOrWhiteSpace(t.CustomerDetails?.Name))
|
|
{
|
|
includedCustomerDetails[t.CustomerDetails.Name] = t.CustomerDetails.GetISOCustomer();
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(t.TestEngineerDetails?.Name))
|
|
{
|
|
includedTestEngineerDetails[t.TestEngineerDetails.Name] = t.TestEngineerDetails.GetISOTestEngineer();
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(t.LabDetails?.Name))
|
|
{
|
|
includedLabDetails[t.LabDetails.Name] = t.LabDetails.GetIsoLab();
|
|
}
|
|
|
|
var groups = new List<IGroup>(t.Groups);
|
|
|
|
var sensorLookup = new Dictionary<int, ISensorData>();
|
|
var sensors = SensorsCollection.SensorsList.GetAllSensors(false);
|
|
foreach (var s in sensors)
|
|
{
|
|
sensorLookup[s.DatabaseId] = s;
|
|
}
|
|
var hardwareList = GetHardware();
|
|
var dasList = DTS.Common.ISO.Hardware.GetAllDAS();
|
|
foreach (var embeddedGroup in groups)
|
|
{
|
|
//Find the channels in this embedded Group so the Sensors will be included
|
|
var groupChannelList = new List<IGroupChannel>();
|
|
foreach (var groupChannelsList in t.ChannelsForGroup) //make this a linq statement?
|
|
{
|
|
if (groupChannelsList.Key == embeddedGroup)
|
|
{
|
|
groupChannelList = groupChannelsList.Value.ToList();
|
|
}
|
|
}
|
|
foreach (var groupChannel in groupChannelList)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(groupChannel.Sensor))
|
|
{
|
|
var sd = SensorsCollection.SensorsList.GetOriginalSensorBySensorDatabaseId(
|
|
groupChannel.SensorId);
|
|
var scs = SensorCalibration.GetCalibrationsBySerialNumber(sd);
|
|
if (null != sd && null != scs && scs.Length > 0)
|
|
{
|
|
if (!sensorsAlreadyAdded.Contains(sd.DatabaseId))
|
|
{
|
|
if (!sd.IsTestSpecificDigitalOutput && !sd.IsTestSpecificSquib && !sd.IsTestSpecificDigitalIn)
|
|
{
|
|
includedCalibration.Add(sd.SerialNumber, scs);
|
|
}
|
|
|
|
includedSensors.Add(sd.SerialNumber, sd);
|
|
sensorsAlreadyAdded.Add(sd.DatabaseId);
|
|
}
|
|
}
|
|
}
|
|
foreach (var dasId in embeddedGroup.IncludedHardware)
|
|
{
|
|
var h = GetDAS(hardwareList, dasId, dasList);
|
|
if (!includedDAS.ContainsKey(h.SerialNumber))
|
|
{
|
|
includedDAS.Add(h.SerialNumber, new DataModel.DASHardware(h));
|
|
}
|
|
}
|
|
}
|
|
|
|
//If there's a non-imbedded (static) Group in the db, process it too.
|
|
IGroup nonEmbeddedGroup = null;
|
|
if (embeddedGroup.StaticGroupId != null)
|
|
{
|
|
if (System.Windows.Application.Current.Dispatcher.CheckAccess())
|
|
{
|
|
nonEmbeddedGroup = GetNonEmbeddedGroup(embeddedGroup.StaticGroupId);
|
|
}
|
|
else
|
|
{
|
|
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
|
|
|
|
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
nonEmbeddedGroup = GetNonEmbeddedGroup(embeddedGroup.StaticGroupId);
|
|
manualResetEvent.Set();
|
|
}));
|
|
|
|
|
|
manualResetEvent.WaitOne();
|
|
}
|
|
}
|
|
|
|
if (nonEmbeddedGroup == null || nonEmbeddedGroup.Id != embeddedGroup.StaticGroupId)
|
|
{
|
|
//We can get here if the static Group was created from a static Group which was later deleted,
|
|
//but the embedded Group didn't have its StaticGroupId set to null (also fixed in this patch,
|
|
//but pre-existing embedded Groups in the database could be pointing to a non-existent record)
|
|
embeddedGroup.StaticGroupId = null;
|
|
continue;
|
|
}
|
|
|
|
var hardwareLookup = new Dictionary<int, IDASHardware>();
|
|
using (var enumHardware = includedDAS.GetEnumerator())
|
|
{
|
|
while (enumHardware.MoveNext()) { hardwareLookup[enumHardware.Current.Value.DASId] = enumHardware.Current.Value; }
|
|
}
|
|
|
|
var channelDefaults = DbOperations.GetChannelSettingDefaults();
|
|
|
|
var groupChannelArray = nonEmbeddedGroup.GetAllChannels(false, sensorLookup, hardwareLookup, channelDefaults);
|
|
foreach (var groupChannel in groupChannelArray)
|
|
{
|
|
nonEmbeddedGroup.GroupChannelList.Add(groupChannel);
|
|
nonEmbeddedGroup.ChannelCount++;
|
|
}
|
|
|
|
var channels = t.ChannelsForGroup[embeddedGroup];
|
|
|
|
foreach (var groupChannel in channels)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(groupChannel.Sensor))
|
|
{
|
|
var sd = SensorsCollection.SensorsList.GetOriginalSensorBySensorDatabaseId(groupChannel.SensorId);
|
|
var scs = SensorCalibration.GetCalibrationsBySerialNumber(sd);
|
|
if (null != sd && null != scs && scs.Length > 0)
|
|
{
|
|
if (!sensorsAlreadyAdded.Contains(sd.DatabaseId))
|
|
{
|
|
if (!sd.IsTestSpecificSquib && !sd.IsTestSpecificDigitalOutput && !sd.IsTestSpecificDigitalIn)
|
|
{
|
|
includedCalibration.Add(sd.SerialNumber, scs);
|
|
}
|
|
|
|
includedSensors.Add(sd.SerialNumber, sd);
|
|
sensorsAlreadyAdded.Add(sd.DatabaseId);
|
|
}
|
|
}
|
|
}
|
|
foreach (var dasId in nonEmbeddedGroup.IncludedHardware)
|
|
{
|
|
var h = GetDAS(hardwareList, dasId, dasList);
|
|
if (!includedDAS.ContainsKey(h.SerialNumber))
|
|
{
|
|
includedDAS.Add(h.SerialNumber, new DataModel.DASHardware(h));
|
|
}
|
|
}
|
|
}
|
|
|
|
//Only add static Groups to includedGroups
|
|
if (!includedGroups.ContainsKey(nonEmbeddedGroup.Name))
|
|
{
|
|
includedGroups.Add(nonEmbeddedGroup.Name, nonEmbeddedGroup);
|
|
}
|
|
}
|
|
|
|
foreach (var group in t.Groups)
|
|
{
|
|
var channels = t.ChannelsForGroup[group];
|
|
foreach (var ch in channels)
|
|
{
|
|
if (ch.IsBlank())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (ch.SensorId > 0)
|
|
{
|
|
var sd = SensorsCollection.SensorsList.GetOriginalSensorBySensorDatabaseId(ch.SensorId);
|
|
if (!includedSensors.ContainsKey(sd.SerialNumber))
|
|
{
|
|
if (!sensorsAlreadyAdded.Contains(sd.DatabaseId))
|
|
{
|
|
includedSensors.Add(sd.SerialNumber, sd);
|
|
if (!sd.IsTestSpecificDigitalOutput && !sd.IsTestSpecificSquib && !sd.IsTestSpecificDigitalIn)
|
|
{
|
|
var scs = SensorCalibration.GetCalibrationsBySerialNumber(sd);
|
|
includedCalibration.Add(sd.SerialNumber, scs);
|
|
var sm = SensorModelCollection.SensorModelList.GetSensorModel(sd.Manufacturer,
|
|
sd.Model);
|
|
if (null == sm)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var key = $"{sm.Manufacturer}x_x{sm.Model}";
|
|
if (!includedSensorModels.ContainsKey(key))
|
|
{
|
|
includedSensorModels.Add(key, sm);
|
|
}
|
|
}
|
|
|
|
sensorsAlreadyAdded.Add(sd.DatabaseId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var hardware = t.GetHardware();
|
|
foreach (var h in hardware)
|
|
{
|
|
if (!includedDAS.ContainsKey(h.SerialNumber))
|
|
{
|
|
includedDAS.Add(h.SerialNumber, h);
|
|
}
|
|
}
|
|
|
|
if (!savingTTSImport) return;
|
|
var allSensors = SensorsCollection.SensorsList.GetAllSensors(true);
|
|
foreach (var sd in allSensors)
|
|
{
|
|
if (includedSensors.ContainsKey(sd.SerialNumber)) continue;
|
|
var scs = SensorCalibration.GetCalibrationsBySerialNumber(sd);
|
|
if (null != scs && scs.Length > 0)
|
|
{
|
|
includedCalibration.Add(sd.SerialNumber, scs);
|
|
includedSensors.Add(sd.SerialNumber, sd);
|
|
var sm = SensorModelCollection.SensorModelList.GetSensorModel(sd.Manufacturer,
|
|
sd.Model);
|
|
if (null == sm) continue;
|
|
var key = $"{sm.Manufacturer}x_x{sm.Model}";
|
|
if (!includedSensorModels.ContainsKey(key))
|
|
{
|
|
includedSensorModels.Add(key, sm);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
System.Diagnostics.Trace.WriteLine("calibration record is null");
|
|
}
|
|
}
|
|
}
|
|
public static string ExportToFile(Dictionary<string, DataModel.TestTemplate> includedTests,
|
|
Dictionary<string, IGroup> includedGroups,
|
|
Dictionary<string, DataModel.DASHardware> includedDAS,
|
|
Dictionary<string, SensorData> includedSensors,
|
|
Dictionary<string, SensorModel> includedSensorModels,
|
|
Dictionary<string, SensorCalibration[]> includedCalibration,
|
|
Dictionary<string, DTS.Common.ISO.CustomerDetails> includedCustomerDetails,
|
|
Dictionary<string, DTS.Common.ISO.TestEngineerDetails> includedTestEngineerDetails,
|
|
Dictionary<string, DTS.Common.ISO.LabratoryDetails> includedLabDetails,
|
|
Dictionary<string, DTS.Slice.Users.User> includedUsers,
|
|
Dictionary<string, string> includedGlobalSettings,
|
|
string exportFile,
|
|
string originalImportFile,
|
|
bool bUseFirstUseDate = true)
|
|
{
|
|
double totalStepsToComplete = includedCalibration.Count + includedDAS.Count +
|
|
includedGroups.Count +
|
|
+includedSensorModels.Count + includedSensors.Count + includedTests.Count +
|
|
includedLabDetails.Count
|
|
+ includedCustomerDetails.Count + includedTestEngineerDetails.Count +
|
|
includedUsers.Count + includedGlobalSettings.Count;
|
|
|
|
double done = 0;
|
|
var writer = FileUtils.GetExportWriter(Convert.ToInt32(totalStepsToComplete), FileUtils.CurrentXmlVersion,
|
|
System.Reflection.Assembly.GetEntryAssembly().GetName().Name,
|
|
System.Reflection.Assembly.GetEntryAssembly().GetName().Version.ToString(4), APILogger.Log, out var sb);
|
|
|
|
try
|
|
{
|
|
writer.WriteAttributeString("OriginalImportFile", originalImportFile);
|
|
|
|
var fields = Enum.GetValues(typeof(TopLevelFields)).Cast<TopLevelFields>().ToArray();
|
|
|
|
foreach (var f in fields)
|
|
{
|
|
switch (f)
|
|
{
|
|
case TopLevelFields.Calibrations:
|
|
if (includedCalibration.Count > 0)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
foreach (var c in includedCalibration)
|
|
{
|
|
foreach (var sc in c.Value) { writer.Flush(); sc.WriteXML(ref writer); writer.Flush(); }
|
|
done++;
|
|
}
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.CustomChannels:
|
|
break;
|
|
case TopLevelFields.DASList:
|
|
if (includedDAS.Count > 0)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
foreach (var h in includedDAS)
|
|
{
|
|
writer.Flush(); h.Value.WriteXML(ref writer); writer.Flush();
|
|
done++;
|
|
}
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.Groups:
|
|
if (includedGroups.Count > 0)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
foreach (var g in includedGroups)
|
|
{
|
|
writer.Flush(); g.Value.WriteXML(ref writer); writer.Flush();
|
|
done++;
|
|
}
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.GroupTemplates:
|
|
break;
|
|
case TopLevelFields.SensorModels:
|
|
if (includedSensorModels.Count > 0)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
foreach (var sm in includedSensorModels)
|
|
{
|
|
writer.Flush(); sm.Value.WriteXML(ref writer); writer.Flush();
|
|
done++;
|
|
}
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.Sensors:
|
|
if (includedSensors.Count > 0)
|
|
{
|
|
writer.Flush();
|
|
writer.WriteStartElement(f.ToString());
|
|
foreach (var sd in includedSensors)
|
|
{
|
|
writer.Flush(); sd.Value.WriteXML(ref writer, bUseFirstUseDate); writer.Flush();
|
|
done++;
|
|
}
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.TestSetups:
|
|
if (includedTests.Count > 0)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
foreach (var t in includedTests)
|
|
{
|
|
writer.Flush(); t.Value.WriteXML(ref writer); writer.Flush();
|
|
done++;
|
|
}
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.CustomerDetails:
|
|
if (includedCustomerDetails.Count > 0)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
foreach (var c in includedCustomerDetails)
|
|
{
|
|
writer.Flush(); c.Value.WriteXML(ref writer); writer.Flush();
|
|
done++;
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.Users:
|
|
if (includedUsers.Count > 0)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
|
|
foreach (var user in includedUsers)
|
|
{
|
|
writer.Flush();
|
|
user.Value.WriteXML(ref writer);
|
|
writer.Flush();
|
|
done++;
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.TestEngineerDetails:
|
|
if (includedTestEngineerDetails.Count > 0)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
foreach (var c in includedTestEngineerDetails)
|
|
{
|
|
writer.Flush(); c.Value.WriteXML(ref writer); writer.Flush();
|
|
done++;
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.LabDetails:
|
|
if (includedLabDetails.Count > 0)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
|
|
foreach (var ld in includedLabDetails)
|
|
{
|
|
writer.Flush(); ld.Value.WriteXML(ref writer); writer.Flush();
|
|
done++;
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.CustomDirections:
|
|
case TopLevelFields.CustomFilterClasses:
|
|
case TopLevelFields.CustomFinLoc1s:
|
|
case TopLevelFields.CustomFinLoc2s:
|
|
case TopLevelFields.CustomFinLoc3s:
|
|
case TopLevelFields.CustomMainLocs:
|
|
case TopLevelFields.CustomTestObjects:
|
|
case TopLevelFields.CustomPhysicalDimensions:
|
|
case TopLevelFields.CustomPositions:
|
|
break;
|
|
case TopLevelFields.GlobalSettings:
|
|
{
|
|
if (includedGlobalSettings.Any())
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
|
|
foreach (var setting in includedGlobalSettings)
|
|
{
|
|
writer.Flush();
|
|
WriteGlobalSetting(setting.Key, setting.Value, ref writer);
|
|
writer.Flush();
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
break;
|
|
case TopLevelFields.SensorChangeHistory: break;
|
|
default:
|
|
throw new NotSupportedException("ExportTestSetup::ExportFunc unknown element: " + f);
|
|
}
|
|
}
|
|
writer.WriteEndElement();//exportdocument
|
|
writer.WriteEndDocument();
|
|
|
|
writer.Flush();
|
|
writer.Close();
|
|
if (null != exportFile)
|
|
{
|
|
System.IO.File.WriteAllText(exportFile, sb.ToString(), Encoding.Unicode);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log(ex);
|
|
return string.Empty;
|
|
}
|
|
}
|
|
private static IGroup GetNonEmbeddedGroup(int? embeddedGroupStaticGroupId)
|
|
{
|
|
var unityContainer = ContainerLocator.Container.Resolve<IUnityContainer>();
|
|
var vm = unityContainer.Resolve<IGroupListViewModel>();
|
|
var g = vm.GetGroup(embeddedGroupStaticGroupId);
|
|
return g;
|
|
}
|
|
private static List<DTS.Common.ISO.Hardware> GetHardware()
|
|
{
|
|
var hardwareList = new List<DTS.Common.ISO.Hardware>();
|
|
var hResult = DbOperations.DASGet(null, null, out var dbDAS);
|
|
if (0 == hResult)
|
|
{
|
|
foreach (var das in dbDAS)
|
|
{
|
|
hardwareList.Add(new DTS.Common.ISO.Hardware(das));
|
|
}
|
|
}
|
|
return hardwareList;
|
|
}
|
|
private static DTS.Common.ISO.Hardware GetDAS(List<DTS.Common.ISO.Hardware> hardwareList, int hardwareId, DTS.Common.ISO.Hardware[] dasList)
|
|
{
|
|
var dasSerialNumber = GetHardwareSerialNumber(hardwareList, hardwareId);
|
|
foreach (var das in dasList)
|
|
{
|
|
if (das.SerialNumber == dasSerialNumber)
|
|
{
|
|
return das;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
private static string GetHardwareSerialNumber(List<DTS.Common.ISO.Hardware> hardwareList, int hId)
|
|
{
|
|
foreach (var hardware in hardwareList)
|
|
{
|
|
if (hardware.DASId == hId)
|
|
{
|
|
return hardware.SerialNumber;
|
|
}
|
|
}
|
|
return string.Empty;
|
|
}
|
|
private static void WriteGlobalSetting(string key, string value, ref System.Xml.XmlWriter writer)
|
|
{
|
|
writer.WriteStartElement("Setting");
|
|
writer.WriteStartElement("SettingName");
|
|
writer.WriteString(key);
|
|
writer.WriteEndElement();
|
|
writer.WriteStartElement("SettingValue");
|
|
writer.WriteString(value);
|
|
writer.WriteEndElement();
|
|
writer.WriteEndElement();
|
|
}
|
|
public static void PrepareForExportFields(DataModel.TestTemplate t,
|
|
Dictionary<string, DataModel.TestTemplate> includedTests,
|
|
Dictionary<string, DataModel.DASHardware> includedDAS
|
|
)
|
|
{
|
|
if (!includedTests.ContainsKey(t.Name)) { includedTests[t.Name] = t; }
|
|
|
|
var groups = new List<IGroup>(t.Groups);
|
|
|
|
var sensorLookup = new Dictionary<int, ISensorData>();
|
|
var sensors = SensorsCollection.SensorsList.GetAllSensors(false);
|
|
foreach (var s in sensors)
|
|
{
|
|
sensorLookup[s.DatabaseId] = s;
|
|
}
|
|
var hardwareList = GetHardware();
|
|
var dasList = DTS.Common.ISO.Hardware.GetAllDAS();
|
|
foreach (var embeddedGroup in groups)
|
|
{
|
|
//Find the channels in this embedded Group so the Sensors will be included
|
|
var groupChannelList = new List<IGroupChannel>();
|
|
foreach (var groupChannelsList in t.ChannelsForGroup) //make this a linq statement?
|
|
{
|
|
if (groupChannelsList.Key == embeddedGroup)
|
|
{
|
|
groupChannelList = groupChannelsList.Value.ToList();
|
|
}
|
|
}
|
|
foreach (var groupChannel in groupChannelList)
|
|
{
|
|
foreach (var dasId in embeddedGroup.IncludedHardware)
|
|
{
|
|
var h = GetDAS(hardwareList, dasId, dasList);
|
|
if (!includedDAS.ContainsKey(h.SerialNumber))
|
|
{
|
|
includedDAS.Add(h.SerialNumber, new DataModel.DASHardware(h));
|
|
}
|
|
}
|
|
}
|
|
|
|
//If there's a non-imbedded (static) Group in the db, process it too.
|
|
IGroup nonEmbeddedGroup = null;
|
|
if (embeddedGroup.StaticGroupId != null)
|
|
{
|
|
if (Application.Current.Dispatcher.CheckAccess())
|
|
{
|
|
nonEmbeddedGroup = GetNonEmbeddedGroup(embeddedGroup.StaticGroupId);
|
|
}
|
|
else
|
|
{
|
|
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
|
|
|
|
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
nonEmbeddedGroup = GetNonEmbeddedGroup(embeddedGroup.StaticGroupId);
|
|
manualResetEvent.Set();
|
|
}));
|
|
|
|
|
|
manualResetEvent.WaitOne();
|
|
}
|
|
}
|
|
|
|
if (nonEmbeddedGroup == null || nonEmbeddedGroup.Id != embeddedGroup.StaticGroupId)
|
|
{
|
|
//We can get here if the static Group was created from a static Group which was later deleted,
|
|
//but the embedded Group didn't have its StaticGroupId set to null (also fixed in this patch,
|
|
//but pre-existing embedded Groups in the database could be pointing to a non-existent record)
|
|
embeddedGroup.StaticGroupId = null;
|
|
continue;
|
|
}
|
|
|
|
var hardwareLookup = new Dictionary<int, IDASHardware>();
|
|
using (var enumHardware = includedDAS.GetEnumerator())
|
|
{
|
|
while (enumHardware.MoveNext()) { hardwareLookup[enumHardware.Current.Value.DASId] = enumHardware.Current.Value; }
|
|
}
|
|
|
|
var channelDefaults = DbOperations.GetChannelSettingDefaults();
|
|
|
|
var groupChannelArray = nonEmbeddedGroup.GetAllChannels(false, sensorLookup, hardwareLookup, channelDefaults);
|
|
foreach (var groupChannel in groupChannelArray)
|
|
{
|
|
nonEmbeddedGroup.GroupChannelList.Add(groupChannel);
|
|
nonEmbeddedGroup.ChannelCount++;
|
|
}
|
|
|
|
var channels = t.ChannelsForGroup[embeddedGroup];
|
|
|
|
foreach (var groupChannel in channels)
|
|
{
|
|
foreach (var dasId in nonEmbeddedGroup.IncludedHardware)
|
|
{
|
|
var h = GetDAS(hardwareList, dasId, dasList);
|
|
if (!includedDAS.ContainsKey(h.SerialNumber))
|
|
{
|
|
includedDAS.Add(h.SerialNumber, new DataModel.DASHardware(h));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var hardware = t.GetHardware();
|
|
foreach (var h in hardware)
|
|
{
|
|
if (!includedDAS.ContainsKey(h.SerialNumber))
|
|
{
|
|
includedDAS.Add(h.SerialNumber, h);
|
|
}
|
|
}
|
|
foreach (var h in hardwareList)
|
|
{
|
|
if (includedDAS.ContainsKey(h.SerialNumber)) continue;
|
|
|
|
if (t.DASSampleRateList.ContainsKey(h.SerialNumber))
|
|
{
|
|
t.DASSampleRateList.Remove(h.SerialNumber);
|
|
}
|
|
}
|
|
}
|
|
public static string ExportToFileFields(Dictionary<string, DataModel.TestTemplate> includedTests,
|
|
Dictionary<string, DataModel.DASHardware> includedDAS,
|
|
string originalImportFile)
|
|
{
|
|
double totalStepsToComplete = includedDAS.Count +
|
|
includedTests.Count;
|
|
|
|
double done = 0;
|
|
var writer = FileUtils.GetExportWriter(Convert.ToInt32(totalStepsToComplete), FileUtils.CurrentXmlVersion,
|
|
System.Reflection.Assembly.GetEntryAssembly().GetName().Name,
|
|
System.Reflection.Assembly.GetEntryAssembly().GetName().Version.ToString(4), APILogger.Log, out var sb);
|
|
|
|
try
|
|
{
|
|
writer.WriteAttributeString("OriginalImportFile", originalImportFile);
|
|
|
|
var fields = Enum.GetValues(typeof(TopLevelFields)).Cast<TopLevelFields>().ToArray();
|
|
|
|
foreach (var f in fields)
|
|
{
|
|
switch (f)
|
|
{
|
|
case TopLevelFields.DASList:
|
|
if (includedDAS.Count > 0)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
foreach (var h in includedDAS)
|
|
{
|
|
writer.Flush(); h.Value.WriteXML(ref writer); writer.Flush();
|
|
done++;
|
|
}
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.TestSetups:
|
|
if (includedTests.Count > 0)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
foreach (var t in includedTests)
|
|
{
|
|
writer.Flush(); t.Value.WriteXML(ref writer); writer.Flush();
|
|
done++;
|
|
}
|
|
writer.WriteEndElement();
|
|
}
|
|
break;
|
|
case TopLevelFields.CustomerDetails:
|
|
case TopLevelFields.Users:
|
|
case TopLevelFields.Calibrations:
|
|
case TopLevelFields.CustomChannels:
|
|
case TopLevelFields.Groups:
|
|
case TopLevelFields.GroupTemplates:
|
|
case TopLevelFields.SensorModels:
|
|
case TopLevelFields.Sensors:
|
|
case TopLevelFields.TestEngineerDetails:
|
|
case TopLevelFields.LabDetails:
|
|
case TopLevelFields.CustomDirections:
|
|
case TopLevelFields.CustomFilterClasses:
|
|
case TopLevelFields.CustomFinLoc1s:
|
|
case TopLevelFields.CustomFinLoc2s:
|
|
case TopLevelFields.CustomFinLoc3s:
|
|
case TopLevelFields.CustomMainLocs:
|
|
case TopLevelFields.CustomTestObjects:
|
|
case TopLevelFields.CustomPhysicalDimensions:
|
|
case TopLevelFields.CustomPositions:
|
|
case TopLevelFields.GlobalSettings:
|
|
case TopLevelFields.SensorChangeHistory:
|
|
break;
|
|
default:
|
|
throw new NotSupportedException("ExportTestSetup::ExportFunc unknown element: " + f);
|
|
}
|
|
}
|
|
writer.WriteEndElement();//exportdocument
|
|
writer.WriteEndDocument();
|
|
|
|
writer.Flush();
|
|
writer.Close();
|
|
return sb.ToString();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log(ex);
|
|
return string.Empty;
|
|
}
|
|
}
|
|
}
|
|
}
|