936 lines
36 KiB
C#
936 lines
36 KiB
C#
|
||
namespace Xylem.Common.Logic.ProductionOrderCore.KitronTestResults
|
||
{
|
||
using Newtonsoft.Json;
|
||
using Newtonsoft.Json.Converters;
|
||
using Newtonsoft.Json.Linq;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Globalization;
|
||
|
||
public partial class RadioTest
|
||
{
|
||
[JsonProperty("$id")]
|
||
[JsonConverter(typeof(ParseStringConverter))]
|
||
public Int64 Id { get; set; }
|
||
|
||
[JsonProperty("TestStepResults")]
|
||
public TestStep TestStepResults { get; set; }
|
||
|
||
[JsonProperty("TestStepGP30Interface")]
|
||
public TestStep TestStepGp30Interface { get; set; }
|
||
|
||
[JsonProperty("TestStepLoopCalibrate")]
|
||
public TestStep TestStepLoopCalibrate { get; set; }
|
||
|
||
[JsonProperty("GUIDKey")]
|
||
public Guid GuidKey { get; set; }
|
||
|
||
[JsonProperty("TestID")]
|
||
[JsonConverter(typeof(ParseStringConverter))]
|
||
public Int64 TestId { get; set; }
|
||
|
||
[JsonProperty("TestPlace")]
|
||
public String TestPlace { get; set; }
|
||
|
||
[JsonProperty("TestAdapter")]
|
||
public String TestAdapter { get; set; }
|
||
|
||
[JsonProperty("MaterialNumber")]
|
||
public String MaterialNumber { get; set; }
|
||
|
||
[JsonProperty("PanelBarcode")]
|
||
[JsonConverter(typeof(ParseStringConverter))]
|
||
public Int64 PanelBarcode { get; set; }
|
||
|
||
[JsonProperty("TestProgramm")]
|
||
public String TestProgramm { get; set; }
|
||
|
||
[JsonProperty("TestProgramVer")]
|
||
public String TestProgramVer { get; set; }
|
||
|
||
[JsonProperty("TestBoardSerialNr")]
|
||
public String TestBoardSerialNr { get; set; }
|
||
|
||
[JsonProperty("TestBoardVersionInfo")]
|
||
public String TestBoardVersionInfo { get; set; }
|
||
|
||
[JsonProperty("TestOperator")]
|
||
public String TestOperator { get; set; }
|
||
|
||
[JsonProperty("TestMachineName")]
|
||
public String TestMachineName { get; set; }
|
||
|
||
|
||
|
||
[JsonProperty("TestNumber")]
|
||
public String TestNumber { get; set; }
|
||
|
||
[JsonProperty("StartDT")]
|
||
public String StartDt { get; set; }
|
||
|
||
[JsonProperty("TestDuration")]
|
||
public String TestDuration { get; set; }
|
||
|
||
[JsonProperty("TestResult")]
|
||
public Result TestResult { get; set; }
|
||
|
||
[JsonProperty("AttachmentFile")]
|
||
public String AttachmentFile { get; set; }
|
||
}
|
||
|
||
public class TestStep
|
||
{
|
||
[JsonProperty("$id")]
|
||
[JsonConverter(typeof(ParseStringConverter))]
|
||
public Int64 Id { get; set; }
|
||
|
||
[JsonProperty("$values")]
|
||
public Value[] Values { get; set; }
|
||
}
|
||
|
||
public class Value
|
||
{
|
||
[JsonProperty("$id")]
|
||
[JsonConverter(typeof(ParseStringConverter))]
|
||
public Int64 Id { get; set; }
|
||
|
||
[JsonProperty("TestDate", NullValueHandling = NullValueHandling.Ignore)]
|
||
public DateTimeOffset? TestDate { get; set; }
|
||
|
||
[JsonProperty("Barcode", NullValueHandling = NullValueHandling.Ignore)]
|
||
[JsonConverter(typeof(ParseStringConverter))]
|
||
public Int64? Barcode { get; set; }
|
||
|
||
[JsonProperty("ResultCalibration", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String ResultCalibration { get; set; }
|
||
|
||
[JsonProperty("TestLoop", NullValueHandling = NullValueHandling.Ignore)]
|
||
[JsonConverter(typeof(ParseStringConverter))]
|
||
public Int64? TestLoop { get; set; }
|
||
|
||
[JsonProperty("LengthCode", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String LengthCode { get; set; }
|
||
|
||
[JsonProperty("RunCalibrate", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String RunCalibrate { get; set; }
|
||
|
||
[JsonProperty("RFCalibrationCurrent", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String RfCalibrationCurrent { get; set; }
|
||
|
||
[JsonProperty("RFCalibrationPower", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String RfCalibrationPower { get; set; }
|
||
|
||
[JsonProperty("iPowerLevelCalculated", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String IPowerLevelCalculated { get; set; }
|
||
|
||
[JsonProperty("iExternalPowerlevel", NullValueHandling = NullValueHandling.Ignore)]
|
||
[JsonConverter(typeof(ParseStringConverter))]
|
||
public Int64? IExternalPowerlevel { get; set; }
|
||
|
||
[JsonProperty("iAntennaMatching", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String IAntennaMatching { get; set; }
|
||
|
||
[JsonProperty("sLookupTablePower", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String SLookupTablePower { get; set; }
|
||
|
||
[JsonProperty("dReferenceCurrent1", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String DReferenceCurrent1 { get; set; }
|
||
|
||
[JsonProperty("dReferenceCurrentLow1", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String DReferenceCurrentLow1 { get; set; }
|
||
|
||
[JsonProperty("dReferenceCurrentHigh1", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String DReferenceCurrentHigh1 { get; set; }
|
||
|
||
[JsonProperty("dReferencePower1", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String DReferencePower1 { get; set; }
|
||
|
||
[JsonProperty("dReferencePowerLow1", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String DReferencePowerLow1 { get; set; }
|
||
|
||
[JsonProperty("dReferencePowerHigh1", NullValueHandling = NullValueHandling.Ignore)]
|
||
public DReferencePowerHigh1? DReferencePowerHigh1 { get; set; }
|
||
|
||
[JsonProperty("RunRemeasure", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String RunRemeasure { get; set; }
|
||
|
||
[JsonProperty("ResultRemeasure", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String ResultRemeasure { get; set; }
|
||
|
||
[JsonProperty("RFRemeasureCurrent", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String RfRemeasureCurrent { get; set; }
|
||
|
||
[JsonProperty("RFRemeasurePower", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String RfRemeasurePower { get; set; }
|
||
|
||
[JsonProperty("dReferenceCurrent2", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String DReferenceCurrent2 { get; set; }
|
||
|
||
[JsonProperty("dReferenceCurrentLow2", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String DReferenceCurrentLow2 { get; set; }
|
||
|
||
[JsonProperty("dReferenceCurrentHigh2", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String DReferenceCurrentHigh2 { get; set; }
|
||
|
||
[JsonProperty("dReferencePower2", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String DReferencePower2 { get; set; }
|
||
|
||
[JsonProperty("dReferencePowerLow2", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String DReferencePowerLow2 { get; set; }
|
||
|
||
[JsonProperty("dReferencePowerHigh2", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String DReferencePowerHigh2 { get; set; }
|
||
|
||
[JsonProperty("TestStepName", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String TestStepName { get; set; }
|
||
|
||
[JsonProperty("TestStepType", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String TestStepType { get; set; }
|
||
|
||
[JsonProperty("TestStepDesc", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String TestStepDesc { get; set; }
|
||
|
||
[JsonProperty("TestInstrument", NullValueHandling = NullValueHandling.Ignore)]
|
||
public TestInstrument? TestInstrument { get; set; }
|
||
|
||
[JsonProperty("TestTypeMeasured", NullValueHandling = NullValueHandling.Ignore)]
|
||
public TestTypeMeasured? TestTypeMeasured { get; set; }
|
||
|
||
[JsonProperty("StartDT", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String StartDt { get; set; }
|
||
|
||
[JsonProperty("TestDuration", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String TestDuration { get; set; }
|
||
|
||
[JsonProperty("Result", NullValueHandling = NullValueHandling.Ignore)]
|
||
public Result? Result { get; set; }
|
||
|
||
[JsonProperty("TestValue", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String TestValue { get; set; }
|
||
|
||
[JsonProperty("Units", NullValueHandling = NullValueHandling.Ignore)]
|
||
public Units? Units { get; set; }
|
||
|
||
[JsonProperty("LowerLimit", NullValueHandling = NullValueHandling.Ignore)]
|
||
public String LowerLimit { get; set; }
|
||
|
||
[JsonProperty("UpperLimit", NullValueHandling = NullValueHandling.Ignore)]
|
||
public UpperLimit? UpperLimit { get; set; }
|
||
|
||
[JsonProperty("FailDesc", NullValueHandling = NullValueHandling.Ignore)]
|
||
public FailDesc? FailDesc { get; set; }
|
||
|
||
[JsonProperty("AttachmentFile", NullValueHandling = NullValueHandling.Ignore)]
|
||
public AttachmentFile? AttachmentFile { get; set; }
|
||
}
|
||
|
||
public enum Result { Fail, Pass };
|
||
|
||
public enum AttachmentFile { DatenGenesisMfgradiotest433MHzV324Bin, Empty };
|
||
|
||
public enum DReferencePowerHigh1 { Empty, The000999999999999979PowerDiff, The004PowerDiff, The031PowerDiff, The033PowerDiff, The034PowerDiff, The15, The182, The200, The2828 };
|
||
|
||
public enum FailDesc { CouldNotSetCwWithInternalPowerLevel, Empty, ErrorCheckCalculatePowerDifferenz };
|
||
|
||
public enum TestInstrument { Empty, JLinkFlasher, KeyenceBarcoderReader, Multimeter, Pcb };
|
||
|
||
public enum TestTypeMeasured { Empty, FlashFirmware, GetAnswerFromPcbDevice, QrCodeRead, ReadFromMeasuringDevice };
|
||
|
||
public enum Units { Db, Empty, KHz, MA, Volt, ΜA };
|
||
|
||
public struct UpperLimit
|
||
{
|
||
public DReferencePowerHigh1? Enum;
|
||
public Int64? Integer;
|
||
|
||
public static implicit operator UpperLimit(DReferencePowerHigh1 enumeration) => new UpperLimit { Enum = enumeration };
|
||
public static implicit operator UpperLimit(Int64 integer) => new UpperLimit { Integer = integer };
|
||
}
|
||
|
||
public partial class RadioTest
|
||
{
|
||
public static RadioTest FromJson(String json)
|
||
{
|
||
if (string.IsNullOrEmpty(json)) return new RadioTest { TestResult = Result.Fail };
|
||
|
||
try
|
||
{
|
||
|
||
if (json.Contains("\"JsonObject\":"))
|
||
{
|
||
var newFromat = JsonConvert.DeserializeObject<Root>(json);
|
||
//breakt down all and pass all data to the old format
|
||
|
||
var alternateReturnObj = new RadioTest();
|
||
|
||
if (newFromat.JsonObject.TestResult.ToLower().Contains("pass"))
|
||
{
|
||
alternateReturnObj.TestResult = Result.Pass;
|
||
}
|
||
|
||
if (newFromat.JsonObject.AttachmentFile.ToLower().Contains("_868_"))
|
||
{
|
||
|
||
}
|
||
alternateReturnObj.StartDt = newFromat.JsonObject.StartDT;
|
||
alternateReturnObj.TestStepLoopCalibrate = new TestStep
|
||
{
|
||
Values = new Value[23]
|
||
};
|
||
|
||
var testStepLoopCalibrateToAdd = new List<Value>();
|
||
|
||
var joResponse = JObject.Parse(json);
|
||
|
||
var loopCount = 0;
|
||
if (joResponse["JsonObject"] == null) return new RadioTest { TestResult = Result.Fail };
|
||
|
||
foreach (var item in joResponse["JsonObject"].Children())
|
||
{
|
||
|
||
if (item is JProperty pItem)
|
||
{
|
||
if (pItem.Name == $"ResultCalibration Loop_{loopCount +1}")
|
||
{
|
||
if (pItem.Value.ToString() == "ok")
|
||
{
|
||
|
||
testStepLoopCalibrateToAdd.Add(new Value());
|
||
testStepLoopCalibrateToAdd[loopCount].ResultCalibration = pItem.Value.ToString();
|
||
testStepLoopCalibrateToAdd[loopCount].SLookupTablePower = newFromat.JsonObject.AttachmentFile.ToLower();
|
||
loopCount += 1;
|
||
}
|
||
}
|
||
|
||
if (pItem.Name == $"LengthCode Loop_{loopCount}")
|
||
{
|
||
if (testStepLoopCalibrateToAdd.Count == loopCount)
|
||
{
|
||
testStepLoopCalibrateToAdd[loopCount-1].LengthCode = pItem.Value.ToString();
|
||
}
|
||
|
||
}
|
||
if (pItem.Name == $"PowerLevelCalculated Loop_{loopCount}")
|
||
{
|
||
if (testStepLoopCalibrateToAdd.Count == loopCount)
|
||
{
|
||
testStepLoopCalibrateToAdd[loopCount-1].IPowerLevelCalculated = pItem.Value.ToString();
|
||
}
|
||
|
||
}
|
||
|
||
if (pItem.Name == $"AntennaMatching Loop_{loopCount}")
|
||
{
|
||
if (testStepLoopCalibrateToAdd.Count == loopCount)
|
||
{
|
||
testStepLoopCalibrateToAdd[loopCount-1].IAntennaMatching = pItem.Value.ToString();
|
||
}
|
||
|
||
}
|
||
|
||
|
||
}
|
||
//if (item.Name
|
||
//{
|
||
|
||
//}
|
||
|
||
}
|
||
Int32 i = 0;
|
||
|
||
foreach (var item in testStepLoopCalibrateToAdd)
|
||
{
|
||
try
|
||
{
|
||
if (alternateReturnObj.TestStepLoopCalibrate.Values.Length > i)
|
||
{
|
||
alternateReturnObj.TestStepLoopCalibrate.Values.SetValue(item, i);
|
||
i += 1;
|
||
}
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
|
||
}
|
||
}
|
||
|
||
return alternateReturnObj;
|
||
}
|
||
|
||
return JsonConvert.DeserializeObject<RadioTest>(json, Converter.Settings);
|
||
|
||
}
|
||
catch (Exception)
|
||
{
|
||
return new RadioTest { TestResult = Result.Fail };
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
public static class Serialize
|
||
{
|
||
public static String ToJson(this RadioTest self) => JsonConvert.SerializeObject(self, Converter.Settings);
|
||
}
|
||
|
||
internal static class Converter
|
||
{
|
||
public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
|
||
{
|
||
MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
|
||
DateParseHandling = DateParseHandling.None,
|
||
Converters =
|
||
{
|
||
ResultConverter.Singleton,
|
||
AttachmentFileConverter.Singleton,
|
||
FailDescConverter.Singleton,
|
||
TestInstrumentConverter.Singleton,
|
||
TestTypeMeasuredConverter.Singleton,
|
||
UnitsConverter.Singleton,
|
||
UpperLimitConverter.Singleton,
|
||
DReferencePowerHigh1Converter.Singleton,
|
||
new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
|
||
},
|
||
};
|
||
}
|
||
|
||
internal class ParseStringConverter : JsonConverter
|
||
{
|
||
public override Boolean CanConvert(Type t) => t == typeof(Int64) || t == typeof(Int64?);
|
||
|
||
public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
|
||
{
|
||
if (reader.TokenType == JsonToken.Null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var value = serializer.Deserialize<String>(reader);
|
||
Int64 l;
|
||
if (long.TryParse(value, out l))
|
||
{
|
||
return l;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
|
||
{
|
||
if (untypedValue == null)
|
||
{
|
||
serializer.Serialize(writer, null);
|
||
return;
|
||
}
|
||
var value = (Int64)untypedValue;
|
||
serializer.Serialize(writer, value.ToString());
|
||
}
|
||
|
||
public static readonly ParseStringConverter Singleton = new ParseStringConverter();
|
||
}
|
||
|
||
internal class ResultConverter : JsonConverter
|
||
{
|
||
public override Boolean CanConvert(Type t) => t == typeof(Result) || t == typeof(Result?);
|
||
|
||
public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
|
||
{
|
||
if (reader.TokenType == JsonToken.Null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var value = serializer.Deserialize<String>(reader);
|
||
switch (value)
|
||
{
|
||
case "FAIL":
|
||
return Result.Fail;
|
||
case "PASS":
|
||
return Result.Pass;
|
||
}
|
||
throw new Exception("Cannot unmarshal type Result");
|
||
}
|
||
|
||
public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
|
||
{
|
||
if (untypedValue == null)
|
||
{
|
||
serializer.Serialize(writer, null);
|
||
return;
|
||
}
|
||
var value = (Result)untypedValue;
|
||
switch (value)
|
||
{
|
||
case Result.Fail:
|
||
serializer.Serialize(writer, "FAIL");
|
||
return;
|
||
case Result.Pass:
|
||
serializer.Serialize(writer, "PASS");
|
||
return;
|
||
}
|
||
throw new Exception("Cannot marshal type Result");
|
||
}
|
||
|
||
public static readonly ResultConverter Singleton = new ResultConverter();
|
||
}
|
||
|
||
internal class AttachmentFileConverter : JsonConverter
|
||
{
|
||
public override Boolean CanConvert(Type t) => t == typeof(AttachmentFile) || t == typeof(AttachmentFile?);
|
||
|
||
public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
|
||
{
|
||
if (reader.TokenType == JsonToken.Null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var value = serializer.Deserialize<String>(reader);
|
||
switch (value)
|
||
{
|
||
case "":
|
||
return AttachmentFile.Empty;
|
||
case "Daten\\Genesis_mfgradiotest_433MHz_v324.bin":
|
||
return AttachmentFile.DatenGenesisMfgradiotest433MHzV324Bin;
|
||
default:
|
||
return AttachmentFile.Empty;
|
||
}
|
||
}
|
||
|
||
public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
|
||
{
|
||
if (untypedValue == null)
|
||
{
|
||
serializer.Serialize(writer, null);
|
||
return;
|
||
}
|
||
var value = (AttachmentFile)untypedValue;
|
||
switch (value)
|
||
{
|
||
case AttachmentFile.Empty:
|
||
serializer.Serialize(writer, "");
|
||
return;
|
||
case AttachmentFile.DatenGenesisMfgradiotest433MHzV324Bin:
|
||
serializer.Serialize(writer, "Daten\\Genesis_mfgradiotest_433MHz_v324.bin");
|
||
return;
|
||
}
|
||
throw new Exception("Cannot marshal type AttachmentFile");
|
||
}
|
||
|
||
public static readonly AttachmentFileConverter Singleton = new AttachmentFileConverter();
|
||
}
|
||
|
||
internal class FailDescConverter : JsonConverter
|
||
{
|
||
public override Boolean CanConvert(Type t) => t == typeof(FailDesc) || t == typeof(FailDesc?);
|
||
|
||
public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
|
||
{
|
||
if (reader.TokenType == JsonToken.Null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var value = serializer.Deserialize<String>(reader);
|
||
switch (value)
|
||
{
|
||
|
||
case "Error Check Calculate Power Differenz":
|
||
return FailDesc.ErrorCheckCalculatePowerDifferenz;
|
||
case "could not set CW with Internal power level":
|
||
return FailDesc.CouldNotSetCwWithInternalPowerLevel;
|
||
default:
|
||
return FailDesc.Empty;
|
||
}
|
||
}
|
||
|
||
public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
|
||
{
|
||
if (untypedValue == null)
|
||
{
|
||
serializer.Serialize(writer, null);
|
||
return;
|
||
}
|
||
var value = (FailDesc)untypedValue;
|
||
switch (value)
|
||
{
|
||
case FailDesc.Empty:
|
||
serializer.Serialize(writer, "");
|
||
return;
|
||
case FailDesc.ErrorCheckCalculatePowerDifferenz:
|
||
serializer.Serialize(writer, "Error Check Calculate Power Differenz");
|
||
return;
|
||
case FailDesc.CouldNotSetCwWithInternalPowerLevel:
|
||
serializer.Serialize(writer, "could not set CW with Internal power level");
|
||
return;
|
||
}
|
||
throw new Exception("Cannot marshal type FailDesc");
|
||
}
|
||
|
||
public static readonly FailDescConverter Singleton = new FailDescConverter();
|
||
}
|
||
|
||
internal class TestInstrumentConverter : JsonConverter
|
||
{
|
||
public override Boolean CanConvert(Type t) => t == typeof(TestInstrument) || t == typeof(TestInstrument?);
|
||
|
||
public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
|
||
{
|
||
if (reader.TokenType == JsonToken.Null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var value = serializer.Deserialize<String>(reader);
|
||
switch (value)
|
||
{
|
||
case "":
|
||
return TestInstrument.Empty;
|
||
case "J-Link Flasher":
|
||
return TestInstrument.JLinkFlasher;
|
||
case "Keyence Barcoder Reader":
|
||
return TestInstrument.KeyenceBarcoderReader;
|
||
case "Multimeter":
|
||
return TestInstrument.Multimeter;
|
||
case "PCB":
|
||
return TestInstrument.Pcb;
|
||
}
|
||
return TestInstrument.Empty;
|
||
// throw new Exception("Cannot unmarshal type TestInstrument");
|
||
}
|
||
|
||
public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
|
||
{
|
||
if (untypedValue == null)
|
||
{
|
||
serializer.Serialize(writer, null);
|
||
return;
|
||
}
|
||
var value = (TestInstrument)untypedValue;
|
||
switch (value)
|
||
{
|
||
case TestInstrument.Empty:
|
||
serializer.Serialize(writer, "");
|
||
return;
|
||
case TestInstrument.JLinkFlasher:
|
||
serializer.Serialize(writer, "J-Link Flasher");
|
||
return;
|
||
case TestInstrument.KeyenceBarcoderReader:
|
||
serializer.Serialize(writer, "Keyence Barcoder Reader");
|
||
return;
|
||
case TestInstrument.Multimeter:
|
||
serializer.Serialize(writer, "Multimeter");
|
||
return;
|
||
case TestInstrument.Pcb:
|
||
serializer.Serialize(writer, "PCB");
|
||
return;
|
||
}
|
||
throw new Exception("Cannot marshal type TestInstrument");
|
||
}
|
||
|
||
public static readonly TestInstrumentConverter Singleton = new TestInstrumentConverter();
|
||
}
|
||
|
||
internal class TestTypeMeasuredConverter : JsonConverter
|
||
{
|
||
public override Boolean CanConvert(Type t) => t == typeof(TestTypeMeasured) || t == typeof(TestTypeMeasured?);
|
||
|
||
public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
|
||
{
|
||
if (reader.TokenType == JsonToken.Null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var value = serializer.Deserialize<String>(reader);
|
||
switch (value)
|
||
{
|
||
case "":
|
||
return TestTypeMeasured.Empty;
|
||
case "Flash Firmware":
|
||
return TestTypeMeasured.FlashFirmware;
|
||
case "Get Answer from PCB Device":
|
||
return TestTypeMeasured.GetAnswerFromPcbDevice;
|
||
case "QR Code read":
|
||
return TestTypeMeasured.QrCodeRead;
|
||
case "Read from Measuring Device":
|
||
return TestTypeMeasured.ReadFromMeasuringDevice;
|
||
}
|
||
return TestTypeMeasured.Empty;
|
||
}
|
||
|
||
public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
|
||
{
|
||
if (untypedValue == null)
|
||
{
|
||
serializer.Serialize(writer, null);
|
||
return;
|
||
}
|
||
var value = (TestTypeMeasured)untypedValue;
|
||
switch (value)
|
||
{
|
||
case TestTypeMeasured.Empty:
|
||
serializer.Serialize(writer, "");
|
||
return;
|
||
case TestTypeMeasured.FlashFirmware:
|
||
serializer.Serialize(writer, "Flash Firmware");
|
||
return;
|
||
case TestTypeMeasured.GetAnswerFromPcbDevice:
|
||
serializer.Serialize(writer, "Get Answer from PCB Device");
|
||
return;
|
||
case TestTypeMeasured.QrCodeRead:
|
||
serializer.Serialize(writer, "QR Code read");
|
||
return;
|
||
case TestTypeMeasured.ReadFromMeasuringDevice:
|
||
serializer.Serialize(writer, "Read from Measuring Device");
|
||
return;
|
||
}
|
||
throw new Exception("Cannot marshal type TestTypeMeasured");
|
||
}
|
||
|
||
public static readonly TestTypeMeasuredConverter Singleton = new TestTypeMeasuredConverter();
|
||
}
|
||
|
||
internal class UnitsConverter : JsonConverter
|
||
{
|
||
public override Boolean CanConvert(Type t) => t == typeof(Units) || t == typeof(Units?);
|
||
|
||
public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
|
||
{
|
||
if (reader.TokenType == JsonToken.Null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var value = serializer.Deserialize<String>(reader);
|
||
switch (value)
|
||
{
|
||
case "":
|
||
return Units.Empty;
|
||
case "Volt":
|
||
return Units.Volt;
|
||
case "db":
|
||
return Units.Db;
|
||
case "kHz":
|
||
return Units.KHz;
|
||
case "mA":
|
||
return Units.MA;
|
||
case "µA":
|
||
return Units.ΜA;
|
||
}
|
||
throw new Exception("Cannot unmarshal type Units");
|
||
}
|
||
|
||
public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
|
||
{
|
||
if (untypedValue == null)
|
||
{
|
||
serializer.Serialize(writer, null);
|
||
return;
|
||
}
|
||
var value = (Units)untypedValue;
|
||
switch (value)
|
||
{
|
||
case Units.Empty:
|
||
serializer.Serialize(writer, "");
|
||
return;
|
||
case Units.Volt:
|
||
serializer.Serialize(writer, "Volt");
|
||
return;
|
||
case Units.Db:
|
||
serializer.Serialize(writer, "db");
|
||
return;
|
||
case Units.KHz:
|
||
serializer.Serialize(writer, "kHz");
|
||
return;
|
||
case Units.MA:
|
||
serializer.Serialize(writer, "mA");
|
||
return;
|
||
case Units.ΜA:
|
||
serializer.Serialize(writer, "µA");
|
||
return;
|
||
}
|
||
throw new Exception("Cannot marshal type Units");
|
||
}
|
||
|
||
public static readonly UnitsConverter Singleton = new UnitsConverter();
|
||
}
|
||
|
||
internal class UpperLimitConverter : JsonConverter
|
||
{
|
||
public override Boolean CanConvert(Type t) => t == typeof(UpperLimit) || t == typeof(UpperLimit?);
|
||
|
||
public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
|
||
{
|
||
switch (reader.TokenType)
|
||
{
|
||
case JsonToken.String:
|
||
case JsonToken.Date:
|
||
var stringValue = serializer.Deserialize<String>(reader);
|
||
switch (stringValue)
|
||
{
|
||
case "":
|
||
return new UpperLimit { Enum = DReferencePowerHigh1.Empty };
|
||
case "-0.31 PowerDiff":
|
||
return new UpperLimit { Enum = DReferencePowerHigh1.The031PowerDiff };
|
||
case "-0.33 PowerDiff":
|
||
return new UpperLimit { Enum = DReferencePowerHigh1.The033PowerDiff };
|
||
case "-0.34 PowerDiff":
|
||
return new UpperLimit { Enum = DReferencePowerHigh1.The034PowerDiff };
|
||
case "0.00999999999999979 PowerDiff":
|
||
return new UpperLimit { Enum = DReferencePowerHigh1.The000999999999999979PowerDiff };
|
||
case "0.04 PowerDiff":
|
||
return new UpperLimit { Enum = DReferencePowerHigh1.The004PowerDiff };
|
||
case "1.5":
|
||
return new UpperLimit { Enum = DReferencePowerHigh1.The15 };
|
||
case "1.82":
|
||
return new UpperLimit { Enum = DReferencePowerHigh1.The182 };
|
||
case "2,828":
|
||
return new UpperLimit { Enum = DReferencePowerHigh1.The2828 };
|
||
case "20.0":
|
||
return new UpperLimit { Enum = DReferencePowerHigh1.The200 };
|
||
default:
|
||
return new UpperLimit { Enum = DReferencePowerHigh1.Empty };
|
||
|
||
}
|
||
}
|
||
throw new Exception("Cannot unmarshal type UpperLimit");
|
||
}
|
||
|
||
public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
|
||
{
|
||
var value = (UpperLimit)untypedValue;
|
||
if (value.Enum != null)
|
||
{
|
||
switch (value.Enum)
|
||
{
|
||
case DReferencePowerHigh1.Empty:
|
||
serializer.Serialize(writer, "");
|
||
return;
|
||
case DReferencePowerHigh1.The031PowerDiff:
|
||
serializer.Serialize(writer, "-0.31 PowerDiff");
|
||
return;
|
||
case DReferencePowerHigh1.The033PowerDiff:
|
||
serializer.Serialize(writer, "-0.33 PowerDiff");
|
||
return;
|
||
case DReferencePowerHigh1.The034PowerDiff:
|
||
serializer.Serialize(writer, "-0.34 PowerDiff");
|
||
return;
|
||
case DReferencePowerHigh1.The000999999999999979PowerDiff:
|
||
serializer.Serialize(writer, "0.00999999999999979 PowerDiff");
|
||
return;
|
||
case DReferencePowerHigh1.The004PowerDiff:
|
||
serializer.Serialize(writer, "0.04 PowerDiff");
|
||
return;
|
||
case DReferencePowerHigh1.The15:
|
||
serializer.Serialize(writer, "1.5");
|
||
return;
|
||
case DReferencePowerHigh1.The182:
|
||
serializer.Serialize(writer, "1.82");
|
||
return;
|
||
case DReferencePowerHigh1.The2828:
|
||
serializer.Serialize(writer, "2,828");
|
||
return;
|
||
case DReferencePowerHigh1.The200:
|
||
serializer.Serialize(writer, "20.0");
|
||
return;
|
||
}
|
||
}
|
||
if (value.Integer != null)
|
||
{
|
||
serializer.Serialize(writer, value.Integer.Value.ToString());
|
||
return;
|
||
}
|
||
throw new Exception("Cannot marshal type UpperLimit");
|
||
}
|
||
|
||
public static readonly UpperLimitConverter Singleton = new UpperLimitConverter();
|
||
}
|
||
|
||
internal class DReferencePowerHigh1Converter : JsonConverter
|
||
{
|
||
public override Boolean CanConvert(Type t) => t == typeof(DReferencePowerHigh1) || t == typeof(DReferencePowerHigh1?);
|
||
|
||
public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
|
||
{
|
||
if (reader.TokenType == JsonToken.Null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var value = serializer.Deserialize<String>(reader);
|
||
switch (value)
|
||
{
|
||
case "":
|
||
return DReferencePowerHigh1.Empty;
|
||
case "-0.31 PowerDiff":
|
||
return DReferencePowerHigh1.The031PowerDiff;
|
||
case "-0.33 PowerDiff":
|
||
return DReferencePowerHigh1.The033PowerDiff;
|
||
case "-0.34 PowerDiff":
|
||
return DReferencePowerHigh1.The034PowerDiff;
|
||
case "0.00999999999999979 PowerDiff":
|
||
return DReferencePowerHigh1.The000999999999999979PowerDiff;
|
||
case "0.04 PowerDiff":
|
||
return DReferencePowerHigh1.The004PowerDiff;
|
||
case "1.5":
|
||
return DReferencePowerHigh1.The15;
|
||
case "1.82":
|
||
return DReferencePowerHigh1.The182;
|
||
case "2,828":
|
||
return DReferencePowerHigh1.The2828;
|
||
case "20.0":
|
||
return DReferencePowerHigh1.The200;
|
||
}
|
||
return DReferencePowerHigh1.Empty;
|
||
//throw new Exception("Cannot unmarshal type DReferencePowerHigh1");
|
||
}
|
||
|
||
public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
|
||
{
|
||
if (untypedValue == null)
|
||
{
|
||
serializer.Serialize(writer, null);
|
||
return;
|
||
}
|
||
var value = (DReferencePowerHigh1)untypedValue;
|
||
switch (value)
|
||
{
|
||
case DReferencePowerHigh1.Empty:
|
||
serializer.Serialize(writer, "");
|
||
return;
|
||
case DReferencePowerHigh1.The031PowerDiff:
|
||
serializer.Serialize(writer, "-0.31 PowerDiff");
|
||
return;
|
||
case DReferencePowerHigh1.The033PowerDiff:
|
||
serializer.Serialize(writer, "-0.33 PowerDiff");
|
||
return;
|
||
case DReferencePowerHigh1.The034PowerDiff:
|
||
serializer.Serialize(writer, "-0.34 PowerDiff");
|
||
return;
|
||
case DReferencePowerHigh1.The000999999999999979PowerDiff:
|
||
serializer.Serialize(writer, "0.00999999999999979 PowerDiff");
|
||
return;
|
||
case DReferencePowerHigh1.The004PowerDiff:
|
||
serializer.Serialize(writer, "0.04 PowerDiff");
|
||
return;
|
||
case DReferencePowerHigh1.The15:
|
||
serializer.Serialize(writer, "1.5");
|
||
return;
|
||
case DReferencePowerHigh1.The182:
|
||
serializer.Serialize(writer, "1.82");
|
||
return;
|
||
case DReferencePowerHigh1.The2828:
|
||
serializer.Serialize(writer, "2,828");
|
||
return;
|
||
case DReferencePowerHigh1.The200:
|
||
serializer.Serialize(writer, "20.0");
|
||
return;
|
||
}
|
||
throw new Exception("Cannot marshal type DReferencePowerHigh1");
|
||
}
|
||
|
||
public static readonly DReferencePowerHigh1Converter Singleton = new DReferencePowerHigh1Converter();
|
||
}
|
||
}
|