327 lines
14 KiB
C#
327 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Data.SqlClient;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using DTS.Common.Interface.Groups;
|
|
using DTS.Common.Storage;
|
|
using DTS.Common.Utilities.Logging;
|
|
using DTS.Common.Enums.Sensors;
|
|
using DTS.Common.Interface.GroupTemplate;
|
|
|
|
// ReSharper disable once CheckNamespace
|
|
namespace DTS.Common.ISO
|
|
{
|
|
public class TestObject : IComparable, ITestObject
|
|
{
|
|
private List<TestObjectChannel> _allChannels = new List<TestObjectChannel>();
|
|
public TestObjectChannel[] AllChannels
|
|
{
|
|
get => _allChannels.ToArray();
|
|
set
|
|
{
|
|
_allChannels = new List<TestObjectChannel>(value);
|
|
SortChannels();
|
|
}
|
|
}
|
|
|
|
public void SortChannels()
|
|
{
|
|
_allChannels.Sort();
|
|
}
|
|
|
|
public TestObjectChannel GetChannel(string channelid)
|
|
{
|
|
return Array.Find(AllChannels, ch => ch.GetId() == channelid || ch.Name == channelid);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
if (Embedded)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(DisplaySerialNumber))
|
|
{
|
|
var index = SerialNumber.LastIndexOf('_');
|
|
var displaySerialNumber = SerialNumber;
|
|
if (index >= 0)
|
|
{
|
|
displaySerialNumber = SerialNumber.Substring(index + 1);
|
|
}
|
|
return displaySerialNumber;
|
|
}
|
|
return DisplaySerialNumber;
|
|
}
|
|
return SerialNumber;
|
|
//return Embedded ?
|
|
// DisplaySerialNumber : SerialNumber;
|
|
}
|
|
|
|
public string DisplaySerialNumber => SysBuilt ? SerialNumberConverted : OriginalSerialNumber;
|
|
|
|
public string SerialNumberConverted { get; set; }
|
|
|
|
public string SerialNumber { get; set; }
|
|
|
|
public string SerialNumberOrOriginalSerialNumber => Embedded ? OriginalSerialNumber : SerialNumber;
|
|
|
|
public string TestObjectType { get; set; }
|
|
|
|
public string ParentObject { get; set; }
|
|
|
|
public bool SysBuilt { get; set; }
|
|
|
|
public string TextL1 { get; set; }
|
|
|
|
private List<string> _hardwareIds = new List<string>();
|
|
public string[] HardwareIds
|
|
{
|
|
get => _hardwareIds.ToArray();
|
|
set { _hardwareIds.Clear(); _hardwareIds.AddRange(value); }
|
|
}
|
|
|
|
public string Template { get; set; }
|
|
|
|
public void SetTemplateOnly(string value) { Template = value; }
|
|
public void SetTemplate(string value, ref ISO13499FileDb db)
|
|
{
|
|
Template = value;
|
|
var template = TestObjectTemplate.GetTemplate(ref db, Template);
|
|
SetTemplate(template);
|
|
}
|
|
public void SetTemplate(TestObjectTemplate template)
|
|
{
|
|
_allChannels.Clear();
|
|
if (null == template) return;
|
|
Template = template.TemplateName;
|
|
AllChannels = template.Channels.Select(c => new TestObjectChannel(c, this, template)).ToArray();
|
|
}
|
|
|
|
public bool LocalOnly { get; set; }
|
|
|
|
public string LastModifiedBy { get; set; }
|
|
|
|
public DateTime LastModified { get; set; }
|
|
|
|
public TestObject(TestObject copy, TestObjectTemplate template, ISO13499FileDb db)
|
|
{
|
|
SerialNumberConverted = string.Empty;
|
|
_allChannels = new List<TestObjectChannel>();
|
|
foreach (var ch in copy.AllChannels) { _allChannels.Add(new TestObjectChannel(ch, this, template)); }
|
|
Embedded = copy.Embedded;
|
|
_hardwareIds = new List<string>();
|
|
_hardwareIds.AddRange(copy.HardwareIds.ToArray());
|
|
LastModified = copy.LastModified;
|
|
LastModifiedBy = copy.LastModifiedBy;
|
|
LocalOnly = copy.LocalOnly;
|
|
OriginalSerialNumber = copy.OriginalSerialNumber;
|
|
OriginalTemplate = copy.OriginalTemplate;
|
|
ParentObject = copy.ParentObject;
|
|
_sensorSettings = new Dictionary<string, Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>>();
|
|
using (var e1 = copy._sensorSettings.GetEnumerator())
|
|
{
|
|
while (e1.MoveNext())
|
|
{
|
|
using (var e2 = e1.Current.Value.GetEnumerator())
|
|
{
|
|
while (e2.MoveNext())
|
|
{
|
|
using (var e3 = e2.Current.Value.GetEnumerator())
|
|
{
|
|
while (e3.MoveNext())
|
|
{
|
|
if (!_sensorSettings.ContainsKey(e1.Current.Key))
|
|
{
|
|
_sensorSettings.Add(e1.Current.Key,
|
|
new Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>());
|
|
}
|
|
if (!_sensorSettings[e1.Current.Key].ContainsKey(e2.Current.Key))
|
|
{
|
|
_sensorSettings[e1.Current.Key].Add(e2.Current.Key,
|
|
new Dictionary<SensorConstants.SensorSettings, SensorSetting>());
|
|
}
|
|
if (!_sensorSettings[e1.Current.Key][e2.Current.Key].ContainsKey(e3.Current.Key))
|
|
{
|
|
_sensorSettings[e1.Current.Key][e2.Current.Key].Add(e3.Current.Key,
|
|
new SensorSetting(e3.Current.Value));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SerialNumber = copy.SerialNumber;
|
|
SysBuilt = copy.SysBuilt;
|
|
Template = copy.Template;
|
|
TestObjectType = copy.TestObjectType;
|
|
TextL1 = copy.TextL1;
|
|
}
|
|
|
|
public bool Embedded { get; set; }
|
|
|
|
/// <summary>
|
|
/// original serial number of this group (the serial number will be changed once it's embedded in a test setup)
|
|
/// </summary>
|
|
public string OriginalSerialNumber { get; set; }
|
|
|
|
/// <summary>
|
|
/// the original template for this group (the template is also changed once it's embedded in a test setup)
|
|
/// </summary>
|
|
public string OriginalTemplate { get; set; }
|
|
|
|
|
|
public static SensorSetting[] GetSettingsFromString(string s, string sensor, string channelid)
|
|
{
|
|
var tokens = s.Split(',');
|
|
|
|
return (from token in tokens select token.Split('=') into subtokens let setting = (SensorConstants.SensorSettings)Convert.ToInt32(subtokens[0]) select new SensorSetting(setting, subtokens[1], channelid, sensor)).ToArray();
|
|
}
|
|
public TestObject()
|
|
{
|
|
OriginalTemplate = "";
|
|
OriginalSerialNumber = "";
|
|
SerialNumberConverted = string.Empty;
|
|
_allChannels = new List<TestObjectChannel>();
|
|
_hardwareIds = new List<string>();
|
|
LastModified = DateTime.MinValue;
|
|
LastModifiedBy = "N/A";
|
|
LocalOnly = false;
|
|
SerialNumber = "";
|
|
Template = "";
|
|
ParentObject = "";
|
|
}
|
|
public class SensorSetting
|
|
{
|
|
public string ChannelId { get; set; }
|
|
public string SerialNumber { get; set; }
|
|
public SensorConstants.SensorSettings Setting { get; set; }
|
|
public string Value { get; set; }
|
|
public SensorSetting(SensorConstants.SensorSettings setting, string value, string channelId, string serialNumber)
|
|
{
|
|
ChannelId = channelId;
|
|
Value = value;
|
|
Setting = setting;
|
|
SerialNumber = serialNumber;
|
|
}
|
|
public SensorSetting(SensorSetting copy)
|
|
{
|
|
ChannelId = copy.ChannelId;
|
|
Value = copy.Value;
|
|
Setting = copy.Setting;
|
|
SerialNumber = copy.SerialNumber;
|
|
}
|
|
}
|
|
private readonly Dictionary<string, Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>> _sensorSettings =
|
|
new Dictionary<string, Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>>();
|
|
|
|
public SensorSetting[] GetSensorSettings(string channelId, string serialNumber)
|
|
{
|
|
if (!_sensorSettings.ContainsKey(channelId)) return new SensorSetting[0];
|
|
return _sensorSettings[channelId].ContainsKey(serialNumber) ? _sensorSettings[channelId][serialNumber].Values.ToArray() : new SensorSetting[0];
|
|
}
|
|
public void SetSensorSetting(string channelId, string serialNumber, SensorSetting setting)
|
|
{
|
|
if (!_sensorSettings.ContainsKey(channelId)) { _sensorSettings[channelId] = new Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>(); }
|
|
if (!_sensorSettings[channelId].ContainsKey(serialNumber)) { _sensorSettings[channelId][serialNumber] = new Dictionary<SensorConstants.SensorSettings, SensorSetting>(); }
|
|
_sensorSettings[channelId][serialNumber][setting.Setting] = setting;
|
|
}
|
|
private void RemoveSensorSetting(string channelId, string serialNumber)
|
|
{
|
|
if (!_sensorSettings.ContainsKey(channelId)) return;
|
|
if (_sensorSettings[channelId].ContainsKey(serialNumber)) { _sensorSettings[channelId].Remove(serialNumber); }
|
|
}
|
|
|
|
public TestObject(TestObject copy, ref ISO13499FileDb db)
|
|
{
|
|
SerialNumberConverted = string.Empty;
|
|
OriginalSerialNumber = copy.OriginalSerialNumber;
|
|
OriginalTemplate = copy.OriginalTemplate;
|
|
Embedded = copy.Embedded;
|
|
|
|
_allChannels = new List<TestObjectChannel>();
|
|
|
|
var t = TestObjectTemplate.GetTemplate(ref db, Template);
|
|
|
|
copy.SortChannels();
|
|
foreach (var c in copy.AllChannels) { _allChannels.Add(new TestObjectChannel(c, this, t)); }
|
|
|
|
for (var i = 0; i < copy.AllChannels.Length && i < _allChannels.Count; i++)
|
|
{
|
|
_allChannels[i].ChannelIdx = i;
|
|
}
|
|
|
|
_hardwareIds = new List<string>(copy.HardwareIds);
|
|
LastModified = copy.LastModified;
|
|
LastModifiedBy = copy.LastModifiedBy;
|
|
LocalOnly = copy.LocalOnly;
|
|
SerialNumber = copy.SerialNumber;
|
|
Template = copy.Template;
|
|
ParentObject = copy.ParentObject;
|
|
SysBuilt = copy.SysBuilt;
|
|
using (var e = copy._sensorSettings.GetEnumerator())
|
|
{
|
|
_sensorSettings =
|
|
new Dictionary<string, Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>>();
|
|
while (e.MoveNext())
|
|
{
|
|
if (!_sensorSettings.ContainsKey(e.Current.Key))
|
|
{
|
|
_sensorSettings[e.Current.Key] =
|
|
new Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>();
|
|
}
|
|
using (var e2 = copy._sensorSettings[e.Current.Key].GetEnumerator())
|
|
{
|
|
while (e2.MoveNext())
|
|
{
|
|
if (!_sensorSettings[e.Current.Key].ContainsKey(e2.Current.Key))
|
|
{
|
|
_sensorSettings[e.Current.Key][e2.Current.Key] =
|
|
new Dictionary<SensorConstants.SensorSettings, SensorSetting>();
|
|
}
|
|
using (var e3 = copy._sensorSettings[e.Current.Key][e2.Current.Key].GetEnumerator())
|
|
{
|
|
while (e3.MoveNext())
|
|
{
|
|
_sensorSettings[e.Current.Key][e2.Current.Key][e3.Current.Key] =
|
|
new SensorSetting(e3.Current.Value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public string GetSerializedSetting(SensorSetting[] settings)
|
|
{
|
|
var sb = new StringBuilder();
|
|
var bNeedComma = false;
|
|
foreach (var setting in settings)
|
|
{
|
|
if (bNeedComma) { sb.Append(","); }
|
|
bNeedComma = true;
|
|
|
|
sb.AppendFormat("{0}={1}", (int)setting.Setting, setting.Value);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static int CompareTestObject(TestObject left, TestObject right)
|
|
{
|
|
if (left == right) { return 0; }
|
|
if (null == left) { return -1; }
|
|
return null == right ? 1 : string.Compare(left.SerialNumber, right.SerialNumber, StringComparison.Ordinal);
|
|
}
|
|
|
|
public int CompareTo(object o)
|
|
{
|
|
if (o is TestObject testObject)
|
|
{
|
|
return CompareTestObject(this, testObject);
|
|
}
|
|
throw new ArgumentException($"object {o} is not the same type as this instance (TestObject)");
|
|
}
|
|
}
|
|
} |