516 lines
29 KiB
C#
516 lines
29 KiB
C#
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.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using System.Threading;
|
|
|
|
namespace Adaptation.FileHandlers.MET08RESIMAPCDE;
|
|
|
|
public class FileRead : Shared.FileRead, IFileRead
|
|
{
|
|
|
|
private readonly Timer _Timer;
|
|
private int _LastDummyRunIndex;
|
|
private readonly string _IqsFile;
|
|
private readonly int _HyphenIsDummy;
|
|
private readonly int _HyphenIsNaEDA;
|
|
private readonly string _MemoryPath;
|
|
private readonly int _HyphenIsXToAPC;
|
|
private readonly int _HyphenIsXToIQSSi;
|
|
private readonly int _HyphenIsXToSPaCe;
|
|
private readonly int _HyphenIsXToOpenInsight;
|
|
private readonly string _EventNameFileReadDaily;
|
|
private readonly string _OpenInsightFilePattern;
|
|
private readonly string _OpenInsightMetrologyViewerAPI;
|
|
private readonly Dictionary<string, string> _CellNames;
|
|
private readonly int _HyphenIsXToOpenInsightMetrologyViewer;
|
|
private readonly int _HyphenIsXToOpenInsightMetrologyViewerAttachments;
|
|
|
|
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;
|
|
if (_HyphenIsNaEDA == 0)
|
|
{ }
|
|
if (_HyphenIsXToSPaCe == 0)
|
|
{ }
|
|
if (_HyphenIsXToIQSSi == 0)
|
|
{ }
|
|
_CellNames = new Dictionary<string, string>();
|
|
_HyphenIsNaEDA = (int)Hyphen.IsNaEDA;
|
|
_HyphenIsDummy = (int)Hyphen.IsDummy;
|
|
_HyphenIsXToAPC = (int)Hyphen.IsXToAPC;
|
|
_HyphenIsXToIQSSi = (int)Hyphen.IsXToIQSSi;
|
|
_HyphenIsXToSPaCe = (int)Hyphen.IsXToSPaCe;
|
|
_HyphenIsXToOpenInsight = (int)Hyphen.IsXToOpenInsight;
|
|
_EventNameFileReadDaily = string.Concat(_EventNameFileRead, "Daily");
|
|
_IqsFile = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "IQS.File");
|
|
_MemoryPath = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "Path.Memory");
|
|
_HyphenIsXToOpenInsightMetrologyViewer = (int)Hyphen.IsXToOpenInsightMetrologyViewer;
|
|
_HyphenIsXToOpenInsightMetrologyViewerAttachments = (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);
|
|
if (_Hyphens == _HyphenIsDummy)
|
|
{
|
|
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) && _Hyphens == _HyphenIsXToOpenInsightMetrologyViewerAttachments);
|
|
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 (_Hyphens != _HyphenIsXToOpenInsight)
|
|
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 (_Hyphens != _HyphenIsXToAPC)
|
|
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 (_Hyphens == _HyphenIsXToAPC)
|
|
{
|
|
if (!isDummyRun && _IsEAFHosted)
|
|
File.Copy(reportFullPath, duplicateFile, overwrite: true);
|
|
}
|
|
else
|
|
{
|
|
if (_Hyphens == _HyphenIsXToOpenInsightMetrologyViewer)
|
|
{
|
|
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 (_Hyphens != _HyphenIsXToOpenInsight)
|
|
scopeInfo = new ScopeInfo(test, _IqsFile);
|
|
else
|
|
scopeInfo = new ScopeInfo(test, _OpenInsightFilePattern);
|
|
//lines = ProcessDataStandardFormat.GetLines(this, scopeInfo, names, values, dateFormat: "M/d/yyyy hh:mm:ss tt", timeFormat: string.Empty, pairedColumns: ExtractResultPairedColumns);
|
|
lines = ProcessData.GetLines(this, _Logistics, descriptions);
|
|
tuples.Add(new Tuple<Shared.Properties.IScopeInfo, string>(scopeInfo, lines));
|
|
}
|
|
}
|
|
if (_Hyphens == _HyphenIsXToOpenInsightMetrologyViewerAttachments)
|
|
{
|
|
string[] matchDirectories = Shared1567(reportFullPath, tuples);
|
|
if (!isDummyRun && _IsEAFHosted && !isNotUsedInsightMetrologyViewerAttachments)
|
|
ProcessData.PostOpenInsightMetrologyViewerAttachments(this, dateTime, logisticsSequenceMemoryDirectory, descriptions, matchDirectories[0]);
|
|
}
|
|
}
|
|
if (_Hyphens != _HyphenIsXToOpenInsightMetrologyViewer && _Hyphens != _HyphenIsXToOpenInsightMetrologyViewerAttachments)
|
|
Shared0413(dateTime, isDummyRun, successDirectory, duplicateDirectory, tuples, duplicateFile);
|
|
}
|
|
if (_Hyphens == _HyphenIsXToOpenInsightMetrologyViewerAttachments)
|
|
{
|
|
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)
|
|
{
|
|
if (_EventName == _EventNameFileRead)
|
|
checkDirectory = string.Concat(checkDirectory, @"\", sequence);
|
|
else if (_EventName == _EventNameFileReadDaily)
|
|
checkDirectory = string.Concat(checkDirectory, @"\Source\", sequence);
|
|
else
|
|
throw new Exception();
|
|
}
|
|
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 (_Hyphens != _HyphenIsDummy)
|
|
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) { }
|
|
}
|
|
}
|
|
|
|
} |