429 lines
14 KiB
C#
429 lines
14 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.RegularExpressions;
|
|
|
|
namespace Adaptation.FileHandlers.QS408M;
|
|
|
|
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 string Date { get; set; }
|
|
public string Employee { get; set; }
|
|
public string Layer { get; set; }
|
|
public string MeanThickness { get; set; }
|
|
public string PSN { get; set; }
|
|
public string PassFail { get; set; }
|
|
public string RDS { get; set; }
|
|
public string RVThickness { get; set; }
|
|
public string Reactor { get; set; }
|
|
public string Recipe { get; set; }
|
|
public string StdDev { get; set; }
|
|
public string Title { get; set; }
|
|
public string UniqueId { get; set; }
|
|
public string Wafer { get; set; }
|
|
public string Zone { get; set; }
|
|
|
|
List<object> Shared.Properties.IProcessData.Details => _Details;
|
|
|
|
private int _I;
|
|
private string _Data;
|
|
private readonly ILog _Log;
|
|
|
|
public ProcessData()
|
|
{
|
|
}
|
|
|
|
public ProcessData(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection, string originalDataBioRad, ProcessData lastProcessData)
|
|
{
|
|
JobID = logistics.JobID;
|
|
fileInfoCollection.Clear();
|
|
_Details = new List<object>();
|
|
MesEntity = logistics.MesEntity;
|
|
_Log = LogManager.GetLogger(typeof(ProcessData));
|
|
Parse(fileRead, logistics, fileInfoCollection, originalDataBioRad, lastProcessData);
|
|
}
|
|
|
|
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.BioRadQS408M);
|
|
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();
|
|
}
|
|
List<Description> fileReadDescriptions = (from l in descriptions select (Description)l).ToList();
|
|
string json = JsonSerializer.Serialize(fileReadDescriptions, fileReadDescriptions.GetType());
|
|
JsonElement[] jsonElements = JsonSerializer.Deserialize<JsonElement[]>(json);
|
|
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 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 = "ddd mmm dd HH:mm:ss yyyy";
|
|
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 void Parse(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection, string originalDataBioRad, ProcessData lastProcessData)
|
|
{
|
|
if (fileRead is null)
|
|
{ }
|
|
_I = 0;
|
|
_Data = string.Empty;
|
|
List<Detail> details = new();
|
|
string receivedData = File.ReadAllText(logistics.ReportFullPath);
|
|
_Log.Debug($"****ParseData - Source file contents:");
|
|
_Log.Debug(receivedData);
|
|
string[] files = Directory.GetFiles(Path.GetDirectoryName(logistics.ReportFullPath), string.Concat(originalDataBioRad, logistics.Sequence, "*"), SearchOption.TopDirectoryOnly);
|
|
foreach (string file in files)
|
|
fileInfoCollection.Add(new FileInfo(file));
|
|
// occasionally there are multiple blocks of results, get the last one as earlier ones may be aborted runs.
|
|
int index = receivedData.LastIndexOf("Bio-Rad");
|
|
if (index > -1)
|
|
receivedData = receivedData.Substring(index);
|
|
_Log.Debug($"****ParseData - Source file contents to be parsed:");
|
|
_Log.Debug(receivedData);
|
|
if (!string.IsNullOrEmpty(receivedData))
|
|
{
|
|
_I = 0;
|
|
_Data = receivedData;
|
|
Title = GetBefore("Recipe:");
|
|
Recipe = GetToken();
|
|
string dateTimeText = GetToEOL();
|
|
if (dateTimeText.EndsWith("."))
|
|
dateTimeText = dateTimeText.Remove(dateTimeText.Length - 1, 1);
|
|
DateTime dateTime = GetDateTime(logistics, dateTimeText);
|
|
Date = dateTime.ToString();
|
|
ScanPast("operator:");
|
|
Employee = GetBefore("batch:");
|
|
Batch = GetToEOL();
|
|
// Remove illegal characters \/:*?"<>| found in the Batch
|
|
Batch = Regex.Replace(Batch, @"[\\,\/,\:,\*,\?,\"",\<,\>,\|]", "_").Split('\r')[0].Split('\n')[0];
|
|
ScanPast("cassette:");
|
|
Cassette = GetBefore("wafer:");
|
|
if (string.IsNullOrEmpty(Batch))
|
|
{
|
|
_I = 0;
|
|
_Data = receivedData;
|
|
ScanPast("wafer:");
|
|
}
|
|
Wafer = GetToEOL();
|
|
_ = GetToEOL();
|
|
_ = GetToEOL();
|
|
string token = GetToken();
|
|
int counter = 1;
|
|
while (true)
|
|
{
|
|
if ((string.IsNullOrEmpty(token) || !char.IsDigit(token[0])))
|
|
break;
|
|
Detail detail = new()
|
|
{
|
|
Position = token,
|
|
Thickness = GetToken(),
|
|
UniqueId = string.Concat("_Point-", counter)
|
|
};
|
|
details.Add(detail);
|
|
token = GetToken();
|
|
counter++;
|
|
}
|
|
ScanPast("mean thickness =");
|
|
MeanThickness = GetBefore(", std. dev =");
|
|
StdDev = GetToken();
|
|
PassFail = GetToEOL();
|
|
ScanPast("thickness");
|
|
RVThickness = GetToEOL();
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(Wafer))
|
|
throw new Exception("Wafer field is missing.");
|
|
|
|
//parse out batch and validate
|
|
string[] parsedBatch = Wafer.Split('-');
|
|
if (parsedBatch.Length >= 1)
|
|
Reactor = parsedBatch[0];
|
|
if (parsedBatch.Length >= 2)
|
|
RDS = parsedBatch[1];
|
|
if (parsedBatch.Length >= 3)
|
|
{
|
|
string[] parsedPSN = parsedBatch[2].Split('.');
|
|
if (parsedPSN.Length >= 1)
|
|
PSN = parsedPSN[0];
|
|
if (parsedPSN.Length >= 2)
|
|
Layer = parsedPSN[1];
|
|
}
|
|
if (parsedBatch.Length >= 4)
|
|
Zone = parsedBatch[3];
|
|
|
|
JobID = logistics.JobID;
|
|
|
|
if (logistics.DateTimeFromSequence > DateTime.Now.AddHours(-24))
|
|
{
|
|
if (string.IsNullOrEmpty(lastProcessData.Wafer))
|
|
{
|
|
lastProcessData.Batch = JobID;
|
|
lastProcessData.Cassette = JobID;
|
|
lastProcessData.Employee = JobID;
|
|
lastProcessData.Recipe = JobID;
|
|
lastProcessData.Title = JobID;
|
|
}
|
|
lastProcessData.Wafer = Wafer;
|
|
lastProcessData.Reactor = Reactor;
|
|
lastProcessData.RDS = RDS;
|
|
|
|
string check = "--------";
|
|
if (string.IsNullOrEmpty(Batch) || Batch.Contains(check))
|
|
Batch = lastProcessData.Batch;
|
|
else
|
|
lastProcessData.Batch = Batch;
|
|
if (string.IsNullOrEmpty(Cassette) || Cassette.Contains(check))
|
|
Cassette = lastProcessData.Cassette;
|
|
else
|
|
lastProcessData.Cassette = Cassette;
|
|
if (string.IsNullOrEmpty(Employee) || Employee.Contains(check))
|
|
Employee = lastProcessData.Employee;
|
|
else
|
|
lastProcessData.Employee = Employee;
|
|
if (string.IsNullOrEmpty(Recipe) || Recipe.Contains(check))
|
|
Recipe = lastProcessData.Recipe;
|
|
else
|
|
lastProcessData.Recipe = Recipe;
|
|
if (string.IsNullOrEmpty(Title) || Title.Contains(check))
|
|
Title = lastProcessData.Title;
|
|
else
|
|
lastProcessData.Title = Title;
|
|
}
|
|
|
|
//fix title
|
|
StringBuilder titleFixed = new();
|
|
foreach (char c in Title)
|
|
{
|
|
if (char.IsLetterOrDigit(c) || c == '-' || c == '.')
|
|
_ = titleFixed.Append(c);
|
|
}
|
|
Title = titleFixed.ToString();
|
|
|
|
//fix wafer
|
|
StringBuilder waferFixed = new();
|
|
foreach (char c in Wafer)
|
|
{
|
|
if (char.IsLetterOrDigit(c) || c == '-' || c == '.')
|
|
_ = waferFixed.Append(c);
|
|
}
|
|
Wafer = waferFixed.ToString();
|
|
|
|
//create filename / unique id
|
|
UniqueId = string.Concat(Title, "_", Wafer, "_", logistics.DateTimeFromSequence.ToString("yyyyMMddHHmmssffff"));
|
|
foreach (Detail detail in details)
|
|
{
|
|
detail.HeaderUniqueId = UniqueId;
|
|
detail.UniqueId = string.Concat(UniqueId, detail.UniqueId);
|
|
}
|
|
|
|
//trace datatype
|
|
_Log.Debug("BioRad parsed infomation:");
|
|
_Log.Debug(string.Format("Batch: {0}", Batch));
|
|
_Log.Debug(string.Format("Cassette: {0}", Cassette));
|
|
_Log.Debug(string.Format("Date: {0}", Date));
|
|
foreach (Detail bioRadDetail in details)
|
|
_Log.Debug(string.Format("Details: {0} - {1}", bioRadDetail.Position, bioRadDetail.Thickness));
|
|
_Log.Debug(string.Format("Mean Thickness: {0}", MeanThickness));
|
|
_Log.Debug(string.Format("Operator: {0}", Employee));
|
|
_Log.Debug(string.Format("Pass/Fail: {0}", PassFail));
|
|
_Log.Debug(string.Format("Recipe: {0}", Recipe));
|
|
_Log.Debug(string.Format("RV Thickness: {0}", RVThickness));
|
|
_Log.Debug(string.Format("Std Dev: {0}", StdDev));
|
|
_Log.Debug(string.Format("Title: {0}", Title));
|
|
_Log.Debug(string.Format("Wafer: {0}", Wafer));
|
|
fileInfoCollection.Add(new FileInfo(logistics.ReportFullPath));
|
|
_Details.AddRange(details);
|
|
}
|
|
|
|
} |