noisedestroyers/DP44
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
bc3ac1d4c9bfb56c00ec892a5a321bb0e5dcc55d
DP44/DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/Classes/TestTemplate/TestTemplate.cs
noisedestroyers bc3ac1d4c9 init
2026-04-17 14:55:32 -04:00

2474 lines
131 KiB
C#
Raw Blame History

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
namespace DatabaseExport
{
public class TestTemplate : TagAwareBase, IComparable<TestTemplate>
{
/// <summary>
/// returns true whenever the test template is a quick test setup, false otherwise
/// </summary>
public bool QuickSensorCheck { get; set; }
public const string NON_ISO_INTERNAL_GROUP_NAME = "[NONE]";
private const int MaxRealtimeChannels = 6;
private const int MaxErrorsToDisplay = 5;
internal List<CalculatedValueClass> _calculatedChannels = new List<CalculatedValueClass>();
private readonly List<string> _channelKeysInOrder = new List<string>();
private readonly List<HardwareChannel> _hardwareChannelsInOrder = new List<HardwareChannel>();
private string _errorMessage = "";
/// <summary>
/// dictionary of harware overrides for the test
/// key is hardware id
/// if present, then value is whether the hardware is included or removed from the test.
/// </summary>
internal Dictionary<string, HardwareInclusionInstruction> _hardwareOverrides = new Dictionary<string, HardwareInclusionInstruction>();
/// <summary>
/// cache of sensors for the test setup
/// this keeps us from having to lookup sensors and apply changes every time we need to use them
/// </summary>
public Dictionary<string, Dictionary<string, Dictionary<string, SensorData>>> _sensorLookup = new Dictionary<string, Dictionary<string, Dictionary<string, SensorData>>>();
private readonly Dictionary<string, int> _dasChannelNumberToAbsoluteNumber = null;
private readonly Dictionary<string, DASSettings> _dasSettings = new Dictionary<string, DASSettings>();
public DASSettings[] DASSettings
{
get => _dasSettings.Count < 1 ? new DASSettings[0] : _dasSettings.Values.ToArray();
set
{
_dasSettings.Clear();
foreach (var setting in value) { _dasSettings[setting.DASSerialNumber] = setting; }
}
}
/// <summary>
/// whether to upload data after data collection is completed
/// this lets you separate out the time consumptive network data tasks from the ones you want to keep fast (export/view)
/// </summary>
private bool _uploadData = Properties.Settings.Default.DefaultUploadEnabled;
public bool UploadData
{
get => _uploadData;
set => SetProperty(ref _uploadData, value, TestTemplateTags.UploadData.ToString());
}
/// <summary>
/// folder to upload to
/// </summary>
private string _uploadFolder = "";
public string UploadFolder
{
get => _uploadFolder;
set => SetProperty(ref _uploadFolder, value, TestTemplateTags.UploadFolder.ToString());
}
/// <summary>
/// whether all units in the test share a common line
/// this should be set to false if DAS in the test don't share a common line
/// the default is true
/// if units share a common status line and there are multiple units in the test, then each unit will monitor the status line
/// if false or there's only one unit, the status line should not be monitored
/// </summary>
private bool _bCommonLine = SerializedSettings.TestSetupDefaultCommonStatusLine;
public bool CommonLine
{
get => _bCommonLine;
set => SetProperty(ref _bCommonLine, value, TestTemplateTags.CommonLine.ToString());
}
/// <summary>
/// true if the test objects and other fields have already been loaded from the database, false otherwise
/// </summary>
internal bool _bIsLoaded = false;
public bool IsLoaded => _bIsLoaded;
/// <summary>
/// when true the expectation is that any unit that can have a battery will have a battery, and the user should be warned
/// whenever a unit that should have a battery does not have an acceptable battery voltage
/// </summary>
private bool _warnOnFailedBattery = SerializedSettings.TestSetupDefaultWarnOnBatteryFail;
public bool WarnOnFailedBattery
{
get => _warnOnFailedBattery;
set => SetProperty(ref _warnOnFailedBattery, value, TestTemplateTags.WarnOnFailedBattery.ToString());
}
public string CompletionErrorMessage => _errorMessage.Length > 250 ? _errorMessage.Substring(0, 250) : _errorMessage;
/// <summary>
/// returns whether the test setup is complete or not.
/// WILL FORCE IsComplete TO BE CALCULATED IF IsDirty is true
/// (you might not want this if you are adding a new test setup for instance...)
/// </summary>
public bool IsComplete
{
get
{
if (string.IsNullOrWhiteSpace(Name)) { return false; }
//TODO: review property functionality
if (IsDirty) { CalculateIsComplete(); }
return _testTemplateLite.IsComplete;
}
set => _testTemplateLite.IsComplete = value;
}
/// <summary>
/// returns whether the test setup is dirty or not (whether the is complete is calculated already or not)
/// </summary>
private bool _bIsDirty = true;
public bool IsDirty
{
get => _bIsDirty;
set => _bIsDirty = value;
}
private readonly Dictionary<string, double> _filterLookup = new Dictionary<string, double>();
private List<TestGraph> _testGraphs = new List<TestGraph>();
public TestGraph[] TestGraphs
{
get => _testGraphs.ToArray();
set { SetProperty(ref _testGraphs, new List<TestGraph>(value), TestTemplateTags.TestGraphs.ToString()); OnPropertyChanged(TestTemplateTags.GraphCount.ToString()); }
}
private readonly TestTemplateLite _testTemplateLite = new TestTemplateLite();
public string Name
{
get => _testTemplateLite.Name;
set
{
_testTemplateLite.Name = value;
OnPropertyChanged(TestTemplateTags.Name.ToString());
}
}
private bool _bAllowMissingSensors = Properties.Settings.Default.DefaultTestAllowMissingSensors;
public bool AllowMissingSensors
{
get => _bAllowMissingSensors;
set => SetProperty(ref _bAllowMissingSensors, value, TestTemplateTags.AllowMissingSensors.ToString());
}
private bool _bAllowSensorIdToBlankChannel = Properties.Settings.Default.DefaultTestAllowSensorIdToBlankChannel;
public bool AllowSensorIdToBlankChannel
{
get => _bAllowSensorIdToBlankChannel;
set => SetProperty(ref _bAllowSensorIdToBlankChannel, value, TestTemplateTags.AllowSensorIdToBlankChannel.ToString());
}
private bool _bAutomaticProgression = SerializedSettings.TestSetupAutomaticMode; //Properties.Settings.Default.DefaultTestAutomaticProgression
public bool AutomaticProgression
{
get => _bAutomaticProgression;
set => SetProperty(ref _bAutomaticProgression, value, TestTemplateTags.AutomaticProgression.ToString());
}
private int _automaticProgressionDelayMs = SerializedSettings.TestSetupAutomaticProgressDelayMS;
public int AutomaticProgressionDelayMS
{
get => _automaticProgressionDelayMs;
set => SetProperty(ref _automaticProgressionDelayMs, value, TestTemplateTags.AutomaticProgressionDelayMS.ToString());
}
private bool _invertTriggerCompletion;
public bool InvertTriggerCompletion
{
get => _invertTriggerCompletion;
set => SetProperty(ref _invertTriggerCompletion, value, TestTemplateTags.InvertTriggerCompletion.ToString());
}
private bool _triggerCheckStep = Properties.Settings.Default.DefaultTestTriggerCheckStep;
public bool TriggerCheckStep
{
get => _triggerCheckStep;
set => SetProperty(ref _triggerCheckStep, value, TestTemplateTags.TriggerCheckStep.ToString());
}
private int _postTestDiagnosticsLevel = Properties.Settings.Default.DefaultTestRunPostTestDiagnostics ? 255 : 0;
public bool PostTestDiagnosticsLevel
{
get => _postTestDiagnosticsLevel != 0;
set
{
if (value) { SetProperty(ref _postTestDiagnosticsLevel, 255, TestTemplateTags.PostTestDiagnostics.ToString()); }
else { SetProperty(ref _postTestDiagnosticsLevel, 0, TestTemplateTags.PostTestDiagnostics.ToString()); }
}
}
private bool _triggerCheckRealtime;
public bool TriggerCheckRealtime
{
get => _triggerCheckRealtime;
set => SetProperty(ref _triggerCheckRealtime, value, TestTemplateTags.TriggerCheckRealtime.ToString());
}
private bool _invertStartRecordCompletion;
public bool InvertStartRecordCompletion
{
get => _invertStartRecordCompletion;
set => SetProperty(ref _invertStartRecordCompletion, value, TestTemplateTags.InvertStartRecordCompletion.ToString());
}
private bool _bViewDiagnostics = true;
public bool ViewDiagnostics
{
get => _bViewDiagnostics;
set => SetProperty(ref _bViewDiagnostics, value, TestTemplateTags.ViewDiagnostics.ToString());
}
private bool _bVerify = true;
public bool VerifyChannels
{
get => _bVerify;
set => SetProperty(ref _bVerify, value, TestTemplateTags.VerifyChannels.ToString());
}
private bool _bAutoVerifyChannels = true;
public bool AutoVerifyChannels
{
get => _bAutoVerifyChannels;
set => SetProperty(ref _bAutoVerifyChannels, value, TestTemplateTags.AutoVerifyProgress.ToString());
}
private double _autoVerifyDelay = 2D;
public double AutoVerifyDelaySeconds
{
get => _autoVerifyDelay;
set => SetProperty(ref _autoVerifyDelay, value, TestTemplateTags.AutoVerifyDelaySeconds.ToString());
}
private bool _bUseCustomerDetails;
public bool UseCustomerDetails
{
get => _bUseCustomerDetails;
set => SetProperty(ref _bUseCustomerDetails, value, TestTemplateTags.UseCustomerDetails.ToString());
}
private bool _bUseTestEngineerDetails;
public bool UseTestEngineerDetails
{
get => _bUseTestEngineerDetails;
set => SetProperty(ref _bUseTestEngineerDetails, value, TestTemplateTags.UseTestEngineerDetails.ToString());
}
private bool _bTurnOffExcitation = true;
public bool TurnOffExcitation
{
get => _bTurnOffExcitation;
set => SetProperty(ref _bTurnOffExcitation, value, TestTemplateTags.TurnOffExcitation.ToString());
}
private bool _bUseLabratoryDetails;
public bool UseLabratoryDetails
{
get => _bUseLabratoryDetails;
set => SetProperty(ref _bUseLabratoryDetails, value, TestTemplateTags.UseLabratoryDetails.ToString());
}
private bool _localOnly;
public bool LocalOnly
{
get => _localOnly;
set => SetProperty(ref _localOnly, value, TestTemplateTags.LocalOnly.ToString());
}
public DateTime LastModified
{
get => _testTemplateLite.LastModified;
set
{
_testTemplateLite.LastModified = value;
OnPropertyChanged(TestTemplateTags.LastModified.ToString());
}
}
public string LastModifiedBy
{
get => _testTemplateLite.LastModifiedBy;
set
{
_testTemplateLite.LastModifiedBy = value;
OnPropertyChanged(TestTemplateTags.LastMmodifiedBy.ToString());
}
}
public string Description
{
get => _testTemplateLite.Description;
set
{
_testTemplateLite.Description = value;
OnPropertyChanged(TestTemplateTags.Description.ToString());
}
}
private double _samplesPerSecond = Properties.Settings.Default.DefaultTestSampleRate;
public double SamplesPerSecond
{
get => _samplesPerSecond;
set
{
SetProperty(ref _samplesPerSecond, value, TestTemplateTags.SamplesPerSecond.ToString());
OnPropertyChanged(TestTemplateTags.SampleRateText.ToString());
}
}
public double PreTriggerSeconds
{
get => _testTemplateLite.PreTriggerSeconds;
set
{
_testTemplateLite.PreTriggerSeconds = value;
OnPropertyChanged(TestTemplateTags.PreTriggerSeconds.ToString());
}
}
public double PostTriggerSeconds
{
get => _testTemplateLite.PostTriggerSeconds;
set
{
_testTemplateLite.PostTriggerSeconds = value;
OnPropertyChanged(TestTemplateTags.PostTriggerSeconds.ToString());
}
}
private string _isfFile = "";
public string ISFFile
{
get => _isfFile;
set => SetProperty(ref _isfFile, value, TestTemplateTags.ISFFile.ToString());
}
private bool _doAutoArm = false;
public bool DoAutoArm
{
get => _doAutoArm;
set => SetProperty(ref _doAutoArm, value, TestTemplateTags.DoAutoArm.ToString());
}
private bool _doStreaming = false;
public bool DoStreaming
{
get => _doStreaming;
set => SetProperty(ref _doStreaming, value, TestTemplateTags.DoStreaming.ToString());
}
/// <summary>
/// CheckoutMode means a non destructive data collection
/// squib fires will only occur internally
/// </summary>
private bool _checkoutMode = false;
public bool CheckoutMode
{
get => _checkoutMode;
set => SetProperty(ref _checkoutMode, value, TestTemplateTags.CheckoutMode.ToString());
}
/// <summary>
/// QuitTestWithoutWarning flag will suppress warnings on exit
/// see: 7509 add option to Quit Test Without Warning
/// </summary>
private bool _quitTestWithoutWarning = Properties.Settings.Default.DefaultTestQuitTestWithoutWarning;
public bool QuitTestWithoutWarning
{
get => _quitTestWithoutWarning;
set => SetProperty(ref _quitTestWithoutWarning, value, TestTemplateTags.QuitTestWithoutWarning.ToString());
}
/// <summary>
/// SuppressMissingSensorsWarning flag will suppress missing sensors warnings
/// see: 8877 Suppress modal warning in checkout mode for missing sensors.
/// </summary>
private bool _suppressMissingSensorsWarning = Properties.Settings.Default.DefaultSuppressMissingSensorsWarning;
public bool SuppressMissingSensorsWarning
{
get => _suppressMissingSensorsWarning;
set => SetProperty(ref _suppressMissingSensorsWarning, value, TestTemplateTags.SuppressMissingSensorsWarning.ToString());
}
/// <summary>
/// suppress warnings on exit
/// see: 7642 add two test setup option to suppress "not all channels have been viewed" warnings in both real-time and viewer.
/// </summary>
private bool _notAllChannelsRealTime = Properties.Settings.Default.DefaultTestSuppressNotAllChannelsViewedWarningRealTime;
public bool NotAllChannelsRealTime
{
get => _notAllChannelsRealTime;
set => SetProperty(ref _notAllChannelsRealTime, value, TestTemplateTags.NotAllChannelsRealTime.ToString());
}
/// <summary>
/// suppress warnings on exit
/// see: 7642 add two test setup option to suppress "not all channels have been viewed" warnings in both real-time and viewer.
/// </summary>
private bool _notAllChannelsViewer = Properties.Settings.Default.DefaultTestSuppressNotAllChannelsViewedWarningViewer;
public bool NotAllChannelsViewer
{
get => _notAllChannelsViewer;
set => SetProperty(ref _notAllChannelsViewer, value, TestTemplateTags.NotAllChannelsViewer.ToString());
}
public RecordingModes RecordingMode
{
get => _testTemplateLite.RecordingMode;
set
{
if (value != _testTemplateLite.RecordingMode)
{
_testTemplateLite.RecordingMode = value;
OnPropertyChanged(TestTemplateTags.RecordingMode.ToString());
OnPropertyChanged(TestTemplateTags.RecordingModeText.ToString());
}
}
}
private bool _bStrictDiagnostics = Properties.Settings.Default.DefaultTestRequireAllUnitsPassDiagnostics;
public bool StrictDiagnostics
{
get => _bStrictDiagnostics;
set => SetProperty(ref _bStrictDiagnostics, value, TestTemplateTags.StrictDiagnostics.ToString());
}
private readonly List<string> _checkedDASList = new List<string>();
public TestTestObject[] TestObjectsWithChannels
{
get
{
var list = new List<TestTestObject>(_testObjects);
for (var i = list.Count - 1; i >= 0; i--)
{
var isoTO = list[i].GetISOTestObject();
if (0 == isoTO.AllChannels.Length) { list.RemoveAt(i); }
}
return list.ToArray();
}
}
public List<TestObject> TestObjectsAndAddedGroupsList = new List<TestObject>();
public TestObject[] TestObjectsAndAddedGroups => TestObjectsAndAddedGroupsList.ToArray();
private List<TestTestObject> _testObjects = new List<TestTestObject>();
public TestTestObject[] TestObjects
{
get => _testObjects.ToArray();
set => SetTestObjects(false, value);
}
private List<TestTestObject> _addedGroups = new List<TestTestObject>();
public TestTestObject[] AddedGroups
{
get => _addedGroups.ToArray();
set
{
//MarkIsCompleteUnchecked(); Removed to fix FB 10241 with the assumption that simply Setting AddedGroups should not cause a database write.
SetProperty(ref _addedGroups, new List<TestTestObject>(value), TestTemplateTags.SysBuiltTestObjectTypes.ToString());
OnPropertyChanged(TestTemplateTags.AllTestObjects.ToString());//check this
OnPropertyChanged("TestObjectsAndAddedGroups");
OnPropertyChanged(TestTemplateTags.TestObjectsAndAddedGroups.ToString());
}
}
private bool _bRequireUserConfirmationOnErrors = Properties.Settings.Default.DefaultTestRequireUserConfirmationOnErrors;
public bool RequireUserConfirmationOnErrors
{
get => _bRequireUserConfirmationOnErrors;
set => SetProperty(ref _bRequireUserConfirmationOnErrors, value, TestTemplateTags.RequireUserConfirmationOnErrors.ToString());
}
private bool _ROIDownload = Properties.Settings.Default.DefaultTestDownloadROI;
public bool DoROIDownload
{
get => _ROIDownload;
set
{
SetProperty(ref _ROIDownload, value, TestTemplateTags.DoROIDownload.ToString());
OnPropertyChanged(TestTemplateTags.ROIButtonVisibility.ToString());
}
}
private bool _ROIDownloadView = Properties.Settings.Default.DefaultTestViewROI;
public bool ViewROIDownload
{
get => _ROIDownloadView;
set
{
SetProperty(ref _ROIDownloadView, value, TestTemplateTags.ViewROIDownload.ToString());
OnPropertyChanged(TestTemplateTags.ViewROIDownloadButtonVisibility.ToString());
}
}
private bool _DownloadAll = Properties.Settings.Default.DefaultTestDownloadAll;
public bool DownloadAll
{
get => _DownloadAll;
set
{
SetProperty(ref _DownloadAll, value, TestTemplateTags.DownloadAll.ToString());
OnPropertyChanged(TestTemplateTags.DownloadAllButtonVisibility.ToString());
}
}
private bool _ViewRealtime = Properties.Settings.Default.DefaultTestViewAll;
public bool ViewRealtime
{
get => 0 != GetNumberOfRealtimeSupportedChannels() && _ViewRealtime;
set
{
SetProperty(ref _ViewRealtime, value, TestTemplateTags.ViewRealtime.ToString());
OnPropertyChanged(TestTemplateTags.ViewRealtime.ToString());
}
}
private double _roiStart = Properties.Settings.Default.DefaultTestROIStart;
public double ROIStart
{
get => _roiStart;
set => SetProperty(ref _roiStart, value, TestTemplateTags.ROIStart.ToString());
}
private double _roiEnd = Properties.Settings.Default.DefaultTestROIEnd;
public double ROIEnd
{
get => _roiEnd;
set => SetProperty(ref _roiEnd, value, TestTemplateTags.ROIEnd.ToString());
}
private bool _viewDownloadAll = Properties.Settings.Default.DefaultTestViewAll;
public bool ViewDownloadAll
{
get => _viewDownloadAll;
set
{
SetProperty(ref _viewDownloadAll, value, TestTemplateTags.ViewDownloadAll.ToString());
OnPropertyChanged(TestTemplateTags.ViewDownloadAllButtonVisibility.ToString());
}
}
private bool _viewExport = Properties.Settings.Default.DefaultTestExport;
public bool ViewExport
{
get => _viewExport;
set
{
SetProperty(ref _viewExport, value, TestTemplateTags.ViewExport.ToString());
OnPropertyChanged(TestTemplateTags.ViewExportButtonVisibility.ToString());
}
}
private SupportedExportFormatBitFlags _exportFormats = (SupportedExportFormatBitFlags)Properties.Settings.Default.DefaultTestExportFormat;
public SupportedExportFormatBitFlags ExportFormats
{
get => _exportFormats;
set => SetProperty(ref _exportFormats, value, TestTemplateTags.ExportFormats.ToString());
}
private string _downloadFolder = Properties.Settings.Default.DownloadFolder;
public string DownloadFolder
{
get => _downloadFolder;
set => SetProperty(ref _downloadFolder, value, TestTemplateTags.DownloadFolder.ToString());
}
private string _exportFolder = Properties.Settings.Default.DownloadFolder;
public string ExportFolder
{
get => _exportFolder;
set => SetProperty(ref _exportFolder, value, TestTemplateTags.ExportFolder.ToString());
}
private bool _sameAsDownloadFolder = true;
public bool SameAsDownloadFolder
{
get => _sameAsDownloadFolder;
set => SetProperty(ref _sameAsDownloadFolder, value, TestTemplateTags.SameAsDownloadFolder.ToString());
}
private LabratoryDetails _labDetails = null;
public LabratoryDetails LabDetails
{
get => _labDetails;
set => SetProperty(ref _labDetails, value, TestTemplateTags.LabDetails.ToString());
}
private CustomerDetails _customerDetails = null;
public CustomerDetails CustomerDetails
{
get => _customerDetails;
set => SetProperty(ref _customerDetails, value, TestTemplateTags.CustomerDetails.ToString());
}
private TestEngineerDetails _testEngineerDetails = null;
public TestEngineerDetails TestEngineerDetails
{
get => _testEngineerDetails;
set => SetProperty(ref _testEngineerDetails, value, TestTemplateTags.TestEngineerDetails.ToString());
}
private int _defaultNumberRealtimeGraphs = Properties.Settings.Default.DefaultTestRealtimeModeGraphCount;
public int DefaultNumberRealtimeGraphs
{
get
{
switch (_defaultNumberRealtimeGraphs)
{
case 6:
return 6;
case 3:
return 3;
case 1:
default:
return 1;
}
}
set
{
switch (value)
{
case 6:
_defaultNumberRealtimeGraphs = value;
break;
case 3:
_defaultNumberRealtimeGraphs = value;
break;
case 1:
default:
_defaultNumberRealtimeGraphs = value;
break;
}
OnPropertyChanged(TestTemplateTags.DefaultNumberRealtimeGraphs.ToString());
}
}
public override ConstraintHelper[] GetConstraints()
{
return new[]
{
new ConstraintHelper()
{
ColumnName = DbOperations.TestSetups.Fields.SetupName.ToString(),
DbType = SqlDbType.NVarChar,
DbValue = Name
}
};
}
public override string LookupTable => DbOperations.TestSetups.TestSetupsTable;
/// <summary>
/// this is a brave new world, this is the hardware for this test.
/// now groups in this test setup may have hardware assigned, or no hardware assigned
/// we'll take that if we find it, but then we'll also check a list we have for the test itself and intersect the two
/// we then modify the groups IN MEMORY and change their hardware to match all hardware officially in the test
/// </summary>
/// <returns></returns>
public void ApplyHardwareOverrides()
{
//for now don't do anything if the test setup is non iso
var hardwareInTest = new Dictionary<string, DASHardware>();
foreach (var group in TestObjects)
{
foreach (var h in group.Hardware)
{
var hiso = h.GetHardware();
if (!hardwareInTest.ContainsKey(hiso.GetId()))
{
hardwareInTest.Add(hiso.GetId(), h);
}
}
}
foreach (var group in AddedGroups)
{
foreach (var h in group.Hardware)
{
var hiso = h.GetHardware();
if (!hardwareInTest.ContainsKey(hiso.GetId()))
{
hardwareInTest.Add(hiso.GetId(), h);
}
}
}
var e = _hardwareOverrides.GetEnumerator();
while (e.MoveNext())
{
switch (e.Current.Value.Action)
{
case HardwareInclusionInstruction.Actions.Add:
if (!hardwareInTest.ContainsKey(e.Current.Value.HardwareId))
{
DASHardware h = null;
try { h = DASHardwareList.GetList().GetHardware(e.Current.Value.HardwareId); }
catch (DASHardwareList.HardwareTypeChangedException)
{
//ignore
}
if (null != h) { hardwareInTest.Add(h.GetHardware().GetId(), h); }
}
break;
case HardwareInclusionInstruction.Actions.Remove:
if (hardwareInTest.ContainsKey(e.Current.Value.HardwareId)) { hardwareInTest.Remove(e.Current.Value.HardwareId); }
break;
}
}
GetNonISOTestObject();
foreach (var group in TestObjects)
{
var hardware = new List<DASHardware>();
var e2 = hardwareInTest.GetEnumerator();
while (e2.MoveNext())
{
var newH = new DASHardware(e2.Current.Value.GetHardware());
newH.SetTimeStampMemory(e2.Current.Value.GetTimeStampMemory());
hardware.Add(newH);
}
group.SetHardware(hardware.ToArray());
}
foreach (var ag in AddedGroups)
{
var hardware = new List<DASHardware>();
var e2 = hardwareInTest.GetEnumerator();
while (e2.MoveNext())
{
var newH = new DASHardware(e2.Current.Value.GetHardware());
newH.SetTimeStampMemory(e2.Current.Value.GetTimeStampMemory());
hardware.Add(newH);
}
ag.SetHardware(hardware.ToArray());
}
}
internal Dictionary<string, LevelTriggerChannel> LevelTriggerChannels = new Dictionary<string, LevelTriggerChannel>();
public string GetLTKey(LevelTriggerChannel ch)
{
return string.Format("{0}x{1}", ch.HardwareChannelId, ch.SensorSerialNumber);
}
public void SetLevelTrigger(LevelTriggerChannel channel)
{
var key = GetLTKey(channel);
LevelTriggerChannels[key] = new LevelTriggerChannel(channel);//do a copy just for safety
}
public SensorData GetSensor(string serialNumber, string testObjectSerial, string channelName)
{
lock (SensorLock)
{
var tto = GetTestTestObject(testObjectSerial);
if (_sensorLookup.ContainsKey(testObjectSerial))
{
if (_sensorLookup[testObjectSerial].ContainsKey(channelName))
{
if (_sensorLookup[testObjectSerial][channelName].ContainsKey(serialNumber))
{
if (_sensorLookup[testObjectSerial][channelName][serialNumber].FilterClassIso == "?")
{
_sensorLookup[testObjectSerial][channelName][serialNumber].FilterClassIso = "P"; // "Prefiltered > CFC 1000" (Unfiltered)
}
//for some reason the Filter isn't always set, setting filterclassiso will ensure it gets set, even though it should have already _been_ set
_sensorLookup[testObjectSerial][channelName][serialNumber].FilterClassIso = _sensorLookup[testObjectSerial][channelName][serialNumber].FilterClassIso;
if (null == tto)
{ return _sensorLookup[testObjectSerial][channelName][serialNumber]; }
var position = tto.Position.Position;
if (position != TestTestObject.UserSetKey &&
position != TestTestObject.ChannelDefaultsKey &&
position != _sensorLookup[testObjectSerial][channelName][serialNumber].Position)
{
_sensorLookup[testObjectSerial][channelName][serialNumber].Position = position;
}
return _sensorLookup[testObjectSerial][channelName][serialNumber];
}
}
}
if (null == tto)
{ return SensorData.IsTestSpecificDigitalOutSN(serialNumber) ? new DigitalOutputSetting { SerialNumber = serialNumber } : SensorsCollection.SensorsList.GetSensorBySerialNumber(serialNumber); }
{
var ttosd = tto.GetSensor(channelName, serialNumber);
if (ttosd != null)
{
ttosd.TestObject = tto.TestObject.Test_Object;
var position = tto.Position.Position;
if (position != TestTestObject.UserSetKey &&
position != TestTestObject.ChannelDefaultsKey &&
position != ttosd.Position)
{
ttosd.Position = position;
}
}
else
{
return SensorData.IsTestSpecificDigitalOutSN(serialNumber) ? new DigitalOutputSetting { SerialNumber = serialNumber } : null;
}
return ttosd;
}
}
}
public void SetSensor(SensorData sd, string testobjectserial, string channelname)
{
SetSensor(sd, testobjectserial, channelname, false);
}
private static readonly object SensorLock = new object();
/// <summary>
/// sets the sensor (and custom values like range/CFC/polarity) for a channel in the test
/// </summary>
/// <param name="sd"></param>
/// <param name="testobjectserial"></param>
/// <param name="channelname"></param>
/// <param name="bSetPositionFromSensor"></param>
public void SetSensor(SensorData sd, string testobjectserial, string channelname, bool bSetPositionFromSensor)
{
lock (SensorLock)
{
if (!_sensorLookup.ContainsKey(testobjectserial))
{
_sensorLookup.Add(testobjectserial, new Dictionary<string, Dictionary<string, SensorData>>());
}
if (!_sensorLookup[testobjectserial].ContainsKey(channelname))
{
_sensorLookup[testobjectserial].Add(channelname, new Dictionary<string, SensorData>());
}
//Build out the ISO fields we know about
// FB 5423
var tto = GetTestTestObject(testobjectserial) ?? new TestTestObject(new TestObject());
sd.TestObject = tto.TestObject.Test_Object;
// ReSharper disable once InconsistentNaming
var isoTO = tto.GetISOTestObject();
var channel = isoTO.GetChannel(channelname);
if (bSetPositionFromSensor)
{
if (tto.Position.Position != sd.Position && tto.Position.Position != TestTestObject.UserSetKey)
{
tto.SetPosition(TestTestObject.UserSetKey);
}
}
else
{
if ((tto.Position.Position != TestTestObject.ChannelDefaultsKey) && //Remove this?
(tto.Position.Position != TestTestObject.UserSetKey))
{
sd.Position = tto.Position.Position;
}
}
if (null != channel)
{
sd.FineLocation1 = channel.Channel.Fine_Loc_1;
sd.FineLocation2 = channel.Channel.Fine_Loc_2;
sd.FineLocation3 = channel.Channel.Fine_Loc_3;
sd.MainLocation = channel.Channel.Trans_Main_Loc;
sd.PhysicalDimension = channel.Channel.Physical_Dimension;
sd.Direction = channel.Channel.Direction;
}
_sensorLookup[testobjectserial][channelname][sd.SerialNumber] = sd;
}
}
public const string HARDWAREOVERRIDE_ACTION = "Action";
public const string HARDWAREOVERRIDE_HID = "HID";
private const string LT_TESTSETUPNAME = "TestSetupName";
private const string LT_TESTOBJECTCHANNELID = "TestObjectChannelId";
private const string LT_HARDWARECHANNELID = "HardwareChannelId";
private const string LT_GROUPSERIALNUMBER = "GroupId";
private const string LT_SENSORSERIALNUMBER = "SensorSerialNumber";
private const string LT_LESSTHANTHRESHOLDEU = "LessThanValue";
private const string LT_LESSTHANENABLED = "LessThanEnabled";
private const string LT_GREATERTHANENABLED = "GreaterThanEnabled";
private const string LT_GREATERTHANTHRESHOLDEU = "GreaterThanValue";
private const string LT_TRIGGEROUTSIDE = "TriggerOutside";
private const string LT_TRIGGERINSIDE = "TriggerInside";
private const string LT_OUTSIDEUPPEREU = "OutsideUpperEU";
private const string LT_OUTSIDELOWEREU = "OutsideLowerEU";
private const string LT_INSIDEUPPEREU = "InsideUpperEU";
private const string LT_INSIDELOWEREU = "InsideLowerEU";
private const string CC_CALCULATEDCHANNELVALUE = "ISOCODE";
private const string CC_CFCFORINPUTCHANNELS = "CFCInputChannels";
private const string CC_CFCFOROUTPUTCHANNELS = "CFCOutput";
private const string CC_TESTSETUPNAME = "TestSetupName";
private const string CC_NAME = "Name";
private const string CC_INPUTCHANNELIDS = "InputChannelIds";
private const string CC_ID = "ID";
private const string CC_OPERATION = "Operation";
public Dictionary<string, string> GetTestObjectValues(TestTestObject to)
{
var elementNameValuePairs = new Dictionary<string, string>();
elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.TestObjectSerialNumber.ToString()] = to.SerialNumber;
elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.TestSetupName.ToString()] = Name;
elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.TargetSampleRate.ToString()] = to.TargetSampleRate.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.ExcitationWarmupTimeMS.ToString()] = to.ExcitationWarmupTimeMS.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.LocalOnly.ToString()] = to.LocalOnly.ToString();
elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.TestObjectType.ToString()] = to.TestObject.Test_Object;
elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.TestObjectPosition.ToString()] = to.Position.Position;
return elementNameValuePairs;
}
public Dictionary<string, string> GetDASSettingsValues(DASSettings settings)
{
var elementNameValuePairs = new Dictionary<string, string>();
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.DASSerialNumber.ToString()] = settings.DASSerialNumber;
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.TestSetupName.ToString()] = Name;
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.TargetSampleRate.ToString()] = settings.SampleRate.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.ExcitationWarmupTimeMS.ToString()] = settings.ExcitationWarmupTimeMS.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.AAFilterRate.ToString()] = settings.HardwareAAF.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.PreTriggerSeconds.ToString()] = settings.PreTriggerSeconds.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.PostTriggerSeconds.ToString()] = settings.PostTriggerSeconds.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.StatusLineCheck.ToString()] = settings.StatusLineCheck.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.BatteryCheck.ToString()] = settings.BatteryCheck.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.InputVoltageMin.ToString()] = settings.InputVoltageMin.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.InputVoltageMax.ToString()] = settings.InputVoltageMax.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.BatteryVoltageMin.ToString()] = settings.BatteryVoltageMin.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.BatteryVoltageMax.ToString()] = settings.BatteryVoltageMax.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.LocalOnly.ToString()] = false.ToString(System.Globalization.CultureInfo.InvariantCulture);
return elementNameValuePairs;
}
public Dictionary<string, string> GetChannelSettingValues(TestTestObject to, TestObjectChannel channel, SensorData sd)
{
var elementNameValuePairs = new Dictionary<string, string>();
elementNameValuePairs[DbOperations.TestSetups.ChannelSettingFields.TestName.ToString()] = Name;
elementNameValuePairs[DbOperations.TestSetups.ChannelSettingFields.TestObjectName.ToString()] = to.SerialNumber;
elementNameValuePairs[DbOperations.TestSetups.ChannelSettingFields.ChannelId.ToString()] = channel.NameOfTheChannel;
elementNameValuePairs[DbOperations.TestSetups.ChannelSettingFields.Setting.ToString()] = TestTemplateList.GetSensorSettings(sd);
elementNameValuePairs[DbOperations.TestSetups.ChannelSettingFields.SensorSerial.ToString()] = channel.SensorSerialNumber;
return elementNameValuePairs;
}
public Dictionary<string, string> GetGraphValues(TestGraph g)
{
var elementNameValuePairs = new Dictionary<string, string>();
elementNameValuePairs[DbOperations.TestSetups.GraphFields.GraphName.ToString()] = g.GraphName;
elementNameValuePairs[DbOperations.TestSetups.GraphFields.GraphDescription.ToString()] = g.GraphDescription;
elementNameValuePairs[DbOperations.TestSetups.GraphFields.TemplateName.ToString()] = Name;
elementNameValuePairs[DbOperations.TestSetups.GraphFields.Channels.ToString()] = g.GetChannelsForSQL();
elementNameValuePairs[DbOperations.TestSetups.GraphFields.UseDomainMin.ToString()] = g.UseDomainMin.ToString();
elementNameValuePairs[DbOperations.TestSetups.GraphFields.DomainMin.ToString()] = g.DomainMin.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.GraphFields.UseDomainMax.ToString()] = g.UseDomainMax.ToString();
elementNameValuePairs[DbOperations.TestSetups.GraphFields.DomainMax.ToString()] = g.DomainMax.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.GraphFields.UseRangeMin.ToString()] = g.UseRangeMin.ToString();
elementNameValuePairs[DbOperations.TestSetups.GraphFields.RangeMin.ToString()] = g.RangeMin.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.GraphFields.UseRangeMax.ToString()] = g.UseRangeMax.ToString();
elementNameValuePairs[DbOperations.TestSetups.GraphFields.RangeMax.ToString()] = g.RangeMax.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.GraphFields.Thresholds.ToString()] = g.GetThresholdsSQL();
elementNameValuePairs[DbOperations.TestSetups.GraphFields.LocalOnly.ToString()] = LocalOnly.ToString();
return elementNameValuePairs;
}
public Dictionary<string, string> GetFieldValues()
{
var elementNameValuePairs = new Dictionary<string, string>();
elementNameValuePairs[DbOperations.TestSetups.Fields.SetupName.ToString()] = Name;
elementNameValuePairs[DbOperations.TestSetups.Fields.SetupDescription.ToString()] = Description;
elementNameValuePairs[DbOperations.TestSetups.Fields.AutomaticTestProgression.ToString()] = AutomaticProgression.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.AutomaticProgressionDelayMS.ToString()] = AutomaticProgressionDelayMS.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.Fields.InvertTrigger.ToString()] = InvertTriggerCompletion.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.InvertStart.ToString()] = InvertStartRecordCompletion.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.ViewDiagnostics.ToString()] = ViewDiagnostics.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.VerifyChannels.ToString()] = VerifyChannels.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.AutoVerifyChannels.ToString()] = AutoVerifyChannels.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.VerifyChannelsDelayMS.ToString()] = (AutoVerifyDelaySeconds * 1000D).ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.Fields.RecordingMode.ToString()] = RecordingMode.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.SamplesPerSecond.ToString()] = SamplesPerSecond.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.Fields.PreTriggerSeconds.ToString()] = PreTriggerSeconds.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.Fields.PostTriggerSeconds.ToString()] = PostTriggerSeconds.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.Fields.StrictDiagnostics.ToString()] = StrictDiagnostics.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.RequireConfirmationOnErrors.ToString()] = RequireUserConfirmationOnErrors.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.ROIDownload.ToString()] = DoROIDownload.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.ViewROIDownload.ToString()] = ViewROIDownload.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.DownloadAll.ToString()] = DownloadAll.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.ViewRealtime.ToString()] = ViewRealtime.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.RealtimePlotCount.ToString()] = DefaultNumberRealtimeGraphs.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.Fields.ROIStart.ToString()] = ROIStart.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.Fields.ROIEnd.ToString()] = ROIEnd.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.Fields.ViewDownloadAll.ToString()] = ViewDownloadAll.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.Export.ToString()] = ViewExport.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.ExportFormat.ToString()] = ((ulong)ExportFormats).ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.Fields.LabDetails.ToString()] = (null != LabDetails) ? LabDetails.Name : "";
elementNameValuePairs[DbOperations.TestSetups.Fields.UseLabDetails.ToString()] = UseLabratoryDetails.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.CustomerDetails.ToString()] = null != CustomerDetails ? CustomerDetails.Name : "";
elementNameValuePairs[DbOperations.TestSetups.Fields.UseCustomerDetails.ToString()] = UseCustomerDetails.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.AllowMissingSensors.ToString()] = AllowMissingSensors.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.AllowSensorIdToBlankChannel.ToString()] = AllowSensorIdToBlankChannel.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.LocalOnly.ToString()] = LocalOnly.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.LastModified.ToString()] = LastModified.ToString(System.Globalization.CultureInfo.InvariantCulture);
elementNameValuePairs[DbOperations.TestSetups.Fields.LastModifiedBy.ToString()] = LastModifiedBy;
elementNameValuePairs[DbOperations.TestSetups.Fields.TurnOffExcitation.ToString()] = TurnOffExcitation.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.TriggerCheckRealtime.ToString()] = TriggerCheckRealtime.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.TriggerCheckStep.ToString()] = TriggerCheckStep.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.PostTestDiagnostics.ToString()] = PostTestDiagnosticsLevel.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.ExportFolder.ToString()] = ExportFolder;
elementNameValuePairs[DbOperations.TestSetups.Fields.DownloadFolder.ToString()] = DownloadFolder;
elementNameValuePairs[DbOperations.TestSetups.Fields.CommonStatusLine.ToString()] = CommonLine.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.SameAsDownloadFolder.ToString()] = SameAsDownloadFolder.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.UploadData.ToString()] = UploadData.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.UploadDataFolder.ToString()] = UploadFolder;
elementNameValuePairs[DbOperations.TestSetups.Fields.Settings.ToString()] = _settings.ToSerializeString();
elementNameValuePairs[DbOperations.TestSetups.Fields.WarnOnBatteryFail.ToString()] = WarnOnFailedBattery.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.Dirty.ToString()] = IsDirty.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.Complete.ToString()] = IsComplete.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.ErrorMessage.ToString()] = CompletionErrorMessage;
elementNameValuePairs[DbOperations.TestSetups.Fields.TestEngineerDetails.ToString()] = null != TestEngineerDetails ? TestEngineerDetails.Name : "";
elementNameValuePairs[DbOperations.TestSetups.Fields.UseTestEngineerDetails.ToString()] = UseTestEngineerDetails.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.UserTags.ToString()] = GetTagsCommaSeperatedString();
elementNameValuePairs[DbOperations.TestSetups.Fields.DoAutoArm.ToString()] = DoAutoArm.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.DoStreaming.ToString()] = DoStreaming.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.CheckoutMode.ToString()] = CheckoutMode.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.QuitTestWithoutWarning.ToString()] = QuitTestWithoutWarning.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.SuppressMissingSensorsWarning.ToString()] = SuppressMissingSensorsWarning.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.ISFFile.ToString()] = ISFFile;
elementNameValuePairs[DbOperations.TestSetups.Fields.NotAllChannelsRealTime.ToString()] = NotAllChannelsRealTime.ToString();
elementNameValuePairs[DbOperations.TestSetups.Fields.NotAllChannelsViewer.ToString()] = NotAllChannelsViewer.ToString();
return elementNameValuePairs;
}
public Dictionary<string, string> GetHardwareOverrideValues(HardwareInclusionInstruction hii)
{
var attributeNameValuePairs = new Dictionary<string, string>();
attributeNameValuePairs[HARDWAREOVERRIDE_HID] = hii.HardwareId;
attributeNameValuePairs[HARDWAREOVERRIDE_ACTION] = hii.Action.ToString();
return attributeNameValuePairs;
}
public Dictionary<string, string> GetCalculatedChannelValues(CalculatedValueClass cc)
{
var attributeNameValuePairs = new Dictionary<string, string>();
attributeNameValuePairs[CC_CALCULATEDCHANNELVALUE] = cc.CalculatedValueCode;
attributeNameValuePairs[CC_CFCFORINPUTCHANNELS] = cc.CFCForInputChannels;
attributeNameValuePairs[CC_CFCFOROUTPUTCHANNELS] = cc.ChannelFilterClassForOutput;
attributeNameValuePairs[CC_ID] = cc.Id.ToString(System.Globalization.CultureInfo.InvariantCulture);
attributeNameValuePairs[CC_INPUTCHANNELIDS] = string.Join(System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator, cc.InputChannelIds);
attributeNameValuePairs[CC_NAME] = cc.Name;
attributeNameValuePairs[CC_OPERATION] = cc.Operation.ToString();
attributeNameValuePairs[CC_TESTSETUPNAME] = cc.TestSetupName;
return attributeNameValuePairs;
}
public Dictionary<string, string> GetLevelTriggerValues(LevelTriggerChannel lt)
{
var attributeNameValuePairs = new Dictionary<string, string>();
attributeNameValuePairs[LT_TESTSETUPNAME] = lt.TestSetupName;
attributeNameValuePairs[LT_GROUPSERIALNUMBER] = lt.GroupSerialNumber;
attributeNameValuePairs[LT_TESTOBJECTCHANNELID] = lt.TestObjectChannelId;
attributeNameValuePairs[LT_HARDWARECHANNELID] = lt.HardwareChannelId;
attributeNameValuePairs[LT_SENSORSERIALNUMBER] = lt.SensorSerialNumber;
attributeNameValuePairs[LT_GREATERTHANENABLED] = lt.GreaterThanEnabled.ToString(System.Globalization.CultureInfo.InvariantCulture);
attributeNameValuePairs[LT_GREATERTHANTHRESHOLDEU] = lt.GreaterThanThresholdEU.ToString(System.Globalization.CultureInfo.InvariantCulture);
attributeNameValuePairs[LT_LESSTHANENABLED] = lt.LessThanEnabled.ToString(System.Globalization.CultureInfo.InvariantCulture);
attributeNameValuePairs[LT_LESSTHANTHRESHOLDEU] = lt.LessThanThresholdEU.ToString(System.Globalization.CultureInfo.InvariantCulture);
attributeNameValuePairs[LT_TRIGGERINSIDE] = lt.TriggerBetweenBounds.ToString(System.Globalization.CultureInfo.InvariantCulture);
attributeNameValuePairs[LT_TRIGGEROUTSIDE] = lt.TriggerOutsideBounds.ToString(System.Globalization.CultureInfo.InvariantCulture);
attributeNameValuePairs[LT_INSIDELOWEREU] = lt.InsideLowerLevelEU.ToString(System.Globalization.CultureInfo.InvariantCulture);
attributeNameValuePairs[LT_INSIDEUPPEREU] = lt.InsideUpperLevelEU.ToString(System.Globalization.CultureInfo.InvariantCulture);
attributeNameValuePairs[LT_OUTSIDELOWEREU] = lt.OutsideLowerLevelEU.ToString(System.Globalization.CultureInfo.InvariantCulture);
attributeNameValuePairs[LT_OUTSIDEUPPEREU] = lt.OutsideUpperLevelEU.ToString(System.Globalization.CultureInfo.InvariantCulture);
return attributeNameValuePairs;
}
public Dictionary<string, string> GetMetaDataValues(TestSetupMetaData testMeta, MetaData prop)
{
var attributeNameValuePairs = new Dictionary<string, string>();
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.TestObject.ToString()] = testMeta.TestObject.ToString();
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.SetupName.ToString()] = Name;
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.PropName.ToString()] = prop.Name;
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.PropValue.ToString()] = prop.Value;
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.Optional.ToString()] = prop.IsOptional.ToString();
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.Version.ToString()] = prop.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
return attributeNameValuePairs;
}
public Dictionary<string, string> GetMetaDataValues(TestObjectMetaData testMeta, MetaData prop)
{
var attributeNameValuePairs = new Dictionary<string, string>();
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.TestObject.ToString()] = testMeta.TestObject.ToString();
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.SetupName.ToString()] = Name;
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.PropName.ToString()] = prop.Name;
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.PropValue.ToString()] = prop.Value;
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.Optional.ToString()] = prop.IsOptional.ToString();
attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.Version.ToString()] = prop.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
return attributeNameValuePairs;
}
/// <summary>
/// sets the dirty flag
/// does NOT set the flag in the database, so this should only be called when the flag needs to be set in memory
/// (for instance during initialization)
/// </summary>
/// <param name="bDirty"></param>
public void SetIsDirty(bool bDirty)
{
_bIsDirty = bDirty;
}
/// <summary>
/// sets the complete flag
/// does not set the flag in the database, so this should only be called when the flag needs to be set in memory
/// (for instance during initialization)
/// </summary>
/// <param name="bComplete"></param>
public void SetIsComplete(bool bComplete)
{
_testTemplateLite.IsComplete = bComplete;
}
/// <summary>
/// sets the completion error message.
/// does not set the field in the db, so this should only be called when the information nets to be set in memory and not the db
/// (for instance during initialization)
/// </summary>
/// <param name="msg"></param>
public void SetCompletionErrorMessage(string msg)
{
_errorMessage = msg;
}
public int CompareTo(TestTemplate right)
{
if (null == right) { return 1; }
var r = Name.CompareTo(right.Name);
return 0 == r ? LastModified.CompareTo(right.LastModified) : r;
}
public TestTestObject GetTestTestObject(string testObjectSerial)
{
foreach (var tto in TestObjects)
{
if (tto.SerialNumber == testObjectSerial) { return tto; }
}
return Array.Find(AddedGroups, addedGroup => addedGroup.SerialNumber == testObjectSerial);
}
/// <summary>
/// calculates whether the test setup is complete or not
/// will cause the test setup to be loaded if it is not yet
/// does not unload the test setup
/// </summary>
private void CalculateIsComplete()
{
if (!IsLoaded)
{
Load();
}
var errorMessage = string.Empty;
var errors = new List<string>();
var warnings = new List<string>();
var res = Validate(ref errors, ref warnings, false, this, true, StrictLevel.UpdateTable, false, true);
//don't limit quick sensor check to one operating mode
if (!QuickSensorCheck)
{
switch (GetISOTestSetupISOSupportLevel())
{
case SerializedSettings.ISOSupportLevels.NO_ISO:
//Only valid if exact mode
if (SerializedSettings.ISOSupportLevel !=
SerializedSettings.ISOSupportLevels.NO_ISO)
{
res = false;
errors.Add("TestObject_GroupNotSupportedInCurrentISOSupportLevel"/*Strings.StringResources.TestObject_GroupNotSupportedInCurrentISOSupportLevel*/);
}
break;
case SerializedSettings.ISOSupportLevels.ISO_ONLY:
case SerializedSettings.ISOSupportLevels.TRANSITORY:
//Allow either non-ISO modes (TRANSITORY or ISO_ONLY)
if (SerializedSettings.ISOSupportLevel ==
SerializedSettings.ISOSupportLevels.NO_ISO)
{
res = false;
errors.Add("TestObject_GroupNotSupportedInCurrentISOSupportLevel"/*Strings.StringResources.TestObject_GroupNotSupportedInCurrentISOSupportLevel*/);
}
break;
}
}
if (errors.Count > MaxErrorsToDisplay)
{
errorMessage = string.Format("{0}{1}{2}", string.Join(Environment.NewLine, errors.ToArray(), 0, MaxErrorsToDisplay),
Environment.NewLine, string.Format("TestTemplate_MoreErrors"/*Strings.StringResources.TestTemplate_MoreErrors*/, (errors.Count - MaxErrorsToDisplay)));
}
else if (errors.Count > 0) { errorMessage = string.Join(System.Environment.NewLine, errors.ToArray()); }
if (!res) { IsComplete = false; }
IsComplete = errors.Count <= 0;
_errorMessage = errorMessage;
_bIsDirty = false;
if (0 == Properties.Settings.Default.DBType && IsOutOfDate()) { return; } //DON'T UPDATE, our record is old, just leave it as it is in the db and let the user play around with the mem copy for now
using (var cmd = DbOperations.GetCommand())
{
cmd.CommandText = string.Format("UPDATE {0} SET {1}=@{1}, {2}=@{2}, {3}=@{3} WHERE {4}=@{4}",
DbOperations.TestSetups.TestSetupsTable,
DbOperations.TestSetups.Fields.Complete.ToString(),
DbOperations.TestSetups.Fields.Dirty.ToString(),
DbOperations.TestSetups.Fields.ErrorMessage.ToString(),
DbOperations.TestSetups.Fields.SetupName.ToString());
DbOperations.CreateParam(cmd, string.Format("@{0}", DbOperations.TestSetups.Fields.Dirty.ToString()), SqlDbType.Bit, _bIsDirty);
DbOperations.CreateParam(cmd, string.Format("@{0}", DbOperations.TestSetups.Fields.Complete.ToString()), SqlDbType.Bit, _testTemplateLite.IsComplete);
DbOperations.CreateParam(cmd, string.Format("@{0}", DbOperations.TestSetups.Fields.ErrorMessage.ToString()), SqlDbType.NVarChar, CompletionErrorMessage);
DbOperations.CreateParam(cmd, string.Format("@{0}", DbOperations.TestSetups.Fields.SetupName.ToString()), SqlDbType.NVarChar, Name);
DbOperations.Connection.ExecuteCommand(cmd);
SetTimeStampMemory(GetTimeStampDb());
}
}
/// <summary>
/// marks a test setup as unchecked by setting the dirty flag, which means the next time completion is checked it will be calculated again
/// this function will change that flag in the database immediately
/// </summary>
public void MarkIsCompleteUnchecked(bool skipMemoryCheck = false)
{
//Ensure that our UPDATE below will not cause us to return without resetting our memory timestamp.
var previouslyOutOfDate = IsOutOfDate();
IsComplete = false;
_bIsDirty = true;
_errorMessage = string.Empty;
if (string.IsNullOrEmpty(Name)) { return; }
using (var sql = DbOperations.GetCommand())
{
sql.CommandText = string.Format("UPDATE tblTestSetups SET Dirty=1, Complete=0 WHERE {0}=@{0}", DbOperations.TestSetups.Fields.SetupName.ToString());
DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestSetups.Fields.SetupName.ToString()), SqlDbType.NVarChar, Name);
DbOperations.Connection.ExecuteCommand(sql);
//If this Test Setup was out-of-date before we did the above UPDATE, keep it out-of-date.
if (!skipMemoryCheck && 0 == Properties.Settings.Default.DBType && previouslyOutOfDate) return;
SetTimeStampMemory(GetTimeStampDb());
//THIS FUNCTION NOT ONLY CHANGES THIS COPY OF THE TEST SETUP, BUT ALL!!!
var original = TestTemplateList.TestTemplatesList.GetTemplate(Name);
if (null == original) return;
original.SetTimeStampMemory(GetTimeStampMemory());
original.IsDirty = true;
original.IsComplete = false;
//delete sensor
}
}
/// <summary>
/// frees up the memory assigned during Load, this includes channels, groups, meta data, etc
/// various things may cause us to load the information and hold the information for some setups,
/// but in general we want to unload it if we don't need it
/// </summary>
public void UnLoad()
{
if (QuickSensorCheck) { return; }
_bIsLoaded = false;
if (null != _testObjects) { _testObjects.Clear(); }
if (null != _addedGroups) { _addedGroups.Clear(); }
if (null != TestObjectsAndAddedGroupsList) { TestObjectsAndAddedGroupsList.Clear(); }
if (null != _channelKeysInOrder) { _channelKeysInOrder.Clear(); }
if (null != _channelLookup) { _channelLookup.Clear(); }
if (null != _checkedDASList) { _checkedDASList.Clear(); }
if (null != _dasChannelNumberToAbsoluteNumber) { _dasChannelNumberToAbsoluteNumber.Clear(); }
if (null != _dasSettings) { _dasSettings.Clear(); }
if (null != _filterLookup) { _filterLookup.Clear(); }
if (null != _hardwareChannelsInOrder) { _hardwareChannelsInOrder.Clear(); }
if (null != _metaDataLookup) { _metaDataLookup.Clear(); }
if (null != _oldChannelLookup) { _oldChannelLookup.Clear(); }
lock (SensorLock)
{
if (null != _sensorLookup) { _sensorLookup.Clear(); }
}
if (null != _sessionOpen) { _sessionOpen.Clear(); }
//6552 Cannot set prepare hardware delay seconds. (this information is in the root table, don't unload it)
if (null != _testGraphs) { _testGraphs.Clear(); }
if (null != _testSetupMeta) { _testSetupMeta.Clear(); }
if (null != _hardwareOverrides) { _hardwareOverrides.Clear(); }
if (null != LevelTriggerChannels) { LevelTriggerChannels.Clear(); }
}
/// <summary>
/// loads all the information for the test setup from tables in the db
/// we do this so that we can keep the minimal information on hand until we need it
/// </summary>
public void Load()
{
if (QuickSensorCheck) { return; }
if (string.IsNullOrWhiteSpace(Name)) { return; } //nothing to load!
//intermediate structures. originally we loaded all test graphs at once, so these structures made sense, now they are a little
//vestigial, but it was a clean transition from the old loading structure ...
var tblTestGraphs = new Dictionary<string, List<Dictionary<string, object>>>(100);
var tblTestSetupDASSettings = new Dictionary<string, List<Dictionary<string, object>>>(100);
var tblTestObjects = new Dictionary<string, List<Dictionary<string, object>>>(100);
var tblChannelSettings = new Dictionary<string, List<Dictionary<string, object>>>(100);
var tblMetaData = new Dictionary<string, List<Dictionary<string, object>>>(100);
#region Load Graphs
try
{
using (var sql = DbOperations.GetCommand())
{
//sp_GetTestGraphs
sql.CommandText = string.Format("SELECT * from [{0}] where {1}=@{1}", DbOperations.TestSetups.TestGraphsTable, DbOperations.TestSetups.GraphFields.TemplateName.ToString());
DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestSetups.GraphFields.TemplateName.ToString()), SqlDbType.NVarChar,
Name);
using (var ds = DbOperations.Connection.QueryDataSet(sql))
{
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
TestTemplateList.ConvertToDictionary(ds.Tables[0], ref tblTestGraphs, DbOperations.TestSetups.GraphFields.TemplateName.ToString());
}
}
}
}
catch (Exception)
{
//ignore
}
#endregion Graphs
#region Load DAS Settings
try
{
using (var sql = DbOperations.GetCommand())
{
//sp_GetTestSetupDASSettings
sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE TestSetupName=@TestSetupName", DbOperations.TestSetups.DASSettingsTable);
DbOperations.CreateParam(sql, "@TestSetupName", SqlDbType.NVarChar, Name);
using (var ds = DbOperations.Connection.QueryDataSet(sql))
{
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
TestTemplateList.ConvertToDictionary(ds.Tables[0], ref tblTestSetupDASSettings, "TestSetupName");
}
}
}
}
catch (Exception)
{
//ignore
}
#endregion DAS Settings
#region Load Groups
try
{
using (var sql = DbOperations.GetCommand())
{
//sp_GetTestSetupObjects
sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE {1}=@{1}", DbOperations.TestSetups.TestSetupObjectsTable,
DbOperations.TestSetups.TestSetupObjectFields.TestSetupName.ToString());
DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestSetups.TestSetupObjectFields.TestSetupName.ToString()),
SqlDbType.NVarChar, Name);
using (var ds = DbOperations.Connection.QueryDataSet(sql))
{
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
TestTemplateList.ConvertToDictionary(ds.Tables[0], ref tblTestObjects, DbOperations.TestSetups.TestSetupObjectFields.TestSetupName.ToString());
}
}
}
}
catch (Exception)
{
//ignore
}
#endregion Objects
#region Load Channel Settings
try
{
using (var sql = DbOperations.GetCommand())
{
//sp_GetTestChannelSettings
sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE {1}=@{1}", DbOperations.TestSetups.ChannelSettingsTable,
DbOperations.TestSetups.ChannelSettingFields.TestName.ToString());
DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestSetups.ChannelSettingFields.TestName.ToString()),
SqlDbType.NVarChar, Name);
using (var ds = DbOperations.Connection.QueryDataSet(sql))
{
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
TestTemplateList.ConvertToDictionary(ds.Tables[0], ref tblChannelSettings, DbOperations.TestSetups.ChannelSettingFields.TestName.ToString());
}
}
}
}
catch (Exception)
{
//ignore
}
#endregion Channel Settings
#region Load Meta Data
try
{
using (var sql = DbOperations.GetCommand())
{
//sp_GetTestSetupObjectMetaData
sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE {1}=@{1}", DbOperations.TestSetups.TestObjectMetaDataTable,
DbOperations.TestSetups.TestObjectMetaDataFields.SetupName.ToString());
DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestSetups.TestObjectMetaDataFields.SetupName.ToString()),
SqlDbType.NVarChar, Name);
using (var ds = DbOperations.Connection.QueryDataSet(sql))
{
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
TestTemplateList.ConvertToDictionary(ds.Tables[0], ref tblMetaData, DbOperations.TestSetups.TestObjectMetaDataFields.SetupName.ToString());
}
}
}
}
catch (Exception)
{
//ignore
}
#endregion Meta Data
#region Load Hardware Overrides
try
{
_hardwareOverrides.Clear();
using (var sql = DbOperations.GetCommand())
{
//sp_GetTestSetupHardware
sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE {1}=@{1}",
DbOperations.TestSetups.HardwareTable,
DbOperations.TestSetups.HardwareFields.TestSetupName.ToString());
DbOperations.CreateParam(sql,
string.Format("@{0}", DbOperations.TestSetups.HardwareFields.TestSetupName.ToString()),
SqlDbType.NVarChar,
Name);
var columns = Enum.GetValues(typeof(DbOperations.TestSetups.HardwareFields))
.Cast<DbOperations.TestSetups.HardwareFields>().ToArray();
using (var ds = DbOperations.Connection.QueryDataSet(sql))
{
foreach (DataRow row in ds.Tables[0].Rows)
{
var bAdd = true;
var hid = "";
foreach (var column in columns)
{
var o = row[column.ToString()];
if (DBNull.Value.Equals(o)) { continue; }
switch (column)
{
case DbOperations.TestSetups.HardwareFields.AddOrRemove:
bAdd = Convert.ToBoolean(o);
break;
case DbOperations.TestSetups.HardwareFields.HardwareId:
hid = Convert.ToString(o);
break;
case DbOperations.TestSetups.HardwareFields.TestSetupName:
//don't need
break;
}
}
if (!string.IsNullOrEmpty(hid))
{
_hardwareOverrides[hid] = new HardwareInclusionInstruction(hid,
bAdd ? HardwareInclusionInstruction.Actions.Add : HardwareInclusionInstruction.Actions.Remove);
}
}
}
}
}
catch (Exception)
{
//ignore
}
#endregion
//now all the structures are populated from the db, we just have to process and populate into classes
#region Load Calculated Channels
_calculatedChannels.Clear();
var calculatedChannels = new List<CalculatedValueClass>();
try
{
using (var sql = DbOperations.GetCommand())
{
//sp_GetCalculatedChannels
sql.CommandText = string.Format("SELECT * from {0} WHERE [{1}]=@1",
DbOperations.CalculatedChannels.Table,
DbOperations.CalculatedChannels.Fields.TestSetupName.ToString());
DbOperations.CreateParam(sql, "@1", SqlDbType.NVarChar, Name);
using (var ds = DbOperations.Connection.QueryDataSet(sql))
{
foreach (DataRow row in ds.Tables[0].Rows)
{
try
{
calculatedChannels.Add(new CalculatedValueClass(row));
}
catch (Exception)
{
//ignore
}
}
}
}
}
catch (Exception)
{
//ignore
}
#endregion Calculated Channels
#region Load Level Triggers
LevelTriggerChannels.Clear();
var levelTriggerChannels = new List<LevelTriggerChannel>();
try
{
using (var sql = DbOperations.GetCommand())
{
//sp_GetLevelTriggers
sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE {1}=@1",
DbOperations.LevelTriggers.Table,
DbOperations.LevelTriggers.Fields.TestSetupName.ToString());
DbOperations.CreateParam(sql, "@1", SqlDbType.NVarChar, Name);
using (var ds = DbOperations.Connection.QueryDataSet(sql))
{
foreach (DataRow row in ds.Tables[0].Rows)
{
try
{
levelTriggerChannels.Add(new LevelTriggerChannel(row));
}
catch (Exception)
{
//ignore
}
}
}
}
}
catch (Exception)
{
//ignore
}
#endregion
#region Process Groups
_testObjects.Clear();
_addedGroups.Clear();
TestObjectsAndAddedGroupsList.Clear();
if (tblTestObjects.ContainsKey(Name))
{
foreach (var row in tblTestObjects[Name])
{
var serialNumber = "";
var excitationWarmupTimeMs = 0;
var targetSampleRate = 20000D;
var testobject = "?";
var position = "?";
var tsofields = Enum.GetValues(typeof(DbOperations.TestSetups.TestSetupObjectFields))
.Cast<DbOperations.TestSetups.TestSetupObjectFields>().ToArray();
foreach (var field in tsofields)
{
var o = row[field.ToString()];
if (DBNull.Value.Equals(o)) { continue; }
switch (field)
{
case DbOperations.TestSetups.TestSetupObjectFields.TestSetupName:
break;
case DbOperations.TestSetups.TestSetupObjectFields.TestObjectType:
testobject = Convert.ToString(o);
break;
case DbOperations.TestSetups.TestSetupObjectFields.TestObjectSerialNumber:
serialNumber = Convert.ToString(o);
break;
case DbOperations.TestSetups.TestSetupObjectFields.TestObjectPosition:
position = Convert.ToString(o);
break;
case DbOperations.TestSetups.TestSetupObjectFields.TargetSampleRate:
targetSampleRate = Convert.ToDouble(o);
break;
case DbOperations.TestSetups.TestSetupObjectFields.LocalOnly:
break;
case DbOperations.TestSetups.TestSetupObjectFields.ExcitationWarmupTimeMS:
excitationWarmupTimeMs = Convert.ToInt32(o);
break;
}
}
try
{
if (TestTemplateList.SysBuiltObject(serialNumber))
{
AddAddedGroup(serialNumber, testobject, position);
}
else
{
AddTestObject(serialNumber, excitationWarmupTimeMs, targetSampleRate, testobject, position);
}
}
catch (Exception)
{
//ignore
}
}
}
#endregion Groups
#region Process Graphs
if (null != _testGraphs) { _testGraphs.Clear(); }
if (tblTestGraphs.ContainsKey(Name))
{
foreach (var row in tblTestGraphs[Name])
{
var tg = new TestGraph(this)
{
GraphName = Convert.ToString(row["GraphName"]),
GraphDescription = Convert.ToString(row["GraphDescription"]),
UseDomainMin = Convert.ToBoolean(row["UseDomainMin"]),
DomainMin = Convert.ToDouble(row["DomainMin"]),
UseDomainMax = Convert.ToBoolean(row["UseDomainMax"]),
DomainMax = Convert.ToDouble(row["DomainMax"]),
UseRangeMin = Convert.ToBoolean(row["UseRangeMin"]),
RangeMin = Convert.ToDouble(row["RangeMin"]),
UseRangeMax = Convert.ToBoolean(row["UseRangeMax"]),
RangeMax = Convert.ToDouble(row["RangeMax"]),
};
tg.SetChannelsFromSQL(Convert.ToString(row["Channels"]));
tg.SetThresholdsFromSQL(Convert.ToString(row["Thresholds"]));
AddTestGraph(tg);
}
}
#endregion Graphs
#region Process DASSettings
var settings = new List<DASSettings>();
if (tblTestSetupDASSettings.ContainsKey(Name))
{
settings.AddRange(tblTestSetupDASSettings[Name].Select(row => new DASSettings
{
BatteryCheck = Convert.ToBoolean(row["BatteryCheck"])
,
BatteryVoltageMax = Convert.ToDouble(row["BatteryVoltageMax"])
,
BatteryVoltageMin = Convert.ToDouble(row["BatteryVoltageMin"])
,
DASSerialNumber = Convert.ToString(row["DASSerialNumber"])
,
ExcitationWarmupTimeMS = Convert.ToInt32(row["ExcitationWarmupTimeMS"])
,
HardwareAAF = Convert.ToDouble(row["AAFilterRate"])
,
InputVoltageMax = Convert.ToDouble(row["InputVoltageMax"])
,
InputVoltageMin = Convert.ToDouble(row["InputVoltageMin"])
,
PostTriggerSeconds = Convert.ToDouble(row["PostTriggerSeconds"])
,
PreTriggerSeconds = Convert.ToDouble(row["PreTriggerSeconds"])
,
SampleRate = Convert.ToDouble(row["TargetSampleRate"])
,
StatusLineCheck = Convert.ToBoolean(row["StatusLineCheck"])
}));
}
#endregion DASSettings
#region Process ChannelSettings
if (tblChannelSettings.ContainsKey(Name))
{
var cFields = Enum.GetValues(typeof(DbOperations.TestSetups.ChannelSettingFields)).Cast<DbOperations.TestSetups.ChannelSettingFields>().ToArray();
foreach (var row in tblChannelSettings[Name])
{
string testobjectname = null;
string channelname = null;
string sensorserial = null;
string setting = null;
foreach (var cf in cFields)
{
switch (cf)
{
case DbOperations.TestSetups.ChannelSettingFields.TestName: break;
case DbOperations.TestSetups.ChannelSettingFields.Setting:
setting = row[cf.ToString()] as string;
break;
case DbOperations.TestSetups.ChannelSettingFields.TestObjectName:
testobjectname = row[cf.ToString()] as string;
break;
case DbOperations.TestSetups.ChannelSettingFields.ChannelId:
channelname = row[cf.ToString()] as string;
break;
case DbOperations.TestSetups.ChannelSettingFields.SensorSerial:
sensorserial = row[cf.ToString()] as string;
break;
}
}
if (string.IsNullOrEmpty(testobjectname) || string.IsNullOrEmpty(channelname) ||
string.IsNullOrEmpty(setting)) continue;
try
{
var sd = TestTemplateList.GetSensorFromSettings(setting, sensorserial);
if (null != sd)
{
if (sd.FilterClassIso == "?")
{
sd.FilterClassIso = "P"; // "Prefiltered > CFC 1000" (Unfiltered)
}
SetSensor(sd, testobjectname, channelname);
}
}
catch (Exception)
{
//ignore
}
}
}
DASSettings = settings.ToArray();
#endregion Channel Settings
#region Process MetaData
var metas = new Dictionary<char, TestObjectMetaData>();
var setupMeta = new TestSetupMetaData(Properties.Settings.Default.RequireXCrashCompatibilityForISOExports);
if (tblMetaData.ContainsKey(Name))
{
foreach (var row in tblMetaData[Name])
{
var bOptional = Convert.ToBoolean(row[DbOperations.TestSetups.TestObjectMetaDataFields.Optional.ToString()]);
var pname = Convert.ToString(row[DbOperations.TestSetups.TestObjectMetaDataFields.PropName.ToString()]);
var pvalue = Convert.ToString(row[DbOperations.TestSetups.TestObjectMetaDataFields.PropValue.ToString()]);
var to = "?";
try
{
if (row[DbOperations.TestSetups.TestObjectMetaDataFields.TestObject.ToString()] is string)
{
to = (row[DbOperations.TestSetups.TestObjectMetaDataFields.TestObject.ToString()] as string);
}
else
{
to = Convert.ToString(Convert.ToChar(Convert.ToInt32(row[DbOperations.TestSetups.TestObjectMetaDataFields.TestObject.ToString()])));
}
}
catch (Exception)
{
//ignore
}
//little wonky here, sometimes the character comes in as a number, sometimes as a string.
//if we end up with a string longer than 1 character, then we definitely need to convert it.
//there are no strings of length 2 that are a valid character
if (to.Length > 1)
{
try
{
if (int.TryParse(to, out int iTemp)) { to = Convert.ToString(Convert.ToChar(iTemp)); }
}
catch (Exception)
{
//ignore
}
}
var version = Convert.ToDouble(row[DbOperations.TestSetups.TestObjectMetaDataFields.Version.ToString()]);
if (to == "_")
{
if ((pname == "Title") && ((pvalue == "NOVALUE") || (string.IsNullOrWhiteSpace(pvalue))))
{
pvalue = Name;
}
else if (pname == "DateOfTheTest")
{
pvalue = DateTime.Now.ToString("yyyy-MM-dd");
}
setupMeta.SetProperty(new MetaData(pname, bOptional, pvalue, version), Properties.Settings.Default.RequireXCrashCompatibilityForISOExports);
}
else
{
if (!metas.ContainsKey(to[0])) { metas.Add(to[0], new TestObjectMetaData(to[0])); }
metas[to[0]].SetProperty(new MetaData(pname, bOptional, pvalue, version));
}
}
}
foreach (var v in metas.Values)
{
SetMetaData(v.TestObject, v);
}
SetTestSetupMetaData(setupMeta);
_bIsLoaded = true;
#endregion
#region Process Calculated Channels
foreach (var cc in calculatedChannels)
{
AddCalculatedChannel(cc);
}
#endregion Process Calculated Channels
#region Process Level Triggers
foreach (var lt in levelTriggerChannels)
{
SetLevelTrigger(lt);
}
#endregion Process Level Triggers
ApplyHardwareOverrides();
}
// #region Validate
public static bool ValidateTestSetupName(ref List<string> errors, TestTemplate CurrentTestSetup)
{
if (string.IsNullOrWhiteSpace(CurrentTestSetup.Name))
{
errors.Add("EditTestSetup_NameRequired"/*Strings.StringResources.EditTestSetup_NameRequired*/);
return false;
}
if (CurrentTestSetup.Name == "QuickSensorCheck_DefaultTestName"/*Strings.StringResources.QuickSensorCheck_DefaultTestName*/ &&
!CurrentTestSetup.QuickSensorCheck)
{
errors.Add("QuickSensorCheck_DefaultTestNameInvalid"/*Strings.StringResources.QuickSensorCheck_DefaultTestNameInvalid*/);
return false;
}
if (DiskUtility.ValidateFileAndPathNameChars(CurrentTestSetup.Name))
{
var nameToCheck = CurrentTestSetup.Name.ToLower();
if (nameToCheck.Equals("iso") || nameToCheck.Equals("csv") || nameToCheck.Equals("realtime"))
{
errors.Add("EditTestSetup_NameCannotBeISOCSVOrRealtime"/*Strings.StringResources.EditTestSetup_NameCannotBeISOCSVOrRealtime*/);
return false;
}
var encoding = Encoding.GetEncoding("UTF-8");
var nameInBytes = encoding.GetBytes(nameToCheck);
if (nameInBytes.Length == nameToCheck.Length) return true;
errors.Add("EditTestSetup_NameCannotContainDoubleByteCharacters"/*Strings.StringResources.EditTestSetup_NameCannotContainDoubleByteCharacters*/);
return false;
}
errors.Add("EditTestSetup_NameContainsInvalidCharacters"/*Strings.StringResources.EditTestSetup_NameContainsInvalidCharacters*/);
//fatal
return false;
}
public static bool Validate(ref List<string> errors, ref List<string> warnings, bool displayWindow, TestTemplate CurrentTestSetup, bool bValid, StrictLevel strictness, bool markIsCompleteUnchecked, bool bWarnOnNotFullyAssigned)
{
//I'm not sure of all the entry points into this function
//it seems like there are many
//however there are definite times we _don't_ want to just blindly change the iscompleteunchecked flag
//just because we want to do some validation on the test plan ...
//for now I just fixed the ones I know shouldn't be changing the flag blindly
//and preserved current behavior for the rest ...
var bHasHardware = false;
var bHasChannels = false;
var testobjects = new List<TestTestObject>();
testobjects.AddRange(CurrentTestSetup.TestObjects);
testobjects.AddRange(CurrentTestSetup.AddedGroups);
var serialNumbersProcessed = new Dictionary<string, bool>();
var hardwareChannelIdsProcessed = new Dictionary<string, bool>();
var channelLookup = new Dictionary<string, HardwareChannel>();
var usedISOCodesLookup = new Dictionary<string, bool>();
var availableAnalogChannels = 0;
var availableDigitalInputChannels = 0;
var availableDigitalOutputChannels = 0;
var availableSquibChannels = 0;
if (testobjects.Any())
{
//this is using the assumption that all testobjects now have the same list of hardware
foreach (var lastTO in testobjects)
{
lastTO.RefreshHardware();
foreach (var h in lastTO.Hardware)
{
if (null != h)
{
var ser = h.SerialNumber;
var hFromDB = DASHardwareList.GetList().GetHardware(h.GetHardware().GetId());
if (null == hFromDB)
{
var err = string.Format("Test includes hardware which is no longer available ({0})" /*Strings.StringResources.TestTemplate_HardwareNotFound*/, ser);
continue;
}
}
else
{
continue;
}
var hType = h.GetHardwareTypeEnum();
if (hType == Hardware.HardwareTypes.SLICE_EthernetController
|| hType == Hardware.HardwareTypes.SLICE_Distributor
|| hType == Hardware.HardwareTypes.SLICE_LabEthernet)
{
continue;
}
bHasHardware = true;
if (CurrentTestSetup.DoAutoArm)
{
switch (hType)
{
case Hardware.HardwareTypes.TDAS_Pro_Rack:
case Hardware.HardwareTypes.TDAS_LabRack:
case Hardware.HardwareTypes.G5INDUMMY:
case Hardware.HardwareTypes.G5VDS:
errors.Add("Some hardware does not support auto-arming");
break;
}
}
for (var i = 0; i < h.Channels.Length; i++)
{
var ch = h.Channels[i];
if (channelLookup.ContainsKey(ch.GetId())) continue;
channelLookup.Add(ch.GetId(), ch);
if (ch.IsSupportedBridgeType(Test.Module.Channel.Sensor.BridgeType.SQUIB))
{ availableSquibChannels++; i++; /*bypass next channel as it's also a squib*/ }
else if (ch.IsSupportedBridgeType(Test.Module.Channel.Sensor.BridgeType.DigitalInput))
{ availableDigitalInputChannels++; }
else if (ch.IsSupportedBridgeType(Test.Module.Channel.Sensor.BridgeType.TOMDigital))
{ availableDigitalOutputChannels++; }
else { availableAnalogChannels++; }
}
}
}
if (!bHasHardware && bWarnOnNotFullyAssigned)
{
errors.Add("Test requires Hardware");
}
}
else
{
errors.Add("Test requires at least one Group");
}
foreach (var to in testobjects)
{
var isoTO = to.GetISOTestObject();
foreach (var ch in isoTO.AllChannels)
{
if (!ch.Required) { continue; }
bHasChannels = true;
if (string.IsNullOrWhiteSpace(ch.SensorSerialNumber))
{
if (!errors.Contains("Some channels have no sensor assigned." /*Strings.StringResources.EditTestSetupPage_NoSensorOnChannel*/) && bWarnOnNotFullyAssigned)
{ errors.Add("Some channels have no sensor assigned." /*Strings.StringResources.EditTestSetupPage_NoSensorOnChannel*/); }
}
else
{
if (serialNumbersProcessed.ContainsKey(ch.SensorSerialNumber))
{
var err = string.Format("Sensor {0} appears multiple times in the test setup." /*Strings.StringResources.EditTestSetupPage_SerialNumberAppearsTwice*/, ch.SensorSerialNumber);
if (!errors.Contains(err)) { errors.Add(err); return false; }
}
else
{ serialNumbersProcessed.Add(ch.SensorSerialNumber, true); }
var sd = CurrentTestSetup.GetSensor(ch.SensorSerialNumber, to.SerialNumber, ch.Name);
if (null == sd)
{
var err = string.Format("Couldn't find sensor {0} for channel {1} for group {2}" /*Strings.StringResources.EditTestSetupPage_CouldNotFindSensor*/, ch.SensorSerialNumber, ch.Name, to.DisplaySerialNumber);
if (!errors.Contains(err)) { errors.Add(err); }
}
else
{
if (sd.IsSquib())
{
availableSquibChannels--;
if (sd.SquibFireDelayMS + sd.SquibFireDurationMS > CurrentTestSetup.PostTriggerSeconds * 1000)
{ errors.Add(string.Format("Sensor '{0}' on channel '{1}' has output that exceeds post-trigger time."/*Strings.StringResources.TestTemplate_InsufficientPostTriggerLength*/, sd.SerialNumber, ch.Name)); }
}
else if (sd.IsDigitalInput()) { availableDigitalInputChannels--; }
else if (sd.IsDigitalOutput())
{
availableDigitalOutputChannels--;
if (sd.DigitalOutputDelayMS + sd.DigitalOutputDurationMS > CurrentTestSetup.PostTriggerSeconds * 1000)
{ errors.Add(string.Format("Sensor '{0}' on channel '{1}' has output that exceeds post-trigger time." /*Strings.StringResources.TestTemplate_InsufficientPostTriggerLength*/, sd.SerialNumber, ch.Name)); }
}
else { availableAnalogChannels--; }
var sensor = SensorsCollection.SensorsList.GetSensorBySerialNumber(ch.SensorSerialNumber);
if (sensor != null)
{
var sensorDimension = sensor.PhysicalDimension;
if (((ISO13499FileDb.IsoDb.GetPhysicalDimensionByIso(sensorDimension) != null) &&
((ISO13499FileDb.IsoDb.GetPhysicalDimensionByIso(ch.Channel.Physical_Dimension) != null) &&
(sd.IncompatibleSensorAssignment(sensorDimension, ch.Channel.Physical_Dimension)))))
{
var err = string.Format("Dimension ({0}) of sensor ({1}) is different than dimension ({2}) of channel ({3}) in group {4}", //Strings.StringResources.EditTestSetupPage_IncompatibleSensorNotSupported,
ISO13499FileDb.IsoDb.GetPhysicalDimensionByIso(sensorDimension).Text_L1,
ch.SensorSerialNumber,
ISO13499FileDb.IsoDb.GetPhysicalDimensionByIso(ch.Channel.Physical_Dimension).Text_L1,
ch.Name, to.DisplaySerialNumber);
switch (SerializedSettings.IsoChannelSensorCompatibilityLevel)
{
case IsoChannelSensorCompatibilityLevels.DontAllow:
if (!errors.Contains(err)) { errors.Add(err); }
bValid = false;
break;
case IsoChannelSensorCompatibilityLevels.Warn:
if (!warnings.Contains("Warning"/*Strings.StringResources.EditObjectSensorsControl_Warning*/ + ": " + err)) { warnings.Add("Warning"/*Strings.StringResources.EditObjectSensorsControl_Warning */+ ": " + err); }
break;
}
}
}
if (!sd.IsDigitalOutput() && (CurrentTestSetup.GetISOTestSetupISOSupportLevel() == SerializedSettings.ISOSupportLevels.ISO_ONLY))
{
if (sd.MainLocation.Contains('?') ||
sd.FineLocation1.Contains('?') ||
sd.FineLocation2.Contains('?') ||
sd.FineLocation3.Contains('?') ||
sd.Direction.Contains('?') ||
sd.PhysicalDimension.Contains('?'))
{
var isoto = to.GetISOTestObject();
foreach (var isotoChannel in isoto.AllChannels)
{
//reapplying channel iso settings here with the exception of filter class, position, and test object
if (ch.Name != isotoChannel.Name) continue;
sd.MainLocation = ch.Channel.Trans_Main_Loc;
sd.FineLocation1 = ch.Channel.Fine_Loc_1;
sd.FineLocation2 = ch.Channel.Fine_Loc_2;
sd.FineLocation3 = ch.Channel.Fine_Loc_3;
sd.Direction = ch.Channel.Direction;
sd.PhysicalDimension = ch.Channel.Physical_Dimension;
}
}
if (usedISOCodesLookup.ContainsKey(sd.ISOCode))
{
var err = $"TestTemplate_DuplicateISOCode {sd.ISOCode}";
if (!errors.Contains(err)) { errors.Add(err); }
}
else { usedISOCodesLookup[sd.ISOCode] = true; }
}
SensorCalibration sc = null;
var preferredExcitation = sd.SupportedExcitation[0];
sc = SensorCalibration.GetLatestCalibrationBySerialNumberAndExcitation(sd, preferredExcitation);
if (null == sc)
{
bValid = false;
var err = $"EditTestSetupPage_MissingCalibration {ch.Name}, {sd.SerialNumber}";
if (!errors.Contains(err)) { errors.Add(err); }
}
else
{
var now = DateTime.Now;
var days = sc.CalibrationDate.AddDays(sd.CalInterval).Subtract(now).TotalDays;
if (SerializedSettings.TestSetupDefaultDontAllowOutOfCalSensors && ((days < 0) || (days < Properties.Settings.Default.CalWarningPeriodDays)))
{
bValid = false;
var err = $"OverdueSensors_CalibrationDateOverdueOrNear {ch.Name}, {sd.SerialNumber}";
if (!errors.Contains(err)) { errors.Add(err); }
}
}
if (!string.IsNullOrWhiteSpace(ch.HardwareId))
{
if (!channelLookup.ContainsKey(ch.HardwareId))
{
var err = $"EditTestSetupPage_InvalidHardware {ch.Name}, {to.DisplaySerialNumber}";
if (!errors.Contains(err)) { errors.Add(err); }
}
else
{
if (hardwareChannelIdsProcessed.ContainsKey(ch.HardwareId))
{
bValid = false;
var err = $"EditTestSetupPage_HardwareAlreadyInUse, {ch.Name}, {to.DisplaySerialNumber}";
if (!errors.Contains(err)) { errors.Add(err); }
}
else
{
hardwareChannelIdsProcessed.Add(ch.HardwareId, true);
var hch = channelLookup[ch.HardwareId];
if (sd.ByPassFilter &&
((hch.Hardware.GetHardwareTypeEnum() != Hardware.HardwareTypes.TDAS_Pro_Rack) &&
(hch.Hardware.GetHardwareTypeEnum() != Hardware.HardwareTypes.TDAS_LabRack)))
{
var err = $"EditTestSetupPage_BypassAAFilterNotSupported, {ch.Name}, {to.DisplaySerialNumber}";
if (!errors.Contains(err)) { errors.Add(err); }
}
else
{
if (hch.IsSupportedBridgeType(sd.Bridge)) continue;
var err = $"EditTestSetupPage_BridgeNotSupported, {sd.Bridge}, {ch.Name}, {to.DisplaySerialNumber}";
if (!errors.Contains(err)) { errors.Add(err); }
}
}
}
}
}
}
}
}
if (!bHasChannels) { errors.Add("EditTestSetupPage_NoChannelsInTest"); }
if (availableAnalogChannels < 0 && !CurrentTestSetup.AllowMissingSensors && bWarnOnNotFullyAssigned)
{
if (!errors.Contains("EditTestSetupPage_NeedMoreAnalogChannels") && !errors.Contains("EditTestSetupPage_NoHardwareInTest"))
{ errors.Add("EditTestSetupPage_NeedMoreAnalogChannels"); }
}
if (availableDigitalInputChannels < 0 && !CurrentTestSetup.AllowMissingSensors && bWarnOnNotFullyAssigned)
{
if (!errors.Contains("EditTestSetupPage_NeedMoreDigitalInputChannels") && !errors.Contains("EditTestSetupPage_NoHardwareInTest"))
{ errors.Add("EditTestSetupPage_NeedMoreDigitalInputChannels"); }
}
if (availableDigitalOutputChannels < 0 && !CurrentTestSetup.AllowMissingSensors && bWarnOnNotFullyAssigned)
{
if (!errors.Contains("EditTestSetupPage_NeedMoreDigitalOutputChannels"/*Strings.StringResources.EditTestSetupPage_NeedMoreDigitalOutputChannels*/) && !errors.Contains("EditTestSetupPage_NoHardwareInTest"/*Strings.StringResources.EditTestSetupPage_NoHardwareInTest */))
{ errors.Add("EditTestSetupPage_NeedMoreDigitalOutputChannels"/*Strings.StringResources.EditTestSetupPage_NeedMoreDigitalOutputChannels*/); }
}
if (availableSquibChannels < 0 && !CurrentTestSetup.AllowMissingSensors && bWarnOnNotFullyAssigned)
{
if (!errors.Contains("EditTestSetupPage_NeedMoreSquibChannels"/*Strings.StringResources.EditTestSetupPage_NeedMoreSquibChannels*/) && !errors.Contains("EditTestSetupPage_NoHardwareInTest"/*Strings.StringResources.EditTestSetupPage_NoHardwareInTest */))
{ errors.Add(""/*Strings.StringResources.EditTestSetupPage_NeedMoreSquibChannels*/); }
}
if (!ValidateTestSetupName(ref errors, CurrentTestSetup)) { bValid = false; }
ValidateStorageSpace(ref errors, CurrentTestSetup);//not fatal
ValidateUploadFolder(ref errors, CurrentTestSetup);//not fatal
ValidateAutoArmAllowability(ref errors, CurrentTestSetup);
return bValid;
}
public static bool ValidateUploadFolder(ref List<string> errors, TestTemplate currentTest)
{
//if we have a export ini file, we still allow a blank upload folder
if (!currentTest.UploadData || !string.IsNullOrWhiteSpace(currentTest.UploadFolder)) return true;
if (SerializedSettings.ExportINIFile.Length > 0) { return true; }
errors.Add("TestTestTemplate_InvalidUploadPath"/*Strings.StringResources.TestTestTemplate_InvalidUploadPath*/);
return false;
}
private static bool ValidateAutoArmAllowability(ref List<string> errors, TestTemplate currentTest)
{
if (!currentTest.DoAutoArm || Properties.Settings.Default.AllowAutoArm) return true;
errors.Add("EditTestSetupInfo_AutoArmNotAllowed");
return false;
}
public static bool ValidateStorageSpace(ref List<string> errors, TestTemplate currentTest)
{
var bStorageSpaceValid = true;
var preTriggerSeconds = currentTest.PreTriggerSeconds;
var postTriggerSeconds = currentTest.PostTriggerSeconds;
var sampleRate = currentTest.SamplesPerSecond;
var secondsToRecord = preTriggerSeconds + postTriggerSeconds;
var sampleClocksToRecord = (ulong)(secondsToRecord * sampleRate + 1);
var das = new List<DASHardware>();
foreach (var to in currentTest.TestObjects)
{
foreach (var h in to.Hardware)
{
if (!das.Contains(h)) { das.Add(h); }
}
}
foreach (var to in currentTest.AddedGroups)
{
foreach (var h in to.Hardware)
{
if (!das.Contains(h)) { das.Add(h); }
}
}
foreach (var d in das)
{
double maxSampleClockTicks = d.GetMaxMemoryLong();
if (!(maxSampleClockTicks > 0)) continue;
if (!(sampleClocksToRecord > maxSampleClockTicks)) continue;
bStorageSpaceValid = false;
errors.Add(string.Format("TestTemplate_InsufficientMemory"/*Strings.StringResources.TestTemplate_InsufficientMemory*/, d.SerialNumber, maxSampleClockTicks));
}
return bStorageSpaceValid;
}
public void AddTestGraph(TestGraph tg)
{
_testGraphs.Add(tg);
}
/// <summary>
/// holds test settings that don't have individual db columns
/// </summary>
private readonly TestSettingDictionary _settings = CreateSettingsDictionary();
/// <summary>
/// loads values from a serialized string into the settings table
/// </summary>
/// <param name="s"></param>
public void LoadSettings(string s)
{
_settings.LoadSettings(s);
}
/// <summary>
/// constructs a settings table with some default values
/// default values can then have their values changed by LoadSettings if we are loading from a db
/// </summary>
/// <returns></returns>
private static TestSettingDictionary CreateSettingsDictionary()
{
var settings = new TestSettingDictionary();
var mySettings = Enum.GetValues(typeof(TestSettingsEnum)).Cast<TestSettingsEnum>().ToArray();
foreach (var setting in mySettings)
{
switch (setting)
{
case TestSettingsEnum.ArmCheckListStep:
settings.SetValue(new TestSetting(TestSettingsEnum.ArmCheckListStep.ToString(), Properties.Settings.Default.DefaultTestArmCheckListStep.ToString(), Properties.Settings.Default.DefaultTestArmCheckListStep.ToString()));
break;
case TestSettingsEnum.CheckListBatteryVoltageCheck:
settings.SetValue(new TestSetting(TestSettingsEnum.CheckListBatteryVoltageCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListBatteryVoltageCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListBatteryVoltageCheck.ToString()));
break;
case TestSettingsEnum.CheckListInputVoltageCheck:
settings.SetValue(new TestSetting(TestSettingsEnum.CheckListInputVoltageCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListInputVoltageCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListInputVoltageCheck.ToString()));
break;
case TestSettingsEnum.CheckListSensorIDCheck:
settings.SetValue(new TestSetting(TestSettingsEnum.CheckListSensorIDCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListSensorIDCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListSensorIDCheck.ToString()));
break;
case TestSettingsEnum.CheckListSquibResistanceCheck:
settings.SetValue(new TestSetting(TestSettingsEnum.CheckListSquibResistanceCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListSquibResistanceCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListSquibResistanceCheck.ToString()));
break;
case TestSettingsEnum.CheckListTriggerStartCheck:
settings.SetValue(new TestSetting(TestSettingsEnum.CheckListTriggerStartCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListTriggerStartCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListTriggerStartCheck.ToString()));
break;
case TestSettingsEnum.CheckListMustPass:
settings.SetValue(new TestSetting(TestSettingsEnum.CheckListMustPass.ToString(), Properties.Settings.Default.DefaultTestCheckListMustPass.ToString(), Properties.Settings.Default.DefaultTestCheckListMustPass.ToString()));
break;
case TestSettingsEnum.EW:
settings.SetValue(new TestSetting(TestSettingsEnum.EW.ToString(), Properties.Settings.Default.DefaultTestExcitationWarmupMS.ToString(System.Globalization.CultureInfo.InvariantCulture), Properties.Settings.Default.DefaultTestExcitationWarmupMS.ToString(System.Globalization.CultureInfo.InvariantCulture)));
break;
default:
throw new NotSupportedException("unsupported setting:" + setting.ToString());
}
}
//initialize here
return settings;
}
/// <summary>
/// returns the iso support level of object (as determined by it's groups, or the current application support level)
/// </summary>
/// <returns></returns>
public SerializedSettings.ISOSupportLevels GetISOTestSetupISOSupportLevel()
{
var nonISOTO = GetNonISOTestObject();
foreach (var to in TestObjects)
{
if (to == nonISOTO)
{
//if it only has digital outputs, it could be either a non iso or an iso group, so ignore it
var isoto = to.GetISOTestObject();
if (isoto.AllChannels.Where(ch => ch.Required && !string.IsNullOrWhiteSpace(ch.SensorSerialNumber)).Any(ch => !SensorData.IsTestSpecificDigitalOutSN(ch.SensorSerialNumber)))
{
return SerializedSettings.ISOSupportLevels.NO_ISO;
}
}
else
{
return to.GetObjectISOLevel();
}
}
foreach (var to in AddedGroups) { return SerializedSettings.ISOSupportLevels.ISO_ONLY; }
return SerializedSettings.ISOSupportLevel;
}
private TestTestObject CreateNonISOGroupIfNecessary()
{
foreach (var group in _testObjects)
{
if (group.SerialNumberOrOriginalSerialNumber == NON_ISO_INTERNAL_GROUP_NAME)
{
return group;
}
}
//if you got here it wasn't found
var guid = Guid.NewGuid();
var template = new TestObjectTemplate();
var isoTO = template.ToISOTestObjectTemplate();
isoTO.Embedded = true;
isoTO.TemplateName = guid.ToString();
var db = ISO13499FileDb.IsoDb;
template = new TestObjectTemplate(isoTO, ref db);
var to = new TestObject { Template = template };
to.GetISOTestObject().Embedded = true;
to.GetISOTestObject().OriginalSerialNumber = NON_ISO_INTERNAL_GROUP_NAME;
to.SerialNumber = guid.ToString();
var g = new TestTestObject(to);
_testObjects.Add(g);
TestObjectsAndAddedGroupsList.Add(g);
return g;
}
public TestTestObject GetNonISOTestObject()
{
return CreateNonISOGroupIfNecessary();
}
public void SetTestObjects(bool bMemoryOnly, TestTestObject[] value)
{
if (!bMemoryOnly)
{
MarkIsCompleteUnchecked();
}
var position = 0;
if (SerializedSettings.ISOSupportLevel == SerializedSettings.ISOSupportLevels.NO_ISO)
{
foreach (var to in value)
{
if (to.GetObjectISOLevel() != SerializedSettings.ISOSupportLevels.NO_ISO) continue;
var availablePositions = to.AvailablePositions;
if (position < availablePositions.Length)
{
to.Position = availablePositions[position];
position++;
}
else
{
throw new NotSupportedException("TestTemplate::Not enough positions for groups in test");
}
}
}
SetProperty(ref _testObjects, new List<TestTestObject>(value), TestTemplateTags.TestObjects.ToString());
OnPropertyChanged(TestTemplateTags.AvailableTestObjects.ToString()); //No longer needed for added test objects combobox, but still used to update the remaining list of available test objects
OnPropertyChanged(TestTemplateTags.AllTestObjects.ToString());
OnPropertyChanged("TestObjectsAndAddedGroups");
}
public void AddTestObject(TestObject to, int excitationWarmupMs, double targetSampleRate, string testobject, string position)
{
if (null != to)
{
var tto = new TestTestObject(to)
{
ExcitationWarmupTimeMS = excitationWarmupMs,
TargetSampleRate = targetSampleRate
};
tto.SetPosition(position);
tto.SetTestObject(testobject);
//if this is the NON ISO group (which is created by default), the replace the original NONE group ...
if (tto.SerialNumberOrOriginalSerialNumber == NON_ISO_INTERNAL_GROUP_NAME)
{
var index = -1;
for (var i = 0; i < TestObjectsAndAddedGroupsList.Count; i++)
{
if (TestObjectsAndAddedGroupsList[i].SerialNumberOrOriginalSerialNumber != NON_ISO_INTERNAL_GROUP_NAME) continue;
index = i;
break;
}
if (index >= 0)
{
TestObjectsAndAddedGroupsList.RemoveAt(index);
}
index = -1;
for (var i = 0; i < _testObjects.Count; i++)
{
if (_testObjects[i].SerialNumberOrOriginalSerialNumber != NON_ISO_INTERNAL_GROUP_NAME) continue;
index = i;
break;
}
if (index >= 0)
{
_testObjects.RemoveAt(index);
}
}
_testObjects.Add(tto);
TestObjectsAndAddedGroupsList.Add(tto);
OnPropertyChanged(TestTemplateTags.TestObjects.ToString());
OnPropertyChanged(TestTemplateTags.DefaultNumberRealtimeGraphs.ToString());
}
}
public void AddTestObject(string serialNumber, int excitationWarmupMs, double targetSampleRate, string testobject, string position)
{
var to = TestObjectList.TestObjectsList.GetTestObject(serialNumber);
AddTestObject(to, excitationWarmupMs, targetSampleRate, testobject, position);
OnPropertyChanged(TestTemplateTags.DefaultNumberRealtimeGraphs.ToString());
}
public void AddAddedGroup(TestObject to, string testobject, string position)
{
if (null == to) return;
var tto = new TestTestObject(to);
tto.SetPosition(position);
tto.SetTestObject(testobject);
tto.SerialNumberConverted = tto.SerialNumber.Remove(0, Name.Length + 1);
tto.TestSetupName = Name;
_addedGroups.Add(tto);
TestObjectsAndAddedGroupsList.Add(tto);
OnPropertyChanged(TestTemplateTags.DefaultNumberRealtimeGraphs.ToString());
}
public void AddAddedGroup(string serialNumber, string testobject, string position)
{
var to = TestObjectList.TestObjectsList.GetAddedGroup(serialNumber);
AddAddedGroup(to, testobject, position);
OnPropertyChanged(TestTemplateTags.DefaultNumberRealtimeGraphs.ToString());
}
public int GetNumberOfRealtimeSupportedChannels()
{
var count = 0;
foreach (var to in TestObjects)
{
var isoto = to.GetISOTestObject();
count += isoto.AllChannels.Where(ch => ch.Required && !string.IsNullOrWhiteSpace(ch.SensorSerialNumber)).Select(ch => GetSensor(ch.SensorSerialNumber, to.SerialNumber, ch.Name)).Where(sd => null != sd).Count(sd => !sd.IsDigitalInput() && !sd.IsDigitalOutput() && !sd.IsSquib());
}
foreach (var to in AddedGroups)
{
var isoto = to.GetISOTestObject();
count += isoto.AllChannels.Where(ch => ch.Required && !string.IsNullOrWhiteSpace(ch.SensorSerialNumber)).Select(ch => GetSensor(ch.SensorSerialNumber, to.SerialNumber, ch.Name)).Where(sd => null != sd).Count(sd => !sd.IsDigitalInput() && !sd.IsDigitalOutput() && !sd.IsSquib());
}
if (0 == count) { count = MaxRealtimeChannels; }
return count;
}
private readonly Dictionary<string, File.PersistentChannel> _oldChannelLookup = new Dictionary<string, File.PersistentChannel>();
private readonly Dictionary<string, Event.Module.Channel> _channelLookup = new Dictionary<string, Event.Module.Channel>();
private readonly Dictionary<string, bool> _sessionOpen = new Dictionary<string, bool>();
public void AddCalculatedChannel(CalculatedValueClass ch)
{
_calculatedChannels.Add(ch);
}
private readonly Dictionary<char, TestObjectMetaData> _metaDataLookup = new Dictionary<char, TestObjectMetaData>();
private TestSetupMetaData _testSetupMeta = new TestSetupMetaData(Properties.Settings.Default.RequireXCrashCompatibilityForISOExports);
public TestSetupMetaData GetTestMetaData()
{
return _testSetupMeta;
}
public void SetTestSetupMetaData(TestSetupMetaData meta)
{
_testSetupMeta = meta;
}
public TestObjectMetaData[] GetMetaData()
{
var metas = new List<TestObjectMetaData>();
foreach (var to in TestObjects.Select(x=>x.TestObject))
{
if (to == null) continue;
var m = GetMetaData(to.Test_Object[0]);
if (!metas.Contains(m)) { metas.Add(m); }
}
foreach (var to in AddedGroups.Select(x=>x.TestObject))
{
if (to == null) continue;
var m = GetMetaData(to.Test_Object[0]);
if (!metas.Contains(m)) { metas.Add(m); }
}
metas.Sort(CompareMeta);
return metas.ToArray();
}
public TestObjectMetaData GetMetaData(char testobject)
{
if (!_metaDataLookup.ContainsKey(testobject))
{
_metaDataLookup.Add(testobject, new TestObjectMetaData(testobject));
}
return _metaDataLookup[testobject];
}
private int CompareMeta(TestObjectMetaData left, TestObjectMetaData right)
{
if (left == right) { return 0; }
if (null == left) { return -1; }
return null == right ? 1 : left.TestObject.CompareTo(right.TestObject);
}
public void SetMetaData(char testobject, TestObjectMetaData meta)
{
_metaDataLookup[testobject] = meta;
}
}
}
Reference in New Issue View Git Blame Copy Permalink