Ready to test

Adaptation/FileHandlers/MET08RESIHGCV/FileRead.cs

@@ -0,0 +1,507 @@
+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 Adaptation.Shared.Metrology;
+using Infineon.Monitoring.MonA;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading;
+
+namespace Adaptation.FileHandlers.MET08RESIHGCV;
+
+public class FileRead : Shared.FileRead, IFileRead
+{
+
+    private readonly Timer _Timer;
+    private int _LastDummyRunIndex;
+    private readonly bool _IsDummy;
+    private readonly bool _IsNaEDA;
+    private readonly bool _IsXToAPC;
+    private readonly string _IqsFile;
+    private readonly bool _IsXToIQSSi;
+    private readonly bool _IsXToSPaCe;
+    private readonly string _MemoryPath;
+    private readonly bool _IsXToOpenInsight;
+    private readonly string _LincPDFCFileName;
+    private readonly string _OpenInsightFilePattern;
+    private readonly bool _IsXToOpenInsightMetrologyViewer;
+    private readonly Dictionary<string, string> _CellNames;
+    private readonly string _OpenInsightMetrologyViewerAPI;
+    private readonly bool _IsXToOpenInsightMetrologyViewerAttachments;
+
+    public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, bool useCyclicalForDescription, bool isEAFHosted) :
+        base(new Description(), false, smtp, fileParameter, cellInstanceName, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, useCyclicalForDescription, isEAFHosted)
+    {
+        _MinFileLength = 10;
+        _NullData = string.Empty;
+        _Logistics = new Logistics(this);
+        if (_FileParameter is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (_ModelObjectParameterDefinitions is null)
+            throw new Exception(cellInstanceConnectionName);
+        if (!_IsDuplicator)
+            throw new Exception(cellInstanceConnectionName);
+        _LastDummyRunIndex = -1;
+        _IsDummy = _Hyphens == (int)Hyphen.IsDummy;
+        _IsNaEDA = _Hyphens == (int)Hyphen.IsNaEDA;
+        _IsXToAPC = _Hyphens == (int)Hyphen.IsXToAPC;
+        _CellNames = new Dictionary<string, string>();
+        _IsXToIQSSi = _Hyphens == (int)Hyphen.IsXToIQSSi;
+        _IsXToSPaCe = _Hyphens == (int)Hyphen.IsXToSPaCe;
+        _IsXToOpenInsight = _Hyphens == (int)Hyphen.IsXToOpenInsight;
+        _IsXToOpenInsightMetrologyViewer = _Hyphens == (int)Hyphen.IsXToOpenInsightMetrologyViewer;
+        _IqsFile = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "IQS.File");
+        _MemoryPath = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "Path.Memory");
+        _IsXToOpenInsightMetrologyViewerAttachments = _Hyphens == (int)Hyphen.IsXToOpenInsightMetrologyViewerAttachments;
+        _OpenInsightFilePattern = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "OpenInsight.FilePattern");
+        _OpenInsightMetrologyViewerAPI = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "OpenInsight.MetrologyViewerAPI");
+        ModelObjectParameterDefinition[] cellInstanceCollection = GetProperties(cellInstanceConnectionName, modelObjectParameters, "CellInstance.", ".Path");
+        foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in cellInstanceCollection)
+            _CellNames.Add(modelObjectParameterDefinition.Name.Split('.')[1], modelObjectParameterDefinition.Value);
+        _LincPDFCFileName = string.Concat(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), @"\LincPDFC.exe");
+        if (_IsEAFHosted && _IsXToOpenInsightMetrologyViewerAttachments && !File.Exists(_LincPDFCFileName))
+            throw new Exception("LincPDFC FileName doesn't Exist!");
+        if (_IsDummy)
+        {
+            if (Debugger.IsAttached || fileConnectorConfiguration.PreProcessingMode == FileConnectorConfiguration.PreProcessingModeEnum.Process)
+            {
+                _Timer = new Timer(Callback, null, Timeout.Infinite, Timeout.Infinite);
+                Callback(null);
+            }
+            else
+            {
+                int milliSeconds;
+                milliSeconds = (int)(fileConnectorConfiguration.FileScanningIntervalInSeconds * 1000 / 2);
+                _Timer = new Timer(Callback, null, milliSeconds, Timeout.Infinite);
+                milliSeconds += 2000;
+            }
+        }
+    }
+
+    void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception) => Move(extractResults, exception);
+
+    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;
+    }
+
+    void IFileRead.CheckTests(Test[] tests, bool extra)
+    {
+        if (_Description is not Description)
+            throw new Exception();
+    }
+
+    void IFileRead.Callback(object state) => Callback(state);
+
+    protected static List<pcl.Description> GetDescriptions(JsonElement[] jsonElements)
+    {
+        List<pcl.Description> results = new();
+        pcl.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<pcl.Description>(jsonElement.ToString(), jsonSerializerOptions);
+            results.Add(description);
+        }
+        return results;
+    }
+
+    private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime dateTime)
+    {
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
+        string duplicateDirectory;
+        Tuple<string, string[], string[]> pdsf = ProcessDataStandardFormat.GetLogisticsColumnsAndBody(reportFullPath);
+        _Logistics = new Logistics(reportFullPath, pdsf.Item1);
+        SetFileParameterLotIDToLogisticsMID();
+        JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(pdsf);
+        List<pcl.Description> descriptions = GetDescriptions(jsonElements);
+        Tuple<Test[], Dictionary<Test, List<Shared.Properties.IDescription>>> tuple = GetTuple(this, from l in descriptions select (Shared.Properties.IDescription)l, extra: false);
+        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(pdsf.Item1, tuple.Item1, jsonElements, new List<FileInfo>());
+        bool isNotUsedInsightMetrologyViewerAttachments = !(_FileConnectorConfiguration.FileScanningIntervalInSeconds > 0) && _IsXToOpenInsightMetrologyViewerAttachments;
+        bool isDummyRun = _DummyRuns.Any() && _DummyRuns.ContainsKey(_Logistics.JobID) && _DummyRuns[_Logistics.JobID].Any() && (from l in _DummyRuns[_Logistics.JobID] where l == _Logistics.Sequence select 1).Any();
+        if (isDummyRun)
+        {
+            try
+            { File.SetLastWriteTime(reportFullPath, dateTime); }
+            catch (Exception) { }
+        }
+        string[] segments = Path.GetFileNameWithoutExtension(reportFullPath).Split('_');
+        if (_IsXToIQSSi)
+            duplicateDirectory = string.Concat(_FileConnectorConfiguration.TargetFileLocation, @"\All");
+        else if (!_IsXToOpenInsight)
+            duplicateDirectory = string.Concat(_FileConnectorConfiguration.TargetFileLocation, @"\", segments[0]);
+        else
+            duplicateDirectory = string.Concat(Path.GetDirectoryName(Path.GetDirectoryName(_FileConnectorConfiguration.TargetFileLocation)), @"\Data");
+        if (segments.Length > 2)
+            duplicateDirectory = string.Concat(duplicateDirectory, @"-", segments[2]);
+        if (!Directory.Exists(duplicateDirectory))
+            _ = Directory.CreateDirectory(duplicateDirectory);
+        if (isDummyRun || isNotUsedInsightMetrologyViewerAttachments || _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0)
+        {
+            if (!Directory.Exists(duplicateDirectory))
+                _ = Directory.CreateDirectory(duplicateDirectory);
+            string successDirectory;
+            if (!_IsXToAPC)
+                successDirectory = string.Empty;
+            else
+            {
+                successDirectory = string.Concat(Path.GetDirectoryName(_FileConnectorConfiguration.TargetFileLocation), @"\ViewerPath");
+                if (!Directory.Exists(successDirectory))
+                    _ = Directory.CreateDirectory(successDirectory);
+            }
+            List<Tuple<Shared.Properties.IScopeInfo, string>> tuples = new();
+            string duplicateFile = string.Concat(duplicateDirectory, @"\", Path.GetFileName(reportFullPath));
+            string weekOfYear = _Calendar.GetWeekOfYear(_Logistics.DateTimeFromSequence, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
+            string weekDirectory = string.Concat(_Logistics.DateTimeFromSequence.ToString("yyyy"), "_Week_", weekOfYear, @"\", _Logistics.DateTimeFromSequence.ToString("yyyy-MM-dd"));
+            string logisticsSequenceMemoryDirectory = string.Concat(_MemoryPath, @"\", _EquipmentType, @"\Source\", weekDirectory, @"\", _Logistics.Sequence);
+            if (!Directory.Exists(logisticsSequenceMemoryDirectory))
+                _ = Directory.CreateDirectory(logisticsSequenceMemoryDirectory);
+            if (_IsXToAPC)
+            {
+                if (!isDummyRun && _IsEAFHosted)
+                    File.Copy(reportFullPath, duplicateFile, overwrite: true);
+            }
+            else
+            {
+                if (_IsXToOpenInsightMetrologyViewer)
+                {
+                    WSRequest wsRequest = new(this, _Logistics, descriptions);
+                    if (!isDummyRun && _IsEAFHosted)
+                    {
+                        Tuple<string, WS.Results> wsResults = WS.SendData(_OpenInsightMetrologyViewerAPI, wsRequest);
+                        if (!wsResults.Item2.Success)
+                            throw new Exception(wsResults.ToString());
+                        _Log.Debug(wsResults.Item2.HeaderID);
+                        File.WriteAllText(string.Concat(logisticsSequenceMemoryDirectory, @"\", nameof(WS.Results), ".json"), wsResults.Item1);
+                    }
+                }
+                else
+                {
+                    Test test;
+                    string lines;
+                    Shared.Properties.IScopeInfo scopeInfo;
+                    foreach (KeyValuePair<Test, List<Shared.Properties.IDescription>> keyValuePair in tuple.Item2)
+                    {
+                        test = keyValuePair.Key;
+                        //scopeInfo = new ScopeInfo(test);
+                        if (!_IsXToOpenInsight)
+                            scopeInfo = new ScopeInfo(test, _IqsFile);
+                        else
+                            scopeInfo = new ScopeInfo(test, _OpenInsightFilePattern);
+                        lines = ProcessData.GetLines(this, _Logistics, descriptions);
+                        tuples.Add(new Tuple<Shared.Properties.IScopeInfo, string>(scopeInfo, lines));
+                    }
+                }
+                if (_IsXToOpenInsightMetrologyViewerAttachments)
+                {
+                    string[] matchDirectories = Shared1567(reportFullPath, tuples);
+                    if (!isDummyRun && _IsEAFHosted && !isNotUsedInsightMetrologyViewerAttachments)
+                        ProcessData.PostOpenInsightMetrologyViewerAttachments(this, _Logistics, _OpenInsightMetrologyViewerAPI, _LincPDFCFileName, dateTime, logisticsSequenceMemoryDirectory, descriptions, matchDirectories[0]);
+                }
+            }
+            if (!_IsXToOpenInsightMetrologyViewer && !_IsXToOpenInsightMetrologyViewerAttachments)
+                Shared0413(dateTime, isDummyRun, successDirectory, duplicateDirectory, tuples, duplicateFile);
+        }
+        if (_IsXToOpenInsightMetrologyViewerAttachments)
+        {
+            string destinationDirectory;
+            //string destinationDirectory = WriteScopeInfo(_ProgressPath, _Logistics, dateTime, duplicateDirectory, tuples);
+            FileInfo fileInfo = new(reportFullPath);
+            string logisticsSequence = _Logistics.Sequence.ToString();
+            if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
+                File.SetLastWriteTime(reportFullPath, fileInfo.CreationTime);
+            string jobIdDirectory = string.Concat(Path.GetDirectoryName(Path.GetDirectoryName(_FileConnectorConfiguration.TargetFileLocation)), @"\", _Logistics.JobID);
+            if (!Directory.Exists(jobIdDirectory))
+                _ = Directory.CreateDirectory(jobIdDirectory);
+            string[] matchDirectories;
+            if (!_IsEAFHosted)
+                matchDirectories = new string[] { Path.GetDirectoryName(Path.GetDirectoryName(reportFullPath)) };
+            else
+                matchDirectories = Directory.GetDirectories(jobIdDirectory, string.Concat(_Logistics.MID, '*', logisticsSequence, '*'), SearchOption.TopDirectoryOnly);
+            if ((matchDirectories is null) || matchDirectories.Length != 1)
+                throw new Exception("Didn't find directory by logistics sequence");
+            destinationDirectory = matchDirectories[0];
+            if (isDummyRun)
+                Shared0607(reportFullPath, duplicateDirectory, logisticsSequence, destinationDirectory);
+            else
+            {
+                WSRequest wsRequest = new(this, _Logistics, descriptions);
+                JsonSerializerOptions jsonSerializerOptions = new() { WriteIndented = true };
+                string json = JsonSerializer.Serialize(wsRequest, wsRequest.GetType(), jsonSerializerOptions);
+                if (_IsEAFHosted)
+                    Shared1277(reportFullPath, destinationDirectory, logisticsSequence, jobIdDirectory, json);
+                else
+                {
+                    string jsonFileName = Path.ChangeExtension(reportFullPath, ".json");
+                    string historicalText = File.ReadAllText(jsonFileName);
+                    if (json != historicalText)
+                        throw new Exception("File doesn't match historical!");
+                }
+            }
+        }
+        return results;
+    }
+
+    private void CallbackIsDummy(string traceDummyFile, List<Tuple<string, string, string, string, int>> tuples, bool fileConnectorConfigurationIncludeSubDirectories, bool includeSubDirectoriesExtra)
+    {
+        int fileCount;
+        string[] files;
+        string monARessource;
+        string checkDirectory;
+        string sourceArchiveFile;
+        string inProcessDirectory;
+        const string site = "sjc";
+        string stateName = string.Concat("Dummy_", _EventName);
+        const string monInURL = "http://moninhttp.sjc.infineon.com/input/text";
+        MonIn monIn = MonIn.GetInstance(monInURL);
+        foreach (Tuple<string, string, string, string, int> item in tuples)
+        {
+            monARessource = item.Item1;
+            sourceArchiveFile = item.Item2;
+            inProcessDirectory = item.Item3;
+            checkDirectory = item.Item4;
+            fileCount = item.Item5;
+            try
+            {
+                if (fileCount > 0 || string.IsNullOrEmpty(checkDirectory))
+                {
+                    File.AppendAllLines(traceDummyFile, new string[] { site, monARessource, stateName, State.Warning.ToString() });
+                    _ = monIn.SendStatus(site, monARessource, stateName, State.Warning);
+                    for (int i = 1; i < 12; i++)
+                        Thread.Sleep(500);
+                }
+                else if (inProcessDirectory == checkDirectory)
+                    continue;
+                if (!_IsEAFHosted)
+                    continue;
+                if (!File.Exists(sourceArchiveFile))
+                    continue;
+                if (!long.TryParse(Path.GetFileNameWithoutExtension(sourceArchiveFile).Replace("x", string.Empty), out long sequence))
+                    continue;
+                ZipFile.ExtractToDirectory(sourceArchiveFile, inProcessDirectory);
+                if (fileConnectorConfigurationIncludeSubDirectories && includeSubDirectoriesExtra)
+                    checkDirectory = string.Concat(checkDirectory, @"\", sequence);
+                if (fileConnectorConfigurationIncludeSubDirectories)
+                    files = Directory.GetFiles(inProcessDirectory, "*", SearchOption.AllDirectories);
+                else
+                    files = Directory.GetFiles(inProcessDirectory, "*", SearchOption.TopDirectoryOnly);
+                if (files.Length > 250)
+                    throw new Exception("Safety net!");
+                foreach (string file in files)
+                    File.SetLastWriteTime(file, new DateTime(sequence));
+                if (!fileConnectorConfigurationIncludeSubDirectories)
+                {
+                    foreach (string file in files)
+                        File.Move(file, string.Concat(checkDirectory, @"\", Path.GetFileName(file)));
+                }
+                else
+                {
+                    string[] directories = Directory.GetDirectories(inProcessDirectory, "*", SearchOption.AllDirectories);
+                    foreach (string directory in directories)
+                        _ = Directory.CreateDirectory(string.Concat(checkDirectory, directory.Substring(inProcessDirectory.Length)));
+                    foreach (string file in files)
+                        File.Move(file, string.Concat(checkDirectory, file.Substring(inProcessDirectory.Length)));
+                }
+                File.AppendAllLines(traceDummyFile, new string[] { site, monARessource, stateName, State.Ok.ToString() });
+                _ = monIn.SendStatus(site, monARessource, stateName, State.Ok);
+            }
+            catch (Exception exception)
+            {
+                string subject = string.Concat("Exception:", _CellInstanceConnectionName);
+                string body = string.Concat(exception.Message, Environment.NewLine, Environment.NewLine, exception.StackTrace);
+                try
+                { _SMTP.SendHighPriorityEmailMessage(subject, body); }
+                catch (Exception) { }
+                File.AppendAllLines(traceDummyFile, new string[] { site, monARessource, stateName, State.Critical.ToString(), exception.Message, exception.StackTrace });
+                _ = monIn.SendStatus(site, monARessource, stateName, State.Critical);
+            }
+        }
+    }
+
+    private void Callback(object state)
+    {
+        if (!_IsDummy)
+            throw new Exception();
+        try
+        {
+            DateTime dateTime = DateTime.Now;
+            bool check = dateTime.Hour > 7 && dateTime.Hour < 18 && dateTime.DayOfWeek != DayOfWeek.Sunday && dateTime.DayOfWeek != DayOfWeek.Saturday;
+            if (check)
+            {
+                int fileCount;
+                string[] files;
+                string monARessource;
+                string checkDirectory;
+                string sourceArchiveFile;
+                string sourceFileLocation;
+                string inProcessDirectory;
+                string weekOfYear = _Calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
+                string traceDummyDirectory = string.Concat(Path.GetPathRoot(_TracePath), @"\TracesDummy\", _CellInstanceName, @"\Source\", dateTime.ToString("yyyy"), "___Week_", weekOfYear);
+                if (!Directory.Exists(traceDummyDirectory))
+                    _ = Directory.CreateDirectory(traceDummyDirectory);
+                string traceDummyFile = string.Concat(traceDummyDirectory, @"\", dateTime.Ticks, " - ", _CellInstanceName, ".txt");
+                File.AppendAllText(traceDummyFile, string.Empty);
+                List<Tuple<string, string, string, string, int>> tuples = new();
+                string progressDirectory = Path.GetFullPath(string.Concat(_FileConnectorConfiguration.SourceFileLocation, @"\_ Progress"));
+                if (progressDirectory != _ProgressPath || !Directory.Exists(progressDirectory))
+                    throw new Exception("Invalid progress path");
+                foreach (KeyValuePair<string, string> keyValuePair in _CellNames)
+                {
+                    monARessource = keyValuePair.Key;
+                    if (!keyValuePair.Value.Contains('\\'))
+                        continue;
+                    foreach (string sourceFileFilter in _FileConnectorConfiguration.SourceFileFilter.Split('|'))
+                    {
+                        if (sourceFileFilter.ToLower().StartsWith(keyValuePair.Value.Replace(@"\", string.Empty)))
+                            sourceFileLocation = Path.GetFullPath(_FileConnectorConfiguration.SourceFileLocation);
+                        else if (_FileConnectorConfiguration.SourceFileLocation.ToLower().EndsWith(keyValuePair.Value))
+                            sourceFileLocation = Path.GetFullPath(_FileConnectorConfiguration.SourceFileLocation);
+                        else
+                            sourceFileLocation = Path.GetFullPath(string.Concat(_FileConnectorConfiguration.SourceFileLocation, @"\", keyValuePair.Value));
+                        sourceArchiveFile = Path.GetFullPath(string.Concat(sourceFileLocation, @"\", sourceFileFilter));
+                        if (!File.Exists(sourceArchiveFile))
+                            continue;
+                        if (!_DummyRuns.ContainsKey(monARessource))
+                            _DummyRuns.Add(monARessource, new List<long>());
+                        tuples.Add(new Tuple<string, string, string, string, int>(monARessource, sourceFileFilter, sourceFileLocation, sourceArchiveFile, 0));
+                    }
+                }
+                File.AppendAllLines(traceDummyFile, from l in tuples select l.Item4);
+                if (tuples.Any())
+                {
+                    _LastDummyRunIndex += 1;
+                    if (_LastDummyRunIndex >= tuples.Count)
+                        _LastDummyRunIndex = 0;
+                    monARessource = tuples[_LastDummyRunIndex].Item1;
+                    string sourceFileFilter = tuples[_LastDummyRunIndex].Item2;
+                    sourceFileLocation = tuples[_LastDummyRunIndex].Item3;
+                    sourceArchiveFile = tuples[_LastDummyRunIndex].Item4;
+                    //fileCount = tuples[_LastDummyRunIndex].Item5;
+                    tuples.Clear();
+                    if (long.TryParse(Path.GetFileNameWithoutExtension(sourceArchiveFile).Replace("x", string.Empty), out long sequence))
+                    {
+                        if (!_DummyRuns[monARessource].Contains(sequence))
+                            _DummyRuns[monARessource].Add(sequence);
+                        inProcessDirectory = string.Concat(progressDirectory, @"\Dummy_in process\", sequence);
+                        checkDirectory = inProcessDirectory;
+                        if (!Directory.Exists(checkDirectory))
+                            _ = Directory.CreateDirectory(checkDirectory);
+                        files = Directory.GetFiles(checkDirectory, "*", SearchOption.AllDirectories);
+                        fileCount = files.Length;
+                        if (files.Any())
+                        {
+                            if (files.Length > 250)
+                                throw new Exception("Safety net!");
+                            try
+                            {
+                                foreach (string file in files)
+                                    File.Delete(file);
+                            }
+                            catch (Exception) { }
+                        }
+                        tuples.Add(new Tuple<string, string, string, string, int>(monARessource, sourceArchiveFile, inProcessDirectory, checkDirectory, fileCount));
+                        checkDirectory = sourceFileLocation;
+                        files = Directory.GetFiles(checkDirectory, string.Concat("*", sequence, "*"), SearchOption.TopDirectoryOnly);
+                        fileCount = files.Length;
+                        tuples.Add(new Tuple<string, string, string, string, int>(monARessource, sourceArchiveFile, inProcessDirectory, checkDirectory, fileCount));
+                    }
+                }
+                if (tuples.Any())
+                    //CallbackIsDummy(traceDummyFile, tuples, FileConnectorConfiguration.IncludeSubDirectories.Value, includeSubDirectoriesExtra: false);
+                    CallbackIsDummy(traceDummyFile, tuples, fileConnectorConfigurationIncludeSubDirectories: true, includeSubDirectoriesExtra: true);
+            }
+        }
+        catch (Exception exception)
+        {
+            string subject = string.Concat("Exception:", _CellInstanceConnectionName);
+            string body = string.Concat(exception.Message, Environment.NewLine, Environment.NewLine, exception.StackTrace);
+            try
+            { _SMTP.SendHighPriorityEmailMessage(subject, body); }
+            catch (Exception) { }
+        }
+        try
+        {
+            TimeSpan timeSpan = new(DateTime.Now.AddSeconds(_FileConnectorConfiguration.FileScanningIntervalInSeconds.Value).Ticks - DateTime.Now.Ticks);
+            _ = _Timer.Change((long)timeSpan.TotalMilliseconds, Timeout.Infinite);
+        }
+        catch (Exception exception)
+        {
+            string subject = string.Concat("Exception:", _CellInstanceConnectionName);
+            string body = string.Concat(exception.Message, Environment.NewLine, Environment.NewLine, exception.StackTrace);
+            try
+            { _SMTP.SendHighPriorityEmailMessage(subject, body); }
+            catch (Exception) { }
+        }
+    }
+
+}

Adaptation/FileHandlers/MET08RESIHGCV/Hyphen.cs

@@ -0,0 +1,15 @@
+namespace Adaptation.FileHandlers.MET08RESIHGCV;
+
+public enum Hyphen
+{
+    IsXToOpenInsightMetrologyViewer, //MetrologyWS.SendData(file, string.Concat("http://", serverName, "/api/inbound/MercuryProbe"), headerAttachments);
+    IsXToIQSSi, //NA <d7p1:FileScanningIntervalInSeconds>-361</d7p1:FileScanningIntervalInSeconds>
+    IsXToOpenInsight, //NA <d7p1:FileScanningIntervalInSeconds>-363</d7p1:FileScanningIntervalInSeconds>
+    IsXToOpenInsightMetrologyViewerAttachments, //Site-One
+    IsXToAPC,
+    IsXToSPaCe,
+    IsXToArchive,
+    IsArchive,
+    IsDummy,
+    IsNaEDA
+}

Adaptation/FileHandlers/MET08RESIHGCV/ProcessData.cs

@@ -0,0 +1,103 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using Adaptation.Shared.Properties;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+
+namespace Adaptation.FileHandlers.MET08RESIHGCV;
+
+public class ProcessData
+{
+
+    internal static List<Tuple<int, Enum, string>> HyphenTuples => new()
+    {
+        new Tuple<int, Enum, string>(0, Hyphen.IsNaEDA, @"\EC_EDA\Staging\Traces\~\Source"),
+        new Tuple<int, Enum, string>(15, Hyphen.IsXToOpenInsightMetrologyViewer, @"\EC_EAFLog\TracesMES\~\Source"),
+        new Tuple<int, Enum, string>(-36, Hyphen.IsXToIQSSi, @"\EC_SPC_Si\Traces\~\PollPath"),
+        new Tuple<int, Enum, string>(-36, Hyphen.IsXToOpenInsight, @"\\messa01ec.ec.local\APPS\Metrology\~\Source"),
+        new Tuple<int, Enum, string>(36, Hyphen.IsXToOpenInsightMetrologyViewerAttachments, @"\EC_Characterization_Si\In Process\~\Source"),
+        new Tuple<int, Enum, string>(360, Hyphen.IsXToAPC, @"\EC_APC\Staging\Traces\~\PollPath"),
+        new Tuple<int, Enum, string>(-36, Hyphen.IsXToSPaCe, @"\EC_SPC_Si\Traces\~\Source"),
+        new Tuple<int, Enum, string>(180, Hyphen.IsXToArchive, @"\EC_EAFLog\TracesArchive\~\Source"),
+        new Tuple<int, Enum, string>(36, Hyphen.IsArchive, @"\EC_Characterization_Si\Processed")
+        //new Tuple<int, Enum, string>("IsDummy"
+    };
+
+    internal static string GetLines(IFileRead fileRead, Logistics logistics, List<pcl.Description> descriptions)
+    {
+        StringBuilder result = new();
+        if (fileRead is null)
+        { }
+        if (logistics is null)
+        { }
+        if (descriptions is null)
+        { }
+        return result.ToString();
+    }
+
+    /// <summary>
+    /// Convert the raw data file to parsable file format - in this case from PCL to PDF
+    /// </summary>
+    /// <param name="sourceFile">source file to be converted to PDF</param>
+    /// <returns></returns>
+    private static string ConvertSourceFileToPdfWithChartData(string lincPDFCFileName, string sourceFile)
+    {
+        string result = Path.ChangeExtension(sourceFile, ".pdf");
+        if (!File.Exists(result))
+        {
+            string arguments = string.Concat("-i \"", sourceFile, "\" -o \"", result, "\"");
+            //string arguments = string.Concat("-dSAFER -dBATCH -dNOPAUSE -dFIXEDMEDIA -dFitPage -dAutoRotatePages=/All -dDEVICEWIDTHPOINTS=792 -dDEVICEHEIGHTPOINTS=612 -sOutputFile=\"", result, "\" -sDEVICE=pdfwrite \"", sourceFile, "\"");
+            Process process = Process.Start(lincPDFCFileName, arguments);
+            //Process process = Process.Start(ghostPCLFileName, arguments);
+            _ = process.WaitForExit(30000);
+            if (!File.Exists(result))
+                throw new Exception("PDF file wasn't created");
+        }
+        return result;
+    }
+
+    internal static void PostOpenInsightMetrologyViewerAttachments(IFileRead fileRead, Logistics logistics, string openInsightMetrologyViewerAPI, string lincPDFCFileName, DateTime dateTime, string logisticsSequenceMemoryDirectory, List<pcl.Description> descriptions, string matchDirectory)
+    {
+        if (fileRead is null)
+        { }
+        if (dateTime == DateTime.MinValue)
+        { }
+        if (logisticsSequenceMemoryDirectory is null)
+        { }
+        if (descriptions is null)
+        { }
+        if (matchDirectory is null)
+        { }
+        string[] pclFiles = Directory.GetFiles(matchDirectory, "*.pcl", SearchOption.TopDirectoryOnly);
+        if (pclFiles.Length != 1)
+            throw new Exception("Invalid source file count!");
+        string wsResultsMemoryFile = string.Concat(logisticsSequenceMemoryDirectory, @"\", nameof(WS.Results), ".json");
+        if (!File.Exists(wsResultsMemoryFile))
+            throw new Exception(string.Concat("Memory file <", wsResultsMemoryFile, "> doesn't exist!"));
+        string json = File.ReadAllText(wsResultsMemoryFile);
+        WS.Results metrologyWSRequest = JsonSerializer.Deserialize<WS.Results>(json);
+        long wsResultsHeaderID = metrologyWSRequest.HeaderID;
+        List<string> pdfFiles = new();
+        pdfFiles.AddRange(Directory.GetFiles(matchDirectory, "*.pdf_old", SearchOption.TopDirectoryOnly));
+        foreach (string pdfFile in pdfFiles)
+            File.Delete(pdfFile);
+        pdfFiles.Clear();
+        pdfFiles.AddRange(Directory.GetFiles(matchDirectory, "*.pdf", SearchOption.TopDirectoryOnly));
+        foreach (string pdfFile in pdfFiles)
+            File.Move(pdfFile, Path.ChangeExtension(pdfFile, ".pdf_old"));
+        pdfFiles.Clear();
+        foreach (string pclFile in pclFiles.OrderBy(l => l))
+            pdfFiles.Add(ConvertSourceFileToPdfWithChartData(lincPDFCFileName, pclFile));
+        if (pdfFiles.Count == 0)
+            throw new Exception("Invalid *.pdf file count!");
+        List<WS.Attachment> headerAttachments = new()
+        { new WS.Attachment(descriptions[0].HeaderUniqueId, "Data.pdf", pdfFiles[0]) };
+        WS.AttachFiles(openInsightMetrologyViewerAPI, wsResultsHeaderID, headerAttachments, dataAttachments: null);
+    }
+
+}

Adaptation/FileHandlers/MET08RESIHGCV/WSRequest.cs

@@ -0,0 +1,158 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Properties;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Adaptation.FileHandlers.MET08RESIHGCV;
+
+public class WSRequest
+{
+    public bool SentToMetrology { get; set; }
+    public bool SentToSPC { get; set; }
+    //
+
+    public string Area { get; set; }
+    public string Ccomp { get; set; }
+    public string CellName { get; set; }
+    public string CondType { get; set; }
+    public string Date { get; set; }
+    public string FlatZMean { get; set; }
+    public string FlatZRadialGradient { get; set; }
+    public string FlatZStdDev { get; set; }
+    public string Folder { get; set; }
+    public string GLimit { get; set; }
+    public string GradeMean { get; set; }
+    public string GradeRadialGradient { get; set; }
+    public string GradeStdDev { get; set; }
+    public string Id { get; set; }
+    public string Layer { get; set; }
+    public string Lot { get; set; }
+    public string Model { get; set; }
+    public string NAvgMean { get; set; }
+    public string NAvgRadialGradient { get; set; }
+    public string NAvgStdDev { get; set; }
+    public string NslMean { get; set; }
+    public string NslRadialGradient { get; set; }
+    public string NslStdDev { get; set; }
+    public string Operator { get; set; }
+    public string PSN { get; set; }
+    public string Pattern { get; set; }
+    public string PhaseMean { get; set; }
+    public string PhaseRadialGradient { get; set; }
+    public string PhaseStdDev { get; set; }
+    public string Plan { get; set; }
+    public string RDS { get; set; }
+    public string RampRate { get; set; }
+    public string Reactor { get; set; }
+    public string RhoAvgMean { get; set; }
+    public string RhoAvgRadialGradient { get; set; }
+    public string RhoAvgStdDev { get; set; }
+    public string RhoMethod { get; set; }
+    public string RhoslMean { get; set; }
+    public string RhoslRadialGradient { get; set; }
+    public string RhoslStdDev { get; set; }
+    public string RsMean { get; set; }
+    public string RsRadialGradient { get; set; }
+    public string RsStdDev { get; set; }
+    public string SetupFile { get; set; }
+    public string StartVoltage { get; set; }
+    public string StopVoltage { get; set; }
+    public string UniqueId { get; set; }
+    public string VdMean { get; set; }
+    public string VdRadialGradient { get; set; }
+    public string VdStdDev { get; set; }
+    public string Wafer { get; set; }
+    public string WaferSize { get; set; }
+    public string Zone { get; set; }
+    public List<pcl.Detail> Details { get; protected set; }
+
+    [Obsolete("For json")] public WSRequest() { }
+
+    internal WSRequest(IFileRead fileRead, Logistics logistics, List<pcl.Description> descriptions)
+    {
+        if (fileRead is null)
+        { }
+        Id = string.Empty;
+        Details = new List<pcl.Detail>();
+        CellName = logistics.MesEntity;
+        pcl.Description x = descriptions[0];
+        //Header
+        {
+            Area = x.Area;
+            Ccomp = x.Ccomp;
+            CondType = x.CondType;
+            Date = x.Date;
+            FlatZMean = x.FlatZMean;
+            FlatZRadialGradient = x.FlatZRadialGradient;
+            FlatZStdDev = x.FlatZStdDev;
+            Folder = x.Folder;
+            GLimit = x.GLimit;
+            GradeMean = x.GradeMean;
+            GradeRadialGradient = x.GradeRadialGradient;
+            GradeStdDev = x.GradeStdDev;
+            Operator = x.Employee;
+            Layer = x.Layer;
+            Lot = x.Lot;
+            Model = x.Model;
+            NAvgMean = x.NAvgMean;
+            NAvgRadialGradient = x.NAvgRadialGradient;
+            NAvgStdDev = x.NAvgStdDev;
+            NslMean = x.NslMean;
+            NslRadialGradient = x.NslRadialGradient;
+            NslStdDev = x.NslStdDev;
+            PSN = x.PSN;
+            Pattern = x.Pattern;
+            PhaseMean = x.PhaseMean;
+            PhaseRadialGradient = x.PhaseRadialGradient;
+            PhaseStdDev = x.PhaseStdDev;
+            Plan = x.Plan;
+            RDS = x.RDS;
+            RampRate = x.RampRate;
+            Reactor = x.Reactor;
+            RhoAvgMean = x.RhoAvgMean;
+            RhoAvgRadialGradient = x.RhoAvgRadialGradient;
+            RhoAvgStdDev = x.RhoAvgStdDev;
+            RhoMethod = x.RhoMethod;
+            RhoslMean = x.RhoslMean;
+            RhoslRadialGradient = x.RhoslRadialGradient;
+            RhoslStdDev = x.RhoslStdDev;
+            RsMean = x.RsMean;
+            RsRadialGradient = x.RsRadialGradient;
+            RsStdDev = x.RsStdDev;
+            SetupFile = x.SetupFile;
+            StartVoltage = x.StartVoltage;
+            StopVoltage = x.StopVoltage;
+            UniqueId = x.UniqueId;
+            VdMean = x.VdMean;
+            VdRadialGradient = x.VdRadialGradient;
+            VdStdDev = x.VdStdDev;
+            Wafer = x.Wafer;
+            WaferSize = x.WaferSize;
+            Zone = x.Zone;
+        }
+        pcl.Detail detail;
+        foreach (pcl.Description description in descriptions)
+        {
+            detail = new pcl.Detail
+            {
+                FlatZ = description.FlatZ,
+                Grade = description.Grade,
+                HeaderUniqueId = description.HeaderUniqueId,
+                NAvg = description.NAvg,
+                Nsl = description.Nsl,
+                Phase = description.Phase,
+                RhoAvg = description.RhoAvg,
+                Rhosl = description.Rhosl,
+                UniqueId = description.UniqueId,
+                Vd = description.Vd
+            };
+            Details.Add(detail);
+        }
+        if (Date is null)
+            Date = logistics.DateTimeFromSequence.ToString();
+        if (UniqueId is null && Details.Any())
+            UniqueId = Details[0].HeaderUniqueId;
+    }
+
+}