1898 lines
101 KiB
C#
1898 lines
101 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using System.Windows;
|
|
using DatabaseExport.Properties;
|
|
|
|
namespace DatabaseExport
|
|
{
|
|
public class DbExporter
|
|
{
|
|
public static string ISODir { get; set; } = string.Empty;
|
|
|
|
public DbExporter(string isoDir)
|
|
{
|
|
ISODir = isoDir;
|
|
}
|
|
public enum TopLevelFields
|
|
{
|
|
CustomerDetails,
|
|
TestEngineerDetails,
|
|
LabDetails,
|
|
DASList,
|
|
SensorModels,
|
|
Sensors,
|
|
Calibrations,
|
|
CustomDirections,
|
|
CustomFilterClasses,
|
|
CustomTestObjects,
|
|
CustomFinLoc1s,
|
|
CustomFinLoc2s,
|
|
CustomFinLoc3s,
|
|
CustomMainLocs,
|
|
CustomPhysicalDimensions,
|
|
CustomPositions,
|
|
CustomChannels,
|
|
GroupTemplates,
|
|
Groups,
|
|
TestSetups,
|
|
UIItems,
|
|
Users,
|
|
UIItemSettings,
|
|
GlobalSettings,
|
|
LastUsedHardware,
|
|
Tags,
|
|
TagAssignments,
|
|
TemplateZones,
|
|
TemplateRegions,
|
|
DbVersions
|
|
}
|
|
public const string UNINITIALIZED_STRING = "UNINITIALIZED_VALUE";
|
|
public delegate void SetStatusDelegate(string status, bool output = false);
|
|
public void WriteExportXML(string previousDir, string ExportFileName, SetStatusDelegate SetStatus)
|
|
{
|
|
SetStatus("Exporting");
|
|
|
|
var log = new System.Diagnostics.EventLog();
|
|
log.Source = "DataPROInstaller";
|
|
|
|
log.WriteEntry("Starting WriteExportXML");
|
|
|
|
PreviousDir = previousDir;
|
|
using (var sw = new StreamWriter(ExportFileName, false, Encoding.Unicode))// ; //UTF-16 Encoding.UTF8);
|
|
{
|
|
using (var xmlWriter = XmlWriter.Create(sw)) // ;
|
|
{
|
|
//double done = 0;
|
|
|
|
try
|
|
{
|
|
xmlWriter.WriteStartDocument();
|
|
|
|
xmlWriter.WriteStartElement("ExportFile");
|
|
|
|
xmlWriter.WriteAttributeString("Version", "2.0");
|
|
xmlWriter.WriteAttributeString("Software",
|
|
(System.Reflection.Assembly.GetEntryAssembly().GetName().Name));
|
|
xmlWriter.WriteAttributeString("SoftwareVersion",
|
|
(System.Reflection.Assembly.GetEntryAssembly().GetName().Version.ToString(4)));
|
|
|
|
var customers = CustomerDetailsList.CustomerList.Customers;
|
|
if (customers.Any())
|
|
{
|
|
log.WriteEntry("Writing " + customers.Count() + " " +
|
|
TopLevelFields.CustomerDetails.ToString());
|
|
|
|
xmlWriter.WriteStartElement(TopLevelFields.CustomerDetails.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
customers.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var cust in customers)
|
|
{
|
|
var elementNameValuePairs = cust.GetISOCustomer().GetValues();
|
|
AppendToXML(xmlWriter, "CustomerDetail", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Customers..." + counter + "/" + customers.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement();
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var testEngineers = TestEngineerDetailsList.TestEngineerList.TestEngineers;
|
|
if (testEngineers.Any())
|
|
{
|
|
log.WriteEntry("Writing " + testEngineers.Count() + " " +
|
|
TopLevelFields.TestEngineerDetails.ToString());
|
|
|
|
xmlWriter.WriteStartElement(TopLevelFields.TestEngineerDetails.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
testEngineers.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var ted in testEngineers)
|
|
{
|
|
var elementNameValuePairs = ted.GetISOTestEngineer().GetValues();
|
|
AppendToXML(xmlWriter, "TestEngineerDetail", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting TestEngineers..." + counter + "/" + testEngineers.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement();
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var labs = LabratoryDetailsList.LabratoryList.Labs;
|
|
if (labs.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.LabDetails.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
labs.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var ld in labs)
|
|
{
|
|
var elementNameValuePairs = ld.GetIsoLab().GetValues();
|
|
AppendToXML(xmlWriter, "LabDetail", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Laboratories..." + counter + "/" + labs.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement();
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var includedDAS = DASHardwareList.GetList().Hardware;
|
|
if (includedDAS.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.DASList.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedDAS.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var h in includedDAS)
|
|
{
|
|
var elementNameValuePairs = h.GetValues();
|
|
AppendToXML(xmlWriter, "DASHardware", elementNameValuePairs, false);
|
|
foreach (var channel in h.Channels)
|
|
{
|
|
elementNameValuePairs = h.GetChannelValues(channel);
|
|
AppendToXML(xmlWriter, "DASChannel", elementNameValuePairs, true);
|
|
}
|
|
xmlWriter.WriteEndElement();
|
|
xmlWriter.Flush();
|
|
counter++;
|
|
SetStatus("Exporting DAS..." + counter + "/" + includedDAS.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement();
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
//Tags must be stored in the database before Sensors are imported so that the Tag IDs can be found
|
|
var allTags = GetAllTags();
|
|
if (allTags.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.Tags.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
allTags.Count.ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var tagPair in allTags)
|
|
{
|
|
var elementNameValuePairs =
|
|
new Dictionary<string, string>
|
|
{
|
|
["TagText"] = tagPair[0],
|
|
["Obsolete"] = tagPair[1]
|
|
};
|
|
AppendToXML(xmlWriter, "Tag", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Tags..." + counter + "/" + allTags.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //Tag
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var includedSensorModels = SensorModelCollection.SensorModelList.SensorModels;
|
|
if (includedSensorModels.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.SensorModels.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedSensorModels.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var sm in includedSensorModels)
|
|
{
|
|
var elementNameValuePairs = sm.GetValues();
|
|
AppendToXML(xmlWriter, "SensorModel", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Sensor Models..." + counter + "/" + includedSensorModels.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //SensorModels
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var includedSensors = new Dictionary<string, SensorData>();
|
|
var sensors = SensorsCollection.SensorsList.AllSensorsDb;
|
|
//foreach (var sd in DTS.SensorDB.SensorsCollection.SensorsList.AllSensors)
|
|
//{
|
|
// includedSensors[sd.SerialNumber] = sd;
|
|
//}
|
|
var calibrationCounter = 0;
|
|
if (sensors.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.Sensors.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
sensors.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var sensor in sensors)
|
|
{
|
|
includedSensors[sensor.SerialNumber] = sensor; //For calibration below
|
|
var elementNameValuePairs = sensor.GetValues();
|
|
//AppendToXML(elementNameValuePairs, "SensorData", TopLevelFields.Sensors.ToString());
|
|
AppendToXML(xmlWriter, "SensorData", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Sensors..." + counter + "/" + sensors.Count() + " exported");
|
|
//done++;
|
|
calibrationCounter += SensorCalibrationList.GetCalibrationsBySerialNumber(sensor).Count();
|
|
}
|
|
xmlWriter.WriteEndElement();
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
using (var e = includedSensors.GetEnumerator())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.Calibrations.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
calibrationCounter.ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
while (e.MoveNext())
|
|
{
|
|
var calibrations = SensorCalibrationList.GetCalibrationsBySerialNumber(e.Current.Value);
|
|
if (!calibrations.Any()) continue;
|
|
//var counter = 0;
|
|
foreach (var calibration in calibrations)
|
|
{
|
|
var elementNameValuePairs = calibration.GetValues();
|
|
AppendToXML(xmlWriter, "SensorCalibration", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Sensor Calibrations..." + counter + "/" + calibrationCounter + " exported");
|
|
//done++;
|
|
}
|
|
}
|
|
xmlWriter.WriteEndElement(); //Calibrations
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
log.WriteEntry("Getting included Directions");
|
|
var includedDirections = ISO13499FileDb.IsoDb.GetDirections()
|
|
.Where(direction => direction.RecordType !=
|
|
MMEPossibleChannels.MMEChannelTypes.ISO13499_106)
|
|
.ToList();
|
|
log.WriteEntry("Got " + includedDirections.Count + " included Directions");
|
|
if (includedDirections.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.CustomDirections.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedDirections.Count.ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var dir in includedDirections)
|
|
{
|
|
var attributeNameValuePairs = GetDirectionAttributeValues(dir);
|
|
AppendAttributesToXML(xmlWriter, "CustomDirection", attributeNameValuePairs);
|
|
counter++;
|
|
SetStatus("Exporting Custom Directions..." + counter + "/" + includedDirections.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //CustomDirections
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var includedFilterClasses = ISO13499FileDb.IsoDb.GetFilterClasses()
|
|
.Where(fc => fc.RecordType != MMEPossibleChannels.MMEChannelTypes.ISO13499_106).ToList();
|
|
if (includedFilterClasses.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.CustomFilterClasses.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedFilterClasses.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var fc in includedFilterClasses)
|
|
{
|
|
//if (fc.RecordType == ISODll.MMEPossibleChannels.MMEChannelTypes.ISO13499_106) { continue; }
|
|
//includedFilterClasses[fc.Filter_Class] = fc;
|
|
var attributeNameValuePairs = GetFilterClassAttributeValues(fc);
|
|
AppendAttributesToXML(xmlWriter, "CustomFilterClass", attributeNameValuePairs);
|
|
counter++;
|
|
SetStatus("Exporting Custom Filter Classes..." + counter + "/" + includedFilterClasses.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //CustomFilterClasses
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var includedTestObjects = ISO13499FileDb.IsoDb.GetTestObjects(false)
|
|
.Where(isoto => isoto.RecordType != MMEPossibleChannels.MMEChannelTypes.ISO13499_106)
|
|
.ToList();
|
|
if (includedTestObjects.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.CustomTestObjects.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedTestObjects.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var isoto in includedTestObjects)
|
|
{
|
|
var attributeNameValuePairs = GetTestObjectAttributeValues(isoto);
|
|
AppendAttributesToXML(xmlWriter, "TestObject", attributeNameValuePairs);
|
|
counter++;
|
|
SetStatus("Exporting Custom Test Objects..." + counter + "/" + includedTestObjects.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //CustomTestObjects
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var includedFinLoc1s = ISO13499FileDb.IsoDb.GetFineLocations1()
|
|
.Where(finloc1 => finloc1.RecordType != MMEPossibleChannels.MMEChannelTypes.ISO13499_106)
|
|
.ToList();
|
|
if (includedFinLoc1s.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.CustomFinLoc1s.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedFinLoc1s.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var finloc1 in includedFinLoc1s)
|
|
{
|
|
var attributeNameValuePairs = GetFineLoc1AttributeValues(finloc1);
|
|
AppendAttributesToXML(xmlWriter, "FineLocation1", attributeNameValuePairs);
|
|
counter++;
|
|
SetStatus("Exporting Custom Fine Location1s..." + counter + "/" + includedFinLoc1s.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //CustomFinLoc1s
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var includedFinLoc2s = ISO13499FileDb.IsoDb.GetFineLocations2()
|
|
.Where(finloc2 => finloc2.RecordType != MMEPossibleChannels.MMEChannelTypes.ISO13499_106)
|
|
.ToList();
|
|
if (includedFinLoc2s.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.CustomFinLoc2s.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedFinLoc2s.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var finloc2 in includedFinLoc2s)
|
|
{
|
|
var attributeNameValuePairs = GetFineLoc2AttributeValues(finloc2);
|
|
AppendAttributesToXML(xmlWriter, "FineLocation2", attributeNameValuePairs);
|
|
counter++;
|
|
SetStatus("Exporting Custom Fine Location2s..." + counter + "/" + includedFinLoc2s.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //CustomFinLoc2s
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var includedFinLoc3s = ISO13499FileDb.IsoDb.GetFineLocations3()
|
|
.Where(finloc3 => finloc3.RecordType != MMEPossibleChannels.MMEChannelTypes.ISO13499_106)
|
|
.ToList();
|
|
if (includedFinLoc3s.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.CustomFinLoc3s.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedFinLoc3s.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var finloc3 in includedFinLoc3s)
|
|
{
|
|
var attributeNameValuePairs = GetFineLoc3AttributeValues(finloc3);
|
|
AppendAttributesToXML(xmlWriter, "FineLocation3", attributeNameValuePairs);
|
|
counter++;
|
|
SetStatus("Exporting Custom Fine Location3s..." + counter + "/" + includedFinLoc3s.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //CustomFinLoc2s
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
//var includedMainLocs = (App.Current as App).IsoDb.GetMainLocations();
|
|
var includedMainLocs = ISO13499FileDb.IsoDb.GetMainLocations()
|
|
.Where(mainloc => mainloc.RecordType != MMEPossibleChannels.MMEChannelTypes.ISO13499_106)
|
|
.ToList();
|
|
if (includedMainLocs.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.CustomMainLocs.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedMainLocs.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var mainloc in includedMainLocs)
|
|
{
|
|
var attributeNameValuePairs = GetMainLocationAttributeValues(mainloc);
|
|
AppendAttributesToXML(xmlWriter, "TransducerMainLocation", attributeNameValuePairs);
|
|
counter++;
|
|
SetStatus("Exporting Custom Main Locations..." + counter + "/" + includedMainLocs.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //CustomMainLocs
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var includedDimensions = ISO13499FileDb.IsoDb.GetPhysicalDimensions()
|
|
.Where(dim => dim.RecordType != MMEPossibleChannels.MMEChannelTypes.ISO13499_106).ToList();
|
|
if (includedDimensions.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.CustomPhysicalDimensions.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedDimensions.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var dim in includedDimensions)
|
|
{
|
|
var attributeNameValuePairs = GetPhysicalDimensionAttributeValues(dim);
|
|
AppendAttributesToXML(xmlWriter, "PhysicalDimension", attributeNameValuePairs);
|
|
counter++;
|
|
SetStatus("Exporting Custom Physical Dimensions..." + counter + "/" + includedDimensions.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //CustomPhysicalDimensions
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var includedPositions = ISO13499FileDb.IsoDb.GetPositions()
|
|
.Where(pos => pos.RecordType != MMEPossibleChannels.MMEChannelTypes.ISO13499_106).ToList();
|
|
if (includedPositions.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.CustomPositions.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedPositions.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var pos in includedPositions)
|
|
{
|
|
var attributeNameValuePairs = GetPositionAttributeValues(pos);
|
|
AppendAttributesToXML(xmlWriter, "Position", attributeNameValuePairs);
|
|
counter++;
|
|
SetStatus("Exporting Custom Positions..." + counter + "/" + includedPositions.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //CustomPositions
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var includedCustomChannels = CustomChannelList.List.AllChannels;
|
|
if (includedCustomChannels.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.CustomChannels.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
includedCustomChannels.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var cc in includedCustomChannels)
|
|
{
|
|
var elementNameValuePairs = cc.GetValues();
|
|
AppendToXML(xmlWriter, "CustomChannel", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Custom Channels..." + counter + "/" + includedCustomChannels.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //CustomChannels
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var groupTemplateTableInfoList =
|
|
TestObjectTemplateCollection.TemplateCollection.GetAllTemplates();
|
|
if (groupTemplateTableInfoList.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.GroupTemplates.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
groupTemplateTableInfoList.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var groupTemplateTableInfo in groupTemplateTableInfoList)
|
|
{
|
|
var groupTemplate =
|
|
TestObjectTemplateCollection.TemplateCollection.GetTemplate(groupTemplateTableInfo
|
|
.TemplateName);
|
|
var elementNameValuePairs = groupTemplate.GetValues();
|
|
AppendToXML(xmlWriter, "GroupTemplate", elementNameValuePairs, false);
|
|
|
|
xmlWriter.WriteStartElement("TemplateChannels");
|
|
|
|
foreach (var templateChannel in groupTemplate.ToISOTestObjectTemplate().Channels)
|
|
{
|
|
elementNameValuePairs = groupTemplate.GetTemplateChannelValues(templateChannel);
|
|
AppendToXML(xmlWriter, "TemplateChannel", elementNameValuePairs, true);
|
|
}
|
|
xmlWriter.WriteEndElement(); //TemplateChannels
|
|
xmlWriter.Flush();
|
|
xmlWriter.WriteEndElement(); //GroupTemplate
|
|
xmlWriter.Flush();
|
|
counter++;
|
|
SetStatus("Exporting Group Templates..." + counter + "/" + groupTemplateTableInfoList.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //GroupTemplates
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var groupSerialNumbers = TestObjectList.TestObjectsList.GetAllGroupSerialNumbers();
|
|
if (groupSerialNumbers.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.Groups.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
groupSerialNumbers.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var serialNumber in groupSerialNumbers)
|
|
{
|
|
var group = TestObjectList.TestObjectsList.GetTestObject(serialNumber);
|
|
|
|
var elementNameValuePairs = group.GetValues();
|
|
AppendToXML(xmlWriter, "TestObject", elementNameValuePairs, false);
|
|
|
|
xmlWriter.WriteStartElement("HardwareList");
|
|
|
|
var attributeNameValuePairs = new Dictionary<string, string>();
|
|
|
|
foreach (var h in group.Hardware)
|
|
{
|
|
var isoh = h.GetHardware();
|
|
attributeNameValuePairs["Id"] = isoh.GetId();
|
|
attributeNameValuePairs["LocalOnly"] = h.LocalOnly.ToString();
|
|
|
|
AppendAttributesToXML(xmlWriter, "Hardware", attributeNameValuePairs);
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //HardwareList
|
|
xmlWriter.Flush();
|
|
|
|
xmlWriter.WriteStartElement("Sensors");
|
|
|
|
attributeNameValuePairs.Clear();
|
|
var isoTestObject = group.GetISOTestObject();
|
|
foreach (var ch in isoTestObject.AllChannels)
|
|
{
|
|
if (!ch.Required || string.IsNullOrEmpty(ch.SensorSerialNumber)) continue;
|
|
attributeNameValuePairs["ChId"] = ch.GetID();
|
|
attributeNameValuePairs["SId"] = ch.SensorSerialNumber;
|
|
attributeNameValuePairs["HId"] = ch.HardwareId;
|
|
attributeNameValuePairs["LocalOnly"] = ch.LocalOnly.ToString();
|
|
|
|
AppendAttributesToXML(xmlWriter, "Sensor", attributeNameValuePairs);
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //Sensors
|
|
xmlWriter.Flush();
|
|
|
|
xmlWriter.WriteStartElement("ChannelSettings");
|
|
|
|
attributeNameValuePairs.Clear();
|
|
foreach (var ch in isoTestObject.AllChannels)
|
|
{
|
|
if (!ch.Required || string.IsNullOrWhiteSpace(ch.SensorSerialNumber)) continue;
|
|
var channelSettings =
|
|
isoTestObject.GetSensorSettings(ch.Name, ch.SensorSerialNumber);
|
|
if (null == channelSettings || channelSettings.Length <= 0) continue;
|
|
attributeNameValuePairs["ChId"] = ch.GetID();
|
|
attributeNameValuePairs["SId"] = ch.SensorSerialNumber;
|
|
attributeNameValuePairs["Setting"] =
|
|
isoTestObject.GetSerializedSetting(channelSettings);
|
|
|
|
AppendAttributesToXML(xmlWriter, "ChannelSetting", attributeNameValuePairs);
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //ChannelSettings
|
|
xmlWriter.Flush();
|
|
|
|
xmlWriter.WriteEndElement(); //TestObject
|
|
xmlWriter.Flush();
|
|
counter++;
|
|
SetStatus("Exporting Groups..." + counter + "/" + groupSerialNumbers.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //Groups
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
|
|
var testSetups = TestTemplateList.TestTemplatesList.GetAllTemplates();
|
|
if (testSetups.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.TestSetups.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
testSetups.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var tt in testSetups)
|
|
{
|
|
var test = TestTemplateList.TestTemplatesList.GetTemplate(tt.Name);
|
|
if (!test.IsLoaded)
|
|
{
|
|
test.Load();
|
|
}
|
|
|
|
//Add an extraneous <TestSetup>
|
|
var elementNameValuePairs = new Dictionary<string, string>();
|
|
xmlWriter.WriteStartElement("TestSetup");
|
|
xmlWriter.Flush();
|
|
|
|
xmlWriter.WriteStartElement("AddedGroups");
|
|
xmlWriter.Flush();
|
|
|
|
|
|
//<AddedGroups>
|
|
foreach (var addedGroup in test.AddedGroups)
|
|
{
|
|
elementNameValuePairs = test.GetTestObjectValues(addedGroup);
|
|
AppendToXML(xmlWriter, "TestObject", elementNameValuePairs, false);
|
|
|
|
foreach (var channel in addedGroup.GetISOTestObject().AllChannels)
|
|
{
|
|
if (!channel.Required || string.IsNullOrWhiteSpace(channel.SensorSerialNumber))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var sd = test.GetSensor(channel.SensorSerialNumber, addedGroup.SerialNumber,
|
|
channel.Name);
|
|
if (null == sd)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
elementNameValuePairs = test.GetChannelSettingValues(addedGroup, channel, sd);
|
|
AppendToXML(xmlWriter, "ChannelSettings", elementNameValuePairs, true);
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //TestObject
|
|
xmlWriter.Flush();
|
|
}
|
|
xmlWriter.WriteEndElement(); //AddedGroups
|
|
xmlWriter.Flush();
|
|
|
|
//<TestObjects>
|
|
xmlWriter.WriteStartElement("TestObjects");
|
|
xmlWriter.Flush();
|
|
|
|
foreach (var testObject in test.TestObjects)
|
|
{
|
|
elementNameValuePairs = test.GetTestObjectValues(testObject);
|
|
AppendToXML(xmlWriter, "TestObject", elementNameValuePairs, false);
|
|
|
|
foreach (var channel in testObject.GetISOTestObject().AllChannels)
|
|
{
|
|
if (!channel.Required || string.IsNullOrWhiteSpace(channel.SensorSerialNumber))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var sd = test.GetSensor(channel.SensorSerialNumber, testObject.SerialNumber,
|
|
channel.Name);
|
|
if (null == sd)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
elementNameValuePairs = test.GetChannelSettingValues(testObject, channel, sd);
|
|
AppendToXML(xmlWriter, "ChannelSettings", elementNameValuePairs, true);
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //TestObject
|
|
xmlWriter.Flush();
|
|
}
|
|
xmlWriter.WriteEndElement(); //TestObjects
|
|
xmlWriter.Flush();
|
|
|
|
//<Graphs>
|
|
xmlWriter.WriteStartElement("Graphs");
|
|
xmlWriter.Flush();
|
|
|
|
foreach (var graph in test.TestGraphs)
|
|
{
|
|
elementNameValuePairs = test.GetGraphValues(graph);
|
|
AppendToXML(xmlWriter, "Graph", elementNameValuePairs, true);
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //Graphs
|
|
xmlWriter.Flush();
|
|
|
|
//<Fields>
|
|
elementNameValuePairs = test.GetFieldValues();
|
|
AppendToXML(xmlWriter, "Fields", elementNameValuePairs, true);
|
|
|
|
//<HardwareOverrides>
|
|
if (test._hardwareOverrides.Count > 0)
|
|
{
|
|
xmlWriter.WriteStartElement("HardwareOverrides");
|
|
xmlWriter.Flush();
|
|
|
|
using (var e = test._hardwareOverrides.GetEnumerator())
|
|
{
|
|
while (e.MoveNext())
|
|
{
|
|
var attributeNameValuePairs =
|
|
test.GetHardwareOverrideValues(e.Current.Value);
|
|
AppendAttributesToXML(xmlWriter, "HardwareOverrides",
|
|
attributeNameValuePairs);
|
|
}
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //HardwareOverrides
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
//<CalculatedChannels>
|
|
if (test._calculatedChannels.Count > 0)
|
|
{
|
|
xmlWriter.WriteStartElement("CalculatedChannels");
|
|
xmlWriter.Flush();
|
|
|
|
foreach (var cc in test._calculatedChannels)
|
|
{
|
|
var attributeNameValuePairs = test.GetCalculatedChannelValues(cc);
|
|
AppendAttributesToXML(xmlWriter, "CalculatedChannel", attributeNameValuePairs);
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //CalculatedChannels
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
//<LevelTriggers>
|
|
if (test.LevelTriggerChannels.Count > 0)
|
|
{
|
|
xmlWriter.WriteStartElement("LevelTriggers");
|
|
xmlWriter.Flush();
|
|
|
|
using (var e = test.LevelTriggerChannels.GetEnumerator())
|
|
{
|
|
while (e.MoveNext())
|
|
{
|
|
var attributeNameValuePairs = test.GetLevelTriggerValues(e.Current.Value);
|
|
AppendAttributesToXML(xmlWriter, "LevelTrigger", attributeNameValuePairs);
|
|
}
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //LevelTriggers
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
//<MetaDatas>
|
|
xmlWriter.WriteStartElement("MetaDatas");
|
|
xmlWriter.Flush();
|
|
|
|
var testMeta = test.GetTestMetaData();
|
|
foreach (var prop in testMeta.Properties)
|
|
{
|
|
var attributeNameValuePairs = test.GetMetaDataValues(testMeta, prop);
|
|
AppendAttributesToXML(xmlWriter, "MetaData", attributeNameValuePairs);
|
|
}
|
|
|
|
var toMetaDatas = test.GetMetaData();
|
|
foreach (var toMetaData in toMetaDatas)
|
|
{
|
|
foreach (var prop in toMetaData.Properties)
|
|
{
|
|
var attributeNameValuePairs = test.GetMetaDataValues(toMetaData, prop);
|
|
AppendAttributesToXML(xmlWriter, "MetaData", attributeNameValuePairs);
|
|
}
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //MetaDatas
|
|
xmlWriter.Flush();
|
|
|
|
//<DASSettings>
|
|
xmlWriter.WriteStartElement("DASSettings");
|
|
xmlWriter.Flush();
|
|
|
|
foreach (var setting in test.DASSettings)
|
|
{
|
|
elementNameValuePairs = test.GetDASSettingsValues(setting);
|
|
AppendToXML(xmlWriter, "DASSetting", elementNameValuePairs, true);
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //DASSettings
|
|
xmlWriter.Flush();
|
|
|
|
counter++;
|
|
SetStatus("Exporting Test Setups..." + counter + "/" + testSetups.Count() + " exported");
|
|
//done++;
|
|
|
|
test.UnLoad();
|
|
|
|
xmlWriter.WriteEndElement(); //TestSetup
|
|
xmlWriter.Flush();
|
|
}
|
|
testSetups.ToList().Clear();
|
|
|
|
xmlWriter.WriteEndElement(); //TestSetups
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var uiItems = GetAllUIItems();
|
|
if (uiItems.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.UIItems.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
uiItems.Count.ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var idNamePair in uiItems)
|
|
{
|
|
var elementNameValuePairs =
|
|
new Dictionary<string, string>
|
|
{
|
|
["ID"] = idNamePair[0],
|
|
["NAME"] = idNamePair[1]
|
|
};
|
|
AppendToXML(xmlWriter, "UIItem", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting UIItems..." + counter + "/" + uiItems.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //UIItems
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var users = GetAllUsers();
|
|
if (users.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.Users.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
users.Count.ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var user in users)
|
|
{
|
|
var elementNameValuePairs = user.GetValues();
|
|
AppendToXML(xmlWriter, "User", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Users..." + counter + "/" + users.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //Users
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var uiItemSettings = GetAllUIItemSettings();
|
|
if (uiItemSettings.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.UIItemSettings.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
uiItemSettings.Count.ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var uiItemSetting in uiItemSettings)
|
|
{
|
|
var elements =
|
|
new Dictionary<string, string>
|
|
{
|
|
["UserID"] = uiItemSetting[0],
|
|
["UIItemID"] = uiItemSetting[1],
|
|
["Permission"] = uiItemSetting[2],
|
|
["Visible"] = uiItemSetting[3]
|
|
};
|
|
AppendToXML(xmlWriter, "UIItemSetting", elements, true);
|
|
counter++;
|
|
SetStatus("Exporting UIItemSettings..." + counter + "/" + uiItemSettings.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //UIItemSettings
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var settings = Enum.GetValues(typeof(SerializedSettings.Keys)).Cast<SerializedSettings.Keys>().ToArray();
|
|
var settingsList = new List<string>();
|
|
foreach (var setting in settings)
|
|
{
|
|
settingsList.Add(setting.ToString());
|
|
}
|
|
//TDAS AAF Rates
|
|
settingsList.Add("0_x_-1");
|
|
settingsList.Add("0_x_5");
|
|
settingsList.Add("0_x_50");
|
|
settingsList.Add("0_x_100");
|
|
settingsList.Add("0_x_200");
|
|
settingsList.Add("0_x_250");
|
|
settingsList.Add("0_x_500");
|
|
settingsList.Add("0_x_1000");
|
|
settingsList.Add("0_x_2000");
|
|
settingsList.Add("0_x_2500");
|
|
settingsList.Add("0_x_5000");
|
|
settingsList.Add("0_x_8000");
|
|
settingsList.Add("0_x_10000");
|
|
settingsList.Add("0_x_12500");
|
|
settingsList.Add("0_x_20000");
|
|
settingsList.Add("0_x_25000");
|
|
settingsList.Add("0_x_38000");
|
|
settingsList.Add("0_x_40000");
|
|
settingsList.Add("0_x_50000");
|
|
settingsList.Add("0_x_60000");
|
|
settingsList.Add("0_x_75000");
|
|
settingsList.Add("0_x_100000");
|
|
settingsList.Add("0_x_150000");
|
|
settingsList.Add("0_x_300000");
|
|
settingsList.Add("0_x_400000");
|
|
settingsList.Add("0_x_500000");
|
|
//Slice AAF Rates
|
|
settingsList.Add("1_x_5");
|
|
settingsList.Add("1_x_50");
|
|
settingsList.Add("1_x_100");
|
|
settingsList.Add("1_x_200");
|
|
settingsList.Add("1_x_250");
|
|
settingsList.Add("1_x_500");
|
|
settingsList.Add("1_x_1000");
|
|
settingsList.Add("1_x_2000");
|
|
settingsList.Add("1_x_2500");
|
|
settingsList.Add("1_x_5000");
|
|
settingsList.Add("1_x_8000");
|
|
settingsList.Add("1_x_10000");
|
|
settingsList.Add("1_x_12500");
|
|
settingsList.Add("1_x_20000");
|
|
settingsList.Add("1_x_25000");
|
|
settingsList.Add("1_x_40000");
|
|
settingsList.Add("1_x_50000");
|
|
settingsList.Add("1_x_60000");
|
|
settingsList.Add("1_x_75000");
|
|
settingsList.Add("1_x_100000");
|
|
settingsList.Add("1_x_150000");
|
|
settingsList.Add("1_x_300000");
|
|
settingsList.Add("1_x_400000");
|
|
settingsList.Add("1_x_500000");
|
|
|
|
//we may need to make sure all global settings are initialized since they are allowed to have default values...
|
|
//and may therefor not have been set yet?
|
|
//if so write a InitializeAllGlobalSettingsFunction here
|
|
if (settings.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.GlobalSettings.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems", settings.Count().ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
//foreach (var setting in settings)
|
|
foreach (var setting in settingsList)
|
|
{
|
|
var sValue = SettingsDB.GetGlobalValue(setting.ToString(), UNINITIALIZED_STRING);
|
|
if (sValue == UNINITIALIZED_STRING) continue;
|
|
var elementNameValuePairs =
|
|
new Dictionary<string, string>
|
|
{
|
|
["SettingName"] = setting.ToString(),
|
|
["SettingValue"] = sValue
|
|
};
|
|
AppendToXML(xmlWriter, "Setting", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Global Settings..." + counter + "/" + settings.Count() + " exported");
|
|
//done++;
|
|
}
|
|
//writer.WriteEndElement();
|
|
xmlWriter.WriteEndElement(); //GlobalSettings
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var allLastUsedHardware = GetAllLastUsedHardware();
|
|
if (allLastUsedHardware.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.LastUsedHardware.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
allLastUsedHardware.Count.ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var userHardwarePair in allLastUsedHardware)
|
|
{
|
|
int.TryParse(userHardwarePair[0], out int result);
|
|
var elementNameValuePairs =
|
|
new Dictionary<string, string>
|
|
{
|
|
["UserName"] = GetUserNameFromId(result),
|
|
["HardwareId"] = userHardwarePair[1]
|
|
};
|
|
AppendToXML(xmlWriter, "UserHardware", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Last Used Hardware..." + counter + "/" + allLastUsedHardware.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //LastUsedHardware
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
//var allTags = GetAllTags();
|
|
//if (allTags.Any())
|
|
//{
|
|
// xmlWriter.WriteStartElement(TopLevelFields.Tags.ToString());
|
|
// xmlWriter.WriteAttributeString("TotalItems",
|
|
// allTags.Count.ToString(CultureInfo.InvariantCulture));
|
|
// xmlWriter.Flush();
|
|
// var counter = 0;
|
|
// foreach (var tagPair in allTags)
|
|
// {
|
|
// var elementNameValuePairs =
|
|
// new Dictionary<string, string>
|
|
// {
|
|
// ["TagText"] = tagPair[0],
|
|
// ["Obsolete"] = tagPair[1]
|
|
// };
|
|
// AppendToXML(xmlWriter, "Tag", elementNameValuePairs, true);
|
|
// counter++;
|
|
// SetStatus("Exporting Tags..." + counter + "/" + allTags.Count() + " exported");
|
|
// //done++;
|
|
// }
|
|
// xmlWriter.WriteEndElement(); //Tag
|
|
// xmlWriter.Flush();
|
|
//}
|
|
|
|
var allTagAssignments = GetAllTagAssignments();
|
|
if (allTagAssignments.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.TagAssignments.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
allTagAssignments.Count.ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var tagAssignment in allTagAssignments)
|
|
{
|
|
var elementNameValuePairs = GetTagAssignmentValues(tagAssignment);
|
|
AppendToXML(xmlWriter, "TagAssignment", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Tag Assignments..." + counter + "/" + allTagAssignments.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //TagAssignments
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var allTemplateZones = GetAllTemplateZones();
|
|
if (allTemplateZones.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.TemplateZones.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
allTemplateZones.Count.ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var templateZone in allTemplateZones)
|
|
{
|
|
var elementNameValuePairs = GetTemplateZoneAssignmentValues(templateZone);
|
|
AppendToXML(xmlWriter, "TemplateZone", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Template Zones..." + counter + "/" + allTemplateZones.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //TemplateZones
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var allTemplateRegions = GetAllTemplateRegions();
|
|
if (allTemplateRegions.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.TemplateRegions.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
allTemplateRegions.Count.ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var templateRegion in allTemplateRegions)
|
|
{
|
|
var elementNameValuePairs = GetTemplateRegionAssignmentValues(templateRegion);
|
|
AppendToXML(xmlWriter, "TemplateRegion", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Template Regions..." + counter + "/" + allTemplateRegions.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //TemplateRegions
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
var allDbVersions = GetAllDbVersions();
|
|
if (allDbVersions.Any())
|
|
{
|
|
xmlWriter.WriteStartElement(TopLevelFields.DbVersions.ToString());
|
|
xmlWriter.WriteAttributeString("TotalItems",
|
|
allDbVersions.Count.ToString(CultureInfo.InvariantCulture));
|
|
xmlWriter.Flush();
|
|
var counter = 0;
|
|
foreach (var dbVersion in allDbVersions)
|
|
{
|
|
var elementNameValuePairs = GetDbVersionAssignmentValues(dbVersion);
|
|
AppendToXML(xmlWriter, "DbVersion", elementNameValuePairs, true);
|
|
counter++;
|
|
SetStatus("Exporting Database Versions..." + counter + "/" + allDbVersions.Count() + " exported");
|
|
//done++;
|
|
}
|
|
xmlWriter.WriteEndElement(); //DbVersions
|
|
xmlWriter.Flush();
|
|
}
|
|
|
|
xmlWriter.WriteEndElement(); //exportdocument
|
|
xmlWriter.WriteEndDocument();
|
|
|
|
xmlWriter.Flush();
|
|
xmlWriter.Close();
|
|
|
|
SetStatus("Database export has finished");
|
|
//SetStatus(ExportTestSetup.PossibleStatus.Done, string.Empty);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new Exception(ex.Message + " " + ex.StackTrace);
|
|
//MessageBox.Show("Database export failed: " + ex.Message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
private void AppendToXML(XmlWriter xmlWriter, string elementName, Dictionary<string, string> elementNameValuePairs, bool writeEndElement)
|
|
{
|
|
xmlWriter.WriteStartElement(elementName);
|
|
foreach (var pair in elementNameValuePairs)
|
|
{
|
|
xmlWriter.WriteElementString(pair.Key, pair.Value);
|
|
}
|
|
if (writeEndElement)
|
|
{
|
|
xmlWriter.WriteEndElement();
|
|
xmlWriter.Flush();
|
|
}
|
|
}
|
|
private void AppendAttributesToXML(XmlWriter xmlWriter, string elementName, Dictionary<string, string> attributeNameValuePairs)
|
|
{
|
|
xmlWriter.WriteStartElement(elementName);
|
|
foreach (var pair in attributeNameValuePairs)
|
|
{
|
|
xmlWriter.WriteAttributeString(pair.Key, pair.Value);
|
|
}
|
|
xmlWriter.WriteEndElement();
|
|
xmlWriter.Flush();
|
|
}
|
|
static readonly bool IS64_BIT_PROCESS = (IntPtr.Size == 8);
|
|
public bool Is646bitProcess => IS64_BIT_PROCESS;
|
|
public static ISO13499FileDb _isoDb;
|
|
public static string PreviousDir = string.Empty;
|
|
/// <summary>
|
|
/// different tags for an ISODll.MMEDirection
|
|
/// </summary>
|
|
public enum CustomDirectionFields
|
|
{
|
|
Direction,
|
|
Expired,
|
|
History,
|
|
Last_Change,
|
|
Last_Change_Text,
|
|
Remarks,
|
|
GUID,
|
|
SortKey,
|
|
Text_L1,
|
|
Text_L2,
|
|
Version
|
|
}
|
|
public Dictionary<string, string> GetDirectionAttributeValues(MMEDirections d)
|
|
{
|
|
var attributeNameValuePairs = new Dictionary<string, string>();
|
|
|
|
attributeNameValuePairs[CustomDirectionFields.Direction.ToString()] = d.Direction;
|
|
attributeNameValuePairs[CustomDirectionFields.Expired.ToString()] = d.Expired.ToString();
|
|
attributeNameValuePairs[CustomDirectionFields.History.ToString()] = d.History;
|
|
attributeNameValuePairs[CustomDirectionFields.Last_Change.ToString()] = d.Last_Change.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[CustomDirectionFields.Last_Change_Text.ToString()] = d.Last_Change_Text;
|
|
attributeNameValuePairs[CustomDirectionFields.Remarks.ToString()] = d.Remarks;
|
|
attributeNameValuePairs[CustomDirectionFields.GUID.ToString()] = d.S_GUID;
|
|
attributeNameValuePairs[CustomDirectionFields.SortKey.ToString()] = d.SortKey;
|
|
attributeNameValuePairs[CustomDirectionFields.Text_L1.ToString()] = d.Text_L1;
|
|
attributeNameValuePairs[CustomDirectionFields.Text_L2.ToString()] = d.Text_L2;
|
|
attributeNameValuePairs[CustomDirectionFields.Version.ToString()] = d.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
|
|
return attributeNameValuePairs;
|
|
}
|
|
public List<string[]> GetAllUIItems()
|
|
{
|
|
var resultList = new List<string[]>();
|
|
using (var cmd = DbOperations.GetCommand())
|
|
{
|
|
cmd.CommandText = "SELECT [ID], [NAME] FROM [UIItems]";
|
|
using (var ds = DbOperations.Connection.QueryDataSet(cmd))
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
var id = Convert.ToString(dr["ID"]);
|
|
var name = Convert.ToString(dr["NAME"]);
|
|
var results = new[] { id, name };
|
|
resultList.Add(results);
|
|
}
|
|
}
|
|
cmd.Connection.Dispose();
|
|
}
|
|
return resultList;
|
|
}
|
|
private static List<User> GetAllUsers()
|
|
{
|
|
var allUsers = new List<User>();
|
|
try
|
|
{
|
|
using (var sql = DbOperations.GetCommand())
|
|
{
|
|
sql.CommandText = "SELECT * from [DataPROUsers]";
|
|
|
|
using (var ds = DbOperations.Connection.QueryDataSet(sql))
|
|
{
|
|
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
allUsers.Add(new User(dr));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//APILogger.Log("failed to retrieve Users", ex);
|
|
}
|
|
return allUsers;
|
|
}
|
|
private static List<string[]> GetAllUIItemSettings()
|
|
{
|
|
var resultList = new List<string[]>();
|
|
using (var cmd = DbOperations.GetCommand())
|
|
{
|
|
cmd.CommandText = "SELECT [UserID], [UIItemID], [Permission], [Visible] FROM [UserUIItemSettings] ORDER BY UserID, UIItemID";
|
|
using (var ds = DbOperations.Connection.QueryDataSet(cmd))
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
var userId = Convert.ToString(dr["UserID"]);
|
|
var uiItemId = Convert.ToString(dr["UIItemID"]);
|
|
var permission = Convert.ToString(dr["Permission"]);
|
|
var visible = Convert.ToString(dr["Visible"]);
|
|
var results = new[] { userId, uiItemId, permission, visible };
|
|
resultList.Add(results);
|
|
}
|
|
}
|
|
cmd.Connection.Dispose();
|
|
}
|
|
return resultList;
|
|
}
|
|
public List<string[]> GetAllLastUsedHardware()
|
|
{
|
|
var resultList = new List<string[]>();
|
|
using (var cmd = DbOperations.GetCommand())
|
|
{
|
|
cmd.CommandText = "SELECT [UserID], [HardwareID] FROM [LastUsedHardware]";
|
|
using (var ds = DbOperations.Connection.QueryDataSet(cmd))
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
var userId = Convert.ToString(dr["UserID"]);
|
|
var hardwareId = Convert.ToString(dr["HardwareID"]);
|
|
var results = new[] { userId, hardwareId };
|
|
resultList.Add(results);
|
|
}
|
|
}
|
|
}
|
|
return resultList;
|
|
}
|
|
private static string GetUserNameFromId(int id)
|
|
{
|
|
var user = string.Empty;
|
|
try
|
|
{
|
|
using (var cmd = DbOperations.GetCommand())
|
|
{
|
|
cmd.CommandText = "SELECT [UserName] FROM [DataPROUsers] WHERE [ID] = @1";
|
|
DbOperations.CreateParam(cmd, "@1", SqlDbType.Int, id);
|
|
using (var ds = DbOperations.Connection.QueryDataSet(cmd))
|
|
{
|
|
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
try
|
|
{
|
|
user = dr.ItemArray[0].ToString();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//APILogger.Log("Failed to read user", ex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//APILogger.Log("problem getting user", ex2);
|
|
}
|
|
return user;
|
|
}
|
|
private static List<string[]> GetAllTags()
|
|
{
|
|
var resultList = new List<string[]>();
|
|
using (var cmd = DbOperations.GetCommand())
|
|
{
|
|
cmd.CommandText = "SELECT [TagText], [Obsolete] FROM [tblTags]";
|
|
using (var ds = DbOperations.Connection.QueryDataSet(cmd))
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
var tagText = Convert.ToString(dr["TagText"]);
|
|
var obsolete = Convert.ToString(dr["Obsolete"]);
|
|
var results = new[] { tagText, obsolete };
|
|
resultList.Add(results);
|
|
}
|
|
}
|
|
}
|
|
return resultList;
|
|
}
|
|
private static string GetTagTextFromId(int id)
|
|
{
|
|
var tagText = string.Empty;
|
|
try
|
|
{
|
|
using (var cmd = DbOperations.GetCommand())
|
|
{
|
|
cmd.CommandText = "SELECT [TagText] FROM [tblTags] WHERE [TagId] = @1";
|
|
DbOperations.CreateParam(cmd, "@1", SqlDbType.Int, id);
|
|
using (var ds = DbOperations.Connection.QueryDataSet(cmd))
|
|
{
|
|
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
try
|
|
{
|
|
tagText = dr.ItemArray[0].ToString();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//APILogger.Log("Failed to read user", ex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//APILogger.Log("problem getting user", ex2);
|
|
}
|
|
return tagText;
|
|
}
|
|
private static string GetObjectNameFromId(int objectType, int objectId)
|
|
{
|
|
var objectName = string.Empty;
|
|
try
|
|
{
|
|
using (var cmd = DbOperations.GetCommand())
|
|
{
|
|
if (objectType == 0)
|
|
{
|
|
//User
|
|
cmd.CommandText = "SELECT [UserName] FROM [DataPROUsers] WHERE [ID] = @1";
|
|
DbOperations.CreateParam(cmd, "@1", SqlDbType.Int, objectId);
|
|
using (var ds = DbOperations.Connection.QueryDataSet(cmd))
|
|
{
|
|
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
try
|
|
{
|
|
objectName = dr.ItemArray[0].ToString();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//APILogger.Log("Failed to read user", ex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//TestObject, Template, TestSetup, Sensors, and SensorModels are
|
|
//all identified by their unique identifier
|
|
objectName = objectId.ToString();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//APILogger.Log("problem getting user", ex2);
|
|
}
|
|
return objectName;
|
|
}
|
|
private static List<string[]> GetAllTagAssignments()
|
|
{
|
|
var resultList = new List<string[]>();
|
|
using (var cmd = DbOperations.GetCommand())
|
|
{
|
|
cmd.CommandText = "SELECT [ObjectType], [ObjectID], [TagID] FROM [TagAssignments]";
|
|
using (var ds = DbOperations.Connection.QueryDataSet(cmd))
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
var objectType = Convert.ToString(dr["ObjectType"]);
|
|
var objectId = Convert.ToString(dr["ObjectID"]);
|
|
var tagId = Convert.ToString(dr["TagID"]);
|
|
var results = new[] { objectType, objectId, tagId };
|
|
resultList.Add(results);
|
|
}
|
|
}
|
|
}
|
|
return resultList;
|
|
}
|
|
private static Dictionary<string, string> GetTagAssignmentValues(string[] tagAssignment)
|
|
{
|
|
int.TryParse(tagAssignment[0], out var objectTypeResult);
|
|
int.TryParse(tagAssignment[1], out var objectIdResult);
|
|
int.TryParse(tagAssignment[2], out var tagIdResult);
|
|
var elementNameValuePairs = new Dictionary<string, string>
|
|
{
|
|
["ObjectType"] = tagAssignment[0],
|
|
["ObjectName"] = GetObjectNameFromId(objectTypeResult, objectIdResult),
|
|
["TagText"] = GetTagTextFromId(tagIdResult)
|
|
};
|
|
return elementNameValuePairs;
|
|
}
|
|
private static Dictionary<string, string> GetTemplateZoneAssignmentValues(TemplateZone templateZoneAssignment)
|
|
{
|
|
var elementNameValuePairs = new Dictionary<string, string>
|
|
{
|
|
["TemplateName"] = templateZoneAssignment.TemplateName,
|
|
["ZoneName"] = templateZoneAssignment.ZoneName,
|
|
["ZoneDescription"] = templateZoneAssignment.Description,
|
|
["Picture"] = templateZoneAssignment.Picture
|
|
};
|
|
return elementNameValuePairs;
|
|
}
|
|
private static List<TemplateZone> GetAllTemplateZones()
|
|
{
|
|
var allTemplateZones = new List<TemplateZone>();
|
|
try
|
|
{
|
|
using (var sql = DbOperations.GetCommand())
|
|
{
|
|
sql.CommandText = "SELECT * from [tblTemplateZones]";
|
|
|
|
using (var ds = DbOperations.Connection.QueryDataSet(sql))
|
|
{
|
|
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
allTemplateZones.Add(new TemplateZone(dr));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//APILogger.Log("failed to retrieve template zones", ex);
|
|
}
|
|
return allTemplateZones;
|
|
}
|
|
private static List<TemplateRegion> GetAllTemplateRegions()
|
|
{
|
|
var allTemplateRegions = new List<TemplateRegion>();
|
|
try
|
|
{
|
|
using (var sql = DbOperations.GetCommand())
|
|
{
|
|
sql.CommandText = "SELECT * from [tblTemplateRegions]";
|
|
|
|
using (var ds = DbOperations.Connection.QueryDataSet(sql))
|
|
{
|
|
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
allTemplateRegions.Add(new TemplateRegion(dr));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//APILogger.Log("failed to retrieve template regions", ex);
|
|
}
|
|
return allTemplateRegions;
|
|
}
|
|
private static Dictionary<string, string> GetTemplateRegionAssignmentValues(TemplateRegion templateRegionAssignment)
|
|
{
|
|
var elementNameValuePairs = new Dictionary<string, string>
|
|
{
|
|
["TemplateName"] = templateRegionAssignment.TemplateName,
|
|
["RegionNumber"] = templateRegionAssignment.RegionNumber.ToString(),
|
|
["RegionName"] = templateRegionAssignment.RegionName,
|
|
["RegionDescription"] = templateRegionAssignment.RegionDescription,
|
|
["TestObject"] = templateRegionAssignment.TestObject,
|
|
["Position"] = templateRegionAssignment.Position,
|
|
["MainLocation"] = templateRegionAssignment.MainLocation,
|
|
["FineLocation1"] = templateRegionAssignment.FineLocation1,
|
|
["FineLocation2"] = templateRegionAssignment.FineLocation2,
|
|
["FineLocation3"] = templateRegionAssignment.FineLocation3,
|
|
["PhysicalDimension"] = templateRegionAssignment.PhysicalDimension,
|
|
["Direction"] = templateRegionAssignment.Direction,
|
|
["FilterClass"] = templateRegionAssignment.FilterClass,
|
|
["LocalOnly"] = templateRegionAssignment.LocalOnly.ToString(),
|
|
["UpperLeftX"] = templateRegionAssignment.UpperLeft.X.ToString(),
|
|
["UpperLeftY"] = templateRegionAssignment.UpperLeft.Y.ToString(),
|
|
["LowerRightX"] = templateRegionAssignment.LowerRight.X.ToString(),
|
|
["LowerRightY"] = templateRegionAssignment.LowerRight.Y.ToString(),
|
|
["TemplateZone"] = templateRegionAssignment.TemplateZone
|
|
};
|
|
return elementNameValuePairs;
|
|
}
|
|
private static List<DbVersion> GetAllDbVersions()
|
|
{
|
|
var allDbVersions = new List<DbVersion>();
|
|
try
|
|
{
|
|
using (var sql = DbOperations.GetCommand())
|
|
{
|
|
sql.CommandText = "SELECT * from [tblDataPRODbVersion]";
|
|
|
|
using (var ds = DbOperations.Connection.QueryDataSet(sql))
|
|
{
|
|
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
allDbVersions.Add(new DbVersion(dr));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//APILogger.Log("failed to retrieve database versions", ex);
|
|
}
|
|
return allDbVersions;
|
|
}
|
|
private static Dictionary<string, string> GetDbVersionAssignmentValues(DbVersion dbVersionAssignment)
|
|
{
|
|
var elementNameValuePairs = new Dictionary<string, string>
|
|
{
|
|
["Version"] = dbVersionAssignment.Version.ToString(),
|
|
["Step"] = dbVersionAssignment.Step.ToString(),
|
|
["Date"] = dbVersionAssignment.Date.ToString(CultureInfo.InvariantCulture),
|
|
["Remarks"] = dbVersionAssignment.Remarks,
|
|
["UserField"] = dbVersionAssignment.UserField
|
|
};
|
|
return elementNameValuePairs;
|
|
}
|
|
/// <summary>
|
|
/// different tags for an ISODll.MME_FilterClass
|
|
/// </summary>
|
|
public enum CustomFilterFields
|
|
{
|
|
Date,
|
|
Expired,
|
|
Filter_Class,
|
|
History,
|
|
Last_Change,
|
|
Last_Change_Text,
|
|
Remarks,
|
|
S_GUID,
|
|
SortKey,
|
|
Text_L1,
|
|
Text_L2,
|
|
Version,
|
|
}
|
|
public Dictionary<string, string> GetFilterClassAttributeValues(MMEFilterClasses fc)
|
|
{
|
|
var attributeNameValuePairs = new Dictionary<string, string>();
|
|
|
|
attributeNameValuePairs[CustomFilterFields.Date.ToString()] = fc.Date.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[CustomFilterFields.Expired.ToString()] = fc.Expired.ToString();
|
|
attributeNameValuePairs[CustomFilterFields.Filter_Class.ToString()] = fc.Filter_Class;
|
|
attributeNameValuePairs[CustomFilterFields.History.ToString()] = fc.History;
|
|
attributeNameValuePairs[CustomFilterFields.Last_Change.ToString()] = fc.Last_Change.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[CustomFilterFields.Last_Change_Text.ToString()] = fc.Last_Change_Text;
|
|
attributeNameValuePairs[CustomFilterFields.Remarks.ToString()] = fc.Remarks;
|
|
attributeNameValuePairs[CustomFilterFields.S_GUID.ToString()] = fc.S_GUID;
|
|
attributeNameValuePairs[CustomFilterFields.SortKey.ToString()] = fc.SortKey;
|
|
attributeNameValuePairs[CustomFilterFields.Text_L1.ToString()] = fc.Text_L1;
|
|
attributeNameValuePairs[CustomFilterFields.Text_L2.ToString()] = fc.Text_L2;
|
|
attributeNameValuePairs[CustomFilterFields.Version.ToString()] = fc.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
|
|
return attributeNameValuePairs;
|
|
}
|
|
public enum TestObjectFields
|
|
{
|
|
s_GUID,
|
|
TEST_OBJECT,
|
|
TEXT_L1,
|
|
TEXT_L2,
|
|
VERSION,
|
|
DATE,
|
|
REMARKS,
|
|
EXPIRED,
|
|
SORTKEY,
|
|
LAST_CHANGE,
|
|
LAST_CHANGE_TEXT,
|
|
HISTORY
|
|
}
|
|
public Dictionary<string, string> GetTestObjectAttributeValues(MMETestObjects isoto)
|
|
{
|
|
var attributeNameValuePairs = new Dictionary<string, string>();
|
|
|
|
attributeNameValuePairs[TestObjectFields.s_GUID.ToString()] = isoto.S_GUID;
|
|
attributeNameValuePairs[TestObjectFields.TEST_OBJECT.ToString()] = isoto.Test_Object;
|
|
attributeNameValuePairs[TestObjectFields.TEXT_L1.ToString()] = isoto.Text_L1;
|
|
attributeNameValuePairs[TestObjectFields.TEXT_L2.ToString()] = isoto.Text_L2;
|
|
attributeNameValuePairs[TestObjectFields.VERSION.ToString()] = isoto.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[TestObjectFields.DATE.ToString()] = isoto.Date.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[TestObjectFields.REMARKS.ToString()] = isoto.Remarks;
|
|
attributeNameValuePairs[TestObjectFields.EXPIRED.ToString()] = isoto.Expired.ToString();
|
|
attributeNameValuePairs[TestObjectFields.SORTKEY.ToString()] = isoto.SortKey;
|
|
attributeNameValuePairs[TestObjectFields.LAST_CHANGE.ToString()] = isoto.Last_Change.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[TestObjectFields.LAST_CHANGE_TEXT.ToString()] = isoto.Last_Change_Text;
|
|
attributeNameValuePairs[TestObjectFields.HISTORY.ToString()] = isoto.History;
|
|
|
|
return attributeNameValuePairs;
|
|
}
|
|
public enum CustomFinLoc1Fields
|
|
{
|
|
Date,
|
|
Expired,
|
|
Fine_Loc_1,
|
|
History,
|
|
Last_Change,
|
|
Last_Change_Text,
|
|
Remarks,
|
|
S_GUID,
|
|
SortKey,
|
|
Text_L1,
|
|
Text_L2,
|
|
Version,
|
|
}
|
|
public Dictionary<string, string> GetFineLoc1AttributeValues(MMEFineLocations1 fineLoc1)
|
|
{
|
|
var attributeNameValuePairs = new Dictionary<string, string>();
|
|
|
|
attributeNameValuePairs[CustomFinLoc1Fields.Date.ToString()] = fineLoc1.Date.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[CustomFinLoc1Fields.Expired.ToString()] = fineLoc1.Expired.ToString();
|
|
attributeNameValuePairs[CustomFinLoc1Fields.Fine_Loc_1.ToString()] = fineLoc1.Fine_Loc_1;
|
|
attributeNameValuePairs[CustomFinLoc1Fields.History.ToString()] = fineLoc1.History;
|
|
attributeNameValuePairs[CustomFinLoc1Fields.Last_Change.ToString()] = fineLoc1.Last_Change.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[CustomFinLoc1Fields.Last_Change_Text.ToString()] = fineLoc1.Last_Change_Text;
|
|
attributeNameValuePairs[CustomFinLoc1Fields.Remarks.ToString()] = fineLoc1.Remarks;
|
|
attributeNameValuePairs[CustomFinLoc1Fields.S_GUID.ToString()] = fineLoc1.S_GUID;
|
|
attributeNameValuePairs[CustomFinLoc1Fields.SortKey.ToString()] = fineLoc1.SortKey;
|
|
attributeNameValuePairs[CustomFinLoc1Fields.Text_L1.ToString()] = fineLoc1.Text_L1;
|
|
attributeNameValuePairs[CustomFinLoc1Fields.Text_L2.ToString()] = fineLoc1.Text_L2;
|
|
attributeNameValuePairs[CustomFinLoc1Fields.Version.ToString()] = fineLoc1.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
|
|
return attributeNameValuePairs;
|
|
}
|
|
|
|
public enum CustomFinLoc2Fields
|
|
{
|
|
Date,
|
|
Expired,
|
|
Fine_Loc_2,
|
|
History,
|
|
Last_Change,
|
|
Last_Change_Text,
|
|
Remarks,
|
|
S_GUID,
|
|
SortKey,
|
|
Text_L1,
|
|
Text_L2,
|
|
Version,
|
|
}
|
|
public Dictionary<string, string> GetFineLoc2AttributeValues(MMEFineLocations2 fineLoc2)
|
|
{
|
|
var attributeNameValuePairs = new Dictionary<string, string>();
|
|
|
|
attributeNameValuePairs[CustomFinLoc2Fields.Date.ToString()] = fineLoc2.Date.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[CustomFinLoc2Fields.Expired.ToString()] = fineLoc2.Expired.ToString();
|
|
attributeNameValuePairs[CustomFinLoc2Fields.Fine_Loc_2.ToString()] = fineLoc2.FINE_LOC_2;
|
|
attributeNameValuePairs[CustomFinLoc2Fields.History.ToString()] = fineLoc2.History;
|
|
attributeNameValuePairs[CustomFinLoc2Fields.Last_Change.ToString()] = fineLoc2.Last_Change.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[CustomFinLoc2Fields.Last_Change_Text.ToString()] = fineLoc2.Last_Change_Text;
|
|
attributeNameValuePairs[CustomFinLoc2Fields.Remarks.ToString()] = fineLoc2.Remarks;
|
|
attributeNameValuePairs[CustomFinLoc2Fields.S_GUID.ToString()] = fineLoc2.S_GUID;
|
|
attributeNameValuePairs[CustomFinLoc2Fields.SortKey.ToString()] = fineLoc2.SortKey;
|
|
attributeNameValuePairs[CustomFinLoc2Fields.Text_L1.ToString()] = fineLoc2.Text_L1;
|
|
attributeNameValuePairs[CustomFinLoc2Fields.Text_L2.ToString()] = fineLoc2.Text_L2;
|
|
attributeNameValuePairs[CustomFinLoc2Fields.Version.ToString()] = fineLoc2.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
|
|
return attributeNameValuePairs;
|
|
}
|
|
|
|
/// <summary>
|
|
/// different tags for an ISODll.MMEFineLocation3
|
|
/// </summary>
|
|
public enum CustomFinLoc3Fields
|
|
{
|
|
Date,
|
|
Expired,
|
|
Fine_Loc_3,
|
|
History,
|
|
Last_Change,
|
|
Last_Change_Text,
|
|
Remarks,
|
|
S_GUID,
|
|
SortKey,
|
|
Text_L1,
|
|
Text_L2,
|
|
Version,
|
|
}
|
|
public Dictionary<string, string> GetFineLoc3AttributeValues(MMEFineLocations3 fineLoc3)
|
|
{
|
|
var attributeNameValuePairs = new Dictionary<string, string>();
|
|
|
|
attributeNameValuePairs[CustomFinLoc3Fields.Date.ToString()] = fineLoc3.Date.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[CustomFinLoc3Fields.Expired.ToString()] = fineLoc3.Expired.ToString();
|
|
attributeNameValuePairs[CustomFinLoc3Fields.Fine_Loc_3.ToString()] = fineLoc3.FINE_LOC_3;
|
|
attributeNameValuePairs[CustomFinLoc3Fields.History.ToString()] = fineLoc3.History;
|
|
attributeNameValuePairs[CustomFinLoc3Fields.Last_Change.ToString()] = fineLoc3.Last_Change.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[CustomFinLoc3Fields.Last_Change_Text.ToString()] = fineLoc3.Last_Change_Text;
|
|
attributeNameValuePairs[CustomFinLoc3Fields.Remarks.ToString()] = fineLoc3.Remarks;
|
|
attributeNameValuePairs[CustomFinLoc3Fields.S_GUID.ToString()] = fineLoc3.S_GUID;
|
|
attributeNameValuePairs[CustomFinLoc3Fields.SortKey.ToString()] = fineLoc3.SortKey;
|
|
attributeNameValuePairs[CustomFinLoc3Fields.Text_L1.ToString()] = fineLoc3.Text_L1;
|
|
attributeNameValuePairs[CustomFinLoc3Fields.Text_L2.ToString()] = fineLoc3.Text_L2;
|
|
attributeNameValuePairs[CustomFinLoc3Fields.Version.ToString()] = fineLoc3.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
|
|
return attributeNameValuePairs;
|
|
}
|
|
/// <summary>
|
|
/// different tags for an ISODll.MMETransducerMainLocation
|
|
/// </summary>
|
|
public enum MainLocationFields
|
|
{
|
|
Date,
|
|
Expired,
|
|
History,
|
|
Last_Change,
|
|
Last_Change_Text,
|
|
Picture_ShortName,
|
|
Remarks,
|
|
S_GUID,
|
|
SortKey,
|
|
Text_L1,
|
|
Text_L2,
|
|
Trans_Main_Loc,
|
|
Type,
|
|
Version
|
|
}
|
|
public Dictionary<string, string> GetMainLocationAttributeValues(MMETransducerMainLocation mainLocation)
|
|
{
|
|
var attributeNameValuePairs = new Dictionary<string, string>();
|
|
|
|
attributeNameValuePairs[MainLocationFields.Date.ToString()] = mainLocation.Date.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[MainLocationFields.Expired.ToString()] = mainLocation.Expired.ToString();
|
|
attributeNameValuePairs[MainLocationFields.History.ToString()] = mainLocation.History;
|
|
attributeNameValuePairs[MainLocationFields.Last_Change.ToString()] = mainLocation.Last_Change.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[MainLocationFields.Last_Change_Text.ToString()] = mainLocation.Last_Change_Text;
|
|
attributeNameValuePairs[MainLocationFields.Picture_ShortName.ToString()] = mainLocation.Picture_ShortName;
|
|
attributeNameValuePairs[MainLocationFields.Remarks.ToString()] = mainLocation.Remarks;
|
|
attributeNameValuePairs[MainLocationFields.S_GUID.ToString()] = mainLocation.S_GUID;
|
|
attributeNameValuePairs[MainLocationFields.SortKey.ToString()] = mainLocation.SortKey;
|
|
attributeNameValuePairs[MainLocationFields.Text_L1.ToString()] = mainLocation.Text_L1;
|
|
attributeNameValuePairs[MainLocationFields.Text_L2.ToString()] = mainLocation.Text_L2;
|
|
attributeNameValuePairs[MainLocationFields.Trans_Main_Loc.ToString()] = mainLocation.Trans_Main_Loc;
|
|
attributeNameValuePairs[MainLocationFields.Type.ToString()] = mainLocation.Type;
|
|
attributeNameValuePairs[MainLocationFields.Version.ToString()] = mainLocation.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
|
|
return attributeNameValuePairs;
|
|
}
|
|
/// <summary>
|
|
/// different tags for an ISODll.MMEPhysicalDimension
|
|
/// </summary>
|
|
public enum PhysicalDimensionFields
|
|
{
|
|
Amount_Of_Substance_EXP,
|
|
Date,
|
|
Default_Unit,
|
|
Electric_Current_EXP,
|
|
Expired,
|
|
History,
|
|
Last_Change,
|
|
Last_Change_Text,
|
|
Length_EXP,
|
|
Luminous_Intensity_Exp,
|
|
Mass_EXP,
|
|
Physical_Dimension,
|
|
RecordType,
|
|
Remarks,
|
|
S_GUID,
|
|
SortKey,
|
|
Temperature_EXP,
|
|
Text_L1,
|
|
Text_L2,
|
|
Time_EXP,
|
|
Version
|
|
}
|
|
public Dictionary<string, string> GetPhysicalDimensionAttributeValues(MMEPhysicalDimensions dimension)
|
|
{
|
|
var attributeNameValuePairs = new Dictionary<string, string>();
|
|
|
|
attributeNameValuePairs[PhysicalDimensionFields.Amount_Of_Substance_EXP.ToString()] = dimension.Amount_Of_Substance_EXP.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[PhysicalDimensionFields.Date.ToString()] = dimension.Date.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[PhysicalDimensionFields.Default_Unit.ToString()] = dimension.Default_Unit;
|
|
attributeNameValuePairs[PhysicalDimensionFields.Electric_Current_EXP.ToString()] = dimension.Electric_Current_EXP.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[PhysicalDimensionFields.Expired.ToString()] = dimension.Expired.ToString();
|
|
attributeNameValuePairs[PhysicalDimensionFields.History.ToString()] = dimension.History;
|
|
attributeNameValuePairs[PhysicalDimensionFields.Last_Change.ToString()] = dimension.Last_Change.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[PhysicalDimensionFields.Last_Change_Text.ToString()] = dimension.Last_Change_Text;
|
|
attributeNameValuePairs[PhysicalDimensionFields.Length_EXP.ToString()] = dimension.Length_EXP.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[PhysicalDimensionFields.Luminous_Intensity_Exp.ToString()] = dimension.Luminous_Intensity_Exp.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[PhysicalDimensionFields.Mass_EXP.ToString()] = dimension.Mass_EXP.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[PhysicalDimensionFields.Physical_Dimension.ToString()] = dimension.Physical_Dimension;
|
|
attributeNameValuePairs[PhysicalDimensionFields.RecordType.ToString()] = dimension.RecordType.ToString();
|
|
attributeNameValuePairs[PhysicalDimensionFields.Remarks.ToString()] = dimension.Remarks;
|
|
attributeNameValuePairs[PhysicalDimensionFields.S_GUID.ToString()] = dimension.S_GUID;
|
|
attributeNameValuePairs[PhysicalDimensionFields.SortKey.ToString()] = dimension.SortKey;
|
|
attributeNameValuePairs[PhysicalDimensionFields.Temperature_EXP.ToString()] = dimension.Temperature_EXP.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[PhysicalDimensionFields.Text_L1.ToString()] = dimension.Text_L1;
|
|
attributeNameValuePairs[PhysicalDimensionFields.Text_L2.ToString()] = dimension.Text_L2;
|
|
attributeNameValuePairs[PhysicalDimensionFields.Time_EXP.ToString()] = dimension.Time_EXP.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[PhysicalDimensionFields.Version.ToString()] = dimension.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
|
|
return attributeNameValuePairs;
|
|
}
|
|
|
|
/// <summary>
|
|
/// different tags for an ISODll.MMEPositions object
|
|
/// </summary>
|
|
public enum PositionFields
|
|
{
|
|
Date,
|
|
Expired,
|
|
History,
|
|
Last_Change,
|
|
Last_Change_Text,
|
|
Position,
|
|
RecordType,
|
|
Remarks,
|
|
S_GUID,
|
|
SortKey,
|
|
Text_L1,
|
|
Text_L2,
|
|
Version
|
|
}
|
|
public Dictionary<string, string> GetPositionAttributeValues(MMEPositions position)
|
|
{
|
|
var attributeNameValuePairs = new Dictionary<string, string>();
|
|
|
|
attributeNameValuePairs[PositionFields.Date.ToString()] = position.Date.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[PositionFields.Expired.ToString()] = position.Expired.ToString();
|
|
attributeNameValuePairs[PositionFields.History.ToString()] = position.History;
|
|
attributeNameValuePairs[PositionFields.Last_Change.ToString()] = position.Last_Change.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
attributeNameValuePairs[PositionFields.Last_Change_Text.ToString()] = position.Last_Change_Text;
|
|
attributeNameValuePairs[PositionFields.Position.ToString()] = position.Position;
|
|
attributeNameValuePairs[PositionFields.RecordType.ToString()] = position.RecordType.ToString();
|
|
attributeNameValuePairs[PositionFields.Remarks.ToString()] = position.Remarks;
|
|
attributeNameValuePairs[PositionFields.S_GUID.ToString()] = position.S_GUID;
|
|
attributeNameValuePairs[PositionFields.SortKey.ToString()] = position.SortKey;
|
|
attributeNameValuePairs[PositionFields.Text_L1.ToString()] = position.Text_L1;
|
|
attributeNameValuePairs[PositionFields.Text_L2.ToString()] = position.Text_L2;
|
|
attributeNameValuePairs[PositionFields.Version.ToString()] = position.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
|
|
return attributeNameValuePairs;
|
|
}
|
|
|
|
}
|
|
}
|