Filter copy for InfinityQS

Reactor 43 and 56

Adaptation/.vscode/launch.json

@@ -1,43 +1,43 @@
 {
   "configurations": [
     {
-      "mode": "debug",
       "name": "Go launch file",
-      "program": "${file}",
+      "type": "go",
       "request": "launch",
-      "type": "go"
-    },
-    {
-      "name": "node Launch Current Opened File",
-      "program": "${file}",
-      "request": "launch",
-      "type": "node"
-    },
-    {
-      "cwd": "${workspaceFolder}",
-      "internalConsoleOptions": "neverOpen",
-      "name": "Debug File",
-      "program": "${file}",
-      "request": "launch",
-      "stopOnEntry": false,
-      "type": "bun",
-      "watchMode": false
-    },
-    {
-      "cwd": "${workspaceFolder}",
-      "internalConsoleOptions": "neverOpen",
-      "name": "Run File",
-      "noDebug": true,
-      "program": "${file}",
-      "request": "launch",
-      "type": "bun",
-      "watchMode": false
+      "mode": "debug",
+      "program": "${file}"
     },
     {
       "name": ".NET Core Attach",
-      "processId": 32760,
+      "type": "coreclr",
       "request": "attach",
-      "type": "coreclr"
+      "processId": 32760
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "node Launch Current Opened File",
+      "program": "${file}"
+    },
+    {
+      "type": "bun",
+      "internalConsoleOptions": "neverOpen",
+      "request": "launch",
+      "name": "Debug File",
+      "program": "${file}",
+      "cwd": "${workspaceFolder}",
+      "stopOnEntry": false,
+      "watchMode": false
+    },
+    {
+      "type": "bun",
+      "internalConsoleOptions": "neverOpen",
+      "request": "launch",
+      "name": "Run File",
+      "program": "${file}",
+      "cwd": "${workspaceFolder}",
+      "noDebug": true,
+      "watchMode": false
     }
   ]
 }

Adaptation/DEP08CEPIEPSILON.yml

@@ -41,6 +41,24 @@ stages:
             displayName: "Nuget Clear"
             enabled: false
 
+          - task: CopyFiles@2
+            displayName: 'Copy GhostPCL Files to: D:\EAF-Mesa-Integration\copy'
+            inputs:
+              Contents: "*"
+              SourceFolder: '\\mesfs.infineon.com\EC_EAFRepository\Staging\DeploymentStorage\GhostPCL'
+              TargetFolder: 'D:\EAF-Mesa-Integration\copy\GhostPCL'
+              OverWrite: true
+            enabled: true
+
+          - task: CopyFiles@2
+            displayName: 'Copy LincPDFC Files to: D:\EAF-Mesa-Integration\copy'
+            inputs:
+              Contents: "*"
+              SourceFolder: '\\mesfs.infineon.com\EC_EAFRepository\Staging\DeploymentStorage\LincPDFC'
+              TargetFolder: 'D:\EAF-Mesa-Integration\copy\LincPDFC'
+              OverWrite: true
+            enabled: true
+
           - script: |
               "C:\program files\dotnet\dotnet.exe" user-secrets init
               "C:\program files\dotnet\dotnet.exe" user-secrets set "BuildNumber" "$(Build.BuildId)"
@@ -184,6 +202,24 @@ stages:
             displayName: "Nuget Clear"
             enabled: false
 
+          - task: CopyFiles@2
+            displayName: 'Copy GhostPCL Files to: D:\EAF-Mesa-Integration\copy'
+            inputs:
+              Contents: "*"
+              SourceFolder: '\\mestsa003.infineon.com\EC_EAFRepository\Staging\DeploymentStorage\GhostPCL'
+              TargetFolder: 'D:\EAF-Mesa-Integration\copy\GhostPCL'
+              OverWrite: true
+            enabled: true
+
+          - task: CopyFiles@2
+            displayName: 'Copy LincPDFC Files to: D:\EAF-Mesa-Integration\copy'
+            inputs:
+              Contents: "*"
+              SourceFolder: '\\mestsa003.infineon.com\EC_EAFRepository\Staging\DeploymentStorage\LincPDFC'
+              TargetFolder: 'D:\EAF-Mesa-Integration\copy\LincPDFC'
+              OverWrite: true
+            enabled: true
+
           - script: |
               "C:\program files\dotnet\dotnet.exe" user-secrets init
               "C:\program files\dotnet\dotnet.exe" user-secrets set "BuildNumber" "$(Build.BuildId)"

Adaptation/FileHandlers/Aggregation/FileRead.cs

@@ -117,6 +117,43 @@ public class FileRead : Shared.FileRead, IFileRead
         return results;
     }
 
+    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
+    {
+#nullable enable
+        int? result = null;
+        for (int i = 0; i < columns.Length; i++)
+        {
+            if (columns[i] != keyColumn)
+                continue;
+            result = i;
+            break;
+        }
+        return result;
+    }
+
+    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
+    {
+        List<string> results = new();
+        string[] values;
+        string? systemState;
+        string keyColumnValue;
+        for (int i = 7; i < lines.Count; i++)
+        {
+            values = lines[i].Split('\t');
+            if (values.Length != columns.Length)
+                continue;
+            keyColumnValue = values[keyColumnIndex];
+            if (string.IsNullOrEmpty(keyColumnValue))
+                continue;
+            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
+                continue;
+            if (results.Contains(systemState))
+                continue;
+            results.Add(systemState);
+        }
+        return new(results);
+    }
+
     private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
     {
         Tuple<string, Test[], JsonElement[], List<FileInfo>> results;

Adaptation/FileHandlers/CellInstanceConnectionName.cs

@@ -16,13 +16,19 @@ public class CellInstanceConnectionName
             nameof(Aggregation) => new Aggregation.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
             nameof(Dummy) => new Dummy.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
             nameof(InfinityQS) => new InfinityQS.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
-            nameof(Log) => new Log.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
-            nameof(R2) => new R2.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
-            nameof(R3) => new R3.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
-            nameof(R4) => new R4.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
-            nameof(R5) => new R5.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
-            nameof(R6) => new R6.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
-            nameof(R7) => new R7.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R29) => new R29.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R30) => new R30.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R32) => new R32.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R36) => new R36.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R43) => new R43.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R55) => new R55.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R56) => new R56.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R57) => new R57.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R61) => new R61.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R62) => new R62.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R65) => new R65.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R75) => new R75.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
+            nameof(R77) => new R77.FileRead(smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null),
             _ => throw new Exception($"\"{cellInstanceConnectionName}\" not mapped")
         };
         return result;

Adaptation/FileHandlers/InfinityQS/FileRead.cs

@@ -107,7 +107,7 @@ public class FileRead : Shared.FileRead, IFileRead
         return results;
     }
 
-    private void CopyAndWriteFile(string reportFullPath, ProcessDataStandardFormat processDataStandardFormat, JsonElement[] jsonElements)
+    private void CopyAndMoveFile(JsonElement[] jsonElements)
     {
         string day = $"{_Logistics.DateTimeFromSequence:yyyy-MM-dd}";
         string segment = _Logistics.FileInfo.Name.Split('-')[0].Split('_')[0];
@@ -127,15 +127,15 @@ public class FileRead : Shared.FileRead, IFileRead
             try
             {
                 Six six = JsonSerializer.Deserialize(jsonElements[0].GetRawText(), SixSourceGenerationContext.Default.Six) ?? throw new Exception($"{nameof(Six)} deserialization failed");
+                if (six.VP12Count < _IQSVP12Count)
                     File.Delete(_Logistics.FileInfo.FullName);
-                if (six.VP12Count > _IQSVP12Count)
+                else
                 {
                     string duplicateDirectory = Path.Combine(_FileConnectorConfiguration.SourceFileLocation, _CellInstanceName);
                     if (!Directory.Exists(duplicateDirectory))
                         _ = Directory.CreateDirectory(duplicateDirectory);
-                    string duplicateFile = Path.Combine(duplicateDirectory, $"{Path.GetFileName(reportFullPath)}.xml");
-                    string xml = ProcessDataStandardFormat.GetXml(processDataStandardFormat);
-                    File.WriteAllText(duplicateFile, xml);
+                    string duplicateFile = Path.Combine(duplicateDirectory, _Logistics.FileInfo.Name);
+                    File.Move(_Logistics.FileInfo.FullName, duplicateFile);
                 }
             }
             catch (Exception) { File.Delete(_Logistics.FileInfo.FullName); }
@@ -152,7 +152,7 @@ public class FileRead : Shared.FileRead, IFileRead
         List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
         Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
         if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
-            CopyAndWriteFile(reportFullPath, processDataStandardFormat, jsonElements);
+            CopyAndMoveFile(jsonElements);
         results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
         return results;
     }

Adaptation/FileHandlers/Log/FileRead.cs

@@ -1,133 +0,0 @@
-using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
-using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
-using Adaptation.Shared;
-using Adaptation.Shared.Duplicator;
-using Adaptation.Shared.Methods;
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.IO;
-using System.Linq;
-using System.Text.Json;
-
-namespace Adaptation.FileHandlers.Log;
-
-public class FileRead : Shared.FileRead, IFileRead
-{
-
-    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
-
-    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
-        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
-    {
-        _MinFileLength = 10;
-        _NullData = string.Empty;
-        _Logistics = new(this);
-        if (_FileParameter is null)
-            throw new Exception(cellInstanceConnectionName);
-        if (_ModelObjectParameterDefinitions is null)
-            throw new Exception(cellInstanceConnectionName);
-        if (!_IsDuplicator)
-            throw new Exception(cellInstanceConnectionName);
-        string[] segments;
-        Dictionary<string, string> systemStateToNames = new();
-        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
-        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
-        {
-            segments = modelObjectParameterDefinition.Value.Split('|');
-            if (segments.Length != 2)
-                continue;
-            systemStateToNames.Add(segments[0], segments[1]);
-        }
-        _SystemStateToNames = new(systemStateToNames);
-    }
-
-    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
-    {
-        bool isErrorFile = exception is not null;
-        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
-        {
-            FileInfo fileInfo = new(_Logistics.ReportFullPath);
-            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
-                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
-        }
-        Move(extractResults);
-    }
-
-    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
-
-    string IFileRead.GetEventDescription()
-    {
-        string result = _Description.GetEventDescription();
-        return result;
-    }
-
-    List<string> IFileRead.GetHeaderNames()
-    {
-        List<string> results = _Description.GetHeaderNames();
-        return results;
-    }
-
-    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
-    {
-        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
-        return results;
-    }
-
-    JsonProperty[] IFileRead.GetDefault()
-    {
-        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
-        return results;
-    }
-
-    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
-    {
-        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
-        return results;
-    }
-
-    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
-    {
-        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
-        return results;
-    }
-
-    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
-    {
-        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
-        if (string.IsNullOrEmpty(eventName))
-            throw new Exception();
-        _ReportFullPath = reportFullPath;
-        DateTime dateTime = DateTime.Now;
-        results = GetExtractResult(reportFullPath, dateTime);
-        if (results.Item3 is null)
-            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
-        if (results.Item3.Length > 0 && _IsEAFHosted)
-            WritePDSF(this, results.Item3);
-        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
-        return results;
-    }
-
-    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
-    {
-        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
-        List<string> headerNames = _Description.GetHeaderNames();
-        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
-        results = ReExtract(this, headerNames, keyValuePairs);
-        return results;
-    }
-
-    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
-    {
-        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
-        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
-        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
-        SetFileParameterLotIDToLogisticsMID();
-        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
-        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
-        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
-        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
-        return results;
-    }
-
-}

Adaptation/FileHandlers/R29/FileRead.cs

@@ -11,7 +11,7 @@ using System.IO;
 using System.Linq;
 using System.Text.Json;
 
