1041 lines
52 KiB
C#
1041 lines
52 KiB
C#
using Adaptation.Eaf.Core;
|
|
using Adaptation.Eaf.EquipmentCore.DataCollection.Reporting;
|
|
using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
|
|
using Adaptation.Helpers;
|
|
using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
|
|
using Adaptation.Shared;
|
|
using Adaptation.Shared.Metrology;
|
|
using log4net;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using System.Threading;
|
|
|
|
namespace Adaptation.FileHandlers
|
|
{
|
|
|
|
public partial class FileRead
|
|
{
|
|
|
|
public Logistics Logistics { get; protected set; }
|
|
|
|
private bool _TargetFileLocationOkay;
|
|
private bool _ErrorTargetFileLocationOkay;
|
|
|
|
private string _OriginalSourceFileLocation;
|
|
private string _OriginalTargetFileLocation;
|
|
private string _OriginalTarget2FileLocation;
|
|
private string _OriginalErrorTargetFileLocation;
|
|
|
|
#pragma warning disable CS0169
|
|
private readonly ILog _Log;
|
|
private Description _Description;
|
|
#pragma warning restore CS0169
|
|
|
|
private Type _ConfigurationType;
|
|
private MethodInfo _SetPlaceHolderMethodInfo;
|
|
private PropertyInfo _Target2FileLocationPropertyInfo;
|
|
private MethodInfo _ResolveSourcePlaceHoldersMethodInfo;
|
|
private MethodInfo _ResolveTargetPlaceHoldersMethodInfo;
|
|
private MethodInfo _ResolveTarget2PlaceHoldersMethodInfo;
|
|
private MethodInfo _ResolveErrorTargetPlaceHoldersMethodInfo;
|
|
|
|
private string _LastReportFullPath;
|
|
private long _BreakAfterSeconds = 0;
|
|
private long _LastTicksDuration = 0;
|
|
private Dictionary<string, string> _FileParameter;
|
|
private FileConnectorConfiguration _Configuration;
|
|
|
|
public ConfigDataBase GetConfigDataBase(MethodBase methodBase, string cellInstanceName, string equipmentElementName, FileConnectorConfiguration fileConnectorConfiguration, IList<ModelObjectParameterDefinition> modelObjectParameterDefinitions, bool eafHosted)
|
|
{
|
|
ConfigData result;
|
|
_Configuration = fileConnectorConfiguration;
|
|
Type type = methodBase.DeclaringType;
|
|
string equipmentTypeName = string.Empty;
|
|
result = new ConfigData(this, cellInstanceName, equipmentElementName, fileConnectorConfiguration, equipmentTypeName, modelObjectParameterDefinitions, type.FullName, isEAFHosted: true);
|
|
_ConfigData = result;
|
|
return result;
|
|
}
|
|
|
|
public string GetTarget2FileLocation()
|
|
{
|
|
string result;
|
|
if (_Target2FileLocationPropertyInfo is null)
|
|
_Target2FileLocationPropertyInfo = _ConfigurationType.GetProperty("Target2FileLocation", BindingFlags.Instance | BindingFlags.Public);
|
|
if (_Target2FileLocationPropertyInfo is null)
|
|
result = string.Empty;
|
|
else
|
|
{
|
|
object @object = _Target2FileLocationPropertyInfo.GetValue(_Configuration);
|
|
if (@object is null)
|
|
result = string.Empty;
|
|
else
|
|
result = @object.ToString();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public void ReflectionCreateSelfDescription(string equipmentElementName, int? input, string cellName, string debugConfig, string[] strings, bool[] booleans, long[] numbers, string[] enums)
|
|
{
|
|
throw new NotImplementedException("Use V2");
|
|
}
|
|
|
|
public ConfigDataBase ReflectionCreateSelfDescriptionV2(string json)
|
|
{
|
|
ConfigData result;
|
|
string cellInstanceName;
|
|
string equipmentTypeName;
|
|
string cellInstanceConnectionName;
|
|
string parameterizedModelObjectDefinitionType;
|
|
if (!json.Contains(nameof(cellInstanceName)))
|
|
throw new Exception();
|
|
if (!json.Contains(nameof(equipmentTypeName)))
|
|
throw new Exception();
|
|
if (!json.Contains(nameof(cellInstanceConnectionName)))
|
|
throw new Exception();
|
|
if (!json.Contains(nameof(FileConnectorConfiguration)))
|
|
throw new Exception();
|
|
if (!json.Contains(nameof(IList<ModelObjectParameterDefinition>)))
|
|
throw new Exception();
|
|
if (!json.Contains(nameof(parameterizedModelObjectDefinitionType)))
|
|
throw new Exception();
|
|
MethodBase methodBase = new StackFrame().GetMethod();
|
|
JsonElement jsonElement = JsonSerializer.Deserialize<JsonElement>(json);
|
|
cellInstanceName = jsonElement.GetProperty(nameof(cellInstanceName)).ToString();
|
|
equipmentTypeName = jsonElement.GetProperty(nameof(equipmentTypeName)).ToString();
|
|
cellInstanceConnectionName = jsonElement.GetProperty(nameof(cellInstanceConnectionName)).ToString();
|
|
JsonElement fileConnectorConfigurationJsonElement = jsonElement.GetProperty(nameof(FileConnectorConfiguration));
|
|
parameterizedModelObjectDefinitionType = jsonElement.GetProperty(nameof(parameterizedModelObjectDefinitionType)).ToString();
|
|
if (fileConnectorConfigurationJsonElement.ValueKind != JsonValueKind.Object)
|
|
throw new Exception();
|
|
JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions { Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) } };
|
|
FileConnectorConfiguration fileConnectorConfiguration = JsonSerializer.Deserialize<FileConnectorConfiguration>(fileConnectorConfigurationJsonElement.ToString(), jsonSerializerOptions);
|
|
_Configuration = fileConnectorConfiguration;
|
|
JsonElement modelObjectParameterDefinitionJsonElement = jsonElement.GetProperty(nameof(IList<ModelObjectParameterDefinition>));
|
|
if (modelObjectParameterDefinitionJsonElement.ValueKind != JsonValueKind.Array)
|
|
throw new Exception();
|
|
IList<ModelObjectParameterDefinition> modelObjectParameterDefinitions = JsonSerializer.Deserialize<IList<ModelObjectParameterDefinition>>(modelObjectParameterDefinitionJsonElement.ToString(), jsonSerializerOptions);
|
|
#if (false)
|
|
FileConnectorConfiguration fileConnectorConfigurationOld = GetFileConnectorConfiguration(strings, booleans, numbers, enums);
|
|
jsonSerializerOptions = new JsonSerializerOptions { WriteIndented = true };
|
|
string @new = JsonSerializer.Serialize(fileConnectorConfiguration, fileConnectorConfiguration.GetType(), jsonSerializerOptions);
|
|
string old = JsonSerializer.Serialize(fileConnectorConfigurationOld, fileConnectorConfiguration.GetType(), jsonSerializerOptions);
|
|
if (@new != old)
|
|
throw new Exception();
|
|
#endif
|
|
if (!(Backbone.Instance is null))
|
|
{
|
|
Type type = Backbone.Instance.GetType();
|
|
PropertyInfo propertyInfo = type.GetProperty(nameof(Backbone.Instance.CellName));
|
|
if (!(propertyInfo is null))
|
|
{
|
|
MethodInfo methodInfo = propertyInfo.GetSetMethod(nonPublic: true);
|
|
if (!(methodInfo is null))
|
|
methodInfo.Invoke(Backbone.Instance, new object[] { cellInstanceName });
|
|
}
|
|
}
|
|
_Configuration = fileConnectorConfiguration;
|
|
result = new ConfigData(this, cellInstanceName, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, modelObjectParameterDefinitions, parameterizedModelObjectDefinitionType, isEAFHosted: false);
|
|
_ConfigData = result;
|
|
_Description = new Description(this, result, equipmentControl: null);
|
|
Shared0749();
|
|
_FileParameter = new Dictionary<string, string>();
|
|
Shared1301(_FileParameter, fileConnectorConfiguration);
|
|
return result;
|
|
}
|
|
|
|
public object GetFilePathGeneratorInfo(string reportFullPath, bool isErrorFile)
|
|
{
|
|
string result;
|
|
if (!_Configuration.TargetFileLocation.EndsWith(Path.DirectorySeparatorChar.ToString()))
|
|
result = _Configuration.TargetFileLocation;
|
|
else
|
|
result = Path.GetDirectoryName(_Configuration.TargetFileLocation);
|
|
foreach (KeyValuePair<string, string> keyValuePair in _FileParameter)
|
|
result = result.Replace(string.Concat('%', keyValuePair.Key, '%'), keyValuePair.Value);
|
|
return result;
|
|
}
|
|
|
|
private void TriggerEvents(string reportFullPath, Tuple<string, JsonElement?, List<FileInfo>> extractResults)
|
|
{
|
|
List<ParameterValue> parameters;
|
|
int count = extractResults.Item2.Value.GetArrayLength();
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
_Log.Debug(string.Concat("TriggerEvent - {", reportFullPath, "} ", i, " of ", count));
|
|
parameters = _Description.GetParameterValues(this, null, extractResults.Item2.Value, i);
|
|
#if (false)
|
|
if (!(_EquipmentEvent is null))
|
|
Equipment.DataCollection.TriggerEvent(_EquipmentEvent, parameters);
|
|
#endif
|
|
if (_ConfigData.UseCyclicalForDescription)
|
|
break;
|
|
}
|
|
if (_ConfigData.IsDatabaseExportToIPDSF && count > 0)
|
|
{
|
|
_Log.Debug(string.Concat("TriggerEvent - {", reportFullPath, "} ", null, " of ", count));
|
|
parameters = _Description.GetParameterValues(this, null, extractResults.Item2.Value, null);
|
|
#if (false)
|
|
if (!(_EquipmentEvent is null))
|
|
Equipment.DataCollection.TriggerEvent(_EquipmentEvent, parameters);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
public Tuple<string, JsonElement?, List<FileInfo>> ReExtract(string searchDirectory, string sourceFileFilter)
|
|
{
|
|
Tuple<string, JsonElement?, List<FileInfo>> results;
|
|
if (!Directory.Exists(searchDirectory))
|
|
results = null;
|
|
else
|
|
{
|
|
string[] segments;
|
|
string[] matches = null;
|
|
foreach (string subSourceFileFilter in sourceFileFilter.Split('|'))
|
|
{
|
|
segments = subSourceFileFilter.Split('\\');
|
|
if (_Configuration.IncludeSubDirectories.Value)
|
|
matches = Directory.GetFiles(searchDirectory, segments.Last(), SearchOption.AllDirectories);
|
|
else
|
|
matches = Directory.GetFiles(searchDirectory, segments.Last(), SearchOption.TopDirectoryOnly);
|
|
if (matches.Any())
|
|
break;
|
|
}
|
|
if (matches is null || !matches.Any())
|
|
results = null;
|
|
else
|
|
{
|
|
string reportFullPath = matches[0];
|
|
results = GetExtractResult(reportFullPath, Description.FileFound);
|
|
if (!_ConfigData.EafHosted)
|
|
TriggerEvents(Logistics.ReportFullPath, results);
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
public void SetTarget2FileLocation(string value)
|
|
{
|
|
if (_Target2FileLocationPropertyInfo is null)
|
|
_Target2FileLocationPropertyInfo = _ConfigurationType.GetProperty("Target2FileLocation", BindingFlags.Instance | BindingFlags.Public);
|
|
if (!(_Target2FileLocationPropertyInfo is null))
|
|
_Target2FileLocationPropertyInfo.SetValue(_Configuration, value);
|
|
}
|
|
|
|
public void ConfigurationRestore()
|
|
{
|
|
_Configuration.SourceFileLocation = _OriginalSourceFileLocation;
|
|
_Configuration.TargetFileLocation = _OriginalTargetFileLocation;
|
|
SetTarget2FileLocation(_OriginalTarget2FileLocation);
|
|
_Configuration.ErrorTargetFileLocation = _OriginalErrorTargetFileLocation;
|
|
}
|
|
|
|
public string GetConfigurationSourceFileLocation()
|
|
{
|
|
return _Configuration.SourceFileLocation;
|
|
}
|
|
|
|
public string GetConfigurationTargetFileLocation()
|
|
{
|
|
return _Configuration.TargetFileLocation;
|
|
}
|
|
|
|
public string GetConfigurationTargetFileName()
|
|
{
|
|
return _Configuration.TargetFileName;
|
|
}
|
|
|
|
public string GetConfigurationTarget2FileLocation()
|
|
{
|
|
return GetTarget2FileLocation();
|
|
}
|
|
|
|
public string GetConfigurationErrorTargetFileLocation()
|
|
{
|
|
return _Configuration.ErrorTargetFileLocation;
|
|
}
|
|
|
|
public void SetPlaceHolder(string reportFullPath, string key, string value)
|
|
{
|
|
if (!string.IsNullOrEmpty(reportFullPath) && _LastReportFullPath != reportFullPath)
|
|
_LastReportFullPath = reportFullPath;
|
|
if (_SetPlaceHolderMethodInfo is null)
|
|
_SetPlaceHolderMethodInfo = _ConfigurationType.GetMethod(nameof(this.SetPlaceHolder));
|
|
object @object = _SetPlaceHolderMethodInfo.Invoke(_Configuration, new object[] { key, value });
|
|
if (!_FileParameter.ContainsKey(key))
|
|
_FileParameter[key] = string.Empty;
|
|
_FileParameter[key] = value;
|
|
}
|
|
|
|
public string ResolveSourcePlaceHolders(string reportFullPath, bool createDirectory = true)
|
|
{
|
|
string result;
|
|
if (!string.IsNullOrEmpty(reportFullPath) && _LastReportFullPath != reportFullPath)
|
|
_LastReportFullPath = reportFullPath;
|
|
_FileParameter.Clear();
|
|
if (_ResolveSourcePlaceHoldersMethodInfo is null)
|
|
_ResolveSourcePlaceHoldersMethodInfo = _ConfigurationType.GetMethod(nameof(this.ResolveSourcePlaceHolders));
|
|
if (_ResolveSourcePlaceHoldersMethodInfo is null)
|
|
result = string.Empty;
|
|
else
|
|
{
|
|
object @object = _ResolveSourcePlaceHoldersMethodInfo.Invoke(_Configuration, new object[] { createDirectory });
|
|
if (@object is null)
|
|
result = string.Empty;
|
|
else
|
|
result = @object.ToString();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public string ResolveTargetPlaceHolders(string reportFullPath, bool createDirectory = true, string fileFoundPath = "")
|
|
{
|
|
string result;
|
|
if (!string.IsNullOrEmpty(reportFullPath) && _LastReportFullPath != reportFullPath)
|
|
_LastReportFullPath = reportFullPath;
|
|
if (!string.IsNullOrEmpty(reportFullPath) || !string.IsNullOrEmpty(_LastReportFullPath))
|
|
{
|
|
//bool isErrorFile = false;
|
|
//Ifx.Eaf.EquipmentConnector.File.Component.FilePathGenerator filePathGenerator;
|
|
//if (!string.IsNullOrEmpty(reportFullPath))
|
|
// filePathGenerator = new Ifx.Eaf.EquipmentConnector.File.Component.FilePathGenerator(_Configuration, reportFullPath, isErrorFile, _FileParameter);
|
|
//else if (!string.IsNullOrEmpty(_LastReportFullPath))
|
|
// filePathGenerator = new Ifx.Eaf.EquipmentConnector.File.Component.FilePathGenerator(_Configuration, _LastReportFullPath, isErrorFile, _FileParameter);
|
|
//else
|
|
// throw new Exception();
|
|
//result = filePathGenerator.GetTargetFolder();
|
|
}
|
|
_FileParameter.Clear();
|
|
if (_ResolveTargetPlaceHoldersMethodInfo is null)
|
|
_ResolveTargetPlaceHoldersMethodInfo = _ConfigurationType.GetMethod(nameof(this.ResolveTargetPlaceHolders));
|
|
if (_ResolveTargetPlaceHoldersMethodInfo is null)
|
|
result = string.Empty;
|
|
else
|
|
{
|
|
object @object = _ResolveTargetPlaceHoldersMethodInfo.Invoke(_Configuration, new object[] { createDirectory, fileFoundPath });
|
|
if (@object is null)
|
|
result = string.Empty;
|
|
else
|
|
result = @object.ToString();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public string ResolveTarget2PlaceHolders(string reportFullPath, bool createDirectory = true, string fileFoundPath = "")
|
|
{
|
|
string result;
|
|
if (!string.IsNullOrEmpty(reportFullPath) && _LastReportFullPath != reportFullPath)
|
|
_LastReportFullPath = reportFullPath;
|
|
_FileParameter.Clear();
|
|
if (_ResolveTarget2PlaceHoldersMethodInfo is null)
|
|
_ResolveTarget2PlaceHoldersMethodInfo = _ConfigurationType.GetMethod(nameof(this.ResolveTarget2PlaceHolders));
|
|
if (_ResolveTarget2PlaceHoldersMethodInfo is null)
|
|
result = string.Empty;
|
|
else
|
|
{
|
|
object @object = _ResolveTarget2PlaceHoldersMethodInfo.Invoke(_Configuration, new object[] { createDirectory, fileFoundPath });
|
|
if (@object is null)
|
|
result = string.Empty;
|
|
else
|
|
result = @object.ToString();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public string ResolveErrorTargetPlaceHolders(string reportFullPath, bool createDirectory = true, string fileFoundPath = "")
|
|
{
|
|
string result;
|
|
if (!string.IsNullOrEmpty(reportFullPath) && _LastReportFullPath != reportFullPath)
|
|
_LastReportFullPath = reportFullPath;
|
|
if (!string.IsNullOrEmpty(reportFullPath) || !string.IsNullOrEmpty(_LastReportFullPath))
|
|
{
|
|
//bool isErrorFile = true;
|
|
//Ifx.Eaf.EquipmentConnector.File.Component.FilePathGenerator filePathGenerator;
|
|
//if (!string.IsNullOrEmpty(reportFullPath))
|
|
// filePathGenerator = new Ifx.Eaf.EquipmentConnector.File.Component.FilePathGenerator(_Configuration, reportFullPath, isErrorFile, _FileParameter);
|
|
//else if (!string.IsNullOrEmpty(_LastReportFullPath))
|
|
// filePathGenerator = new Ifx.Eaf.EquipmentConnector.File.Component.FilePathGenerator(_Configuration, _LastReportFullPath, isErrorFile, _FileParameter);
|
|
//else
|
|
// throw new Exception();
|
|
//result = filePathGenerator.GetTargetFolder();
|
|
}
|
|
_FileParameter.Clear();
|
|
if (_ResolveErrorTargetPlaceHoldersMethodInfo is null)
|
|
_ResolveErrorTargetPlaceHoldersMethodInfo = _ConfigurationType.GetMethod(nameof(this.ResolveErrorTargetPlaceHolders));
|
|
if (_ResolveErrorTargetPlaceHoldersMethodInfo is null)
|
|
result = string.Empty;
|
|
else
|
|
{
|
|
object @object = _ResolveErrorTargetPlaceHoldersMethodInfo.Invoke(_Configuration, new object[] { createDirectory, fileFoundPath });
|
|
if (@object is null)
|
|
result = string.Empty;
|
|
else
|
|
result = @object.ToString();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public string GetReportFullPath(Dictionary<string, object> keyValuePairs)
|
|
{
|
|
string result;
|
|
if (keyValuePairs is null || !keyValuePairs.Any())
|
|
result = string.Empty;
|
|
else
|
|
{
|
|
string key;
|
|
key = "Param1";
|
|
Dictionary<string, object> eventDataList;
|
|
if (!keyValuePairs.ContainsKey(key))
|
|
eventDataList = keyValuePairs;
|
|
else
|
|
eventDataList = (Dictionary<string, object>)keyValuePairs[key];
|
|
key = "InputFileName";
|
|
if (!eventDataList.ContainsKey(key))
|
|
result = string.Empty;
|
|
else
|
|
result = eventDataList[key].ToString();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public void SetFileParameter(string key, string value)
|
|
{
|
|
if (_Configuration is null || _Configuration.TargetFileLocation.Contains(string.Concat("%", key, "%")) || _Configuration.ErrorTargetFileLocation.Contains(string.Concat("%", key, "%")) || _Configuration.TargetFileName.Contains(string.Concat("%", key, "%")) || _Configuration.ErrorTargetFileName.Contains(string.Concat("%", key, "%")))
|
|
{
|
|
if (_FileParameter.ContainsKey(key))
|
|
_FileParameter[key] = value;
|
|
else
|
|
_FileParameter.Add(key, value);
|
|
}
|
|
}
|
|
|
|
public void SetFileParameterLotID(string value, bool includeLogisticsSequence = true)
|
|
{
|
|
string key;
|
|
if (!includeLogisticsSequence)
|
|
key = "LotID";
|
|
else
|
|
{
|
|
key = "LotIDWithLogisticsSequence";
|
|
value = string.Concat(value, "_", Logistics.Sequence, "_", DateTime.Now.Ticks - Logistics.Sequence);
|
|
}
|
|
SetFileParameter(key, value);
|
|
}
|
|
|
|
public void SetFileParameterLotIDToLogisticsMID(bool includeLogisticsSequence = true)
|
|
{
|
|
string key;
|
|
if (!includeLogisticsSequence)
|
|
key = "LotID";
|
|
else
|
|
key = "LotIDWithLogisticsSequence";
|
|
string value = string.Concat(Logistics.MID, "_", Logistics.Sequence, "_", DateTime.Now.Ticks - Logistics.Sequence);
|
|
SetFileParameter(key, value);
|
|
}
|
|
|
|
public void SetFileParameterSystemDateTimeToLogisticsSequence()
|
|
{
|
|
string key = "SystemDateTime";
|
|
string value = string.Concat(DateTime.Now.ToString("hh;mm;ss_tt_"), Logistics.Sequence);
|
|
SetFileParameter(key, value);
|
|
}
|
|
|
|
private void UpdateLastTicksDuration(long ticksDuration)
|
|
{
|
|
if (ticksDuration < 50000000)
|
|
ticksDuration = 50000000;
|
|
_LastTicksDuration = (long)Math.Ceiling(ticksDuration * .667);
|
|
}
|
|
|
|
private string GetTupleFile(Logistics logistics, IScopeInfo scopeInfo, string duplicateDirectory)
|
|
{
|
|
string result;
|
|
string rds;
|
|
string dateValue;
|
|
string datePlaceholder;
|
|
string[] segments = logistics.MID.Split('-');
|
|
if (segments.Length < 2)
|
|
rds = "%RDS%";
|
|
else
|
|
rds = segments[1];
|
|
segments = scopeInfo.FileName.Split(new string[] { "DateTime:" }, StringSplitOptions.RemoveEmptyEntries);
|
|
if (segments.Length == 0)
|
|
result = string.Concat(duplicateDirectory, @"\", scopeInfo.FileNameWithoutExtension.Replace("%RDS%", rds));
|
|
else
|
|
{
|
|
datePlaceholder = "%DateTime%";
|
|
segments = segments[1].Split('%');
|
|
dateValue = logistics.DateTimeFromSequence.ToString(segments[0]);
|
|
foreach (string segment in scopeInfo.FileName.Split('%'))
|
|
{
|
|
if (!segment.Contains(segments[0]))
|
|
continue;
|
|
datePlaceholder = string.Concat('%', segment, '%');
|
|
}
|
|
result = string.Concat(duplicateDirectory, @"\", scopeInfo.FileName.Replace("%RDS%", rds).Replace(datePlaceholder, dateValue));
|
|
}
|
|
if (result.Contains('%'))
|
|
throw new Exception("Placeholder exists!");
|
|
return result;
|
|
}
|
|
|
|
private void WaitForFileConsumption(string sourceDirectoryCloaking, Logistics logistics, DateTime dateTime, string successDirectory, string duplicateDirectory, string duplicateFile, List<Tuple<IScopeInfo, string>> tuples)
|
|
{
|
|
bool check;
|
|
long preWait;
|
|
string tupleFile;
|
|
List<int> consumedFileIndices = new List<int>();
|
|
List<string> duplicateFiles = new List<string>();
|
|
bool moreThanAnHour = (_BreakAfterSeconds > 3600);
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
long breakAfter = dateTime.AddSeconds(_BreakAfterSeconds).Ticks;
|
|
if (moreThanAnHour)
|
|
preWait = dateTime.AddSeconds(30).Ticks;
|
|
else
|
|
preWait = dateTime.AddTicks(_LastTicksDuration).Ticks;
|
|
if (!tuples.Any())
|
|
duplicateFiles.Add(duplicateFile);
|
|
string fileName = Path.GetFileNameWithoutExtension(logistics.ReportFullPath);
|
|
string successFile = string.Concat(successDirectory, @"\", Path.GetFileName(logistics.ReportFullPath));
|
|
foreach (Tuple<IScopeInfo, string> tuple in tuples)
|
|
{
|
|
if (tuple.Item1.FileName.StartsWith(@"\"))
|
|
tupleFile = tuple.Item1.FileName;
|
|
else if (!tuple.Item1.FileName.Contains('%'))
|
|
tupleFile = string.Concat(duplicateDirectory, @"\", fileName, "_", tuple.Item1.FileNameWithoutExtension, ".pdsfc");
|
|
else
|
|
tupleFile = GetTupleFile(logistics, tuple.Item1, duplicateDirectory);
|
|
duplicateFiles.Add(tupleFile);
|
|
File.WriteAllText(tupleFile, tuple.Item2);
|
|
}
|
|
for (short i = 0; i < short.MaxValue; i++)
|
|
{
|
|
if (DateTime.Now.Ticks > preWait)
|
|
break;
|
|
Thread.Sleep(500);
|
|
}
|
|
if (!moreThanAnHour)
|
|
{
|
|
for (short z = 0; z < short.MaxValue; z++)
|
|
{
|
|
try
|
|
{
|
|
check = (string.IsNullOrEmpty(successDirectory) || File.Exists(successFile));
|
|
if (check)
|
|
{
|
|
consumedFileIndices.Clear();
|
|
for (int i = 0; i < duplicateFiles.Count; i++)
|
|
{
|
|
if (!File.Exists(duplicateFiles[i]))
|
|
consumedFileIndices.Add(i);
|
|
}
|
|
if (consumedFileIndices.Count == duplicateFiles.Count)
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception) { }
|
|
if (DateTime.Now.Ticks > breakAfter)
|
|
{
|
|
for (int i = 0; i < duplicateFiles.Count; i++)
|
|
{
|
|
if (File.Exists(duplicateFiles[i]))
|
|
{
|
|
try
|
|
{ File.Delete(duplicateFiles[i]); }
|
|
catch (Exception) { }
|
|
stringBuilder.Append("<").Append(duplicateFiles[i]).Append("> ");
|
|
}
|
|
}
|
|
throw new Exception(string.Concat("After {", _BreakAfterSeconds, "} seconds, right side of {", sourceDirectoryCloaking, "} didn't consume file(s) ", stringBuilder));
|
|
}
|
|
Thread.Sleep(500);
|
|
}
|
|
}
|
|
}
|
|
|
|
private IEnumerable<string> GetDirectoriesRecursively(string path, string directoryNameSegment = null)
|
|
{
|
|
Queue<string> queue = new Queue<string>();
|
|
queue.Enqueue(path);
|
|
while (queue.Count > 0)
|
|
{
|
|
path = queue.Dequeue();
|
|
foreach (string subDirectory in Directory.GetDirectories(path))
|
|
{
|
|
queue.Enqueue(subDirectory);
|
|
if (string.IsNullOrEmpty(directoryNameSegment) || Path.GetFileName(subDirectory).Contains(directoryNameSegment))
|
|
yield return subDirectory;
|
|
}
|
|
}
|
|
}
|
|
|
|
private string GetProcessedDirectory(string progressPath, Logistics logistics, DateTime dateTime, string duplicateDirectory)
|
|
{
|
|
string result = duplicateDirectory;
|
|
string logisticsSequence = logistics.Sequence.ToString();
|
|
string[] matchDirectories;
|
|
if (!_ConfigData.EafHosted)
|
|
matchDirectories = new string[] { Path.GetDirectoryName(Path.GetDirectoryName(logistics.ReportFullPath)) };
|
|
else
|
|
matchDirectories = new string[] { GetDirectoriesRecursively(Path.GetDirectoryName(progressPath), logisticsSequence).FirstOrDefault() };
|
|
if (matchDirectories.Length == 0 || string.IsNullOrEmpty(matchDirectories[0]))
|
|
matchDirectories = Directory.GetDirectories(duplicateDirectory, string.Concat('*', logisticsSequence, '*'), SearchOption.AllDirectories);
|
|
if ((matchDirectories is null) || matchDirectories.Length != 1)
|
|
throw new Exception("Didn't find directory by logistics sequence");
|
|
if (!matchDirectories[0].Contains("_processed"))
|
|
{
|
|
result = string.Concat(matchDirectories[0].Split(new string[] { logisticsSequence }, StringSplitOptions.None)[0], logistics.DateTimeFromSequence.ToString("yyyy-MM-dd_hh;mm_tt_"), dateTime.Ticks - logistics.Sequence, "_processed");
|
|
Directory.Move(matchDirectories[0], result);
|
|
result = string.Concat(result, @"\", logistics.Sequence);
|
|
if (!Directory.Exists(result))
|
|
Directory.CreateDirectory(result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private string WriteScopeInfo(string progressPath, Logistics logistics, DateTime dateTime, string duplicateDirectory, List<Tuple<IScopeInfo, string>> tuples)
|
|
{
|
|
string result = GetProcessedDirectory(progressPath, logistics, dateTime, duplicateDirectory);
|
|
string tupleFile;
|
|
string fileName = Path.GetFileNameWithoutExtension(logistics.ReportFullPath);
|
|
string duplicateFile = string.Concat(result, @"\", fileName, ".pdsf");
|
|
foreach (Tuple<IScopeInfo, string> tuple in tuples)
|
|
{
|
|
if (tuple.Item1.FileName.StartsWith(@"\"))
|
|
tupleFile = tuple.Item1.FileName;
|
|
else
|
|
tupleFile = string.Concat(result, @"\", fileName, "_", tuple.Item1.FileNameWithoutExtension, ".pdsfc");
|
|
File.WriteAllText(tupleFile, tuple.Item2);
|
|
}
|
|
File.Copy(logistics.ReportFullPath, duplicateFile, overwrite: true);
|
|
return result;
|
|
}
|
|
|
|
private void CreateProgressDirectory(string progressPath, Logistics logistics, int? duplicator, string[] exceptionLines)
|
|
{
|
|
string progressDirectory;
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
if (duplicator is null || duplicator.Value == 0)
|
|
progressDirectory = string.Concat(progressPath, @"\", ProcessDataStandardFormat.EquipmentIntegration());
|
|
else
|
|
{
|
|
stringBuilder.Clear();
|
|
for (int i = 0; i < duplicator.Value; i++)
|
|
{
|
|
if (i > 0 && (i % 2) == 0)
|
|
stringBuilder.Append(' ');
|
|
stringBuilder.Append('-');
|
|
}
|
|
progressDirectory = string.Concat(progressPath, @"\", (duplicator.Value + 1).ToString().PadLeft(2, '0'), " ", stringBuilder).Trim();
|
|
}
|
|
DateTime dateTime = DateTime.Now;
|
|
CultureInfo cultureInfo = new CultureInfo("en-US");
|
|
Calendar calendar = cultureInfo.Calendar;
|
|
string weekOfYear = calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
|
|
progressDirectory = string.Concat(progressDirectory, @"\", dateTime.ToString("yyyy"), "_Week_", weekOfYear, @"\", logistics.MID, "_", logistics.Sequence, "_", DateTime.Now.Ticks - logistics.Sequence);
|
|
if (!Directory.Exists(progressDirectory))
|
|
Directory.CreateDirectory(progressDirectory);
|
|
if (!(exceptionLines is null))
|
|
{
|
|
string fileName = string.Concat(progressDirectory, @"\readme.txt");
|
|
try
|
|
{ File.WriteAllLines(fileName, exceptionLines); }
|
|
catch (Exception) { }
|
|
}
|
|
}
|
|
|
|
private void Shared0192(string reportFullPath)
|
|
{
|
|
if (!string.IsNullOrEmpty(reportFullPath))
|
|
{
|
|
FileInfo fileInfo = new FileInfo(reportFullPath);
|
|
if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
|
|
File.SetLastWriteTime(reportFullPath, fileInfo.CreationTime);
|
|
}
|
|
}
|
|
|
|
public void Shared0231(List<string> directories)
|
|
{
|
|
if (_Configuration.PostProcessingMode != FileConnectorConfiguration.PostProcessingModeEnum.Copy)
|
|
{
|
|
foreach (string directory in (from l in directories orderby l.Split('\\').Length descending select l).Distinct())
|
|
{
|
|
if (Directory.Exists(directory) && !Directory.GetFiles(directory).Any())
|
|
Directory.Delete(directory);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void WriteIO(string reportFullPath)
|
|
{
|
|
if (!_ConfigData.IsSourceTimer && !_ConfigData.IsDatabaseExportToIPDSF)
|
|
{
|
|
string fileName = string.Concat(reportFullPath, ".IO");
|
|
if (!(_Configuration is null) && _Configuration.PostProcessingMode == FileConnectorConfiguration.PostProcessingModeEnum.Copy)
|
|
File.WriteAllLines(fileName, new string[] { _Configuration.TargetFileName, Logistics.Sequence.ToString() });
|
|
}
|
|
}
|
|
|
|
private void Shared0413(DateTime dateTime, bool isDummyRun, string successDirectory, string duplicateDirectory, List<Tuple<IScopeInfo, string>> tuples, string duplicateFile)
|
|
{
|
|
if (!isDummyRun && _ConfigData.EafHosted)
|
|
WaitForFileConsumption(_Configuration.SourceDirectoryCloaking, Logistics, dateTime, successDirectory, duplicateDirectory, duplicateFile, tuples);
|
|
else
|
|
{
|
|
long breakAfter = DateTime.Now.AddSeconds(_Configuration.ConnectionRetryInterval.Value).Ticks;
|
|
for (short i = 0; i < short.MaxValue; i++)
|
|
{
|
|
if (!_ConfigData.EafHosted || DateTime.Now.Ticks > breakAfter)
|
|
break;
|
|
Thread.Sleep(500);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Shared0449(string to, string[] exceptionLines)
|
|
{
|
|
if (_ConfigData.Duplicator.HasValue)
|
|
CreateProgressDirectory(_ConfigData.ProgressPath, Logistics, (int?)_ConfigData.Duplicator, exceptionLines);
|
|
else
|
|
{
|
|
string fileName = string.Concat(to, @"\readme.txt");
|
|
try
|
|
{
|
|
if (!Directory.Exists(to))
|
|
Directory.CreateDirectory(to);
|
|
File.WriteAllLines(fileName, exceptionLines);
|
|
}
|
|
catch (Exception ex) { _Log.Error(ex.Message); }
|
|
}
|
|
}
|
|
|
|
private static void Shared0607(string reportFullPath, string duplicateDirectory, string logisticsSequence, string destinationDirectory)
|
|
{
|
|
if (destinationDirectory == duplicateDirectory)
|
|
throw new Exception("Check Target File Folder for %LotIDWithLogisticsSequence%_in process on CI (not Duplicator)");
|
|
if (destinationDirectory.EndsWith(logisticsSequence))
|
|
destinationDirectory = Path.GetDirectoryName(destinationDirectory);
|
|
string[] deleteFiles = Directory.GetFiles(destinationDirectory, "*", SearchOption.AllDirectories);
|
|
if (deleteFiles.Length > 250)
|
|
throw new Exception("Safety net!");
|
|
foreach (string file in deleteFiles)
|
|
File.Delete(file);
|
|
Directory.Delete(destinationDirectory, recursive: true);
|
|
File.Delete(reportFullPath);
|
|
}
|
|
|
|
public void Shared0749()
|
|
{
|
|
long breakAfterSeconds;
|
|
if (_Configuration is null)
|
|
breakAfterSeconds = 360;
|
|
else
|
|
{
|
|
if (_Configuration.FileScanningOption == FileConnectorConfiguration.FileScanningOptionEnum.TimeBased)
|
|
breakAfterSeconds = 360;
|
|
else
|
|
breakAfterSeconds = Math.Abs(_Configuration.FileScanningIntervalInSeconds.Value);
|
|
}
|
|
_BreakAfterSeconds = breakAfterSeconds;
|
|
UpdateLastTicksDuration(breakAfterSeconds * 10000000);
|
|
if (_ConfigData.Duplicator.HasValue)
|
|
{
|
|
if (string.IsNullOrEmpty(_Configuration.TargetFileLocation) || string.IsNullOrEmpty(_Configuration.ErrorTargetFileLocation))
|
|
throw new Exception("_Configuration is empty?");
|
|
if (_Configuration.TargetFileLocation.Contains('%') || _Configuration.ErrorTargetFileLocation.Contains('%'))
|
|
throw new Exception("_Configuration is incorrect for a duplicator!");
|
|
if (!(_Configuration is null))
|
|
{
|
|
if (string.IsNullOrEmpty(_Configuration.SourceDirectoryCloaking))
|
|
throw new Exception("SourceDirectoryCloaking is empty?");
|
|
if (!_Configuration.SourceDirectoryCloaking.StartsWith("~"))
|
|
throw new Exception("SourceDirectoryCloaking is incorrect for a duplicator!");
|
|
}
|
|
}
|
|
}
|
|
|
|
public string[] Shared1124(string reportFullPath, Tuple<string, JsonElement?, List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception = null)
|
|
{
|
|
string[] results;
|
|
bool isErrorFile = !(exception is null);
|
|
if (!to.EndsWith(@"\"))
|
|
string.Concat(to, @"\");
|
|
if (!isErrorFile)
|
|
results = new string[] { };
|
|
else
|
|
{
|
|
results = new string[] { Logistics.Sequence.ToString(), reportFullPath, from, resolvedFileLocation, to, string.Empty, string.Empty, exception.Message, string.Empty, string.Empty, exception.StackTrace };
|
|
Shared0449(to, results);
|
|
}
|
|
if (!(extractResults is null) && !(extractResults.Item3 is null) && extractResults.Item3.Any())
|
|
{
|
|
string itemFile;
|
|
List<string> directories = new List<string>();
|
|
foreach (FileInfo sourceFile in extractResults.Item3)
|
|
{
|
|
if (sourceFile.FullName != reportFullPath)
|
|
{
|
|
itemFile = sourceFile.FullName.Replace(from, to);
|
|
Shared1880(reportFullPath, itemFile, directories, sourceFile, isErrorFile);
|
|
}
|
|
else if (!isErrorFile && !(Logistics is null))
|
|
Shared1811(to, sourceFile);
|
|
}
|
|
Shared0231(directories);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private void WritePDSF(JsonElement jsonElement)
|
|
{
|
|
string directory;
|
|
string eventName = _ConfigData.GetEventName();
|
|
string equipmentType = _ConfigData.GetEquipmentType();
|
|
if (_ConfigData.EquipmentConnection is null || _ConfigData.EquipmentConnection.Value == _ConfigData.EquipmentType)
|
|
directory = Path.Combine(_ConfigData.TracePath, equipmentType, "Source", _ConfigData.CellName, _ConfigData.EquipmentElementName);
|
|
else
|
|
directory = Path.Combine(_ConfigData.VillachPath, equipmentType, "Target");
|
|
if (!Directory.Exists(directory))
|
|
Directory.CreateDirectory(directory);
|
|
string file = Path.Combine(directory, string.Concat(Logistics.MesEntity, "_", Logistics.Sequence, ".ipdsf"));
|
|
string lines = ProcessDataStandardFormat.GetPDSFText(this, eventName, equipmentType, jsonElement, logisticsText: string.Empty);
|
|
File.WriteAllText(file, lines);
|
|
if (Logistics.TotalSecondsSinceLastWriteTimeFromSequence > 600)
|
|
{
|
|
try
|
|
{ File.SetLastWriteTime(file, Logistics.DateTimeFromSequence); }
|
|
catch (Exception) { }
|
|
}
|
|
}
|
|
|
|
private void Shared1277(string reportFullPath, string destinationDirectory, string logisticsSequence, string jobIdDirectory, string json)
|
|
{
|
|
string ecCharacterizationSi = Path.GetDirectoryName(Path.GetDirectoryName(jobIdDirectory));
|
|
string destinationJobIdDirectory = string.Concat(ecCharacterizationSi, @"\Processed\", Logistics.JobID);
|
|
if (!Directory.Exists(destinationJobIdDirectory))
|
|
Directory.CreateDirectory(destinationJobIdDirectory);
|
|
destinationJobIdDirectory = string.Concat(destinationJobIdDirectory, @"\", Path.GetFileName(destinationDirectory).Split(new string[] { logisticsSequence }, StringSplitOptions.None)[0], Logistics.DateTimeFromSequence.ToString("yyyy-MM-dd_hh;mm_tt_"), DateTime.Now.Ticks - Logistics.Sequence);
|
|
string sequenceDirectory = string.Concat(destinationJobIdDirectory, @"\", logisticsSequence);
|
|
string jsonFileName = string.Concat(sequenceDirectory, @"\", Path.GetFileNameWithoutExtension(reportFullPath), ".json");
|
|
Directory.Move(destinationDirectory, destinationJobIdDirectory);
|
|
if (!Directory.Exists(sequenceDirectory))
|
|
Directory.CreateDirectory(sequenceDirectory);
|
|
File.Copy(reportFullPath, string.Concat(sequenceDirectory, @"\", Path.GetFileName(reportFullPath)), overwrite: true);
|
|
File.WriteAllText(jsonFileName, json);
|
|
}
|
|
|
|
public void Shared1301(Dictionary<string, string> fileParameter, FileConnectorConfiguration configuration)
|
|
{
|
|
if (fileParameter is null)
|
|
throw new Exception("File Parameter is null?");
|
|
_FileParameter = fileParameter;
|
|
_LastReportFullPath = string.Empty;
|
|
_TargetFileLocationOkay = true;
|
|
_ErrorTargetFileLocationOkay = true;
|
|
_ConfigurationType = configuration.GetType();
|
|
_OriginalSourceFileLocation = configuration.SourceFileLocation;
|
|
_OriginalTargetFileLocation = configuration.TargetFileLocation;
|
|
_OriginalTarget2FileLocation = GetTarget2FileLocation();
|
|
_OriginalErrorTargetFileLocation = configuration.ErrorTargetFileLocation;
|
|
if (_TargetFileLocationOkay)
|
|
{ }
|
|
if (_ErrorTargetFileLocationOkay)
|
|
{ }
|
|
}
|
|
|
|
private string[] Shared1567(string reportFullPath, List<Tuple<IScopeInfo, string>> tuples)
|
|
{
|
|
string[] results;
|
|
string historicalText;
|
|
string logisticsSequence = Logistics.Sequence.ToString();
|
|
string jobIdDirectory = string.Concat(Path.GetDirectoryName(Path.GetDirectoryName(_Configuration.TargetFileLocation)), @"\", Logistics.JobID);
|
|
if (!Directory.Exists(jobIdDirectory))
|
|
Directory.CreateDirectory(jobIdDirectory);
|
|
string[] matchDirectories;
|
|
if (!_ConfigData.EafHosted)
|
|
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");
|
|
string fileName = Path.GetFileNameWithoutExtension(reportFullPath);
|
|
string sequenceDirectory = string.Concat(matchDirectories[0], @"\", logisticsSequence);
|
|
if (!Directory.Exists(sequenceDirectory))
|
|
Directory.CreateDirectory(sequenceDirectory);
|
|
foreach (Tuple<IScopeInfo, string> tuple in tuples)
|
|
{
|
|
fileName = string.Concat(sequenceDirectory, @"\", fileName, "_", tuple.Item1.FileNameWithoutExtension, ".pdsfc");
|
|
if (_ConfigData.EafHosted)
|
|
File.WriteAllText(fileName, tuple.Item2);
|
|
else
|
|
{
|
|
historicalText = File.ReadAllText(fileName);
|
|
if (tuple.Item2 != historicalText)
|
|
throw new Exception("File doesn't match historical!");
|
|
}
|
|
}
|
|
results = matchDirectories;
|
|
return results;
|
|
}
|
|
|
|
public void Shared1811(string to, FileInfo sourceFile)
|
|
{
|
|
if (_ConfigData.Duplicator is null && _Configuration.SourceFileFilter != "*" && sourceFile.Exists && sourceFile.Length < ConfigData.MinFileLength)
|
|
{
|
|
string directoryName = Path.GetFileName(to);
|
|
string jobIdDirectory = Path.GetDirectoryName(to);
|
|
CultureInfo cultureInfo = new CultureInfo("en-US");
|
|
Calendar calendar = cultureInfo.Calendar;
|
|
DateTime dateTime = DateTime.Now.AddMinutes(-15);
|
|
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 destinationDirectory = string.Concat(jobIdDirectory, @"\_ Ignore 100 bytes\", weekDirectory, @"\", directoryName);
|
|
if (!Directory.Exists(destinationDirectory))
|
|
Directory.CreateDirectory(destinationDirectory);
|
|
File.Move(sourceFile.FullName, string.Concat(destinationDirectory, @"\", sourceFile.Name));
|
|
try
|
|
{
|
|
string[] checkDirectories = Directory.GetDirectories(jobIdDirectory, "*", SearchOption.TopDirectoryOnly);
|
|
foreach (string checkDirectory in checkDirectories)
|
|
{
|
|
if (!checkDirectory.Contains("_"))
|
|
continue;
|
|
if (Directory.GetDirectories(checkDirectory, "*", SearchOption.TopDirectoryOnly).Any())
|
|
continue;
|
|
if (Directory.GetFiles(checkDirectory, "*", SearchOption.TopDirectoryOnly).Any())
|
|
continue;
|
|
if (Directory.GetDirectories(checkDirectory, "*", SearchOption.AllDirectories).Any())
|
|
continue;
|
|
if (Directory.GetFiles(checkDirectory, "*", SearchOption.AllDirectories).Any())
|
|
continue;
|
|
if (new DirectoryInfo(checkDirectory).CreationTime > dateTime)
|
|
continue;
|
|
Directory.Delete(checkDirectory, recursive: false);
|
|
}
|
|
}
|
|
catch (Exception) { throw; }
|
|
}
|
|
}
|
|
|
|
private void Shared1872(string reportFullPath, Exception exception)
|
|
{
|
|
if (!string.IsNullOrEmpty(reportFullPath) && !(exception is null))
|
|
{
|
|
if (!(_Configuration is null) && _ConfigData.Duplicator.HasValue)
|
|
try
|
|
{ File.WriteAllLines(string.Concat(_Configuration.ErrorTargetFileLocation, @"\", Path.GetFileNameWithoutExtension(reportFullPath), ".err"), new string[] { Logistics.Sequence.ToString(), exception.Message, string.Empty, string.Empty, exception.StackTrace }); }
|
|
catch (Exception) { }
|
|
if (!_ConfigData.IsSourceTimer && !_ConfigData.IsDatabaseExportToIPDSF)
|
|
{
|
|
string fileName = string.Concat(reportFullPath, ".IO");
|
|
if (!(_Configuration is null) && _Configuration.PostProcessingMode == FileConnectorConfiguration.PostProcessingModeEnum.Copy)
|
|
try
|
|
{ File.WriteAllLines(fileName, new string[] { _Configuration.TargetFileName, Logistics.Sequence.ToString(), exception.Message, string.Empty, string.Empty, exception.StackTrace }); }
|
|
catch (Exception) { }
|
|
}
|
|
if (_ConfigData.EquipmentConnection.HasValue && _ConfigData.EquipmentConnection.Value != _ConfigData.EquipmentType)
|
|
{
|
|
if (!reportFullPath.EndsWith(".pdsf") && !reportFullPath.EndsWith(".ipdsf"))
|
|
{
|
|
string fileName = string.Concat(reportFullPath, ".IO");
|
|
try
|
|
{ File.WriteAllLines(fileName, new string[] { _Configuration.TargetFileName, Logistics.Sequence.ToString(), exception.Message, string.Empty, string.Empty, exception.StackTrace }); }
|
|
catch (Exception) { }
|
|
}
|
|
else
|
|
{
|
|
List<string> debug = new List<string> { "//Exception:" };
|
|
if (!(Logistics is null) && !(Logistics.Tags is null))
|
|
debug.AddRange(Logistics.Tags);
|
|
debug.Add(exception.Message);
|
|
debug.Add(exception.StackTrace);
|
|
try
|
|
{ File.AppendAllLines(reportFullPath, debug); }
|
|
catch (Exception) { }
|
|
if (!(Logistics is null) && Logistics.DateTimeFromSequence != DateTime.MinValue && Logistics.TotalSecondsSinceLastWriteTimeFromSequence > 600)
|
|
{
|
|
try
|
|
{ File.SetLastWriteTime(reportFullPath, Logistics.DateTimeFromSequence); }
|
|
catch (Exception) { }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Shared1880(string reportFullPath, string itemFile, List<string> directories, FileInfo sourceFile, bool isErrorFile)
|
|
{
|
|
string itemDirectory;
|
|
directories.Add(Path.GetDirectoryName(sourceFile.FullName));
|
|
itemDirectory = Path.GetDirectoryName(itemFile);
|
|
FileConnectorConfiguration.PostProcessingModeEnum processingModeEnum;
|
|
if (!isErrorFile)
|
|
processingModeEnum = _Configuration.PostProcessingMode.Value;
|
|
else
|
|
processingModeEnum = _Configuration.ErrorPostProcessingMode.Value;
|
|
if (processingModeEnum != FileConnectorConfiguration.PostProcessingModeEnum.Delete && !Directory.Exists(itemDirectory))
|
|
{
|
|
Directory.CreateDirectory(itemDirectory);
|
|
FileInfo fileInfo = new FileInfo(reportFullPath);
|
|
Directory.SetCreationTime(itemDirectory, fileInfo.LastWriteTime);
|
|
}
|
|
if (_ConfigData.EafHosted)
|
|
{
|
|
switch (processingModeEnum)
|
|
{
|
|
case FileConnectorConfiguration.PostProcessingModeEnum.Move:
|
|
File.Move(sourceFile.FullName, itemFile);
|
|
break;
|
|
case FileConnectorConfiguration.PostProcessingModeEnum.Copy:
|
|
File.Copy(sourceFile.FullName, itemFile);
|
|
break;
|
|
case FileConnectorConfiguration.PostProcessingModeEnum.Delete:
|
|
File.Delete(sourceFile.FullName);
|
|
break;
|
|
default:
|
|
throw new Exception();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void WaitForThread(Thread thread, List<Exception> threadExceptions)
|
|
{
|
|
if (!(thread is null))
|
|
{
|
|
System.Threading.ThreadState threadState;
|
|
for (short i = 0; i < short.MaxValue; i++)
|
|
{
|
|
if (thread is null)
|
|
break;
|
|
else
|
|
{
|
|
threadState = thread.ThreadState;
|
|
if (threadState != System.Threading.ThreadState.Running && threadState != System.Threading.ThreadState.WaitSleepJoin)
|
|
break;
|
|
}
|
|
Thread.Sleep(500);
|
|
}
|
|
lock (threadExceptions)
|
|
{
|
|
if (threadExceptions.Any())
|
|
{
|
|
foreach (Exception item in threadExceptions)
|
|
_Log.Error(string.Concat(item.Message, Environment.NewLine, Environment.NewLine, item.StackTrace));
|
|
Exception exception = threadExceptions[0];
|
|
threadExceptions.Clear();
|
|
throw exception;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
} |