646 lines
28 KiB
C#
646 lines
28 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Data;
|
|
using System.ComponentModel;
|
|
using System.Data.SqlClient;
|
|
using System.Text;
|
|
using DTS.Common.DAS.Concepts;
|
|
using DTS.Common.Storage;
|
|
using DTS.Common.Utilities.Logging;
|
|
using DTS.Common.Interface.DASFactory.Diagnostics;
|
|
using DTS.Common.Enums.Hardware;
|
|
using DTS.Common.Enums.Sensors;
|
|
using DTS.Common.Enums.DASFactory;
|
|
using ISO.Strings;
|
|
using DTS.Common.Classes.Hardware;
|
|
using DTS.Common.Interface.DataRecorders;
|
|
// ReSharper disable InconsistentNaming
|
|
// ReSharper disable CheckNamespace
|
|
// ReSharper disable PossibleNullReferenceException
|
|
// ReSharper disable ConvertToAutoProperty
|
|
|
|
namespace DTS.Common.ISO
|
|
{
|
|
public class Hardware : DASDBRecord, INotifyPropertyChanged, IISOHardware
|
|
{
|
|
|
|
public enum ChannelType
|
|
{
|
|
Analog,
|
|
IEPE,
|
|
Squib,
|
|
DigitalOutput,
|
|
RTC,
|
|
UART,
|
|
StreamOutput,
|
|
StreamInput,
|
|
Thermocoupler,
|
|
CAN
|
|
}
|
|
#region Properties
|
|
|
|
public bool IsInvalidDate(DateTime input)
|
|
{
|
|
return input.Date.Equals(DASDBRecord.INVALID_DATE.Date);
|
|
}
|
|
|
|
private int _calInterval = 365;
|
|
|
|
public int CalInterval
|
|
{
|
|
get => _calInterval;
|
|
set => _calInterval = value;
|
|
}
|
|
|
|
public void GetChannelsString(out int analog, out int digitalIn, out int digitalOut, out int squib, out int uart, out int streamOut, out int streamIn, out int can)
|
|
{
|
|
var sb = new StringBuilder();
|
|
analog = 0;
|
|
digitalIn = 0;
|
|
digitalOut = 0;
|
|
squib = 0;
|
|
uart = 0;
|
|
streamOut = 0;
|
|
streamIn = 0;
|
|
can = 0;
|
|
//was returning "1" for ethernet controllers which don't have a channel ...
|
|
switch (DASTypeEnum)
|
|
{
|
|
case HardwareTypes.SLICE_LabEthernet:
|
|
case HardwareTypes.SLICE_EthernetController:
|
|
case HardwareTypes.SLICE_Mini_Distributor:
|
|
case HardwareTypes.SLICE_Distributor:
|
|
return;
|
|
}
|
|
if (null != ISOChannels && ISOChannels.Any())
|
|
{
|
|
foreach (var ch in ISOChannels)
|
|
{
|
|
if (ch.IsSupported(SensorConstants.BridgeType.SQUIB))
|
|
{
|
|
squib++;
|
|
}
|
|
else if (ch.IsSupported(SensorConstants.BridgeType.DigitalInput))
|
|
{
|
|
digitalIn++;
|
|
}
|
|
else if (ch.IsSupported(SensorConstants.BridgeType.TOMDigital))
|
|
{
|
|
digitalOut++;
|
|
}
|
|
else if (ch.IsSupported(SensorConstants.BridgeType.UART))
|
|
{
|
|
uart++;
|
|
}
|
|
else if (ch.IsSupported(SensorConstants.BridgeType.StreamOut))
|
|
{
|
|
streamOut++;
|
|
}
|
|
else if (ch.IsSupported(SensorConstants.BridgeType.StreamIn))
|
|
{
|
|
streamIn++;
|
|
}
|
|
else if (ch.IsSupported(SensorConstants.BridgeType.CAN))
|
|
{
|
|
can++;
|
|
}
|
|
else analog++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public string IPAddress
|
|
{
|
|
get => Connection;
|
|
set
|
|
{
|
|
Connection = value;
|
|
OnPropertyChanged("IPAddress");
|
|
}
|
|
}
|
|
#endregion Properties
|
|
|
|
public Hardware()
|
|
{
|
|
|
|
}
|
|
public Hardware(Hardware copy)
|
|
{
|
|
DASId = copy.DASId;
|
|
Version = copy.Version;
|
|
SerialNumber = copy.SerialNumber;
|
|
ProtocolVersion = copy.ProtocolVersion;
|
|
Position = copy.Position;
|
|
MinSampleRate = copy.MinSampleRate;
|
|
MaxSampleRate = copy.MaxSampleRate;
|
|
MaxAAFRate = copy.MaxAAFRate;
|
|
MaxModules = copy.MaxModules;
|
|
MaxMemory = copy.MaxMemory;
|
|
LocalOnly = copy.LocalOnly;
|
|
LastUsedBy = copy.LastUsedBy;
|
|
LastUsed = copy.LastUsed;
|
|
LastModifiedBy = copy.LastModifiedBy;
|
|
LastModified = copy.LastModified;
|
|
IsReconfigurable = copy.IsReconfigurable;
|
|
IsProgrammable = copy.IsProgrammable;
|
|
ISOChannels = copy.ISOChannels.Select(c => new HardwareChannel(c, this)).ToArray();
|
|
IPAddress = copy.IPAddress;
|
|
FirmwareVersion = copy.FirmwareVersion;
|
|
DASType = copy.DASType;
|
|
var channeltypes = new int[copy?.ChannelTypes.Length??0];
|
|
Array.Copy(copy.ChannelTypes, channeltypes, copy.ChannelTypes.Length);
|
|
ChannelTypes = channeltypes;
|
|
Channels = copy.Channels;
|
|
CalInterval = copy.CalInterval;
|
|
CalDate = copy.CalDate;
|
|
IsModule = copy.IsModule;
|
|
ParentDAS = copy.ParentDAS;
|
|
PositionOnChain = copy.PositionOnChain;
|
|
PositionOnDistributor = copy.PositionOnDistributor;
|
|
Port = copy.Port;
|
|
IsFirstUseValid = copy.IsFirstUseValid;
|
|
FirstUseDate = copy.FirstUseDate;
|
|
StandIn = copy.StandIn;
|
|
TestId = copy.TestId;
|
|
GroupId = copy.GroupId;
|
|
}
|
|
public HardwareTypes DASTypeEnum
|
|
{
|
|
get => (HardwareTypes)DASType;
|
|
set
|
|
{
|
|
DASType = (int)value;
|
|
OnPropertyChanged("DASTypeEnum");
|
|
}
|
|
}
|
|
public bool IsPseudoRackModule()
|
|
{
|
|
switch (DASTypeEnum)
|
|
{
|
|
case HardwareTypes.SLICE6_AIR_BR:
|
|
case HardwareTypes.SLICE6_AIR:
|
|
case HardwareTypes.SLICE6_Base:
|
|
case HardwareTypes.SLICE2_TOM:
|
|
case HardwareTypes.SLICE2_SLT:
|
|
case HardwareTypes.SLICE2_SLS:
|
|
case HardwareTypes.SLICE2_SLD:
|
|
case HardwareTypes.SLICE2_SIM:
|
|
case HardwareTypes.SLICE2_DIM:
|
|
case HardwareTypes.SLICE2_Base:
|
|
return true;
|
|
default: return false;
|
|
}
|
|
}
|
|
public bool IsTSRAIR()
|
|
{
|
|
return IsTSRAIR(DASTypeEnum);
|
|
}
|
|
|
|
public static bool IsTSRAIR(HardwareTypes dasType)
|
|
{
|
|
switch (dasType)
|
|
{
|
|
case HardwareTypes.TSR_AIR:
|
|
case HardwareTypes.TSR_AIR_RevB:
|
|
case HardwareTypes.DKR:
|
|
case HardwareTypes.DIR:
|
|
return true;
|
|
default: return false;
|
|
}
|
|
}
|
|
public bool IsTSRAIRModule()
|
|
{
|
|
return IsTSRAIRModule(DASTypeEnum);
|
|
}
|
|
public static bool IsTSRAIRModule(HardwareTypes dasType)
|
|
{
|
|
switch (dasType)
|
|
{
|
|
case HardwareTypes.EMB_ANG_ACC:
|
|
case HardwareTypes.EMB_ANG_ARS:
|
|
case HardwareTypes.EMB_ATM:
|
|
case HardwareTypes.EMB_LIN_ACC_HI:
|
|
case HardwareTypes.EMB_LIN_ACC_LO:
|
|
case HardwareTypes.EMB_MAG:
|
|
case HardwareTypes.EMB_MAG_SWITCH:
|
|
case HardwareTypes.EMB_MIC:
|
|
case HardwareTypes.EMB_OPT:
|
|
case HardwareTypes.EMB_RTC_S_MARK:
|
|
case HardwareTypes.EMB_RTC_NS_PAD:
|
|
return true;
|
|
default: return false;
|
|
}
|
|
}
|
|
public Hardware(IDASDBRecord copy) : base(copy)
|
|
{
|
|
}
|
|
public Hardware(IDataReader reader) : base(reader)
|
|
{
|
|
}
|
|
|
|
public static List<HardwareChannel> GetDASISOChannels(string hardwareId, Hardware das)
|
|
{
|
|
var channelList = new List<HardwareChannel>();
|
|
|
|
var hResult = DbOperations.DASChannelsGet(hardwareId, out var dbChannels);
|
|
|
|
if (0 == hResult && null != dbChannels && dbChannels.Any())
|
|
{
|
|
foreach (var dbChannel in dbChannels)
|
|
{
|
|
channelList.Add(new HardwareChannel(dbChannel, das));
|
|
}
|
|
}
|
|
channelList.Sort(HardwareChannel.PhysicalCompare);
|
|
return channelList;
|
|
}
|
|
private static void GetAllDASISOChannels(Dictionary<string, Hardware> serialNumberToHardware)
|
|
{
|
|
var channelsByDASKey = new Dictionary<string, List<HardwareChannel>>();
|
|
|
|
var hResult = DbOperations.DASChannelsGet(null, out var dbChannels);
|
|
|
|
foreach (var dbChannel in dbChannels)
|
|
{
|
|
if (!serialNumberToHardware.ContainsKey(dbChannel.HardwareId)) { continue; }
|
|
var hardware = serialNumberToHardware[dbChannel.HardwareId];
|
|
var hc = new HardwareChannel(dbChannel, hardware);
|
|
if (!channelsByDASKey.ContainsKey(dbChannel.HardwareId))
|
|
{
|
|
channelsByDASKey[dbChannel.HardwareId] = new List<HardwareChannel>();
|
|
}
|
|
channelsByDASKey[dbChannel.HardwareId].Add(hc);
|
|
}
|
|
using (var enumHardware = serialNumberToHardware.GetEnumerator())
|
|
{
|
|
while (enumHardware.MoveNext())
|
|
{
|
|
var hardware = enumHardware.Current.Value;
|
|
if (!channelsByDASKey.ContainsKey(enumHardware.Current.Key))
|
|
{
|
|
continue;
|
|
}
|
|
var list = channelsByDASKey[enumHardware.Current.Key];
|
|
list.Sort(HardwareChannel.PhysicalCompare);
|
|
hardware.ISOChannels = list.ToArray();
|
|
}
|
|
}
|
|
}
|
|
private List<HardwareChannel> _isoChannels = new List<HardwareChannel>();
|
|
public HardwareChannel[] ISOChannels
|
|
{
|
|
get => _isoChannels.ToArray();
|
|
set => SetProperty(ref _isoChannels, new List<HardwareChannel>(value), "ISOChannels");
|
|
}
|
|
|
|
public static Hardware[] GetAllDAS()
|
|
{
|
|
return GetAllDAS(null, null);
|
|
}
|
|
public static Hardware[] GetSingleDAS(string serialNumber, string position)
|
|
{
|
|
var list = new List<Hardware>();
|
|
try
|
|
{
|
|
var hResult = DbOperations.DASGet(serialNumber, position, out var dbDAS);
|
|
if (0 == hResult)
|
|
{
|
|
foreach (var curDas in dbDAS)
|
|
{
|
|
list.Add(new Hardware(curDas));
|
|
}
|
|
}
|
|
foreach (var das in list)
|
|
{
|
|
var channels = GetDASISOChannels(das.SerialNumber, das);
|
|
channels.Sort(HardwareChannel.PhysicalCompare);
|
|
das.ISOChannels = channels.ToArray();
|
|
}
|
|
}
|
|
catch (Exception ex) { APILogger.Log("failed to retrieve all das, ", ex); }
|
|
list.Sort(new HardwareCompare());
|
|
return list.ToArray();
|
|
}
|
|
public static Hardware[] GetAllDAS(string serialNumber, string position)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(serialNumber))
|
|
{
|
|
return GetSingleDAS(serialNumber, position);
|
|
}
|
|
var list = new List<Hardware>();
|
|
try
|
|
{
|
|
var hResult = DbOperations.DASGet(serialNumber, position, out var dbDAS);
|
|
if (0 == hResult && null != dbDAS)
|
|
{
|
|
foreach (var curDas in dbDAS)
|
|
{
|
|
list.Add(new Hardware(curDas));
|
|
}
|
|
}
|
|
var serialNumberToDAS = new Dictionary<string, Hardware>();
|
|
foreach (var das in list)
|
|
{
|
|
serialNumberToDAS[$"{das.SerialNumber}_{das.DASType}"] = das;
|
|
}
|
|
GetAllDASISOChannels(serialNumberToDAS);
|
|
}
|
|
catch (Exception ex) { APILogger.Log("failed to retrieve all das, ", ex); }
|
|
list.Sort(new HardwareCompare());
|
|
return list.ToArray();
|
|
}
|
|
public class HardwareCompare : Comparer<Hardware>
|
|
{
|
|
public override int Compare(Hardware x, Hardware y)
|
|
{
|
|
var ret = string.Compare(x.SerialNumber, y.SerialNumber, StringComparison.Ordinal);
|
|
if (0 == ret) { ret = string.Compare(x.IPAddress, y.IPAddress, StringComparison.Ordinal); }
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
public void Delete()
|
|
{
|
|
var embedded = HardwareConstants.HasEmbeddedSensors(DASTypeEnum);
|
|
_ = DbOperations.DASDelete(DASId, null, embedded);
|
|
}
|
|
private void DeleteChannels()
|
|
{
|
|
_ = DbOperations.DASChannelsDelete(GetId());
|
|
}
|
|
|
|
public void Insert()
|
|
{
|
|
var result = DbOperations.DASInsert(this);
|
|
//ErrorCodes.ERROR_SUCCESS = 0
|
|
//We only want to insert the DAS Channels if the DAS was inserted successfully.
|
|
//It could be unsuccessful, for example, if an older database is in use.
|
|
if (result == 0)
|
|
{
|
|
InsertChannels();
|
|
}
|
|
}
|
|
private void InsertChannels()
|
|
{
|
|
foreach (var channel in ISOChannels)
|
|
{
|
|
channel.Insert();
|
|
}
|
|
}
|
|
public bool IsDummyObject => SerialNumber.Contains("Dummy");
|
|
|
|
public void Update()
|
|
{
|
|
DbOperations.DASUpdate(this);
|
|
|
|
DeleteChannels();
|
|
InsertChannels();
|
|
}
|
|
|
|
public string GetId()
|
|
{
|
|
return GetId(SerialNumber, DASType.ToString(), IPAddress);
|
|
}
|
|
public string GetIdOld()
|
|
{
|
|
return $"{SerialNumber}_{DASType}_{IPAddress}";
|
|
}
|
|
public static string GetId(string sn, string dastype, string ip)
|
|
{
|
|
return $"{sn}_{dastype}";
|
|
}
|
|
public void SetChannel(HardwareChannel channel)
|
|
{
|
|
for (var i = 0; i < _isoChannels.Count; i++)
|
|
{
|
|
if (ISOChannels[i].ChannelIdx != channel.ChannelIdx) continue;
|
|
_isoChannels[i] = channel; return;
|
|
}
|
|
_isoChannels.Add(channel);
|
|
}
|
|
|
|
private const string TDAS_RACK_PREPEND = "DR";
|
|
private const string TDAS_LABRACK_PREPEND = "LR";
|
|
private const string SLICE6_PREPEND = "SL6";
|
|
private const string SLICE6AIR_PREPEND = "S6A";
|
|
private const string SLICE6AIRBR_PREPEND = "S6BR";
|
|
private const string SLICE6AIRBR_PREPEND2 = "S6ABR";
|
|
private const string SLICE2SIM_PREPEND = "SPS";
|
|
private const string SLICE2LABSIM_PREPEND = "SLS";
|
|
private const string SLICE2TOM_PREPEND = "SPT";
|
|
private const string SLICE2LABTOM_PREPEND = "SLT";
|
|
private const string SLICE2DIM_PREPEND = "SPD";
|
|
private const string SLICE2LABDIM_PREPEND = "SLD";
|
|
private const string SLICENANO_PREPEND = "BA5";
|
|
private const string SLICEMICRO_PREPEND = "BA0";
|
|
private const string SLICE15NANO_PREPEND = "BA5";
|
|
private const string SLICE15MICRO_PREPEND = "BA0";
|
|
private const string SLICELABETHERNET_PREPEND = "SLE";
|
|
private const string SLICE_PRO_DB_PREPEND = "SPDB";
|
|
private const string SLICE6DB_PREPEND = "S6DB";
|
|
private const string SLICE6DB3_PREPEND = "S6DB3";
|
|
private const string SLICEG5_PREPEND = "SG5";
|
|
private const string G5_PREPEND = "5M";
|
|
private const string SLICEPROETHERNET_PREPEND = "SPE";
|
|
private const string SLICEDB_PREPEND = "SD";
|
|
private const string POWERPRO_PREPEND = "PPR";
|
|
private const string SLICEMINIDB_PREPEND = "SPM";
|
|
private const string DIR_PREPEND = "DI";
|
|
private const string DKR_PREPEND = "DK";
|
|
private const string SLICETC_PREPEND = "STC";
|
|
private const string SLICE_PRO_CAN_FD_PREPEND = "SPFD";
|
|
|
|
private void ValidateSN(ref List<string> errors, ref bool bValid, string prepend, string error, string alternativePrepend = null)
|
|
{
|
|
if (SerialNumber.Contains(DFConstantsAndEnums.SERIAL_SEPARATOR) && !StandIn)
|
|
{
|
|
bValid = false;
|
|
errors.Add($"{Strings.Strings.InvalidCharacterInSerialNumber} '{DFConstantsAndEnums.SERIAL_SEPARATOR}'");
|
|
}
|
|
if (SerialNumber.Contains(DFConstantsAndEnums.CHANNEL_SEPARATOR) && !StandIn)
|
|
{
|
|
bValid = false;
|
|
errors.Add($"{Strings.Strings.InvalidCharacterInSerialNumber} '{DFConstantsAndEnums.CHANNEL_SEPARATOR}'");
|
|
}
|
|
if (!SerialNumber.StartsWith(prepend)
|
|
&& (string.IsNullOrEmpty(alternativePrepend) || !SerialNumber.StartsWith(alternativePrepend)))
|
|
{
|
|
bValid = false;
|
|
errors.Add(error);
|
|
}
|
|
}
|
|
|
|
private void ValidateNotSN(ref List<string> errors, ref bool bValid, string prepend, string error)
|
|
{
|
|
if (SerialNumber.StartsWith(prepend))
|
|
{
|
|
bValid = false;
|
|
errors.Add($"{error} ({DASTypeEnum.ToString()})");
|
|
}
|
|
}
|
|
|
|
public bool ValidateIPAddress(ref List<string> errors)
|
|
{
|
|
var bValid = true;
|
|
switch (DASTypeEnum)
|
|
{
|
|
case HardwareTypes.SLICE_Distributor:
|
|
case HardwareTypes.SLICE_EthernetController:
|
|
case HardwareTypes.SLICE_Mini_Distributor:
|
|
case HardwareTypes.SLICE6DB:
|
|
case HardwareTypes.SLICE6DB3:
|
|
case HardwareTypes.SLICE_Pro_Distributor:
|
|
//case HardwareTypes.SLICE6DB_AIR:
|
|
case HardwareTypes.SLICE6DB_InDummy:
|
|
case HardwareTypes.SLICE_LabEthernet:
|
|
case HardwareTypes.TDAS_Pro_Rack:
|
|
case HardwareTypes.TDAS_LabRack:
|
|
case HardwareTypes.G5VDS:
|
|
//case ISODll.Hardware.HardwareTypes.G5IPORT:
|
|
case HardwareTypes.G5INDUMMY:
|
|
case HardwareTypes.TSR_AIR:
|
|
case HardwareTypes.TSR_AIR_RevB:
|
|
{
|
|
if (string.IsNullOrWhiteSpace(IPAddress))
|
|
{
|
|
bValid = false;
|
|
errors.Add(StringResources.AutoDetectDAS_IPAddressRequired);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return bValid;
|
|
}
|
|
public bool ValidateSerialNumber(ref List<string> errors)
|
|
{
|
|
var bValid = true;
|
|
if (string.IsNullOrWhiteSpace(SerialNumber))
|
|
{
|
|
bValid = false;
|
|
errors.Add(StringResources.AutoDetectDAS_SerialNumberRequired);
|
|
}
|
|
else
|
|
{
|
|
switch (DASTypeEnum)
|
|
{
|
|
case HardwareTypes.TDAS_Pro_Rack:
|
|
ValidateSN(ref errors, ref bValid, TDAS_RACK_PREPEND, StringResources.AutoDetectDas_TDASRackShouldStartWith);
|
|
break;
|
|
case HardwareTypes.TDAS_LabRack:
|
|
ValidateSN(ref errors, ref bValid, TDAS_LABRACK_PREPEND, StringResources.AutoDetectDAS_TDASLabRackShouldStartWith);
|
|
break;
|
|
case HardwareTypes.SLICE6_Base:
|
|
ValidateSN(ref errors, ref bValid, SLICE6_PREPEND, StringResources.AutoDetectDas_SLICE6ShouldStartWith);
|
|
break;
|
|
case HardwareTypes.SLICE6_AIR:
|
|
ValidateSN(ref errors, ref bValid, SLICE6AIR_PREPEND, StringResources.AutoDetectDas_SLICE6AIRShouldStartWith);
|
|
break;
|
|
case HardwareTypes.SLICE6_AIR_BR:
|
|
ValidateSN(ref errors, ref bValid, SLICE6AIRBR_PREPEND, StringResources.AutoDetectDas_SLICE6AIRBRShouldStartWith, SLICE6AIRBR_PREPEND2);
|
|
break;
|
|
case HardwareTypes.SLICE2_SIM:
|
|
ValidateSN(ref errors, ref bValid, SLICE2SIM_PREPEND, StringResources.AutoDetectDas_SIMShouldStartWithSPS);
|
|
break;
|
|
case HardwareTypes.SLICE2_SLS:
|
|
ValidateSN(ref errors, ref bValid, SLICE2LABSIM_PREPEND, StringResources.AutoDetectDAS_SLSShouldStartWithSLS);
|
|
break;
|
|
case HardwareTypes.SLICE2_TOM:
|
|
ValidateSN(ref errors, ref bValid, SLICE2TOM_PREPEND, StringResources.AutoDetectDas_TOMShouldStartWithSPT);
|
|
break;
|
|
case HardwareTypes.SLICE2_SLT:
|
|
ValidateSN(ref errors, ref bValid, SLICE2LABTOM_PREPEND, StringResources.AutoDetectDAS_SLTShouldStartWithSLT);
|
|
break;
|
|
case HardwareTypes.SLICE2_DIM:
|
|
ValidateSN(ref errors, ref bValid, SLICE2DIM_PREPEND, StringResources.AutoDetectDas_DIMShouldStartWithSPD);
|
|
break;
|
|
case HardwareTypes.SLICE2_SLD:
|
|
ValidateSN(ref errors, ref bValid, SLICE2LABDIM_PREPEND, StringResources.AutoDetectDAS_SLDShouldStartWithSLD);
|
|
break;
|
|
case HardwareTypes.SLICE_NANO_Base:
|
|
ValidateSN(ref errors, ref bValid, SLICENANO_PREPEND, StringResources.AutoDetectDas_SLICENanoShouldStartWithBA5);
|
|
break;
|
|
case HardwareTypes.SLICE_Micro_Base:
|
|
ValidateSN(ref errors, ref bValid, SLICEMICRO_PREPEND, StringResources.AutoDetectDas_MicroSerialNumberShouldStartWithBA0);
|
|
break;
|
|
case HardwareTypes.SLICE1_5_Nano_Base:
|
|
ValidateSN(ref errors, ref bValid, SLICE15NANO_PREPEND, StringResources.AutoDetectDAS_NANOBasePlusShouldStartWithBA5);
|
|
break;
|
|
case HardwareTypes.SLICE1_5_Micro_Base:
|
|
ValidateSN(ref errors, ref bValid, SLICE15MICRO_PREPEND, StringResources.AutoDetectDAS_MICROBasePlusShouldStartWithBA0);
|
|
break;
|
|
case HardwareTypes.SLICE_LabEthernet:
|
|
ValidateSN(ref errors, ref bValid, SLICELABETHERNET_PREPEND, StringResources.AutoDetectDAS_SliceLabEthernetShouldStartWithSLE);
|
|
break;
|
|
case HardwareTypes.SLICE_Pro_Distributor:
|
|
ValidateSN(ref errors, ref bValid, SLICE_PRO_DB_PREPEND, StringResources.AutoDetectDAS_SLICEPRODBShouldStartWithSPDB);
|
|
break;
|
|
case HardwareTypes.SLICE6DB3:
|
|
ValidateSN(ref errors, ref bValid, SLICE6DB3_PREPEND, StringResources.AutoDetectDas_SLICE6DB3ShouldStartWith);
|
|
break;
|
|
case HardwareTypes.SLICE6DB:
|
|
ValidateSN(ref errors, ref bValid, SLICE6DB_PREPEND, StringResources.AutoDetectDas_Slice6DBShouldStartWithS6DB);
|
|
break;
|
|
case HardwareTypes.SLICE1_G5Stack:
|
|
ValidateSN(ref errors, ref bValid, SLICEG5_PREPEND, StringResources.AutoDetectDas_SliceG5ShouldStartWithSG5);
|
|
break;
|
|
case HardwareTypes.G5INDUMMY:
|
|
case HardwareTypes.G5VDS:
|
|
ValidateSN(ref errors, ref bValid, G5_PREPEND, StringResources.AutoDetectDas_G5ShouldStartWith5M);
|
|
break;
|
|
case HardwareTypes.SLICE_EthernetController:
|
|
ValidateSN(ref errors, ref bValid, SLICEPROETHERNET_PREPEND, StringResources.AutoDetectDas_SliceECM);
|
|
break;
|
|
case HardwareTypes.SLICE_Mini_Distributor:
|
|
ValidateSN(ref errors, ref bValid, SLICEMINIDB_PREPEND, StringResources.AutoDetectDas_SliceSPM);
|
|
break;
|
|
case HardwareTypes.SLICE_Distributor:
|
|
ValidateSN(ref errors, ref bValid, SLICEDB_PREPEND, StringResources.AutoDetectDas_SliceDBShouldStartWithSDB);
|
|
break;
|
|
case HardwareTypes.PowerPro:
|
|
ValidateSN(ref errors, ref bValid, POWERPRO_PREPEND, StringResources.AutoDetectDas_PowerProShouldStartWithPPRO);
|
|
break;
|
|
case HardwareTypes.TSR_AIR:
|
|
case HardwareTypes.TSR_AIR_RevB:
|
|
ValidateSN(ref errors, ref bValid, HardwareConstants.TSR_AIR_PREPEND, StringResources.AutoDetectDas_TSRAIRShouldStartWithTA);
|
|
break;
|
|
case HardwareTypes.DKR:
|
|
ValidateSN(ref errors, ref bValid, DKR_PREPEND, StringResources.AutoDetectDas_DKRShouldStartWithDK);
|
|
break;
|
|
case HardwareTypes.DIR:
|
|
ValidateSN(ref errors, ref bValid, DIR_PREPEND, StringResources.AutoDetectDas_DIRShouldStartWithDI);
|
|
break;
|
|
case HardwareTypes.SLICE6_AIR_TC:
|
|
ValidateSN(ref errors, ref bValid, SLICETC_PREPEND, string.Format(StringResources.AutoDetectDas_TypeShouldStartWithPrepend, Strings.Strings.SLICE_TC_Description, SLICETC_PREPEND));
|
|
break;
|
|
case HardwareTypes.SLICE_PRO_CAN_FD:
|
|
ValidateSN(ref errors, ref bValid, SLICE_PRO_CAN_FD_PREPEND, string.Format(StringResources.AutoDetectDas_TypeShouldStartWithPrepend, Strings.Strings.SLICE_PRO_CAN_FD_Description, SLICE_PRO_CAN_FD_PREPEND));
|
|
break;
|
|
default:
|
|
|
|
ValidateNotSN(ref errors, ref bValid, G5_PREPEND, StringResources.AutoDetectDAS_SerialNumberBelongsToAG5);
|
|
ValidateNotSN(ref errors, ref bValid, TDAS_RACK_PREPEND, StringResources.AutoDetectDas_SerialNumberBelongsToATDASRack);
|
|
ValidateNotSN(ref errors, ref bValid, SLICENANO_PREPEND, StringResources.AutoDetectDas_SerialNumberBelongsToANano);
|
|
ValidateNotSN(ref errors, ref bValid, SLICEMICRO_PREPEND, StringResources.AutoDetectDAS_SerialNumberBelongsToAMicro);
|
|
ValidateNotSN(ref errors, ref bValid, SLICE2SIM_PREPEND, StringResources.AutoDetectDas_SerialNumberBelongsToASLICEProSim);
|
|
ValidateNotSN(ref errors, ref bValid, SLICE2LABSIM_PREPEND, StringResources.AutoDetectDAS_SerialNumberBelongsToASLICEPROLabSIM);
|
|
ValidateNotSN(ref errors, ref bValid, SLICEG5_PREPEND, StringResources.AutoDetectDas_SerialNumberBelongsToASLICEG5);
|
|
ValidateNotSN(ref errors, ref bValid, SLICELABETHERNET_PREPEND, StringResources.AutoDetectDAS_SerialNumberBelongsToASlicePROLabSLE);
|
|
ValidateNotSN(ref errors, ref bValid, SLICE2DIM_PREPEND, StringResources.AutoDetectDas_SLICE_SerialNumberBelongsToASLICEProDIM);
|
|
ValidateNotSN(ref errors, ref bValid, SLICE2LABTOM_PREPEND, StringResources.AutoDetectDAS_SLICE_SerialNumberBelongsToASLICELABTOM);
|
|
ValidateNotSN(ref errors, ref bValid, SLICE2LABDIM_PREPEND, StringResources.AutoDetectDAS_SLICE_SerialNumberBelongsToASLICELABDIM);
|
|
ValidateNotSN(ref errors, ref bValid, TDAS_LABRACK_PREPEND, StringResources.AutoDetectDAS_SerialNumberBelongsToATDASLabRack);
|
|
ValidateNotSN(ref errors, ref bValid, POWERPRO_PREPEND, StringResources.AutoDetectDAS_SerialNumberBelongsToAPowerPRO);
|
|
break;
|
|
}
|
|
}
|
|
return bValid;
|
|
}
|
|
}
|
|
|
|
}
|