-namespace Adaptation.FileHandlers.R5;
+namespace Adaptation.FileHandlers.R29;
 
 public class FileRead : Shared.FileRead, IFileRead
 {

Adaptation/FileHandlers/R30/FileRead.cs

@@ -11,7 +11,7 @@ using System.IO;
 using System.Linq;
 using System.Text.Json;
 
-namespace Adaptation.FileHandlers.R2;
+namespace Adaptation.FileHandlers.R30;
 
 public class FileRead : Shared.FileRead, IFileRead
 {

Adaptation/FileHandlers/R32/FileRead.cs

@@ -11,7 +11,7 @@ using System.IO;
 using System.Linq;
 using System.Text.Json;
 
-namespace Adaptation.FileHandlers.R3;
+namespace Adaptation.FileHandlers.R32;
 
 public class FileRead : Shared.FileRead, IFileRead
 {

Adaptation/FileHandlers/R36/FileRead.cs

@@ -11,7 +11,7 @@ using System.IO;
 using System.Linq;
 using System.Text.Json;
 
-namespace Adaptation.FileHandlers.R4;
+namespace Adaptation.FileHandlers.R36;
 
 public class FileRead : Shared.FileRead, IFileRead
 {

Adaptation/FileHandlers/R43/FileRead.cs

@@ -0,0 +1,238 @@
+using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using Adaptation.Shared;
+using Adaptation.Shared.Duplicator;
+using Adaptation.Shared.Methods;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+
+namespace Adaptation.FileHandlers.R43;
+
+public class FileRead : Shared.FileRead, IFileRead
+{
+
+    private readonly string _KeyColumn;
+    private readonly string _TimestampFormat;
+    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
+
+    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
+        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
+    {
+        _MinFileLength = 10;
+        _NullData = string.Empty;
+        _Logistics = new(this);
+        if (_FileParameter is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (_ModelObjectParameterDefinitions is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (!_IsDuplicator)
+            throw new Exception(cellInstanceConnectionName);
+        string[] segments;
+        Dictionary<string, string> systemStateToNames = new();
+        _KeyColumn = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.KeyColumn");
+        _TimestampFormat = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.TimestampFormat");
+        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
+        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
+        {
+            segments = modelObjectParameterDefinition.Value.Split('|');
+            if (segments.Length != 2)
+                continue;
+            systemStateToNames.Add(segments[0], segments[1]);
+        }
+        _SystemStateToNames = new(systemStateToNames);
+    }
+
+    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
+    {
+        bool isErrorFile = exception is not null;
+        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
+        {
+            FileInfo fileInfo = new(_Logistics.ReportFullPath);
+            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
+                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
+        }
+        Move(extractResults);
+    }
+
+    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
+
+    string IFileRead.GetEventDescription()
+    {
+        string result = _Description.GetEventDescription();
+        return result;
+    }
+
+    List<string> IFileRead.GetHeaderNames()
+    {
+        List<string> results = _Description.GetHeaderNames();
+        return results;
+    }
+
+    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
+    {
+        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
+        return results;
+    }
+
+    JsonProperty[] IFileRead.GetDefault()
+    {
+        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
+        return results;
+    }
+
+    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
+    {
+        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
+        return results;
+    }
+
+    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
+    {
+        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        if (string.IsNullOrEmpty(eventName))
+            throw new Exception();
+        _ReportFullPath = reportFullPath;
+        DateTime dateTime = DateTime.Now;
+        results = GetExtractResult(reportFullPath, dateTime);
+        if (results.Item3 is null)
+            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
+        if (results.Item3.Length > 0 && _IsEAFHosted)
+            WritePDSF(this, results.Item3);
+        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        List<string> headerNames = _Description.GetHeaderNames();
+        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
+        results = ReExtract(this, headerNames, keyValuePairs);
+        return results;
+    }
+
+    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
+    {
+#nullable enable
+        int? result = null;
+        for (int i = 0; i < columns.Length; i++)
+        {
+            if (columns[i] != keyColumn)
+                continue;
+            result = i;
+            break;
+        }
+        return result;
+    }
+
+    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
+    {
+        List<string> results = new();
+        string[] values;
+        string? systemState;
+        string keyColumnValue;
+        for (int i = 7; i < lines.Count; i++)
+        {
+            values = lines[i].Split('\t');
+            if (values.Length != columns.Length)
+                continue;
+            keyColumnValue = values[keyColumnIndex];
+            if (string.IsNullOrEmpty(keyColumnValue))
+                continue;
+            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
+                continue;
+            if (results.Contains(systemState))
+                continue;
+            results.Add(systemState);
+        }
+        return new(results);
+    }
+
+    private void CopyFile(string reportFullPath)
+    {
+        string equipment;
+        string timestamp;
+        string[] columns;
+        DateTime dateTime;
+        List<string> lines;
+        string systemState;
+        int? keyColumnIndex;
+        string checkFileName;
+        List<string> headerLines = new();
+        ReadOnlyCollection<string> systemStateValues;
+        string missingKeyDirectory = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, "Missing-Key");
+        if (!Directory.Exists(missingKeyDirectory))
+            _ = Directory.CreateDirectory(missingKeyDirectory);
+        string fileName = Path.GetFileName(reportFullPath);
+        string[] segments = fileName.Split('_');
+        for (int z = 0; z < 1; z++)
+        {
+            if (segments.Length != 2)
+                continue;
+            equipment = segments[0];
+            timestamp = segments[1].Split('.')[0];
+            if (timestamp.Length != _TimestampFormat.Length)
+                continue;
+            headerLines.Clear();
+            lines = File.ReadAllLines(reportFullPath).ToList();
+            if (lines.Count < 8)
+                continue;
+            for (int i = 0; i < 6; i++)
+            {
+                headerLines.Add(lines[0]);
+                lines.RemoveAt(0);
+            }
+            if (lines[0].Length < 1 || lines[0][0] != '"' || !lines[0].StartsWith("\"Time\""))
+                continue;
+            columns = lines[0].Split('\t');
+            if (columns.Length < 3)
+                continue;
+            keyColumnIndex = GetKeyColumnIndex(columns, _KeyColumn);
+            if (keyColumnIndex is null)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            systemStateValues = GetSystemStateValues(lines, columns, keyColumnIndex.Value);
+            if (systemStateValues.Count == 0)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            lines.AddRange(headerLines);
+            systemState = string.Join("-", systemStateValues);
+            checkFileName = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, $"{equipment}-{timestamp}-{systemState}.pdsf");
+            File.WriteAllLines(checkFileName, lines);
+            // File.Delete(reportFullPath);
+            if (DateTime.TryParseExact(timestamp, _TimestampFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
+                File.SetLastWriteTime(checkFileName, dateTime);
+        }
+    }
+
+    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
+        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
+        SetFileParameterLotIDToLogisticsMID();
+        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
+        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
+        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
+        if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
+            CopyFile(reportFullPath);
+        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
+        return results;
+    }
+
+}

Adaptation/FileHandlers/R55/FileRead.cs

@@ -0,0 +1,238 @@
+using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using Adaptation.Shared;
+using Adaptation.Shared.Duplicator;
+using Adaptation.Shared.Methods;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+
+namespace Adaptation.FileHandlers.R55;
+
+public class FileRead : Shared.FileRead, IFileRead
+{
+
+    private readonly string _KeyColumn;
+    private readonly string _TimestampFormat;
+    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
+
+    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
+        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
+    {
+        _MinFileLength = 10;
+        _NullData = string.Empty;
+        _Logistics = new(this);
+        if (_FileParameter is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (_ModelObjectParameterDefinitions is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (!_IsDuplicator)
+            throw new Exception(cellInstanceConnectionName);
+        string[] segments;
+        Dictionary<string, string> systemStateToNames = new();
+        _KeyColumn = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.KeyColumn");
+        _TimestampFormat = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.TimestampFormat");
+        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
+        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
+        {
+            segments = modelObjectParameterDefinition.Value.Split('|');
+            if (segments.Length != 2)
+                continue;
+            systemStateToNames.Add(segments[0], segments[1]);
+        }
+        _SystemStateToNames = new(systemStateToNames);
+    }
+
+    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
+    {
+        bool isErrorFile = exception is not null;
+        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
+        {
+            FileInfo fileInfo = new(_Logistics.ReportFullPath);
+            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
+                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
+        }
+        Move(extractResults);
+    }
+
+    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
+
+    string IFileRead.GetEventDescription()
+    {
+        string result = _Description.GetEventDescription();
+        return result;
+    }
+
+    List<string> IFileRead.GetHeaderNames()
+    {
+        List<string> results = _Description.GetHeaderNames();
+        return results;
+    }
+
+    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
+    {
+        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
+        return results;
+    }
+
+    JsonProperty[] IFileRead.GetDefault()
+    {
+        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
+        return results;
+    }
+
+    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
+    {
+        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
+        return results;
+    }
+
+    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
+    {
+        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        if (string.IsNullOrEmpty(eventName))
+            throw new Exception();
+        _ReportFullPath = reportFullPath;
+        DateTime dateTime = DateTime.Now;
+        results = GetExtractResult(reportFullPath, dateTime);
+        if (results.Item3 is null)
+            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
+        if (results.Item3.Length > 0 && _IsEAFHosted)
+            WritePDSF(this, results.Item3);
+        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        List<string> headerNames = _Description.GetHeaderNames();
+        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
+        results = ReExtract(this, headerNames, keyValuePairs);
+        return results;
+    }
+
+    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
+    {
+#nullable enable
+        int? result = null;
+        for (int i = 0; i < columns.Length; i++)
+        {
+            if (columns[i] != keyColumn)
+                continue;
+            result = i;
+            break;
+        }
+        return result;
+    }
+
+    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
+    {
+        List<string> results = new();
+        string[] values;
+        string? systemState;
+        string keyColumnValue;
+        for (int i = 7; i < lines.Count; i++)
+        {
+            values = lines[i].Split('\t');
+            if (values.Length != columns.Length)
+                continue;
+            keyColumnValue = values[keyColumnIndex];
+            if (string.IsNullOrEmpty(keyColumnValue))
+                continue;
+            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
+                continue;
+            if (results.Contains(systemState))
+                continue;
+            results.Add(systemState);
+        }
+        return new(results);
+    }
+
+    private void CopyFile(string reportFullPath)
+    {
+        string equipment;
+        string timestamp;
+        string[] columns;
+        DateTime dateTime;
+        List<string> lines;
+        string systemState;
+        int? keyColumnIndex;
+        string checkFileName;
+        List<string> headerLines = new();
+        ReadOnlyCollection<string> systemStateValues;
+        string missingKeyDirectory = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, "Missing-Key");
+        if (!Directory.Exists(missingKeyDirectory))
+            _ = Directory.CreateDirectory(missingKeyDirectory);
+        string fileName = Path.GetFileName(reportFullPath);
+        string[] segments = fileName.Split('_');
+        for (int z = 0; z < 1; z++)
+        {
+            if (segments.Length != 2)
+                continue;
+            equipment = segments[0];
+            timestamp = segments[1].Split('.')[0];
+            if (timestamp.Length != _TimestampFormat.Length)
+                continue;
+            headerLines.Clear();
+            lines = File.ReadAllLines(reportFullPath).ToList();
+            if (lines.Count < 8)
+                continue;
+            for (int i = 0; i < 6; i++)
+            {
+                headerLines.Add(lines[0]);
+                lines.RemoveAt(0);
+            }
+            if (lines[0].Length < 1 || lines[0][0] != '"' || !lines[0].StartsWith("\"Time\""))
+                continue;
+            columns = lines[0].Split('\t');
+            if (columns.Length < 3)
+                continue;
+            keyColumnIndex = GetKeyColumnIndex(columns, _KeyColumn);
+            if (keyColumnIndex is null)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            systemStateValues = GetSystemStateValues(lines, columns, keyColumnIndex.Value);
+            if (systemStateValues.Count == 0)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            lines.AddRange(headerLines);
+            systemState = string.Join("-", systemStateValues);
+            checkFileName = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, $"{equipment}-{timestamp}-{systemState}.pdsf");
+            File.WriteAllLines(checkFileName, lines);
+            // File.Delete(reportFullPath);
+            if (DateTime.TryParseExact(timestamp, _TimestampFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
+                File.SetLastWriteTime(checkFileName, dateTime);
+        }
+    }
+
+    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
+        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
+        SetFileParameterLotIDToLogisticsMID();
+        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
+        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
+        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
+        if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
+            CopyFile(reportFullPath);
+        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
+        return results;
+    }
+
+}

Adaptation/FileHandlers/R56/FileRead.cs

@@ -0,0 +1,238 @@
+using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using Adaptation.Shared;
+using Adaptation.Shared.Duplicator;
+using Adaptation.Shared.Methods;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+
+namespace Adaptation.FileHandlers.R56;
+
+public class FileRead : Shared.FileRead, IFileRead
+{
+
+    private readonly string _KeyColumn;
+    private readonly string _TimestampFormat;
+    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
+
+    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
+        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
+    {
+        _MinFileLength = 10;
+        _NullData = string.Empty;
+        _Logistics = new(this);
+        if (_FileParameter is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (_ModelObjectParameterDefinitions is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (!_IsDuplicator)
+            throw new Exception(cellInstanceConnectionName);
+        string[] segments;
+        Dictionary<string, string> systemStateToNames = new();
+        _KeyColumn = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.KeyColumn");
+        _TimestampFormat = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.TimestampFormat");
+        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
+        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
+        {
+            segments = modelObjectParameterDefinition.Value.Split('|');
+            if (segments.Length != 2)
+                continue;
+            systemStateToNames.Add(segments[0], segments[1]);
+        }
+        _SystemStateToNames = new(systemStateToNames);
+    }
+
+    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
+    {
+        bool isErrorFile = exception is not null;
+        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
+        {
+            FileInfo fileInfo = new(_Logistics.ReportFullPath);
+            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
+                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
+        }
+        Move(extractResults);
+    }
+
+    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
+
+    string IFileRead.GetEventDescription()
+    {
+        string result = _Description.GetEventDescription();
+        return result;
+    }
+
+    List<string> IFileRead.GetHeaderNames()
+    {
+        List<string> results = _Description.GetHeaderNames();
+        return results;
+    }
+
+    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
+    {
+        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
+        return results;
+    }
+
+    JsonProperty[] IFileRead.GetDefault()
+    {
+        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
+        return results;
+    }
+
+    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
+    {
+        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
+        return results;
+    }
+
+    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
+    {
+        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        if (string.IsNullOrEmpty(eventName))
+            throw new Exception();
+        _ReportFullPath = reportFullPath;
+        DateTime dateTime = DateTime.Now;
+        results = GetExtractResult(reportFullPath, dateTime);
+        if (results.Item3 is null)
+            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
+        if (results.Item3.Length > 0 && _IsEAFHosted)
+            WritePDSF(this, results.Item3);
+        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        List<string> headerNames = _Description.GetHeaderNames();
+        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
+        results = ReExtract(this, headerNames, keyValuePairs);
+        return results;
+    }
+
+    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
+    {
+#nullable enable
+        int? result = null;
+        for (int i = 0; i < columns.Length; i++)
+        {
+            if (columns[i] != keyColumn)
+                continue;
+            result = i;
+            break;
+        }
+        return result;
+    }
+
+    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
+    {
+        List<string> results = new();
+        string[] values;
+        string? systemState;
+        string keyColumnValue;
+        for (int i = 7; i < lines.Count; i++)
+        {
+            values = lines[i].Split('\t');
+            if (values.Length != columns.Length)
+                continue;
+            keyColumnValue = values[keyColumnIndex];
+            if (string.IsNullOrEmpty(keyColumnValue))
+                continue;
+            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
+                continue;
+            if (results.Contains(systemState))
+                continue;
+            results.Add(systemState);
+        }
+        return new(results);
+    }
+
+    private void CopyFile(string reportFullPath)
+    {
+        string equipment;
+        string timestamp;
+        string[] columns;
+        DateTime dateTime;
+        List<string> lines;
+        string systemState;
+        int? keyColumnIndex;
+        string checkFileName;
+        List<string> headerLines = new();
+        ReadOnlyCollection<string> systemStateValues;
+        string missingKeyDirectory = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, "Missing-Key");
+        if (!Directory.Exists(missingKeyDirectory))
+            _ = Directory.CreateDirectory(missingKeyDirectory);
+        string fileName = Path.GetFileName(reportFullPath);
+        string[] segments = fileName.Split('_');
+        for (int z = 0; z < 1; z++)
+        {
+            if (segments.Length != 2)
+                continue;
+            equipment = segments[0];
+            timestamp = segments[1].Split('.')[0];
+            if (timestamp.Length != _TimestampFormat.Length)
+                continue;
+            headerLines.Clear();
+            lines = File.ReadAllLines(reportFullPath).ToList();
+            if (lines.Count < 8)
+                continue;
+            for (int i = 0; i < 6; i++)
+            {
+                headerLines.Add(lines[0]);
+                lines.RemoveAt(0);
+            }
+            if (lines[0].Length < 1 || lines[0][0] != '"' || !lines[0].StartsWith("\"Time\""))
+                continue;
+            columns = lines[0].Split('\t');
+            if (columns.Length < 3)
+                continue;
+            keyColumnIndex = GetKeyColumnIndex(columns, _KeyColumn);
+            if (keyColumnIndex is null)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            systemStateValues = GetSystemStateValues(lines, columns, keyColumnIndex.Value);
+            if (systemStateValues.Count == 0)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            lines.AddRange(headerLines);
+            systemState = string.Join("-", systemStateValues);
+            checkFileName = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, $"{equipment}-{timestamp}-{systemState}.pdsf");
+            File.WriteAllLines(checkFileName, lines);
+            // File.Delete(reportFullPath);
+            if (DateTime.TryParseExact(timestamp, _TimestampFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
+                File.SetLastWriteTime(checkFileName, dateTime);
+        }
+    }
+
+    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
+        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
+        SetFileParameterLotIDToLogisticsMID();
+        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
+        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
+        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
+        if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
+            CopyFile(reportFullPath);
+        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
+        return results;
+    }
+
+}

Adaptation/FileHandlers/R57/FileRead.cs

@@ -0,0 +1,238 @@
+using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using Adaptation.Shared;
+using Adaptation.Shared.Duplicator;
+using Adaptation.Shared.Methods;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+
+namespace Adaptation.FileHandlers.R57;
+
+public class FileRead : Shared.FileRead, IFileRead
+{
+
+    private readonly string _KeyColumn;
+    private readonly string _TimestampFormat;
+    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
+
+    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
+        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
+    {
+        _MinFileLength = 10;
+        _NullData = string.Empty;
+        _Logistics = new(this);
+        if (_FileParameter is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (_ModelObjectParameterDefinitions is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (!_IsDuplicator)
+            throw new Exception(cellInstanceConnectionName);
+        string[] segments;
+        Dictionary<string, string> systemStateToNames = new();
+        _KeyColumn = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.KeyColumn");
+        _TimestampFormat = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.TimestampFormat");
+        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
+        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
+        {
+            segments = modelObjectParameterDefinition.Value.Split('|');
+            if (segments.Length != 2)
+                continue;
+            systemStateToNames.Add(segments[0], segments[1]);
+        }
+        _SystemStateToNames = new(systemStateToNames);
+    }
+
+    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
+    {
+        bool isErrorFile = exception is not null;
+        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
+        {
+            FileInfo fileInfo = new(_Logistics.ReportFullPath);
+            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
+                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
+        }
+        Move(extractResults);
+    }
+
+    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
+
+    string IFileRead.GetEventDescription()
+    {
+        string result = _Description.GetEventDescription();
+        return result;
+    }
+
+    List<string> IFileRead.GetHeaderNames()
+    {
+        List<string> results = _Description.GetHeaderNames();
+        return results;
+    }
+
+    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
+    {
+        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
+        return results;
+    }
+
+    JsonProperty[] IFileRead.GetDefault()
+    {
+        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
+        return results;
+    }
+
+    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
+    {
+        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
+        return results;
+    }
+
+    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
+    {
+        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        if (string.IsNullOrEmpty(eventName))
+            throw new Exception();
+        _ReportFullPath = reportFullPath;
+        DateTime dateTime = DateTime.Now;
+        results = GetExtractResult(reportFullPath, dateTime);
+        if (results.Item3 is null)
+            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
+        if (results.Item3.Length > 0 && _IsEAFHosted)
+            WritePDSF(this, results.Item3);
+        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        List<string> headerNames = _Description.GetHeaderNames();
+        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
+        results = ReExtract(this, headerNames, keyValuePairs);
+        return results;
+    }
+
+    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
+    {
+#nullable enable
+        int? result = null;
+        for (int i = 0; i < columns.Length; i++)
+        {
+            if (columns[i] != keyColumn)
+                continue;
+            result = i;
+            break;
+        }
+        return result;
+    }
+
+    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
+    {
+        List<string> results = new();
+        string[] values;
+        string? systemState;
+        string keyColumnValue;
+        for (int i = 7; i < lines.Count; i++)
+        {
+            values = lines[i].Split('\t');
+            if (values.Length != columns.Length)
+                continue;
+            keyColumnValue = values[keyColumnIndex];
+            if (string.IsNullOrEmpty(keyColumnValue))
+                continue;
+            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
+                continue;
+            if (results.Contains(systemState))
+                continue;
+            results.Add(systemState);
+        }
+        return new(results);
+    }
+
+    private void CopyFile(string reportFullPath)
+    {
+        string equipment;
+        string timestamp;
+        string[] columns;
+        DateTime dateTime;
+        List<string> lines;
+        string systemState;
+        int? keyColumnIndex;
+        string checkFileName;
+        List<string> headerLines = new();
+        ReadOnlyCollection<string> systemStateValues;
+        string missingKeyDirectory = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, "Missing-Key");
+        if (!Directory.Exists(missingKeyDirectory))
+            _ = Directory.CreateDirectory(missingKeyDirectory);
+        string fileName = Path.GetFileName(reportFullPath);
+        string[] segments = fileName.Split('_');
+        for (int z = 0; z < 1; z++)
+        {
+            if (segments.Length != 2)
+                continue;
+            equipment = segments[0];
+            timestamp = segments[1].Split('.')[0];
+            if (timestamp.Length != _TimestampFormat.Length)
+                continue;
+            headerLines.Clear();
+            lines = File.ReadAllLines(reportFullPath).ToList();
+            if (lines.Count < 8)
+                continue;
+            for (int i = 0; i < 6; i++)
+            {
+                headerLines.Add(lines[0]);
+                lines.RemoveAt(0);
+            }
+            if (lines[0].Length < 1 || lines[0][0] != '"' || !lines[0].StartsWith("\"Time\""))
+                continue;
+            columns = lines[0].Split('\t');
+            if (columns.Length < 3)
+                continue;
+            keyColumnIndex = GetKeyColumnIndex(columns, _KeyColumn);
+            if (keyColumnIndex is null)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            systemStateValues = GetSystemStateValues(lines, columns, keyColumnIndex.Value);
+            if (systemStateValues.Count == 0)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            lines.AddRange(headerLines);
+            systemState = string.Join("-", systemStateValues);
+            checkFileName = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, $"{equipment}-{timestamp}-{systemState}.pdsf");
+            File.WriteAllLines(checkFileName, lines);
+            // File.Delete(reportFullPath);
+            if (DateTime.TryParseExact(timestamp, _TimestampFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
+                File.SetLastWriteTime(checkFileName, dateTime);
+        }
+    }
+
+    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
+        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
+        SetFileParameterLotIDToLogisticsMID();
+        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
+        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
+        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
+        if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
+            CopyFile(reportFullPath);
+        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
+        return results;
+    }
+
+}

Adaptation/FileHandlers/R6/FileRead.cs

@@ -1,238 +0,0 @@
-using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
-using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
-using Adaptation.Shared;
-using Adaptation.Shared.Duplicator;
-using Adaptation.Shared.Methods;
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Text.Json;
-
-namespace Adaptation.FileHandlers.R6;
-
-public class FileRead : Shared.FileRead, IFileRead
-{
-
-    private readonly string _KeyColumn;
-    private readonly string _TimestampFormat;
-    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
-
-    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
-        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
-    {
-        _MinFileLength = 10;
-        _NullData = string.Empty;
-        _Logistics = new(this);
-        if (_FileParameter is null)
-            throw new Exception(cellInstanceConnectionName);
-        if (_ModelObjectParameterDefinitions is null)
-            throw new Exception(cellInstanceConnectionName);
-        if (!_IsDuplicator)
-            throw new Exception(cellInstanceConnectionName);
-        string[] segments;
-        Dictionary<string, string> systemStateToNames = new();
-        _KeyColumn = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.KeyColumn");
-        _TimestampFormat = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.TimestampFormat");
-        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
-        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
-        {
-            segments = modelObjectParameterDefinition.Value.Split('|');
-            if (segments.Length != 2)
-                continue;
-            systemStateToNames.Add(segments[0], segments[1]);
-        }
-        _SystemStateToNames = new(systemStateToNames);
-    }
-
-    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
-    {
-        bool isErrorFile = exception is not null;
-        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
-        {
-            FileInfo fileInfo = new(_Logistics.ReportFullPath);
-            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
-                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
-        }
-        Move(extractResults);
-    }
-
-    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
-
-    string IFileRead.GetEventDescription()
-    {
-        string result = _Description.GetEventDescription();
-        return result;
-    }
-
-    List<string> IFileRead.GetHeaderNames()
-    {
-        List<string> results = _Description.GetHeaderNames();
-        return results;
-    }
-
-    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
-    {
-        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
-        return results;
-    }
-
-    JsonProperty[] IFileRead.GetDefault()
-    {
-        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
-        return results;
-    }
-
-    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
-    {
-        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
-        return results;
-    }
-
-    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
-    {
-        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
-        return results;
-    }
-
-    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
-    {
-        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
-        if (string.IsNullOrEmpty(eventName))
-            throw new Exception();
-        _ReportFullPath = reportFullPath;
-        DateTime dateTime = DateTime.Now;
-        results = GetExtractResult(reportFullPath, dateTime);
-        if (results.Item3 is null)
-            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
-        if (results.Item3.Length > 0 && _IsEAFHosted)
-            WritePDSF(this, results.Item3);
-        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
-        return results;
-    }
-
-    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
-    {
-        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
-        List<string> headerNames = _Description.GetHeaderNames();
-        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
-        results = ReExtract(this, headerNames, keyValuePairs);
-        return results;
-    }
-
-    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
-    {
-#nullable enable
-        int? result = null;
-        for (int i = 0; i < columns.Length; i++)
-        {
-            if (columns[i] != keyColumn)
-                continue;
-            result = i;
-            break;
-        }
-        return result;
-    }
-
-    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
-    {
-        List<string> results = new();
-        string[] values;
-        string? systemState;
-        string keyColumnValue;
-        for (int i = 7; i < lines.Count; i++)
-        {
-            values = lines[i].Split('\t');
-            if (values.Length != columns.Length)
-                continue;
-            keyColumnValue = values[keyColumnIndex];
-            if (string.IsNullOrEmpty(keyColumnValue))
-                continue;
-            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
-                continue;
-            if (results.Contains(systemState))
-                continue;
-            results.Add(systemState);
-        }
-        return new(results);
-    }
-
-    private void CopyFile(string reportFullPath)
-    {
-        string equipment;
-        string timestamp;
-        string[] columns;
-        DateTime dateTime;
-        List<string> lines;
-        string systemState;
-        int? keyColumnIndex;
-        string checkFileName;
-        List<string> headerLines = new();
-        ReadOnlyCollection<string> systemStateValues;
-        string missingKeyDirectory = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, "Missing-Key");
-        if (!Directory.Exists(missingKeyDirectory))
-            _ = Directory.CreateDirectory(missingKeyDirectory);
-        string fileName = Path.GetFileName(reportFullPath);
-        string[] segments = fileName.Split('_');
-        for (int z = 0; z < 1; z++)
-        {
-            if (segments.Length != 2)
-                continue;
-            equipment = segments[0];
-            timestamp = segments[1].Split('.')[0];
-            if (timestamp.Length != _TimestampFormat.Length)
-                continue;
-            headerLines.Clear();
-            lines = File.ReadAllLines(reportFullPath).ToList();
-            if (lines.Count < 8)
-                continue;
-            for (int i = 0; i < 6; i++)
-            {
-                headerLines.Add(lines[0]);
-                lines.RemoveAt(0);
-            }
-            if (lines[0].Length < 1 || lines[0][0] != '"' || !lines[0].StartsWith("\"Time\""))
-                continue;
-            columns = lines[0].Split('\t');
-            if (columns.Length < 3)
-                continue;
-            keyColumnIndex = GetKeyColumnIndex(columns, _KeyColumn);
-            if (keyColumnIndex is null)
-            {
-                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
-                continue;
-            }
-            systemStateValues = GetSystemStateValues(lines, columns, keyColumnIndex.Value);
-            if (systemStateValues.Count == 0)
-            {
-                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
-                continue;
-            }
-            lines.AddRange(headerLines);
-            systemState = string.Join("-", systemStateValues);
-            checkFileName = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, $"{equipment}-{timestamp}-{systemState}.pdsf");
-            File.WriteAllLines(checkFileName, lines);
-            // File.Delete(reportFullPath);
-            if (DateTime.TryParseExact(timestamp, _TimestampFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
-                File.SetLastWriteTime(checkFileName, dateTime);
-        }
-    }
-
-    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
-    {
-        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
-        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
-        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
-        SetFileParameterLotIDToLogisticsMID();
-        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
-        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
-        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
-        if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
-            CopyFile(reportFullPath);
-        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
-        return results;
-    }
-
-}

Adaptation/FileHandlers/R61/FileRead.cs

@@ -0,0 +1,238 @@
+using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using Adaptation.Shared;
+using Adaptation.Shared.Duplicator;
+using Adaptation.Shared.Methods;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+
+namespace Adaptation.FileHandlers.R61;
+
+public class FileRead : Shared.FileRead, IFileRead
+{
+
+    private readonly string _KeyColumn;
+    private readonly string _TimestampFormat;
+    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
+
+    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
+        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
+    {
+        _MinFileLength = 10;
+        _NullData = string.Empty;
+        _Logistics = new(this);
+        if (_FileParameter is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (_ModelObjectParameterDefinitions is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (!_IsDuplicator)
+            throw new Exception(cellInstanceConnectionName);
+        string[] segments;
+        Dictionary<string, string> systemStateToNames = new();
+        _KeyColumn = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.KeyColumn");
+        _TimestampFormat = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.TimestampFormat");
+        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
+        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
+        {
+            segments = modelObjectParameterDefinition.Value.Split('|');
+            if (segments.Length != 2)
+                continue;
+            systemStateToNames.Add(segments[0], segments[1]);
+        }
+        _SystemStateToNames = new(systemStateToNames);
+    }
+
+    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
+    {
+        bool isErrorFile = exception is not null;
+        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
+        {
+            FileInfo fileInfo = new(_Logistics.ReportFullPath);
+            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
+                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
+        }
+        Move(extractResults);
+    }
+
+    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
+
+    string IFileRead.GetEventDescription()
+    {
+        string result = _Description.GetEventDescription();
+        return result;
+    }
+
+    List<string> IFileRead.GetHeaderNames()
+    {
+        List<string> results = _Description.GetHeaderNames();
+        return results;
+    }
+
+    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
+    {
+        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
+        return results;
+    }
+
+    JsonProperty[] IFileRead.GetDefault()
+    {
+        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
+        return results;
+    }
+
+    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
+    {
+        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
+        return results;
+    }
+
+    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
+    {
+        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        if (string.IsNullOrEmpty(eventName))
+            throw new Exception();
+        _ReportFullPath = reportFullPath;
+        DateTime dateTime = DateTime.Now;
+        results = GetExtractResult(reportFullPath, dateTime);
+        if (results.Item3 is null)
+            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
+        if (results.Item3.Length > 0 && _IsEAFHosted)
+            WritePDSF(this, results.Item3);
+        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        List<string> headerNames = _Description.GetHeaderNames();
+        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
+        results = ReExtract(this, headerNames, keyValuePairs);
+        return results;
+    }
+
+    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
+    {
+#nullable enable
+        int? result = null;
+        for (int i = 0; i < columns.Length; i++)
+        {
+            if (columns[i] != keyColumn)
+                continue;
+            result = i;
+            break;
+        }
+        return result;
+    }
+
+    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
+    {
+        List<string> results = new();
+        string[] values;
+        string? systemState;
+        string keyColumnValue;
+        for (int i = 7; i < lines.Count; i++)
+        {
+            values = lines[i].Split('\t');
+            if (values.Length != columns.Length)
+                continue;
+            keyColumnValue = values[keyColumnIndex];
+            if (string.IsNullOrEmpty(keyColumnValue))
+                continue;
+            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
+                continue;
+            if (results.Contains(systemState))
+                continue;
+            results.Add(systemState);
+        }
+        return new(results);
+    }
+
+    private void CopyFile(string reportFullPath)
+    {
+        string equipment;
+        string timestamp;
+        string[] columns;
+        DateTime dateTime;
+        List<string> lines;
+        string systemState;
+        int? keyColumnIndex;
+        string checkFileName;
+        List<string> headerLines = new();
+        ReadOnlyCollection<string> systemStateValues;
+        string missingKeyDirectory = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, "Missing-Key");
+        if (!Directory.Exists(missingKeyDirectory))
+            _ = Directory.CreateDirectory(missingKeyDirectory);
+        string fileName = Path.GetFileName(reportFullPath);
+        string[] segments = fileName.Split('_');
+        for (int z = 0; z < 1; z++)
+        {
+            if (segments.Length != 2)
+                continue;
+            equipment = segments[0];
+            timestamp = segments[1].Split('.')[0];
+            if (timestamp.Length != _TimestampFormat.Length)
+                continue;
+            headerLines.Clear();
+            lines = File.ReadAllLines(reportFullPath).ToList();
+            if (lines.Count < 8)
+                continue;
+            for (int i = 0; i < 6; i++)
+            {
+                headerLines.Add(lines[0]);
+                lines.RemoveAt(0);
+            }
+            if (lines[0].Length < 1 || lines[0][0] != '"' || !lines[0].StartsWith("\"Time\""))
+                continue;
+            columns = lines[0].Split('\t');
+            if (columns.Length < 3)
+                continue;
+            keyColumnIndex = GetKeyColumnIndex(columns, _KeyColumn);
+            if (keyColumnIndex is null)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            systemStateValues = GetSystemStateValues(lines, columns, keyColumnIndex.Value);
+            if (systemStateValues.Count == 0)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            lines.AddRange(headerLines);
+            systemState = string.Join("-", systemStateValues);
+            checkFileName = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, $"{equipment}-{timestamp}-{systemState}.pdsf");
+            File.WriteAllLines(checkFileName, lines);
+            // File.Delete(reportFullPath);
+            if (DateTime.TryParseExact(timestamp, _TimestampFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
+                File.SetLastWriteTime(checkFileName, dateTime);
+        }
+    }
+
+    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
+        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
+        SetFileParameterLotIDToLogisticsMID();
+        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
+        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
+        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
+        if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
+            CopyFile(reportFullPath);
+        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
+        return results;
+    }
+
+}

Adaptation/FileHandlers/R62/FileRead.cs

@@ -0,0 +1,238 @@
+using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using Adaptation.Shared;
+using Adaptation.Shared.Duplicator;
+using Adaptation.Shared.Methods;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+
+namespace Adaptation.FileHandlers.R62;
+
+public class FileRead : Shared.FileRead, IFileRead
+{
+
+    private readonly string _KeyColumn;
+    private readonly string _TimestampFormat;
+    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
+
+    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
+        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
+    {
+        _MinFileLength = 10;
+        _NullData = string.Empty;
+        _Logistics = new(this);
+        if (_FileParameter is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (_ModelObjectParameterDefinitions is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (!_IsDuplicator)
+            throw new Exception(cellInstanceConnectionName);
+        string[] segments;
+        Dictionary<string, string> systemStateToNames = new();
+        _KeyColumn = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.KeyColumn");
+        _TimestampFormat = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.TimestampFormat");
+        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
+        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
+        {
+            segments = modelObjectParameterDefinition.Value.Split('|');
+            if (segments.Length != 2)
+                continue;
+            systemStateToNames.Add(segments[0], segments[1]);
+        }
+        _SystemStateToNames = new(systemStateToNames);
+    }
+
+    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
+    {
+        bool isErrorFile = exception is not null;
+        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
+        {
+            FileInfo fileInfo = new(_Logistics.ReportFullPath);
+            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
+                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
+        }
+        Move(extractResults);
+    }
+
+    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
+
+    string IFileRead.GetEventDescription()
+    {
+        string result = _Description.GetEventDescription();
+        return result;
+    }
+
+    List<string> IFileRead.GetHeaderNames()
+    {
+        List<string> results = _Description.GetHeaderNames();
+        return results;
+    }
+
+    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
+    {
+        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
+        return results;
+    }
+
+    JsonProperty[] IFileRead.GetDefault()
+    {
+        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
+        return results;
+    }
+
+    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
+    {
+        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
+        return results;
+    }
+
+    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
+    {
+        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        if (string.IsNullOrEmpty(eventName))
+            throw new Exception();
+        _ReportFullPath = reportFullPath;
+        DateTime dateTime = DateTime.Now;
+        results = GetExtractResult(reportFullPath, dateTime);
+        if (results.Item3 is null)
+            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
+        if (results.Item3.Length > 0 && _IsEAFHosted)
+            WritePDSF(this, results.Item3);
+        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        List<string> headerNames = _Description.GetHeaderNames();
+        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
+        results = ReExtract(this, headerNames, keyValuePairs);
+        return results;
+    }
+
+    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
+    {
+#nullable enable
+        int? result = null;
+        for (int i = 0; i < columns.Length; i++)
+        {
+            if (columns[i] != keyColumn)
+                continue;
+            result = i;
+            break;
+        }
+        return result;
+    }
+
+    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
+    {
+        List<string> results = new();
+        string[] values;
+        string? systemState;
+        string keyColumnValue;
+        for (int i = 7; i < lines.Count; i++)
+        {
+            values = lines[i].Split('\t');
+            if (values.Length != columns.Length)
+                continue;
+            keyColumnValue = values[keyColumnIndex];
+            if (string.IsNullOrEmpty(keyColumnValue))
+                continue;
+            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
+                continue;
+            if (results.Contains(systemState))
+                continue;
+            results.Add(systemState);
+        }
+        return new(results);
+    }
+
+    private void CopyFile(string reportFullPath)
+    {
+        string equipment;
+        string timestamp;
+        string[] columns;
+        DateTime dateTime;
+        List<string> lines;
+        string systemState;
+        int? keyColumnIndex;
+        string checkFileName;
+        List<string> headerLines = new();
+        ReadOnlyCollection<string> systemStateValues;
+        string missingKeyDirectory = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, "Missing-Key");
+        if (!Directory.Exists(missingKeyDirectory))
+            _ = Directory.CreateDirectory(missingKeyDirectory);
+        string fileName = Path.GetFileName(reportFullPath);
+        string[] segments = fileName.Split('_');
+        for (int z = 0; z < 1; z++)
+        {
+            if (segments.Length != 2)
+                continue;
+            equipment = segments[0];
+            timestamp = segments[1].Split('.')[0];
+            if (timestamp.Length != _TimestampFormat.Length)
+                continue;
+            headerLines.Clear();
+            lines = File.ReadAllLines(reportFullPath).ToList();
+            if (lines.Count < 8)
+                continue;
+            for (int i = 0; i < 6; i++)
+            {
+                headerLines.Add(lines[0]);
+                lines.RemoveAt(0);
+            }
+            if (lines[0].Length < 1 || lines[0][0] != '"' || !lines[0].StartsWith("\"Time\""))
+                continue;
+            columns = lines[0].Split('\t');
+            if (columns.Length < 3)
+                continue;
+            keyColumnIndex = GetKeyColumnIndex(columns, _KeyColumn);
+            if (keyColumnIndex is null)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            systemStateValues = GetSystemStateValues(lines, columns, keyColumnIndex.Value);
+            if (systemStateValues.Count == 0)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            lines.AddRange(headerLines);
+            systemState = string.Join("-", systemStateValues);
+            checkFileName = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, $"{equipment}-{timestamp}-{systemState}.pdsf");
+            File.WriteAllLines(checkFileName, lines);
+            // File.Delete(reportFullPath);
+            if (DateTime.TryParseExact(timestamp, _TimestampFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
+                File.SetLastWriteTime(checkFileName, dateTime);
+        }
+    }
+
+    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
+        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
+        SetFileParameterLotIDToLogisticsMID();
+        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
+        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
+        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
+        if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
+            CopyFile(reportFullPath);
+        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
+        return results;
+    }
+
+}

Adaptation/FileHandlers/R65/FileRead.cs

@@ -0,0 +1,238 @@
+using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using Adaptation.Shared;
+using Adaptation.Shared.Duplicator;
+using Adaptation.Shared.Methods;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+
+namespace Adaptation.FileHandlers.R65;
+
+public class FileRead : Shared.FileRead, IFileRead
+{
+
+    private readonly string _KeyColumn;
+    private readonly string _TimestampFormat;
+    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
+
+    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
+        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
+    {
+        _MinFileLength = 10;
+        _NullData = string.Empty;
+        _Logistics = new(this);
+        if (_FileParameter is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (_ModelObjectParameterDefinitions is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (!_IsDuplicator)
+            throw new Exception(cellInstanceConnectionName);
+        string[] segments;
+        Dictionary<string, string> systemStateToNames = new();
+        _KeyColumn = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.KeyColumn");
+        _TimestampFormat = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.TimestampFormat");
+        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
+        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
+        {
+            segments = modelObjectParameterDefinition.Value.Split('|');
+            if (segments.Length != 2)
+                continue;
+            systemStateToNames.Add(segments[0], segments[1]);
+        }
+        _SystemStateToNames = new(systemStateToNames);
+    }
+
+    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
+    {
+        bool isErrorFile = exception is not null;
+        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
+        {
+            FileInfo fileInfo = new(_Logistics.ReportFullPath);
+            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
+                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
+        }
+        Move(extractResults);
+    }
+
+    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
+
+    string IFileRead.GetEventDescription()
+    {
+        string result = _Description.GetEventDescription();
+        return result;
+    }
+
+    List<string> IFileRead.GetHeaderNames()
+    {
+        List<string> results = _Description.GetHeaderNames();
+        return results;
+    }
+
+    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
+    {
+        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
+        return results;
+    }
+
+    JsonProperty[] IFileRead.GetDefault()
+    {
+        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
+        return results;
+    }
+
+    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
+    {
+        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
+        return results;
+    }
+
+    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
+    {
+        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        if (string.IsNullOrEmpty(eventName))
+            throw new Exception();
+        _ReportFullPath = reportFullPath;
+        DateTime dateTime = DateTime.Now;
+        results = GetExtractResult(reportFullPath, dateTime);
+        if (results.Item3 is null)
+            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
+        if (results.Item3.Length > 0 && _IsEAFHosted)
+            WritePDSF(this, results.Item3);
+        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        List<string> headerNames = _Description.GetHeaderNames();
+        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
+        results = ReExtract(this, headerNames, keyValuePairs);
+        return results;
+    }
+
+    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
+    {
+#nullable enable
+        int? result = null;
+        for (int i = 0; i < columns.Length; i++)
+        {
+            if (columns[i] != keyColumn)
+                continue;
+            result = i;
+            break;
+        }
+        return result;
+    }
+
+    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
+    {
+        List<string> results = new();
+        string[] values;
+        string? systemState;
+        string keyColumnValue;
+        for (int i = 7; i < lines.Count; i++)
+        {
+            values = lines[i].Split('\t');
+            if (values.Length != columns.Length)
+                continue;
+            keyColumnValue = values[keyColumnIndex];
+            if (string.IsNullOrEmpty(keyColumnValue))
+                continue;
+            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
+                continue;
+            if (results.Contains(systemState))
+                continue;
+            results.Add(systemState);
+        }
+        return new(results);
+    }
+
+    private void CopyFile(string reportFullPath)
+    {
+        string equipment;
+        string timestamp;
+        string[] columns;
+        DateTime dateTime;
+        List<string> lines;
+        string systemState;
+        int? keyColumnIndex;
+        string checkFileName;
+        List<string> headerLines = new();
+        ReadOnlyCollection<string> systemStateValues;
+        string missingKeyDirectory = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, "Missing-Key");
+        if (!Directory.Exists(missingKeyDirectory))
+            _ = Directory.CreateDirectory(missingKeyDirectory);
+        string fileName = Path.GetFileName(reportFullPath);
+        string[] segments = fileName.Split('_');
+        for (int z = 0; z < 1; z++)
+        {
+            if (segments.Length != 2)
+                continue;
+            equipment = segments[0];
+            timestamp = segments[1].Split('.')[0];
+            if (timestamp.Length != _TimestampFormat.Length)
+                continue;
+            headerLines.Clear();
+            lines = File.ReadAllLines(reportFullPath).ToList();
+            if (lines.Count < 8)
+                continue;
+            for (int i = 0; i < 6; i++)
+            {
+                headerLines.Add(lines[0]);
+                lines.RemoveAt(0);
+            }
+            if (lines[0].Length < 1 || lines[0][0] != '"' || !lines[0].StartsWith("\"Time\""))
+                continue;
+            columns = lines[0].Split('\t');
+            if (columns.Length < 3)
+                continue;
+            keyColumnIndex = GetKeyColumnIndex(columns, _KeyColumn);
+            if (keyColumnIndex is null)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            systemStateValues = GetSystemStateValues(lines, columns, keyColumnIndex.Value);
+            if (systemStateValues.Count == 0)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            lines.AddRange(headerLines);
+            systemState = string.Join("-", systemStateValues);
+            checkFileName = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, $"{equipment}-{timestamp}-{systemState}.pdsf");
+            File.WriteAllLines(checkFileName, lines);
+            // File.Delete(reportFullPath);
+            if (DateTime.TryParseExact(timestamp, _TimestampFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
+                File.SetLastWriteTime(checkFileName, dateTime);
+        }
+    }
+
+    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
+        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
+        SetFileParameterLotIDToLogisticsMID();
+        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
+        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
+        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
+        if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
+            CopyFile(reportFullPath);
+        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
+        return results;
+    }
+
+}

Adaptation/FileHandlers/R7/FileRead.cs

@@ -1,238 +0,0 @@
-using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
-using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
-using Adaptation.Shared;
-using Adaptation.Shared.Duplicator;
-using Adaptation.Shared.Methods;
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Text.Json;
-
-namespace Adaptation.FileHandlers.R7;
-
-public class FileRead : Shared.FileRead, IFileRead
-{
-
-    private readonly string _KeyColumn;
-    private readonly string _TimestampFormat;
-    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
-
-    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
-        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
-    {
-        _MinFileLength = 10;
-        _NullData = string.Empty;
-        _Logistics = new(this);
-        if (_FileParameter is null)
-            throw new Exception(cellInstanceConnectionName);
-        if (_ModelObjectParameterDefinitions is null)
-            throw new Exception(cellInstanceConnectionName);
-        if (!_IsDuplicator)
-            throw new Exception(cellInstanceConnectionName);
-        string[] segments;
-        Dictionary<string, string> systemStateToNames = new();
-        _KeyColumn = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.KeyColumn");
-        _TimestampFormat = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.TimestampFormat");
-        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
-        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
-        {
-            segments = modelObjectParameterDefinition.Value.Split('|');
-            if (segments.Length != 2)
-                continue;
-            systemStateToNames.Add(segments[0], segments[1]);
-        }
-        _SystemStateToNames = new(systemStateToNames);
-    }
-
-    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
-    {
-        bool isErrorFile = exception is not null;
-        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
-        {
-            FileInfo fileInfo = new(_Logistics.ReportFullPath);
-            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
-                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
-        }
-        Move(extractResults);
-    }
-
-    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
-
-    string IFileRead.GetEventDescription()
-    {
-        string result = _Description.GetEventDescription();
-        return result;
-    }
-
-    List<string> IFileRead.GetHeaderNames()
-    {
-        List<string> results = _Description.GetHeaderNames();
-        return results;
-    }
-
-    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
-    {
-        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
-        return results;
-    }
-
-    JsonProperty[] IFileRead.GetDefault()
-    {
-        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
-        return results;
-    }
-
-    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
-    {
-        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
-        return results;
-    }
-
-    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
-    {
-        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
-        return results;
-    }
-
-    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
-    {
-        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
-        if (string.IsNullOrEmpty(eventName))
-            throw new Exception();
-        _ReportFullPath = reportFullPath;
-        DateTime dateTime = DateTime.Now;
-        results = GetExtractResult(reportFullPath, dateTime);
-        if (results.Item3 is null)
-            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
-        if (results.Item3.Length > 0 && _IsEAFHosted)
-            WritePDSF(this, results.Item3);
-        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
-        return results;
-    }
-
-    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
-    {
-        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
-        List<string> headerNames = _Description.GetHeaderNames();
-        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
-        results = ReExtract(this, headerNames, keyValuePairs);
-        return results;
-    }
-
-    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
-    {
-#nullable enable
-        int? result = null;
-        for (int i = 0; i < columns.Length; i++)
-        {
-            if (columns[i] != keyColumn)
-                continue;
-            result = i;
-            break;
-        }
-        return result;
-    }
-
-    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
-    {
-        List<string> results = new();
-        string[] values;
-        string? systemState;
-        string keyColumnValue;
-        for (int i = 7; i < lines.Count; i++)
-        {
-            values = lines[i].Split('\t');
-            if (values.Length != columns.Length)
-                continue;
-            keyColumnValue = values[keyColumnIndex];
-            if (string.IsNullOrEmpty(keyColumnValue))
-                continue;
-            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
-                continue;
-            if (results.Contains(systemState))
-                continue;
-            results.Add(systemState);
-        }
-        return new(results);
-    }
-
-    private void CopyFile(string reportFullPath)
-    {
-        string equipment;
-        string timestamp;
-        string[] columns;
-        DateTime dateTime;
-        List<string> lines;
-        string systemState;
-        int? keyColumnIndex;
-        string checkFileName;
-        List<string> headerLines = new();
-        ReadOnlyCollection<string> systemStateValues;
-        string missingKeyDirectory = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, "Missing-Key");
-        if (!Directory.Exists(missingKeyDirectory))
-            _ = Directory.CreateDirectory(missingKeyDirectory);
-        string fileName = Path.GetFileName(reportFullPath);
-        string[] segments = fileName.Split('_');
-        for (int z = 0; z < 1; z++)
-        {
-            if (segments.Length != 2)
-                continue;
-            equipment = segments[0];
-            timestamp = segments[1].Split('.')[0];
-            if (timestamp.Length != _TimestampFormat.Length)
-                continue;
-            headerLines.Clear();
-            lines = File.ReadAllLines(reportFullPath).ToList();
-            if (lines.Count < 8)
-                continue;
-            for (int i = 0; i < 6; i++)
-            {
-                headerLines.Add(lines[0]);
-                lines.RemoveAt(0);
-            }
-            if (lines[0].Length < 1 || lines[0][0] != '"' || !lines[0].StartsWith("\"Time\""))
-                continue;
-            columns = lines[0].Split('\t');
-            if (columns.Length < 3)
-                continue;
-            keyColumnIndex = GetKeyColumnIndex(columns, _KeyColumn);
-            if (keyColumnIndex is null)
-            {
-                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
-                continue;
-            }
-            systemStateValues = GetSystemStateValues(lines, columns, keyColumnIndex.Value);
-            if (systemStateValues.Count == 0)
-            {
-                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
-                continue;
-            }
-            lines.AddRange(headerLines);
-            systemState = string.Join("-", systemStateValues);
-            checkFileName = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, $"{equipment}-{timestamp}-{systemState}.pdsf");
-            File.WriteAllLines(checkFileName, lines);
-            // File.Delete(reportFullPath);
-            if (DateTime.TryParseExact(timestamp, _TimestampFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
-                File.SetLastWriteTime(checkFileName, dateTime);
-        }
-    }
-
-    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
-    {
-        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
-        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
-        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
-        SetFileParameterLotIDToLogisticsMID();
-        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
-        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
-        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
-        if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
-            CopyFile(reportFullPath);
-        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
-        return results;
-    }
-
-}

Adaptation/FileHandlers/R75/FileRead.cs

@@ -0,0 +1,238 @@
+using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using Adaptation.Shared;
+using Adaptation.Shared.Duplicator;
+using Adaptation.Shared.Methods;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+
+namespace Adaptation.FileHandlers.R75;
+
+public class FileRead : Shared.FileRead, IFileRead
+{
+
+    private readonly string _KeyColumn;
+    private readonly string _TimestampFormat;
+    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
+
+    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
+        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
+    {
+        _MinFileLength = 10;
+        _NullData = string.Empty;
+        _Logistics = new(this);
+        if (_FileParameter is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (_ModelObjectParameterDefinitions is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (!_IsDuplicator)
+            throw new Exception(cellInstanceConnectionName);
+        string[] segments;
+        Dictionary<string, string> systemStateToNames = new();
+        _KeyColumn = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.KeyColumn");
+        _TimestampFormat = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.TimestampFormat");
+        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
+        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
+        {
+            segments = modelObjectParameterDefinition.Value.Split('|');
+            if (segments.Length != 2)
+                continue;
+            systemStateToNames.Add(segments[0], segments[1]);
+        }
+        _SystemStateToNames = new(systemStateToNames);
+    }
+
+    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
+    {
+        bool isErrorFile = exception is not null;
+        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
+        {
+            FileInfo fileInfo = new(_Logistics.ReportFullPath);
+            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
+                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
+        }
+        Move(extractResults);
+    }
+
+    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
+
+    string IFileRead.GetEventDescription()
+    {
+        string result = _Description.GetEventDescription();
+        return result;
+    }
+
+    List<string> IFileRead.GetHeaderNames()
+    {
+        List<string> results = _Description.GetHeaderNames();
+        return results;
+    }
+
+    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
+    {
+        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
+        return results;
+    }
+
+    JsonProperty[] IFileRead.GetDefault()
+    {
+        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
+        return results;
+    }
+
+    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
+    {
+        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
+        return results;
+    }
+
+    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
+    {
+        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        if (string.IsNullOrEmpty(eventName))
+            throw new Exception();
+        _ReportFullPath = reportFullPath;
+        DateTime dateTime = DateTime.Now;
+        results = GetExtractResult(reportFullPath, dateTime);
+        if (results.Item3 is null)
+            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
+        if (results.Item3.Length > 0 && _IsEAFHosted)
+            WritePDSF(this, results.Item3);
+        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        List<string> headerNames = _Description.GetHeaderNames();
+        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
+        results = ReExtract(this, headerNames, keyValuePairs);
+        return results;
+    }
+
+    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
+    {
+#nullable enable
+        int? result = null;
+        for (int i = 0; i < columns.Length; i++)
+        {
+            if (columns[i] != keyColumn)
+                continue;
+            result = i;
+            break;
+        }
+        return result;
+    }
+
+    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
+    {
+        List<string> results = new();
+        string[] values;
+        string? systemState;
+        string keyColumnValue;
+        for (int i = 7; i < lines.Count; i++)
+        {
+            values = lines[i].Split('\t');
+            if (values.Length != columns.Length)
+                continue;
+            keyColumnValue = values[keyColumnIndex];
+            if (string.IsNullOrEmpty(keyColumnValue))
+                continue;
+            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
+                continue;
+            if (results.Contains(systemState))
+                continue;
+            results.Add(systemState);
+        }
+        return new(results);
+    }
+
+    private void CopyFile(string reportFullPath)
+    {
+        string equipment;
+        string timestamp;
+        string[] columns;
+        DateTime dateTime;
+        List<string> lines;
+        string systemState;
+        int? keyColumnIndex;
+        string checkFileName;
+        List<string> headerLines = new();
+        ReadOnlyCollection<string> systemStateValues;
+        string missingKeyDirectory = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, "Missing-Key");
+        if (!Directory.Exists(missingKeyDirectory))
+            _ = Directory.CreateDirectory(missingKeyDirectory);
+        string fileName = Path.GetFileName(reportFullPath);
+        string[] segments = fileName.Split('_');
+        for (int z = 0; z < 1; z++)
+        {
+            if (segments.Length != 2)
+                continue;
+            equipment = segments[0];
+            timestamp = segments[1].Split('.')[0];
+            if (timestamp.Length != _TimestampFormat.Length)
+                continue;
+            headerLines.Clear();
+            lines = File.ReadAllLines(reportFullPath).ToList();
+            if (lines.Count < 8)
+                continue;
+            for (int i = 0; i < 6; i++)
+            {
+                headerLines.Add(lines[0]);
+                lines.RemoveAt(0);
+            }
+            if (lines[0].Length < 1 || lines[0][0] != '"' || !lines[0].StartsWith("\"Time\""))
+                continue;
+            columns = lines[0].Split('\t');
+            if (columns.Length < 3)
+                continue;
+            keyColumnIndex = GetKeyColumnIndex(columns, _KeyColumn);
+            if (keyColumnIndex is null)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            systemStateValues = GetSystemStateValues(lines, columns, keyColumnIndex.Value);
+            if (systemStateValues.Count == 0)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            lines.AddRange(headerLines);
+            systemState = string.Join("-", systemStateValues);
+            checkFileName = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, $"{equipment}-{timestamp}-{systemState}.pdsf");
+            File.WriteAllLines(checkFileName, lines);
+            // File.Delete(reportFullPath);
+            if (DateTime.TryParseExact(timestamp, _TimestampFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
+                File.SetLastWriteTime(checkFileName, dateTime);
+        }
+    }
+
+    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
+        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
+        SetFileParameterLotIDToLogisticsMID();
+        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
+        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
+        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
+        if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
+            CopyFile(reportFullPath);
+        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
+        return results;
+    }
+
+}

Adaptation/FileHandlers/R77/FileRead.cs

@@ -0,0 +1,238 @@
+using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using Adaptation.Shared;
+using Adaptation.Shared.Duplicator;
+using Adaptation.Shared.Methods;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+
+namespace Adaptation.FileHandlers.R77;
+
+public class FileRead : Shared.FileRead, IFileRead
+{
+
+    private readonly string _KeyColumn;
+    private readonly string _TimestampFormat;
+    private readonly ReadOnlyDictionary<string, string> _SystemStateToNames;
+
+    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, int? connectionCount, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, Dictionary<long, List<Shared.Metrology.WS.Results>> staticRuns, bool useCyclicalForDescription, bool isEAFHosted) :
+        base(new Description(), false, smtp, fileParameter, cellInstanceName, connectionCount, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, staticRuns, useCyclicalForDescription, isEAFHosted: connectionCount is null)
+    {
+        _MinFileLength = 10;
+        _NullData = string.Empty;
+        _Logistics = new(this);
+        if (_FileParameter is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (_ModelObjectParameterDefinitions is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (!_IsDuplicator)
+            throw new Exception(cellInstanceConnectionName);
+        string[] segments;
+        Dictionary<string, string> systemStateToNames = new();
+        _KeyColumn = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.KeyColumn");
+        _TimestampFormat = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.TimestampFormat");
+        ModelObjectParameterDefinition[] systemStates = GetProperties(cellInstanceConnectionName, modelObjectParameters, "ProcessDataStandardFormat.SystemState");
+        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in systemStates)
+        {
+            segments = modelObjectParameterDefinition.Value.Split('|');
+            if (segments.Length != 2)
+                continue;
+            systemStateToNames.Add(segments[0], segments[1]);
+        }
+        _SystemStateToNames = new(systemStateToNames);
+    }
+
+    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
+    {
+        bool isErrorFile = exception is not null;
+        if (!isErrorFile && !string.IsNullOrEmpty(_Logistics.ReportFullPath))
+        {
+            FileInfo fileInfo = new(_Logistics.ReportFullPath);
+            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
+                File.SetLastWriteTime(_Logistics.ReportFullPath, fileInfo.CreationTime);
+        }
+        Move(extractResults);
+    }
+
+    void IFileRead.WaitForThread() => WaitForThread(thread: null, threadExceptions: null);
+
+    string IFileRead.GetEventDescription()
+    {
+        string result = _Description.GetEventDescription();
+        return result;
+    }
+
+    List<string> IFileRead.GetHeaderNames()
+    {
+        List<string> results = _Description.GetHeaderNames();
+        return results;
+    }
+
+    string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
+    {
+        string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
+        return results;
+    }
+
+    JsonProperty[] IFileRead.GetDefault()
+    {
+        JsonProperty[] results = _Description.GetDefault(this, _Logistics);
+        return results;
+    }
+
+    Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
+    {
+        Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
+        return results;
+    }
+
+    List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
+    {
+        List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        if (string.IsNullOrEmpty(eventName))
+            throw new Exception();
+        _ReportFullPath = reportFullPath;
+        DateTime dateTime = DateTime.Now;
+        results = GetExtractResult(reportFullPath, dateTime);
+        if (results.Item3 is null)
+            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, Array.Empty<Test>(), JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
+        if (results.Item3.Length > 0 && _IsEAFHosted)
+            WritePDSF(this, results.Item3);
+        UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
+        return results;
+    }
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        List<string> headerNames = _Description.GetHeaderNames();
+        Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
+        results = ReExtract(this, headerNames, keyValuePairs);
+        return results;
+    }
+
+    private static int? GetKeyColumnIndex(string[] columns, string keyColumn)
+    {
+#nullable enable
+        int? result = null;
+        for (int i = 0; i < columns.Length; i++)
+        {
+            if (columns[i] != keyColumn)
+                continue;
+            result = i;
+            break;
+        }
+        return result;
+    }
+
+    private ReadOnlyCollection<string> GetSystemStateValues(List<string> lines, string[] columns, int keyColumnIndex)
+    {
+        List<string> results = new();
+        string[] values;
+        string? systemState;
+        string keyColumnValue;
+        for (int i = 7; i < lines.Count; i++)
+        {
+            values = lines[i].Split('\t');
+            if (values.Length != columns.Length)
+                continue;
+            keyColumnValue = values[keyColumnIndex];
+            if (string.IsNullOrEmpty(keyColumnValue))
+                continue;
+            if (!_SystemStateToNames.TryGetValue(keyColumnValue, out systemState))
+                continue;
+            if (results.Contains(systemState))
+                continue;
+            results.Add(systemState);
+        }
+        return new(results);
+    }
+
+    private void CopyFile(string reportFullPath)
+    {
+        string equipment;
+        string timestamp;
+        string[] columns;
+        DateTime dateTime;
+        List<string> lines;
+        string systemState;
+        int? keyColumnIndex;
+        string checkFileName;
+        List<string> headerLines = new();
+        ReadOnlyCollection<string> systemStateValues;
+        string missingKeyDirectory = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, "Missing-Key");
+        if (!Directory.Exists(missingKeyDirectory))
+            _ = Directory.CreateDirectory(missingKeyDirectory);
+        string fileName = Path.GetFileName(reportFullPath);
+        string[] segments = fileName.Split('_');
+        for (int z = 0; z < 1; z++)
+        {
+            if (segments.Length != 2)
+                continue;
+            equipment = segments[0];
+            timestamp = segments[1].Split('.')[0];
+            if (timestamp.Length != _TimestampFormat.Length)
+                continue;
+            headerLines.Clear();
+            lines = File.ReadAllLines(reportFullPath).ToList();
+            if (lines.Count < 8)
+                continue;
+            for (int i = 0; i < 6; i++)
+            {
+                headerLines.Add(lines[0]);
+                lines.RemoveAt(0);
+            }
+            if (lines[0].Length < 1 || lines[0][0] != '"' || !lines[0].StartsWith("\"Time\""))
+                continue;
+            columns = lines[0].Split('\t');
+            if (columns.Length < 3)
+                continue;
+            keyColumnIndex = GetKeyColumnIndex(columns, _KeyColumn);
+            if (keyColumnIndex is null)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            systemStateValues = GetSystemStateValues(lines, columns, keyColumnIndex.Value);
+            if (systemStateValues.Count == 0)
+            {
+                File.Copy(reportFullPath, Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, missingKeyDirectory, fileName));
+                continue;
+            }
+            lines.AddRange(headerLines);
+            systemState = string.Join("-", systemStateValues);
+            checkFileName = Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, $"{equipment}-{timestamp}-{systemState}.pdsf");
+            File.WriteAllLines(checkFileName, lines);
+            // File.Delete(reportFullPath);
+            if (DateTime.TryParseExact(timestamp, _TimestampFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
+                File.SetLastWriteTime(checkFileName, dateTime);
+        }
+    }
+
+    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime _)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        ProcessDataStandardFormat processDataStandardFormat = ProcessDataStandardFormat.GetProcessDataStandardFormat(reportFullPath);
+        _Logistics = new Logistics(reportFullPath, processDataStandardFormat);
+        SetFileParameterLotIDToLogisticsMID();
+        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(processDataStandardFormat);
+        List<Shared.Properties.IDescription> descriptions = GetDuplicatorDescriptions(jsonElements);
+        Test[] tests = (from l in descriptions select (Test)l.Test).ToArray();
+        if (_IsEAFHosted && _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
+            CopyFile(reportFullPath);
+        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(string.Join(Environment.NewLine, processDataStandardFormat.Logistics), tests, jsonElements, new List<FileInfo>());
+        return results;
+    }
+
+}

Adaptation/Shared/Duplicator/Description.cs

@@ -3,7 +3,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json;
-using System.Text.Json.Serialization;
 
 namespace Adaptation.Shared.Duplicator;
 
@@ -180,15 +179,3 @@ public class Description : IDescription, Properties.IDescription
     internal static string GetDateFormat() => "MM/dd/yyyy hh:mm:ss tt";
 
 }
-
-[JsonSourceGenerationOptions(WriteIndented = true, NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString)]
-[JsonSerializable(typeof(Description))]
-internal partial class SharedDescriptionSourceGenerationContext : JsonSerializerContext
-{
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true, NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString)]
-[JsonSerializable(typeof(Description[]))]
-internal partial class SharedDescriptionArraySourceGenerationContext : JsonSerializerContext
-{
-}

Adaptation/Shared/FileRead.cs

@@ -9,6 +9,7 @@ using System.IO;
 using System.Linq;
 using System.Text;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using System.Threading;
 
 namespace Adaptation.Shared;
@@ -382,12 +383,8 @@ public class FileRead : Properties.IFileRead
         else
         {
             string[] files;
-            string[] directories;
-            string logisticsSequence;
-            for (int i = 0; i < 10; i++)
-            {
-                logisticsSequence = (_Logistics.Sequence + -i).ToString();
-                directories = Directory.GetDirectories(jobIdDirectory, $"*{logisticsSequence}*", SearchOption.TopDirectoryOnly);
+            string logisticsSequence = _Logistics.Sequence.ToString();
+            string[] directories = Directory.GetDirectories(jobIdDirectory, $"*{logisticsSequence}*", SearchOption.TopDirectoryOnly);
             foreach (string directory in directories)
             {
                 files = Directory.GetFiles(directory, "*", SearchOption.TopDirectoryOnly);
@@ -395,11 +392,8 @@ public class FileRead : Properties.IFileRead
                     continue;
                 results.Add(directory);
             }
-                if (results.Count == 1)
-                    break;
         }
-        }
-        if (results.Count != 1)
+        if ((results is null) || results.Count != 1)
             throw new Exception("Didn't find directory by logistics sequence");
         return results.ToArray();
     }
@@ -446,13 +440,12 @@ public class FileRead : Properties.IFileRead
     {
         List<Properties.IDescription> results = new();
         Duplicator.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(jsonElement.ToString(), Duplicator.SharedDescriptionSourceGenerationContext.Default.Description);
-            if (description is null)
-                continue;
+            description = JsonSerializer.Deserialize<Duplicator.Description>(jsonElement.ToString(), jsonSerializerOptions);
             results.Add(description);
         }
         return results;

Adaptation/Shared/ProcessDataStandardFormat.cs

@@ -2,14 +2,12 @@ using Adaptation.Shared.Methods;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Diagnostics;
 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.Shared;
 
@@ -229,19 +227,19 @@ internal class ProcessDataStandardFormat
         return results.AsReadOnly();
     }
 
-    internal static ProcessDataStandardFormat GetProcessDataStandardFormat(string reportFullPath, ProcessDataStandardFormatMapping processDataStandardFormatMapping)
+    internal static ProcessDataStandardFormat GetProcessDataStandardFormat(string reportFullPath, ProcessDataStandardFormatMapping pdsfMapping)
     {
         ProcessDataStandardFormat result;
         const int columnsLine = 6;
         FileInfo fileInfo = new(reportFullPath);
         ProcessDataStandardFormat processDataStandardFormat = GetProcessDataStandardFormat(fileInfo.LastWriteTime, columnsLine, fileInfo.FullName, lines: null);
-        JsonElement[]? jsonElements = processDataStandardFormatMapping.OldColumnNames.Count != processDataStandardFormatMapping.ColumnIndices.Count ? null : GetFullArray(processDataStandardFormat);
+        JsonElement[]? jsonElements = pdsfMapping.OldColumnNames.Count != pdsfMapping.ColumnIndices.Count ? null : GetFullArray(processDataStandardFormat);
         JsonProperty[]? jsonProperties = jsonElements is null || jsonElements.Length == 0 ? null : jsonElements[0].EnumerateObject().ToArray();
-        if (jsonElements is null || jsonProperties is null || jsonProperties.Length != processDataStandardFormatMapping.NewColumnNames.Count)
+        if (jsonElements is null || jsonProperties is null || jsonProperties.Length != pdsfMapping.NewColumnNames.Count)
             result = processDataStandardFormat;
         else
         {
-            result = GetProcessDataStandardFormat(processDataStandardFormatMapping, jsonElements, processDataStandardFormat);
+            result = GetProcessDataStandardFormat(pdsfMapping, jsonElements, processDataStandardFormat);
             if (result.Sequence is null || result.Columns.Count == 0 || result.Body.Count == 0 || result.Logistics.Count == 0)
                 result = processDataStandardFormat;
         }
@@ -337,14 +335,12 @@ internal class ProcessDataStandardFormat
         int column;
         string value;
         JsonProperty jsonProperty;
-        List<string> debug = new();
         List<string> values = new();
         List<string> results = new();
         JsonProperty[] jsonProperties;
         List<string> unknownColumns = new();
         for (int i = 0; i < jsonElements.Length; i++)
         {
-            debug.Clear();
             values.Clear();
             if (jsonElements[i].ValueKind != JsonValueKind.Object)
             {
@@ -358,22 +354,16 @@ internal class ProcessDataStandardFormat
             {
                 column = processDataStandardFormatMapping.ColumnIndices[c];
                 if (column == -1)
-                {
                     value = processDataStandardFormatMapping.OldColumnNames[c];
-                    debug.Add($"<Item C=-01 Name=\"{value}\" DataType=\"8\" XmlType=\"1\" XPath=\"//records/record/{value}\" />");
-                }
                 else
                 {
                     jsonProperty = jsonProperties[column];
                     value = jsonProperty.Value.ToString();
-                    debug.Add($"<Item C={column + 2:000} Name=\"{processDataStandardFormatMapping.OldColumnNames[c]}\" DataType=\"8\" XmlType=\"1\" XPath=\"//records/record/{jsonProperty.Name}\" />");
                 }
                 values.Add(value);
             }
             results.Add(string.Join("\t", values));
         }
-        if (Debugger.IsAttached)
-            File.WriteAllText("../../.txt", string.Join(Environment.NewLine, debug.OrderBy(l => l)));
         result = new(body: new(results),
                      columns: processDataStandardFormatMapping.OldColumnNames,
                      footer: processDataStandardFormat.Footer,
@@ -388,6 +378,7 @@ internal class ProcessDataStandardFormat
     {
         if (processDataStandardFormat.InputPDSF is null)
             throw new NullReferenceException(nameof(processDataStandardFormat.InputPDSF));
+#pragma warning disable CA1845, IDE0057
         string result;
         string line;
         string value;
@@ -578,9 +569,6 @@ internal class ProcessDataStandardFormat
         results.Add(string.Empty);
         results.AddRange(processDataStandardFormat.InputPDSF.Footer.Select(l => $"|{l.Replace('\t', '|')}|"));
         results.Add(string.Empty);
-        string xml = GetXml(processDataStandardFormat);
-        results.Add(xml);
-        results.Add(string.Empty);
         results.Add("EOF");
         results.Add(string.Empty);
         string json = GetJson(processDataStandardFormat);
@@ -654,17 +642,6 @@ internal class ProcessDataStandardFormat
         return results;
     }
 
-    internal static JsonElement[] GetArray(string reportFullPath, string[] lines, ProcessDataStandardFormat processDataStandardFormat)
-    {
-        JsonElement[] results;
-        string? json = GetRecordsJson(reportFullPath, lines);
-        if (string.IsNullOrEmpty(json))
-            results = GetArray(processDataStandardFormat);
-        else
-            results = JsonSerializer.Deserialize(json, JsonElementCollectionSourceGenerationContext.Default.JsonElementArray) ?? throw new Exception();
-        return results;
-    }
-
     internal static string GetPDSFText(IFileRead fileRead, Logistics logistics, JsonElement[] jsonElements, string logisticsText)
     {
         string result;
@@ -877,116 +854,6 @@ internal class ProcessDataStandardFormat
         return result;
     }
 
-    internal static string GetXml(ProcessDataStandardFormat processDataStandardFormat)
-    {
-        string result;
-        string tag;
-        string value;
-        string[] segments;
-        List<string> values;
-        Dictionary<string, List<string>> results = new();
-        ReadOnlyCollection<string> body = processDataStandardFormat.InputPDSF is null ?
-            processDataStandardFormat.Body : processDataStandardFormat.InputPDSF.Body;
-        ReadOnlyCollection<string> columns = processDataStandardFormat.InputPDSF is null ?
-            processDataStandardFormat.Columns : processDataStandardFormat.InputPDSF.Columns;
-        List<string> lines = new() { "<?xml version=\"1.0\" encoding=\"UTF-8\"?>", "<records>" };
-        for (int i = 0; i < body.Count; i++)
-        {
-            segments = body[i].Trim().Split('\t');
-            if (segments.Length != columns.Count)
-                break;
-            for (int c = 0; c < segments.Length; c++)
-            {
-                value = segments[c].Replace("&", "&amp;")
-                                   .Replace("<", "&lt;")
-                                   .Replace(">", "&gt;")
-                                   .Replace("\"", "&quot;")
-                                   .Replace("'", "&apos;");
-                tag = Regex.Replace(columns[c].Trim('"'), @"[^a-zA-Z0-9]", "_").Split('\r')[0].Split('\n')[0];
-                if (i == 0)
-                {
-                    if (results.ContainsKey(tag))
-                        continue;
-                    results.Add(tag, new List<string>());
-                }
-                results[tag].Add(value);
-            }
-        }
-        foreach (KeyValuePair<string, List<string>> keyValuePair in results)
-        {
-            if (body.Count < 2)
-                break;
-            if (keyValuePair.Value.Count != body.Count)
-                continue;
-            values = keyValuePair.Value.Distinct().ToList();
-            if (values.Count == 2 && (string.IsNullOrEmpty(values[0]) || string.IsNullOrEmpty(values[1])))
-            {
-                for (int i = 0; i < body.Count; i++)
-                    keyValuePair.Value[i] = string.Empty;
-                foreach (string v in values)
-                {
-                    if (string.IsNullOrEmpty(v))
-                        continue;
-                    keyValuePair.Value[0] = v;
-                }
-            }
-        }
-        for (int i = 0; i < body.Count; i++)
-        {
-            lines.Add("  <record>");
-            foreach (KeyValuePair<string, List<string>> keyValuePair in results)
-            {
-                if (keyValuePair.Value.Count != body.Count)
-                    continue;
-                lines.Add(string.Concat("    <", keyValuePair.Key, '>', keyValuePair.Value[i], "</", keyValuePair.Key, '>'));
-            }
-            lines.Add("  </record>");
-        }
-        lines.Add("</records>");
-        result = string.Join(Environment.NewLine, lines);
-        return result;
-    }
-
-    internal static string GetXml(string reportFullPath, string[]? lines = null)
-    {
-        string result;
-        bool foundXml = false;
-        List<string> results = new();
-        lines ??= File.ReadAllLines(reportFullPath);
-        foreach (string line in lines)
-        {
-            if (line.StartsWith("<?xml"))
-                foundXml = true;
-            if (!foundXml)
-                continue;
-            if (line.StartsWith("EOF"))
-                break;
-            results.Add(line);
-        }
-        result = string.Join(Environment.NewLine, results);
-        return result;
-    }
-
-    private static string? GetRecordsJson(string reportFullPath, string[] lines)
-    {
-        string? result;
-        bool foundRecords = false;
-        List<string> results = new();
-        lines ??= File.ReadAllLines(reportFullPath);
-        foreach (string line in lines)
-        {
-            if (line.StartsWith("\"Records\""))
-                foundRecords = true;
-            if (!foundRecords)
-                continue;
-            if (line == "],")
-                break;
-            results.Add(line);
-        }
-        result = results.Count == 0 ? null : $"{string.Join(Environment.NewLine, results.Skip(1))}{Environment.NewLine}]";
-        return result;
-    }
-
 }
 
 [JsonSourceGenerationOptions(WriteIndented = true)]

Adaptation/Shared/ProcessDataStandardFormatMapping.cs

@@ -1,34 +1,33 @@
 using System.Collections.ObjectModel;
-using System.Linq;
 
 namespace Adaptation.Shared;
 
 public class ProcessDataStandardFormatMapping
 {
 
+    public ReadOnlyCollection<string> BackfillColumns { get; private set; }
     public ReadOnlyCollection<int> ColumnIndices { get; private set; }
+    public ReadOnlyCollection<string> IgnoreColumns { get; private set; }
+    public ReadOnlyCollection<string> IndexOnlyColumns { get; private set; }
+    public ReadOnlyDictionary<string, string> KeyValuePairs { get; private set; }
     public ReadOnlyCollection<string> NewColumnNames { get; private set; }
     public ReadOnlyCollection<string> OldColumnNames { get; private set; }
 
-    public ProcessDataStandardFormatMapping(ReadOnlyCollection<int> columnIndices,
+    public ProcessDataStandardFormatMapping(ReadOnlyCollection<string> backfillColumns,
+                                            ReadOnlyCollection<int> columnIndices,
+                                            ReadOnlyCollection<string> ignoreColumns,
+                                            ReadOnlyCollection<string> indexOnlyColumns,
+                                            ReadOnlyDictionary<string, string> keyValuePairs,
                                             ReadOnlyCollection<string> newColumnNames,
                                             ReadOnlyCollection<string> oldColumnNames)
     {
+        BackfillColumns = backfillColumns;
         ColumnIndices = columnIndices;
+        IgnoreColumns = ignoreColumns;
+        IndexOnlyColumns = indexOnlyColumns;
+        KeyValuePairs = keyValuePairs;
         NewColumnNames = newColumnNames;
         OldColumnNames = oldColumnNames;
     }
 
-    internal static ProcessDataStandardFormatMapping Get(string processDataStandardFormatMappingOldColumnNames, string processDataStandardFormatMappingNewColumnNames, string processDataStandardFormatMappingColumnIndices)
-    {
-        ProcessDataStandardFormatMapping result;
-        ReadOnlyCollection<string> newColumnNames = new(processDataStandardFormatMappingNewColumnNames.Split(','));
-        ReadOnlyCollection<string> oldColumnNames = new(processDataStandardFormatMappingOldColumnNames.Split(','));
-        ReadOnlyCollection<int> columnIndices = new(processDataStandardFormatMappingColumnIndices.Split(',').Select(int.Parse).ToArray());
-        result = new(columnIndices: columnIndices,
-                     newColumnNames: newColumnNames,
-                     oldColumnNames: oldColumnNames);
-        return result;
-    }
-
 }

DEP08CEPIEPSILON.csproj

@@ -108,13 +108,19 @@
     <Compile Include="Adaptation\FileHandlers\Dummy\FileRead.cs" />
     <Compile Include="Adaptation\FileHandlers\InfinityQS\FileRead.cs" />
     <Compile Include="Adaptation\FileHandlers\InfinityQS\Six.cs" />
-    <Compile Include="Adaptation\FileHandlers\Log\FileRead.cs" />
-    <Compile Include="Adaptation\FileHandlers\R2\FileRead.cs" />
-    <Compile Include="Adaptation\FileHandlers\R3\FileRead.cs" />
-    <Compile Include="Adaptation\FileHandlers\R4\FileRead.cs" />
-    <Compile Include="Adaptation\FileHandlers\R5\FileRead.cs" />
-    <Compile Include="Adaptation\FileHandlers\R6\FileRead.cs" />
-    <Compile Include="Adaptation\FileHandlers\R7\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R29\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R30\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R32\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R36\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R43\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R55\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R56\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R57\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R61\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R62\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R65\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R75\FileRead.cs" />
+    <Compile Include="Adaptation\FileHandlers\R77\FileRead.cs" />
     <Compile Include="Adaptation\Ifx\Eaf\Common\Configuration\ConnectionSetting.cs" />
     <Compile Include="Adaptation\Ifx\Eaf\EquipmentConnector\File\Component\File.cs" />
     <Compile Include="Adaptation\Ifx\Eaf\EquipmentConnector\File\Component\FilePathGenerator.cs" />