682 lines
25 KiB
C#
682 lines
25 KiB
C#
using Adaptation.Shared;
|
|
using Adaptation.Shared.Methods;
|
|
using log4net;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace Adaptation.FileHandlers.Stratus;
|
|
|
|
public partial class ProcessData : IProcessData
|
|
{
|
|
|
|
private readonly List<object> _Details;
|
|
|
|
public string JobID { get; set; }
|
|
public string MesEntity { get; set; }
|
|
public string Batch { get; set; }
|
|
public string Cassette { get; set; }
|
|
public DateTime Date { get; set; }
|
|
public string FilePath { get; set; }
|
|
public string Layer { get; set; }
|
|
public string MeanThickness { get; set; }
|
|
public string Employee { get; set; }
|
|
public string PSN { get; set; }
|
|
public string RDS { get; set; }
|
|
public string Reactor { get; set; }
|
|
public string StdDev { get; set; }
|
|
public string Title { get; set; }
|
|
public string UniqueId { get; set; }
|
|
public string Zone { get; set; }
|
|
//
|
|
public string ThicknessSlotOne { get; set; }
|
|
public string ThicknessSlotTwentyFive { get; set; }
|
|
public string DeltaThicknessSlotsOneAndTwentyFive { get; set; }
|
|
public string PercentDeltaThicknessSlotsOneAndTwentyFive { get; set; }
|
|
|
|
List<object> Shared.Properties.IProcessData.Details => _Details;
|
|
|
|
private int _I;
|
|
private string _Data;
|
|
private readonly ILog _Log;
|
|
|
|
#nullable enable
|
|
|
|
internal ProcessData(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection, string originalDataBioRad, Run? run, string dataText)
|
|
{
|
|
JobID = logistics.JobID;
|
|
if (!string.IsNullOrEmpty(dataText))
|
|
fileInfoCollection.Clear();
|
|
_Details = new List<object>();
|
|
MesEntity = logistics.MesEntity;
|
|
_Log = LogManager.GetLogger(typeof(ProcessData));
|
|
Parse(fileRead, logistics, fileInfoCollection, originalDataBioRad, run, dataText);
|
|
}
|
|
|
|
string IProcessData.GetCurrentReactor(IFileRead fileRead, Logistics logistics, Dictionary<string, string> reactors) => throw new Exception(string.Concat("See ", nameof(Parse)));
|
|
|
|
Tuple<string, Test[], JsonElement[], List<FileInfo>> IProcessData.GetResults(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection)
|
|
{
|
|
Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
|
|
List<Test> tests = new();
|
|
foreach (object item in _Details)
|
|
tests.Add(Test.BioRadStratus);
|
|
List<IDescription> descriptions = fileRead.GetDescriptions(fileRead, tests, this);
|
|
if (tests.Count != descriptions.Count)
|
|
throw new Exception();
|
|
for (int i = 0; i < tests.Count; i++)
|
|
{
|
|
if (descriptions[i] is not Description description)
|
|
throw new Exception();
|
|
if (description.Test != (int)tests[i])
|
|
throw new Exception();
|
|
}
|
|
FileInfo fileInfo = new($"{logistics.ReportFullPath}.descriptions.json");
|
|
List<Description> fileReadDescriptions = (from l in descriptions select (Description)l).ToList();
|
|
string json = JsonSerializer.Serialize(fileReadDescriptions, fileReadDescriptions.GetType());
|
|
File.WriteAllText(fileInfo.FullName, json);
|
|
File.SetLastWriteTime(fileInfo.FullName, logistics.DateTimeFromSequence);
|
|
fileInfoCollection.Add(fileInfo);
|
|
JsonElement[] jsonElements = JsonSerializer.Deserialize<JsonElement[]>(json) ?? throw new Exception();
|
|
results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(logistics.Logistics1[0], tests.ToArray(), jsonElements, fileInfoCollection);
|
|
return results;
|
|
}
|
|
|
|
private string GetBefore(string text)
|
|
{
|
|
string str;
|
|
string str1;
|
|
int num = _Data.IndexOf(text, _I);
|
|
if (num <= -1)
|
|
{
|
|
str = _Data.Substring(_I);
|
|
_I = _Data.Length;
|
|
str1 = str.Trim();
|
|
}
|
|
else
|
|
{
|
|
str = _Data.Substring(_I, num - _I);
|
|
_I = num + text.Length;
|
|
str1 = str.Trim();
|
|
}
|
|
return str1;
|
|
}
|
|
|
|
private string GetBefore(string text, bool trim)
|
|
{
|
|
string str;
|
|
string before;
|
|
if (!trim)
|
|
{
|
|
int num = _Data.IndexOf(text, _I);
|
|
if (num <= -1)
|
|
{
|
|
str = _Data.Substring(_I);
|
|
_I = _Data.Length;
|
|
before = str;
|
|
}
|
|
else
|
|
{
|
|
str = _Data.Substring(_I, num - _I);
|
|
_I = num + text.Length;
|
|
before = str;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
before = GetBefore(text);
|
|
}
|
|
return before;
|
|
}
|
|
|
|
private string GetToEOL()
|
|
{
|
|
string result;
|
|
if (_Data.IndexOf("\n", _I) > -1)
|
|
result = GetBefore("\n");
|
|
else
|
|
result = GetBefore(Environment.NewLine);
|
|
return result;
|
|
}
|
|
|
|
private string GetToEOL(bool trim)
|
|
{
|
|
string str;
|
|
if (_Data.IndexOf("\n", _I) > -1)
|
|
str = !trim ? GetBefore("\n", false) : GetToEOL();
|
|
else
|
|
str = !trim ? GetBefore(Environment.NewLine, false) : GetToEOL();
|
|
return str;
|
|
}
|
|
|
|
private string GetToken()
|
|
{
|
|
while (true)
|
|
{
|
|
if (_I >= _Data.Length || !IsNullOrWhiteSpace(_Data.Substring(_I, 1)))
|
|
{
|
|
break;
|
|
}
|
|
_I++;
|
|
}
|
|
int num = _I;
|
|
while (true)
|
|
{
|
|
if (num >= _Data.Length || IsNullOrWhiteSpace(_Data.Substring(num, 1)))
|
|
{
|
|
break;
|
|
}
|
|
num++;
|
|
}
|
|
string str = _Data.Substring(_I, num - _I);
|
|
_I = num;
|
|
return str.Trim();
|
|
}
|
|
|
|
private string GetToText(string text)
|
|
{
|
|
string str = _Data.Substring(_I, _Data.IndexOf(text, _I) - _I).Trim();
|
|
return str;
|
|
}
|
|
|
|
private bool IsBlankLine()
|
|
{
|
|
int num = _Data.IndexOf("\n", _I);
|
|
return IsNullOrWhiteSpace(num > -1 ? _Data.Substring(_I, num - _I) : _Data.Substring(_I));
|
|
}
|
|
|
|
private static bool IsNullOrWhiteSpace(string text)
|
|
{
|
|
bool flag;
|
|
int num = 0;
|
|
while (true)
|
|
{
|
|
if (num >= text.Length)
|
|
{
|
|
flag = true;
|
|
break;
|
|
}
|
|
else if (char.IsWhiteSpace(text[num]))
|
|
{
|
|
num++;
|
|
}
|
|
else
|
|
{
|
|
flag = false;
|
|
break;
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
private string PeekNextLine()
|
|
{
|
|
int num = _I;
|
|
string toEOL = GetToEOL();
|
|
_I = num;
|
|
return toEOL;
|
|
}
|
|
|
|
private void ScanPast(string text)
|
|
{
|
|
int num = _Data.IndexOf(text, _I);
|
|
if (num <= -1)
|
|
{
|
|
_I = _Data.Length;
|
|
}
|
|
else
|
|
{
|
|
_I = num + text.Length;
|
|
}
|
|
}
|
|
|
|
internal static DateTime GetDateTime(Logistics logistics, string dateTimeText)
|
|
{
|
|
DateTime result;
|
|
string inputDateFormat = "MM/dd/yy HH:mm";
|
|
if (dateTimeText.Length != inputDateFormat.Length)
|
|
result = logistics.DateTimeFromSequence;
|
|
else
|
|
{
|
|
if (!DateTime.TryParseExact(dateTimeText, inputDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime dateTimeParsed))
|
|
result = logistics.DateTimeFromSequence;
|
|
else
|
|
{
|
|
if (dateTimeParsed < logistics.DateTimeFromSequence.AddDays(1) && dateTimeParsed > logistics.DateTimeFromSequence.AddDays(-1))
|
|
result = dateTimeParsed;
|
|
else
|
|
result = logistics.DateTimeFromSequence;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static (string, string) GetReactorAndRDS(string defaultReactor, string defaultRDS, string text, string formattedText, string[] segments)
|
|
{
|
|
string rds;
|
|
string reactor;
|
|
if (string.IsNullOrEmpty(text) || segments.Length == 0 || string.IsNullOrEmpty(formattedText))
|
|
reactor = defaultReactor;
|
|
else
|
|
reactor = segments[0];
|
|
if (segments.Length <= 1 || !int.TryParse(segments[1], out int rdsValue) || rdsValue < 99)
|
|
rds = defaultRDS;
|
|
else
|
|
rds = segments[1];
|
|
if (reactor.Length > 3)
|
|
{
|
|
rds = reactor;
|
|
reactor = defaultReactor;
|
|
}
|
|
return new(reactor, rds);
|
|
}
|
|
|
|
private static (string, string) GetLayerAndPSN(string defaultLayer, string defaultPSN, string[] segments)
|
|
{
|
|
string psn;
|
|
string layer;
|
|
if (segments.Length <= 2)
|
|
{
|
|
psn = defaultPSN;
|
|
layer = defaultLayer;
|
|
}
|
|
else
|
|
{
|
|
string[] segmentsB = segments[2].Split('.');
|
|
psn = segmentsB[0];
|
|
if (segmentsB.Length <= 1)
|
|
layer = defaultLayer;
|
|
else
|
|
{
|
|
layer = segmentsB[1];
|
|
if (layer.Length > 1 && layer[0] == '0')
|
|
layer = layer.Substring(1);
|
|
}
|
|
}
|
|
return (layer, psn);
|
|
}
|
|
|
|
private static string GetZone(string[] segments)
|
|
{
|
|
string result;
|
|
if (segments.Length <= 3)
|
|
result = string.Empty;
|
|
else
|
|
{
|
|
result = segments[3];
|
|
if (result.Length > 1 && result[0] == '0')
|
|
result = result.Substring(1);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static Descriptor GetDescriptor(string text)
|
|
{
|
|
Descriptor result;
|
|
string psn;
|
|
string rds;
|
|
string zone;
|
|
string layer;
|
|
string reactor;
|
|
string cassette;
|
|
string employee;
|
|
string defaultPSN = string.Empty;
|
|
string defaultRDS = string.Empty;
|
|
string defaultZone = string.Empty;
|
|
string defaultLayer = string.Empty;
|
|
string defaultReactor = string.Empty;
|
|
string defaultEmployee = string.Empty;
|
|
if (Regex.IsMatch(text, @"^[a-zA-z][0-9]{2,4}$"))
|
|
{
|
|
cassette = text.ToUpper();
|
|
psn = defaultPSN;
|
|
rds = defaultRDS;
|
|
zone = defaultZone;
|
|
layer = defaultLayer;
|
|
reactor = defaultReactor;
|
|
employee = defaultEmployee;
|
|
}
|
|
else if (string.IsNullOrEmpty(text) || (text.Length is 2 or 3 && Regex.IsMatch(text, "^[a-zA-z]{2,3}")))
|
|
{
|
|
cassette = text;
|
|
psn = defaultPSN;
|
|
rds = defaultRDS;
|
|
zone = defaultZone;
|
|
employee = cassette;
|
|
layer = defaultLayer;
|
|
reactor = defaultReactor;
|
|
}
|
|
else if (Regex.IsMatch(text, @"^[0-9]{2}[.][0-9]{1}[.]?[0-9]{0,1}"))
|
|
{
|
|
string[] segments = text.Split('.');
|
|
cassette = text;
|
|
psn = defaultPSN;
|
|
rds = defaultRDS;
|
|
layer = segments[1];
|
|
reactor = segments[0];
|
|
employee = defaultEmployee;
|
|
if (segments.Length <= 2)
|
|
zone = defaultZone;
|
|
else
|
|
zone = segments[2];
|
|
}
|
|
else
|
|
{
|
|
string[] segments;
|
|
// Remove illegal characters \/:*?"<>| found in the Cassette.
|
|
cassette = Regex.Replace(text, @"[\\,\/,\:,\*,\?,\"",\<,\>,\|]", "_").Split('\r')[0].Split('\n')[0];
|
|
if (cassette.Length > 2 && cassette[0] == '1' && (cassette[1] == 'T' || cassette[1] == 't'))
|
|
cassette = cassette.Substring(2);
|
|
if (cassette.Contains('-'))
|
|
segments = cassette.Split(new char[] { '-' });
|
|
else if (!cassette.Contains('\u005F'))
|
|
segments = cassette.Split(new char[] { ' ' });
|
|
else if (cassette.Contains('.'))
|
|
segments = cassette.Split(new char[] { '.' });
|
|
else
|
|
segments = cassette.Split(new char[] { '\u005F' });
|
|
// bool hasRDS = Regex.IsMatch(cassette, "[-]?([QP][0-9]{4,}|[0-9]{5,})[-]?");
|
|
(reactor, rds) = GetReactorAndRDS(defaultReactor, defaultRDS, text, cassette, segments);
|
|
(layer, psn) = GetLayerAndPSN(defaultLayer, defaultPSN, segments);
|
|
zone = GetZone(segments);
|
|
if (segments.Length <= 3 || segments[3].Length <= 1)
|
|
employee = defaultEmployee;
|
|
else
|
|
employee = segments[3];
|
|
}
|
|
result = new(cassette, employee, layer, psn, rds, reactor, zone);
|
|
return result;
|
|
}
|
|
|
|
private void Set(Logistics logistics, Run? run)
|
|
{
|
|
string psn;
|
|
string rds;
|
|
string text;
|
|
string zone;
|
|
string batch;
|
|
string layer;
|
|
string title;
|
|
DateTime date;
|
|
string reactor;
|
|
string cassette;
|
|
string employee;
|
|
const string batchKey = "Batch";
|
|
const string startedKey = "started";
|
|
const string cassetteKey = "Cassette";
|
|
const string startedAtKey = "started at";
|
|
if (!_Data.Contains(batchKey) || !_Data.Contains(startedKey))
|
|
batch = string.Empty;
|
|
else
|
|
{
|
|
for (int z = 0; z < int.MaxValue; z++)
|
|
{
|
|
ScanPast(batchKey);
|
|
if (!_Data.Substring(_I).Contains(batchKey))
|
|
break;
|
|
}
|
|
batch = GetToText(startedKey);
|
|
ScanPast(startedAtKey);
|
|
}
|
|
if (run is not null)
|
|
{ }
|
|
ScanPast(cassetteKey);
|
|
if (!_Data.Substring(_I).Contains(startedKey))
|
|
text = string.Empty;
|
|
else
|
|
text = GetToText(startedKey);
|
|
ScanPast(startedAtKey);
|
|
string dateTimeText = GetToEOL();
|
|
if (dateTimeText.EndsWith("."))
|
|
dateTimeText = dateTimeText.Remove(dateTimeText.Length - 1, 1);
|
|
date = GetDateTime(logistics, dateTimeText);
|
|
Descriptor descriptor = GetDescriptor(text);
|
|
cassette = descriptor.Cassette;
|
|
psn = descriptor.PSN;
|
|
rds = descriptor.RDS;
|
|
zone = descriptor.Zone;
|
|
layer = descriptor.Layer;
|
|
reactor = descriptor.Reactor;
|
|
employee = descriptor.Employee;
|
|
title = !string.IsNullOrEmpty(batch) ? batch : cassette;
|
|
PSN = psn;
|
|
RDS = rds;
|
|
Date = date;
|
|
Zone = zone;
|
|
Batch = batch;
|
|
Layer = layer;
|
|
Title = title;
|
|
Reactor = reactor;
|
|
Cassette = cassette;
|
|
Employee = employee;
|
|
UniqueId = string.Concat("StratusBioRad_", reactor, "_", rds, "_", psn, "_", logistics.DateTimeFromSequence.ToString("yyyyMMddHHmmssffff"));
|
|
}
|
|
|
|
private void Parse(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection, string originalDataBioRad, Run? run, string dataText)
|
|
{
|
|
if (fileRead is null)
|
|
throw new ArgumentNullException(nameof(fileRead));
|
|
_I = 0;
|
|
_Data = string.Empty;
|
|
List<Detail> details = new();
|
|
if (string.IsNullOrEmpty(dataText))
|
|
dataText = File.ReadAllText(logistics.ReportFullPath);
|
|
_Log.Debug($"****ParseData - Source file contents:");
|
|
_Log.Debug(dataText);
|
|
List<string> moveFiles = new();
|
|
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(logistics.ReportFullPath);
|
|
string directoryName = Path.GetDirectoryName(logistics.ReportFullPath) ?? throw new Exception();
|
|
moveFiles.AddRange(Directory.GetFiles(directoryName, string.Concat(originalDataBioRad, "*", logistics.Sequence, "*"), SearchOption.TopDirectoryOnly));
|
|
moveFiles.AddRange(Directory.GetFiles(directoryName, string.Concat(originalDataBioRad, "*", fileNameWithoutExtension.Split('_').Last(), "*"), SearchOption.TopDirectoryOnly));
|
|
foreach (string moveFile in moveFiles.Distinct())
|
|
fileInfoCollection.Add(new FileInfo(moveFile));
|
|
if (!string.IsNullOrEmpty(dataText))
|
|
{
|
|
int i;
|
|
int num;
|
|
int num2;
|
|
Point point;
|
|
int num1 = 0;
|
|
Detail detail;
|
|
string recipe;
|
|
string nextLine;
|
|
_I = 0;
|
|
_Data = dataText;
|
|
Set(logistics, run);
|
|
nextLine = PeekNextLine();
|
|
string cassette = "Cassette";
|
|
if (nextLine.Contains("Wafer"))
|
|
{
|
|
_Log.Debug("****ProcessData Contains Wafer");
|
|
while (!PeekNextLine().Contains(cassette))
|
|
{
|
|
num2 = num1;
|
|
num1 = num2 + 1;
|
|
if (num2 > 25)
|
|
break;
|
|
else
|
|
{
|
|
_Log.Debug("****ProcessData new stratusBioRadWaferDetail");
|
|
detail = new Detail();
|
|
ScanPast("Wafer");
|
|
detail.Wafer = GetToEOL();
|
|
if (detail.Wafer.EndsWith("."))
|
|
{
|
|
_Log.Debug("****ProcessData Removing Wafer");
|
|
detail.Wafer = detail.Wafer.Remove(detail.Wafer.Length - 1, 1);
|
|
}
|
|
ScanPast("Slot");
|
|
detail.Slot = GetToEOL();
|
|
ScanPast("Recipe");
|
|
recipe = GetToEOL();
|
|
if (recipe.EndsWith("."))
|
|
{
|
|
_Log.Debug("****ProcessData Removing Recipe");
|
|
recipe = recipe.Remove(recipe.Length - 1, 1);
|
|
}
|
|
detail.Recipe = recipe;
|
|
_ = GetToEOL();
|
|
nextLine = PeekNextLine();
|
|
if (nextLine.Contains("Thickness"))
|
|
{
|
|
ScanPast("1 - ");
|
|
num = Convert.ToInt32(GetToken());
|
|
_Log.Debug(string.Concat("****ProcessData Thickness =", num));
|
|
detail.Points = new();
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
point = new() { Thickness = GetToken() };
|
|
if (point.Thickness == "Thickness,")
|
|
{
|
|
ScanPast("um");
|
|
continue;
|
|
}
|
|
detail.Points.Add(point);
|
|
point.Position = Convert.ToString(detail.Points.Count);
|
|
}
|
|
}
|
|
_ = GetToEOL();
|
|
nextLine = PeekNextLine();
|
|
if (nextLine.Contains("Thickness"))
|
|
{
|
|
ScanPast("11 - ");
|
|
num = Convert.ToInt32(GetToken());
|
|
for (i = detail.Points.Count; i < num; i++)
|
|
{
|
|
point = new() { Thickness = GetToken() };
|
|
detail.Points.Add(point);
|
|
point.Position = Convert.ToString(detail.Points.Count);
|
|
}
|
|
}
|
|
ScanPast("Slot");
|
|
_ = GetToken();
|
|
detail.PassFail = GetToken();
|
|
if (detail.PassFail.EndsWith("."))
|
|
{
|
|
_Log.Debug("****ProcessData Removing PassFail");
|
|
detail.PassFail = detail.PassFail.Remove(detail.PassFail.Length - 1, 1);
|
|
}
|
|
ScanPast("Mean");
|
|
detail.Mean = GetToken();
|
|
if (detail.Mean.EndsWith(","))
|
|
{
|
|
_Log.Debug("****ProcessData Removing Mean");
|
|
detail.Mean = detail.Mean.Remove(detail.Mean.Length - 1, 1);
|
|
}
|
|
ScanPast("STDD");
|
|
detail.StdDev = GetToEOL();
|
|
if (detail.StdDev.EndsWith("."))
|
|
{
|
|
_Log.Debug("****ProcessData Removing stdDev");
|
|
detail.StdDev = detail.StdDev.Remove(detail.StdDev.Length - 1, 1);
|
|
}
|
|
detail.UniqueId = string.Concat("_Wafer-", detail.Wafer, "_Slot-", detail.Slot, "_Point-", detail.Position);
|
|
details.Add(detail);
|
|
nextLine = PeekNextLine();
|
|
if (nextLine.Contains(cassette))
|
|
{
|
|
_ = GetToEOL();
|
|
nextLine = PeekNextLine();
|
|
}
|
|
if (nextLine.Contains(cassette))
|
|
{
|
|
_ = GetToEOL();
|
|
nextLine = PeekNextLine();
|
|
}
|
|
if (nextLine.Contains("Process failed"))
|
|
_ = GetToEOL();
|
|
}
|
|
}
|
|
ScanPast("Mean");
|
|
MeanThickness = GetToken();
|
|
if (MeanThickness.EndsWith(","))
|
|
{
|
|
_Log.Debug("****ProcessData Removing MeanThickness");
|
|
MeanThickness = MeanThickness.Remove(MeanThickness.Length - 1, 1);
|
|
}
|
|
ScanPast("STDD");
|
|
StdDev = GetToken();
|
|
if (StdDev.EndsWith(","))
|
|
{
|
|
_Log.Debug("****ProcessData Removing thi.StdDev");
|
|
StdDev = StdDev.Remove(StdDev.Length - 1, 1);
|
|
}
|
|
}
|
|
if (dataText.Contains("------------- Process failed -------------"))
|
|
details.Add(new());
|
|
}
|
|
StringBuilder stringBuilder = new();
|
|
foreach (Detail detail in details)
|
|
{
|
|
detail.HeaderUniqueId = UniqueId;
|
|
detail.UniqueId = string.Concat(UniqueId, detail.UniqueId);
|
|
detail.Points ??= new List<Point>();
|
|
foreach (Point bioRadDetail in detail.Points)
|
|
{
|
|
bioRadDetail.HeaderUniqueId = detail.HeaderUniqueId;
|
|
bioRadDetail.UniqueId = detail.UniqueId;
|
|
}
|
|
_ = stringBuilder.Clear();
|
|
foreach (Point point in detail.Points)
|
|
_ = stringBuilder.Append(point.Thickness).Append(',');
|
|
if (stringBuilder.Length > 0)
|
|
_ = stringBuilder.Remove(stringBuilder.Length - 1, 1);
|
|
detail.Thickness = stringBuilder.ToString();
|
|
_ = stringBuilder.Clear();
|
|
foreach (Point point in detail.Points)
|
|
_ = stringBuilder.Append(point.Position).Append(',');
|
|
if (stringBuilder.Length > 0)
|
|
_ = stringBuilder.Remove(stringBuilder.Length - 1, 1);
|
|
detail.Position = stringBuilder.ToString();
|
|
}
|
|
if (details.Count != 2
|
|
|| details[0].Slot != "1"
|
|
|| details[1].Slot != "25"
|
|
|| string.IsNullOrEmpty(details[0].Thickness)
|
|
|| string.IsNullOrEmpty(details[1].Thickness)
|
|
|| !decimal.TryParse(details[0].Thickness, out decimal thick01)
|
|
|| !decimal.TryParse(details[1].Thickness, out decimal thick25)
|
|
|| (thick01 == 0 && thick25 == 0))
|
|
{
|
|
ThicknessSlotOne = string.Empty;
|
|
ThicknessSlotTwentyFive = string.Empty;
|
|
DeltaThicknessSlotsOneAndTwentyFive = string.Empty;
|
|
PercentDeltaThicknessSlotsOneAndTwentyFive = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
ThicknessSlotOne = details[0].Thickness;
|
|
ThicknessSlotTwentyFive = details[1].Thickness;
|
|
DeltaThicknessSlotsOneAndTwentyFive = (thick01 - thick25).ToString();
|
|
// https://www.calculatorsoup.com/calculators/algebra/percent-difference-calculator.php
|
|
PercentDeltaThicknessSlotsOneAndTwentyFive = $"{Math.Abs(thick01 - thick25) / ((thick01 + thick25) / 2) * 100:0.000}";
|
|
}
|
|
fileInfoCollection.Add(logistics.FileInfo);
|
|
_Details.AddRange(details);
|
|
}
|
|
|
|
internal static List<Description> GetDescriptions(JsonElement[] jsonElements)
|
|
{
|
|
List<Description> results = new();
|
|
Description? description;
|
|
JsonSerializerOptions jsonSerializerOptions = new() { NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString };
|
|
foreach (JsonElement jsonElement in jsonElements)
|
|
{
|
|
if (jsonElement.ValueKind != JsonValueKind.Object)
|
|
throw new Exception();
|
|
description = JsonSerializer.Deserialize<Description>(jsonElement.ToString(), jsonSerializerOptions);
|
|
if (description is null)
|
|
continue;
|
|
results.Add(description);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
} |