830 lines
41 KiB
C#
830 lines
41 KiB
C#
using EDAViewer.Models;
|
|
using EDAViewer.Models.Methods;
|
|
using EDAViewer.Singleton.Helper;
|
|
using IFX.Shared;
|
|
using System.Globalization;
|
|
using System.IO.Compression;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Text.RegularExpressions;
|
|
using System.Xml;
|
|
using System.Xml.Serialization;
|
|
|
|
namespace EDAViewer.Singleton;
|
|
|
|
public class Background : Models.Properties.IBackground, IBackground, IDisposable
|
|
{
|
|
|
|
protected readonly List<Exception> _Exceptions;
|
|
protected readonly List<Timer> _Timers;
|
|
protected readonly string _WorkingDirectory;
|
|
protected string _Message;
|
|
public List<Exception> Exceptions => _Exceptions;
|
|
public List<Timer> Timers => _Timers;
|
|
public string Message => _Message;
|
|
public string WorkingDirectory => _WorkingDirectory;
|
|
|
|
private bool _Stop;
|
|
private readonly object _Lock;
|
|
private readonly Calendar _Calendar;
|
|
private readonly Serilog.ILogger _Log;
|
|
private DateTime _PrimaryInstanceSetAt;
|
|
private readonly AppSettings _AppSettings;
|
|
private readonly IsEnvironment _IsEnvironment;
|
|
private string _EdaDataCollectionPlansLastRun;
|
|
|
|
public Background(IsEnvironment isEnvironment, AppSettings appSettings, string workingDirectory)
|
|
{
|
|
_Stop = false;
|
|
_Timers = new();
|
|
_Lock = new object();
|
|
_Message = string.Empty;
|
|
_AppSettings = appSettings;
|
|
_IsEnvironment = isEnvironment;
|
|
_Exceptions = new List<Exception>();
|
|
_WorkingDirectory = workingDirectory;
|
|
_PrimaryInstanceSetAt = DateTime.MinValue;
|
|
_Log = Serilog.Log.ForContext<Background>();
|
|
_Calendar = new CultureInfo("en-US").Calendar;
|
|
_EdaDataCollectionPlansLastRun = string.Empty;
|
|
}
|
|
|
|
void IBackground.Catch(Exception exception)
|
|
{
|
|
_Exceptions.Add(exception);
|
|
_Log.Error(exception, "Error:");
|
|
}
|
|
|
|
void IBackground.Stop(bool immediate)
|
|
{
|
|
if (!_Stop)
|
|
_Stop = true;
|
|
foreach (Timer timer in _Timers)
|
|
_ = timer.Change(Timeout.Infinite, 0);
|
|
}
|
|
|
|
void IBackground.Update(int milliSeconds)
|
|
{
|
|
_Log.Debug($"{milliSeconds} milliSecond(s) between timers");
|
|
// https://blog.magnusmontin.net/2018/11/05/platform-conditional-compilation-in-net-core/
|
|
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
|
|
_Log.Debug("Running on Linux!");
|
|
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
|
|
_Log.Debug("Running on macOS!");
|
|
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
|
|
_Log.Debug("Running on Windows!");
|
|
#if Linux
|
|
_Log.Debug("Built on Linux!");
|
|
#elif OSX
|
|
_Log.Debug("Built on macOS!");
|
|
#elif Windows
|
|
_Log.Debug("Built in Windows!");
|
|
#else
|
|
()("Built in Unknown!");
|
|
#endif
|
|
if (string.IsNullOrEmpty(_AppSettings.URLs) && !_IsEnvironment.Development)
|
|
throw new Exception("Invalid Application Settings URLs!");
|
|
if (_IsEnvironment.Development)
|
|
{
|
|
}
|
|
else if (_IsEnvironment.Staging)
|
|
{
|
|
}
|
|
else if (_IsEnvironment.Production)
|
|
{
|
|
}
|
|
else
|
|
throw new Exception();
|
|
}
|
|
|
|
void IBackground.ClearMessage() => _Message = string.Empty;
|
|
|
|
void IBackground.SetIsPrimaryInstance() => _PrimaryInstanceSetAt = DateTime.Now;
|
|
|
|
void IBackground.ClearIsPrimaryInstance() => _PrimaryInstanceSetAt = DateTime.MinValue;
|
|
|
|
void IDisposable.Dispose()
|
|
{
|
|
foreach (Timer timer in _Timers)
|
|
timer.Dispose();
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
void IBackground.Dispose()
|
|
{
|
|
IDisposable disposable = this;
|
|
disposable.Dispose();
|
|
}
|
|
|
|
void IBackground.EDAOutputArchiveCallback()
|
|
{
|
|
DateTime dateTime = DateTime.Now;
|
|
if (dateTime.Hour is > 8 and < 17)
|
|
{
|
|
string sourceDirectory = string.Concat(@"\\", _AppSettings.Server, @"\ec_eda\Staging\Traces");
|
|
if (!Directory.Exists(sourceDirectory))
|
|
_Log.Debug(string.Concat("// Source directory <", sourceDirectory, "> doesn't exist."));
|
|
else
|
|
EDAOutputArchive(sourceDirectory);
|
|
}
|
|
|
|
}
|
|
|
|
void IBackground.EdaDataCollectionPlansCallback()
|
|
{
|
|
string cSharpFormat = "yyyy-MM-dd_hh:mm:ss tt";
|
|
string oracleFormat = "yyyy-MM-dd_hh:mi:ss AM";
|
|
_Log.Debug(string.Concat("A) _EdaDataCollectionPlansLastRun = ", _EdaDataCollectionPlansLastRun));
|
|
DataCollectionPlans(_AppSettings, _EdaDataCollectionPlansLastRun, cSharpFormat, oracleFormat);
|
|
_EdaDataCollectionPlansLastRun = DateTime.Now.ToString(cSharpFormat);
|
|
_Log.Debug(string.Concat("B) _EdaDataCollectionPlansLastRun = ", _EdaDataCollectionPlansLastRun));
|
|
|
|
}
|
|
|
|
string IBackground.GetCountDirectory(string verb)
|
|
{
|
|
DateTime dateTime = DateTime.Now;
|
|
string weekOfYear = _Calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
|
|
//string nameSpace = System.Reflection.Assembly.GetExecutingAssembly().EntryPoint.DeclaringType.Namespace;
|
|
string nameSpace = $"{GetType().Namespace}".Split('.')[0];
|
|
// if (!_IsEnvironment.DebuggerWasAttachedDuringConstructor && !string.IsNullOrEmpty(_AppSettings.MonARessource))
|
|
// {
|
|
// MonIn monIn = MonIn.GetInstance();
|
|
// monIn.SendStatus(_Site, _AppSettings.MonARessource, "Heartbeat", State.Up);
|
|
// }
|
|
return string.Concat(@"\\", _AppSettings.Server, @"\EC_EAF\Counts\", dateTime.ToString("yyyy"), @"\", "Week_", weekOfYear, @"\", dateTime.ToString("yyyy - MM - dd"), @"\", "Application", @"\", nameSpace, @"\", verb, @"\", dateTime.Ticks);
|
|
}
|
|
|
|
void IBackground.LogPathCleanUpByWeekCallback()
|
|
{
|
|
DateTime dateTime = DateTime.Now;
|
|
if (dateTime.Hour is > 8 and < 17)
|
|
{
|
|
_Log.Debug(string.Concat("A) ", nameof(LogPathCleanUpByWeek)));
|
|
LogPathCleanUpByWeek(_AppSettings.Server, isEDA: true);
|
|
_Log.Debug(string.Concat("B) ", nameof(LogPathCleanUpByWeek)));
|
|
}
|
|
|
|
}
|
|
|
|
bool IBackground.IsPrimaryInstance()
|
|
{
|
|
bool result;
|
|
DateTime dateTime = DateTime.Now.AddDays(-1);
|
|
result = _PrimaryInstanceSetAt > dateTime;
|
|
return result;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string result = JsonSerializer.Serialize(this, new JsonSerializerOptions() { WriteIndented = true });
|
|
return result;
|
|
}
|
|
|
|
private void DeleteEmptyDirectories(string directory)
|
|
{
|
|
string[] files = Directory.GetFiles(directory, "*", SearchOption.AllDirectories);
|
|
string[] directories = Directory.GetDirectories(directory, "*", SearchOption.AllDirectories);
|
|
if (files.Length == 0 && directories.Length == 0)
|
|
Directory.Delete(directory);
|
|
else
|
|
{
|
|
foreach (string subDirectory in Directory.GetDirectories(directory, "*", SearchOption.TopDirectoryOnly))
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
DeleteEmptyDirectories(subDirectory);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ZipFilesByDate(string sourceDirectory, SearchOption searchOption = SearchOption.TopDirectoryOnly, string? dayFormat = null)
|
|
{
|
|
string key;
|
|
bool addFile;
|
|
string fileName;
|
|
FileInfo fileInfo;
|
|
string weekOfYear;
|
|
string[] segments;
|
|
string[] subFiles;
|
|
DateTime creationTime;
|
|
DateTime lastWriteTime;
|
|
Regex regex = new("[a-zA-Z0-9]{1,}");
|
|
DateTime firstEmail = new(2019, 3, 8);
|
|
CultureInfo cultureInfo = new("en-US");
|
|
Calendar calendar = cultureInfo.Calendar;
|
|
Dictionary<string, DateTime> weeks = new();
|
|
DateTime dateTime = DateTime.Now.AddDays(-6);
|
|
int ticksLength = dateTime.Ticks.ToString().Length;
|
|
for (int i = 0; i < 1000; i++)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
dateTime = firstEmail.AddDays(i);
|
|
weekOfYear = calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
|
|
key = string.Concat(dateTime.ToString("yyyy"), "_Week_", weekOfYear);
|
|
if (!weeks.ContainsKey(key))
|
|
weeks.Add(key, dateTime);
|
|
}
|
|
Dictionary<string, List<string>> keyValuePairs = new();
|
|
weekOfYear = calendar.GetWeekOfYear(DateTime.Now, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
|
|
string skipKey = string.Concat(DateTime.Now.ToString("yyyy"), "_Week_", weekOfYear);
|
|
string[] topDirectories = Directory.GetDirectories(sourceDirectory, "*", SearchOption.TopDirectoryOnly);
|
|
if (topDirectories.Length == 0)
|
|
topDirectories = new string[] { sourceDirectory };
|
|
foreach (string topDirectory in topDirectories)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
keyValuePairs.Clear();
|
|
subFiles = Directory.GetFiles(topDirectory, "*", searchOption);
|
|
foreach (string subFile in subFiles)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
addFile = false;
|
|
if (subFile.EndsWith(".zip"))
|
|
continue;
|
|
fileName = Path.GetFileName(subFile);
|
|
fileInfo = new FileInfo(subFile);
|
|
creationTime = fileInfo.CreationTime;
|
|
if (creationTime > dateTime)
|
|
continue;
|
|
lastWriteTime = fileInfo.LastWriteTime;
|
|
if (fileName.Contains(lastWriteTime.ToString("yyyyMMdd")) || fileName.Contains(lastWriteTime.ToString("yyyy-MM-dd")) ||
|
|
fileName.Contains(creationTime.ToString("yyyyMMdd")) || fileName.Contains(creationTime.ToString("yyyy-MM-dd")) ||
|
|
fileName.Contains(lastWriteTime.ToString("yyMMdd")) || fileName.Contains(lastWriteTime.ToString("yy-MM-dd")) ||
|
|
fileName.Contains(creationTime.ToString("yyMMdd")) || fileName.Contains(creationTime.ToString("yy-MM-dd")) ||
|
|
fileName.Contains(lastWriteTime.AddDays(-1).ToString("yyyyMMdd")) || fileName.Contains(lastWriteTime.AddDays(-1).ToString("yyyy-MM-dd")) ||
|
|
fileName.Contains(creationTime.AddDays(-1).ToString("yyyyMMdd")) || fileName.Contains(creationTime.AddDays(-1).ToString("yyyy-MM-dd")) ||
|
|
fileName.Contains(lastWriteTime.AddDays(-1).ToString("yyMMdd")) || fileName.Contains(lastWriteTime.AddDays(-1).ToString("yy-MM-dd")) ||
|
|
fileName.Contains(creationTime.AddDays(-1).ToString("yyMMdd")) || fileName.Contains(creationTime.AddDays(-1).ToString("yy-MM-dd")))
|
|
addFile = true;
|
|
if (!addFile && fileName.Length > ticksLength)
|
|
{
|
|
MatchCollection matches = regex.Matches(fileName);
|
|
foreach (Match match in matches)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
if (match.Value.Length != ticksLength)
|
|
continue;
|
|
if (!long.TryParse(match.Value, out long ticks))
|
|
continue;
|
|
addFile = true;
|
|
break;
|
|
}
|
|
if (addFile)
|
|
break;
|
|
}
|
|
if (addFile)
|
|
{
|
|
weekOfYear = calendar.GetWeekOfYear(lastWriteTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
|
|
if (string.IsNullOrEmpty(dayFormat))
|
|
key = string.Concat(lastWriteTime.ToString("yyyy"), "_Week_", weekOfYear);
|
|
else
|
|
key = string.Concat(lastWriteTime.ToString("yyyy"), "_Week_", weekOfYear, "_", lastWriteTime.ToString(dayFormat));
|
|
if (key == skipKey)
|
|
continue;
|
|
if (!keyValuePairs.ContainsKey(key))
|
|
keyValuePairs.Add(key, new List<string>());
|
|
keyValuePairs[key].Add(subFile);
|
|
}
|
|
}
|
|
foreach (KeyValuePair<string, List<string>> element in keyValuePairs)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
key = string.Concat(topDirectory, @"\", element.Key, ".zip");
|
|
if (File.Exists(key))
|
|
{
|
|
for (short i = 101; i < short.MaxValue; i++)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
key = string.Concat(topDirectory, @"\", element.Key, "_", i, ".zip");
|
|
if (!File.Exists(key))
|
|
break;
|
|
}
|
|
}
|
|
if (_Stop)
|
|
break;
|
|
lock (_Lock)
|
|
{
|
|
using ZipArchive zip = ZipFile.Open(key, ZipArchiveMode.Create);
|
|
foreach (string file in element.Value)
|
|
{
|
|
_ = zip.CreateEntryFromFile(file, Path.GetFileName(file));
|
|
File.Delete(file);
|
|
}
|
|
}
|
|
}
|
|
subFiles = Directory.GetFiles(topDirectory, "*.zip", SearchOption.TopDirectoryOnly);
|
|
foreach (string subFile in subFiles)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
fileName = Path.GetFileNameWithoutExtension(subFile);
|
|
segments = fileName.Split('_');
|
|
if (segments.Length > 2)
|
|
fileName = string.Concat(segments[0], '_', segments[1], '_', segments[2]);
|
|
if (weeks.ContainsKey(fileName))
|
|
{
|
|
try
|
|
{ File.SetLastWriteTime(subFile, weeks[fileName]); }
|
|
catch (Exception) { }
|
|
}
|
|
}
|
|
if (topDirectory != sourceDirectory)
|
|
try
|
|
{ DeleteEmptyDirectories(topDirectory); }
|
|
catch (Exception) { }
|
|
//Print(topDirectory);
|
|
}
|
|
}
|
|
|
|
private void LogPathCleanUpByWeek(string server, bool isEDA = false, bool isNA = false)
|
|
{
|
|
if (isEDA && isNA)
|
|
throw new Exception();
|
|
else if (!isEDA && !isNA)
|
|
throw new Exception();
|
|
string share;
|
|
Tuple<string, string>[] tuples;
|
|
if (isEDA)
|
|
{
|
|
share = string.Concat(@"\\", server, @"\ec_eda");
|
|
tuples = new Tuple<string, string>[]
|
|
{
|
|
new Tuple<string, string>(@"\Staging\Traces\MET08ANLYSDIFAAST230\LogFile", string.Empty),
|
|
//new Tuple<string, string>(@"\Staging\Traces\DEP08EGANAIXG5HT\R69-HSMS\LogFile", "yyyy_MM_dd"),
|
|
//new Tuple<string, string>(@"\Staging\Traces\DEP08EGANAIXG5\LogFile\R69-HSMS", "yyyy_MM_dd"),
|
|
//new Tuple<string, string>(@"\Staging\Traces\DEP08EGANAIXG5HT\R71-HSMS\LogFile", "yyyy_MM_dd"),
|
|
//new Tuple<string, string>(@"\Staging\Traces\DEP08EGANAIXG5\LogFile\R71-HSMS", "yyyy_MM_dd"),
|
|
new Tuple<string, string>(@"\Staging\Traces\MET08XRDXPERTPROMRDXL_Monthly\LogFile", string.Empty),
|
|
new Tuple<string, string>(@"\Staging\Traces\MET08XRDXPERTPROMRDXL_Weekly\LogFile", string.Empty),
|
|
new Tuple<string, string>(@"\Staging\Traces\MET08DDINCAN8620_Daily\LogFile", string.Empty),
|
|
new Tuple<string, string>(@"\Staging\Traces\MET08PRFUSB4000\LogFile", string.Empty),
|
|
};
|
|
}
|
|
else if (isNA)
|
|
throw new Exception();
|
|
else
|
|
throw new Exception();
|
|
string[] files;
|
|
string weekOfYear;
|
|
FileInfo fileInfo;
|
|
string newDirectroy;
|
|
string sourceDirectory;
|
|
DateTime lastWriteTime;
|
|
string[] topDirectories;
|
|
long twoDays = DateTime.Now.AddDays(-2).Ticks;
|
|
foreach (Tuple<string, string> tuple in tuples)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
sourceDirectory = string.Concat(share, tuple.Item1);
|
|
if (!Directory.Exists(sourceDirectory))
|
|
continue;
|
|
if (isEDA)
|
|
topDirectories = new string[] { sourceDirectory };
|
|
else if (isNA)
|
|
throw new Exception();
|
|
else
|
|
throw new Exception();
|
|
if (topDirectories.Length == 0)
|
|
topDirectories = new string[] { sourceDirectory };
|
|
foreach (string topDirectory in topDirectories)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
files = Directory.GetFiles(topDirectory, "*", SearchOption.TopDirectoryOnly);
|
|
foreach (string file in files)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
if (file.EndsWith(".zip"))
|
|
continue;
|
|
fileInfo = new FileInfo(file);
|
|
lastWriteTime = fileInfo.LastAccessTime;
|
|
if (lastWriteTime.Ticks > twoDays)
|
|
continue;
|
|
weekOfYear = _Calendar.GetWeekOfYear(lastWriteTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
|
|
newDirectroy = string.Concat(topDirectory, @"\", lastWriteTime.ToString("yyyy"), "___Week_", weekOfYear, @"\", lastWriteTime.ToString("yyyy_MM_dd"));
|
|
if (!Directory.Exists(newDirectroy))
|
|
_ = Directory.CreateDirectory(newDirectroy);
|
|
if (!fileInfo.Exists)
|
|
continue;
|
|
if (!_Stop)
|
|
{
|
|
lock (_Lock)
|
|
File.Move(file, string.Concat(newDirectroy, @"\", Path.GetFileName(file)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
foreach (Tuple<string, string> tuple in tuples)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
sourceDirectory = string.Concat(share, tuple.Item1);
|
|
if (!Directory.Exists(sourceDirectory))
|
|
continue;
|
|
ZipFilesByDate(sourceDirectory, SearchOption.AllDirectories, tuple.Item2);
|
|
}
|
|
}
|
|
|
|
void EDAOutputArchive(string sourceDirectory)
|
|
{
|
|
string key;
|
|
string[] files;
|
|
string[] cellIntaces;
|
|
string fileWeekOfYear;
|
|
DateTime fileDateTime;
|
|
string checkDirectory;
|
|
string cellInstancesName;
|
|
string emptyFilesDirectory;
|
|
int today = DateTime.Now.Day;
|
|
string recipeArchiveDirectory;
|
|
Dictionary<string, List<string>> keyValuePairs = new();
|
|
string[] equipmentTypes = Directory.GetDirectories(sourceDirectory, "*", SearchOption.TopDirectoryOnly);
|
|
foreach (string equipmentType in equipmentTypes)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
if (equipmentType.EndsWith(@"\_ Copy") || equipmentType.EndsWith(@"\_ Empty") || equipmentType.EndsWith(@"\CellInstance") || equipmentType.EndsWith(@"\IQS") || equipmentType.EndsWith(@"\Villach"))
|
|
continue;
|
|
checkDirectory = string.Concat(equipmentType, @"\Ignore\Recipe");
|
|
if (!Directory.Exists(checkDirectory))
|
|
_ = Directory.CreateDirectory(checkDirectory);
|
|
cellIntaces = Directory.GetDirectories(checkDirectory, "*", SearchOption.TopDirectoryOnly);
|
|
foreach (string cellIntace in cellIntaces)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
keyValuePairs.Clear();
|
|
cellInstancesName = Path.GetFileName(cellIntace);
|
|
recipeArchiveDirectory = string.Concat(equipmentType, @"\Ignore\!Archive\Recipe\", cellInstancesName);
|
|
if (!Directory.Exists(recipeArchiveDirectory))
|
|
_ = Directory.CreateDirectory(recipeArchiveDirectory);
|
|
emptyFilesDirectory = string.Concat(equipmentType, @"\Ignore\!Archive\EmptyFiles\", cellInstancesName);
|
|
if (!Directory.Exists(emptyFilesDirectory))
|
|
_ = Directory.CreateDirectory(emptyFilesDirectory);
|
|
files = Directory.GetFiles(cellIntace, "*", SearchOption.TopDirectoryOnly);
|
|
foreach (string file in files)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
fileDateTime = new FileInfo(file).LastWriteTime;
|
|
if (fileDateTime.Day != today)
|
|
{
|
|
fileWeekOfYear = _Calendar.GetWeekOfYear(fileDateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
|
|
key = string.Concat(fileDateTime.ToString("yyyy-MM-dd"), "_Week_", fileWeekOfYear);
|
|
if (!keyValuePairs.ContainsKey(key))
|
|
keyValuePairs.Add(key, new List<string>());
|
|
keyValuePairs[key].Add(file);
|
|
}
|
|
}
|
|
foreach (KeyValuePair<string, List<string>> element in keyValuePairs)
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
lock (_Lock)
|
|
{
|
|
key = string.Concat(recipeArchiveDirectory, @"\", element.Key.Split('-')[0]);
|
|
if (!Directory.Exists(key))
|
|
_ = Directory.CreateDirectory(key);
|
|
key = string.Concat(recipeArchiveDirectory, @"\", element.Key.Split('-')[0], @"\", element.Key, ".zip");
|
|
if (File.Exists(key))
|
|
{
|
|
for (short i = 101; i < short.MaxValue; i++)
|
|
{
|
|
key = string.Concat(recipeArchiveDirectory, @"\", element.Key.Split('-')[0], @"\", element.Key, "_", i, ".zip");
|
|
if (!File.Exists(key))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!string.IsNullOrEmpty(key))
|
|
{
|
|
if (_Stop)
|
|
break;
|
|
lock (_Lock)
|
|
{
|
|
using ZipArchive zip = ZipFile.Open(key, ZipArchiveMode.Create);
|
|
foreach (string file in element.Value)
|
|
{
|
|
_ = zip.CreateEntryFromFile(file, Path.GetFileName(file));
|
|
File.Delete(file);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private Stream ToStream(string @this)
|
|
{
|
|
MemoryStream? stream = new();
|
|
StreamWriter? writer = new(stream);
|
|
writer.Write(@this);
|
|
writer.Flush();
|
|
stream.Position = 0;
|
|
return stream;
|
|
}
|
|
|
|
private T? ParseXML<T>(string @this, bool throwExceptions) where T : class
|
|
{
|
|
object? result = null;
|
|
try
|
|
{
|
|
Stream stream = ToStream(@this.Trim());
|
|
XmlReader? reader = XmlReader.Create(stream, new XmlReaderSettings() { ConformanceLevel = ConformanceLevel.Document });
|
|
XmlSerializer xmlSerializer = new(typeof(T), typeof(T).GetNestedTypes());
|
|
result = xmlSerializer.Deserialize(reader);
|
|
stream.Dispose();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
if (throwExceptions)
|
|
throw;
|
|
}
|
|
return result as T;
|
|
}
|
|
|
|
private void DataCollectionPlans(AppSettings appSettings, string edaDataCollectionPlansLastRun, string cSharpFormat, string oracleFormat)
|
|
{
|
|
object _Lock = new();
|
|
bool _ShuttingDown = false;
|
|
bool dev = appSettings.Server.Contains("_ec_");
|
|
Dictionary<string, Dictionary<ModuleInstanceTypeName, List<List<object>>>> rows = new();
|
|
//
|
|
//int moduleinstancetypename = 0;
|
|
int unitname = 1;
|
|
//int modulename = 2;
|
|
int containername = 3;
|
|
int configurationstate = 4;
|
|
int configurationproductivestate = 5;
|
|
//int containermodifiername = 6;
|
|
int containermodifieddate = 7;
|
|
int containerconfiguration = 8;
|
|
int configurationmodifieddate = 9;
|
|
string objectTypeDirectory;
|
|
string workingDirectory = string.Concat(@"\\", appSettings.Server, @"\EC_EDA");
|
|
// ()
|
|
{
|
|
object @object;
|
|
string? @string;
|
|
int fieldCount;
|
|
List<object> row;
|
|
string decrypted;
|
|
string connectionName;
|
|
string connectionString;
|
|
StringBuilder sql = new();
|
|
Array objectTypes = Enum.GetValues(typeof(ModuleInstanceTypeName));
|
|
List<Tuple<string, string>> connections = new();
|
|
if (dev)
|
|
{
|
|
connectionName = @"DEV";
|
|
connectionString = Helper.Background.EDADatabase.GetEdaDevelopment();
|
|
decrypted = RijndaelEncryption.Decrypt(appSettings.IFXEDADatabasePassword, appSettings.Company);
|
|
connectionString = string.Concat(connectionString, decrypted, ";");
|
|
connections.Add(new Tuple<string, string>(connectionName, connectionString));
|
|
}
|
|
else
|
|
{
|
|
connectionName = "Staging";
|
|
connectionString = Helper.Background.EDADatabase.GetEdaStaging();
|
|
decrypted = RijndaelEncryption.Decrypt(appSettings.ECEDADatabasePassword, appSettings.Company);
|
|
connectionString = string.Concat(connectionString, decrypted, ";");
|
|
connections.Add(new Tuple<string, string>(connectionName, connectionString));
|
|
connectionName = "Production";
|
|
connectionString = Helper.Background.EDADatabase.GetEdaProduction();
|
|
connectionString = string.Concat(connectionString, decrypted, ";");
|
|
connections.Add(new Tuple<string, string>(connectionName, connectionString));
|
|
}
|
|
foreach (Tuple<string, string> connection in connections)
|
|
{
|
|
if (_ShuttingDown)
|
|
break;
|
|
rows.Add(connection.Item1, new Dictionary<ModuleInstanceTypeName, List<List<object>>>());
|
|
foreach (ModuleInstanceTypeName objectType in objectTypes)
|
|
{
|
|
if (_ShuttingDown)
|
|
break;
|
|
if (string.IsNullOrEmpty(edaDataCollectionPlansLastRun))
|
|
{
|
|
objectTypeDirectory = string.Concat(workingDirectory, @"\", connection.Item1, @"\", objectType);
|
|
if (!Directory.Exists(objectTypeDirectory))
|
|
_ = Directory.CreateDirectory(objectTypeDirectory);
|
|
else
|
|
edaDataCollectionPlansLastRun = new DirectoryInfo(objectTypeDirectory).LastWriteTime.ToString(cSharpFormat);
|
|
}
|
|
if (!rows[connection.Item1].ContainsKey(objectType))
|
|
rows[connection.Item1].Add(objectType, new List<List<object>>());
|
|
using (Oracle.ManagedDataAccess.Client.OracleConnection oracleConnection = new(connection.Item2))
|
|
{
|
|
_ = sql.Clear();
|
|
oracleConnection.Open();
|
|
_ = sql.Append(" select v.moduleinstancetypename, v.unitname, ").
|
|
Append(" v.modulename, v.containername, v.configurationstate, ").
|
|
Append(" v.configurationproductivestate, v.containermodifiername, ").
|
|
Append(" v.containermodifieddate, v.containerconfiguration, v.configurationmodifieddate ").
|
|
Append(" from veditconfiguration v ").
|
|
Append(" where v.moduleinstancetypename = '").Append(objectType.ToString()).Append("' ");
|
|
//Append(" and v.containerversion in ('4.80', '4.111') ");
|
|
if (!string.IsNullOrEmpty(edaDataCollectionPlansLastRun))
|
|
_ = sql.Append(" and greatest(v.containermodifieddate, v.configurationmodifieddate) >= to_date('").Append(edaDataCollectionPlansLastRun).Append("', '").Append(oracleFormat).Append("') ");
|
|
//Print(sql.ToString());
|
|
using Oracle.ManagedDataAccess.Client.OracleCommand oracleCommand = new(sql.ToString(), oracleConnection);
|
|
using Oracle.ManagedDataAccess.Client.OracleDataReader oracleDataReader = oracleCommand.ExecuteReader();
|
|
fieldCount = oracleDataReader.FieldCount;
|
|
while (oracleDataReader.Read())
|
|
{
|
|
if (_ShuttingDown)
|
|
break;
|
|
row = new List<object>();
|
|
for (int c = 0; c < fieldCount; c++)
|
|
{
|
|
@object = oracleDataReader.GetValue(c);
|
|
row.Add(@object);
|
|
if (@object is null)
|
|
continue;
|
|
@string = @object.ToString();
|
|
//if (@string.Length < 128)
|
|
// _Log.Debug(@string);
|
|
}
|
|
rows[connection.Item1][objectType].Add(row);
|
|
}
|
|
};
|
|
}
|
|
}
|
|
}
|
|
if (rows.Any())
|
|
{
|
|
string csv;
|
|
string? xml;
|
|
string json;
|
|
string text;
|
|
string html;
|
|
Common common;
|
|
string emptyAPC;
|
|
string fileName;
|
|
string? modifiedDate;
|
|
string edaObjectFile;
|
|
string goldDirectory;
|
|
string unitDirectory;
|
|
string replace = "$$$";
|
|
string edaObjectDirectory;
|
|
DateTime lastModifiedDate;
|
|
DateTime containerModifiedDate;
|
|
PDSFConfiguration? configuration;
|
|
DateTime configurationModifiedDate;
|
|
JsonSerializerOptions jsonSerializerOptions = new() { WriteIndented = true };
|
|
foreach (KeyValuePair<string, Dictionary<ModuleInstanceTypeName, List<List<object>>>> databaseElement in rows)
|
|
{
|
|
if (_ShuttingDown)
|
|
break;
|
|
emptyAPC = string.Concat(workingDirectory, @"\", databaseElement.Key, @"\EmptyAPC.xlsx");
|
|
foreach (KeyValuePair<ModuleInstanceTypeName, List<List<object>>> tableNameElement in databaseElement.Value)
|
|
{
|
|
if (_ShuttingDown)
|
|
break;
|
|
objectTypeDirectory = string.Concat(workingDirectory, @"\", databaseElement.Key, @"\", tableNameElement.Key);
|
|
foreach (List<object> rowItem in tableNameElement.Value)
|
|
{
|
|
if (_ShuttingDown)
|
|
break;
|
|
//foreach (var item in rowItem)
|
|
// Print(item.ToString());
|
|
//if (!rowItem[containername].ToString().Contains("Plan_Pdsf_Health_Cp2Mg"))
|
|
//if (!rowItem[unitname].ToString().Contains("XRD04") || !rowItem[containername].ToString().Contains("Plan_Pdsf"))
|
|
// continue;
|
|
modifiedDate = rowItem[containermodifieddate].ToString();
|
|
if (string.IsNullOrEmpty(modifiedDate))
|
|
continue;
|
|
containerModifiedDate = DateTime.Parse(modifiedDate);
|
|
modifiedDate = rowItem[configurationmodifieddate].ToString();
|
|
if (string.IsNullOrEmpty(modifiedDate))
|
|
continue;
|
|
configurationModifiedDate = DateTime.Parse(modifiedDate);
|
|
if (containerModifiedDate < configurationModifiedDate)
|
|
lastModifiedDate = configurationModifiedDate;
|
|
else
|
|
lastModifiedDate = containerModifiedDate;
|
|
goldDirectory = string.Concat(objectTypeDirectory, @"\", rowItem[unitname], @"\", rowItem[containername], @"\Gold");
|
|
if (!Directory.Exists(goldDirectory))
|
|
_ = Directory.CreateDirectory(goldDirectory);
|
|
edaObjectDirectory = string.Concat(objectTypeDirectory, @"\", rowItem[unitname], @"\", rowItem[containername], @"\", rowItem[configurationstate], @"\", rowItem[configurationproductivestate], @"\", lastModifiedDate.ToString("yyyy-MM-dd_"), new TimeSpan(lastModifiedDate.Ticks - new DateTime(lastModifiedDate.Year, lastModifiedDate.Month, lastModifiedDate.Day).Ticks).TotalSeconds);
|
|
if (!Directory.Exists(edaObjectDirectory))
|
|
_ = Directory.CreateDirectory(edaObjectDirectory);
|
|
edaObjectFile = string.Concat(edaObjectDirectory, @"\", rowItem[unitname], " ", rowItem[containername], " - ", replace, " - ", rowItem[configurationstate].ToString(), " ", rowItem[configurationproductivestate].ToString());
|
|
xml = rowItem[containerconfiguration].ToString();
|
|
if (string.IsNullOrEmpty(xml))
|
|
continue;
|
|
//continue;
|
|
lock (_Lock)
|
|
{
|
|
fileName = string.Concat(edaObjectFile.Replace(replace, "Raw"), ".xml");
|
|
File.WriteAllText(fileName, xml);
|
|
try
|
|
{ File.SetCreationTime(fileName, lastModifiedDate); File.SetLastWriteTime(fileName, lastModifiedDate); }
|
|
catch (Exception) { }
|
|
common = new Common(ModuleInstanceTypeName.Pdsf, rowItem[unitname], rowItem[containername], rowItem[configurationstate], rowItem[configurationproductivestate]);
|
|
configuration = ParseXML<PDSFConfiguration>(xml, throwExceptions: true);
|
|
if (configuration is null)
|
|
continue;
|
|
if (!Directory.Exists(Path.GetPathRoot(configuration.Settings.StoragePath)))
|
|
continue;
|
|
else
|
|
{
|
|
common.Update(configuration);
|
|
json = JsonSerializer.Serialize(configuration, configuration.GetType(), jsonSerializerOptions);
|
|
if (!Directory.Exists(common.StoragePath))
|
|
_ = Directory.CreateDirectory(common.StoragePath);
|
|
if (common?.UnitName is null)
|
|
continue;
|
|
if (!common.StoragePath.Contains(common.UnitName) && (common.StoragePath.Contains(@"01EquipmentIntegration") || common.StoragePath.Contains(@"02BusinessIntegration")))
|
|
{
|
|
common.StoragePath = common.StoragePath.Replace("Traces", "Empty");
|
|
if (!Directory.Exists(common.StoragePath))
|
|
_ = Directory.CreateDirectory(common.StoragePath);
|
|
if (common.UnitName != "PRF01")
|
|
{
|
|
unitDirectory = string.Concat(Path.GetDirectoryName(common.StoragePath), @"\", common.UnitName);
|
|
common.StoragePath = string.Concat(unitDirectory, @"\BadPath");
|
|
if (!Directory.Exists(common.StoragePath))
|
|
_ = Directory.CreateDirectory(common.StoragePath);
|
|
common.StoragePath = string.Concat(unitDirectory, @"\LogFile");
|
|
if (!Directory.Exists(common.StoragePath))
|
|
_ = Directory.CreateDirectory(common.StoragePath);
|
|
common.StoragePath = string.Concat(unitDirectory, @"\PollPath");
|
|
if (!Directory.Exists(common.StoragePath))
|
|
_ = Directory.CreateDirectory(common.StoragePath);
|
|
}
|
|
}
|
|
fileName = string.Concat(edaObjectFile.Replace(replace, "Partial"), ".csv");
|
|
File.WriteAllText(fileName, common.ParametersAsCsv);
|
|
try
|
|
{ File.SetCreationTime(fileName, lastModifiedDate); File.SetLastWriteTime(fileName, lastModifiedDate); }
|
|
catch (Exception) { }
|
|
fileName = string.Concat(edaObjectFile.Replace(replace, "Partial"), ".json");
|
|
File.WriteAllText(fileName, json);
|
|
text = Helper.Background.EdaDCP.GetText(edaObjectFile, common, json);
|
|
fileName = string.Concat(edaObjectFile.Replace(replace, "Partial"), ".txt");
|
|
File.WriteAllText(fileName, text);
|
|
try
|
|
{ File.SetCreationTime(fileName, lastModifiedDate); File.SetLastWriteTime(fileName, lastModifiedDate); }
|
|
catch (Exception) { }
|
|
html = Helper.Background.EdaDCP.GetEdaObjectToHtml(edaObjectFile, common);
|
|
fileName = string.Concat(edaObjectFile.Replace(replace, "Partial"), ".html");
|
|
File.WriteAllText(fileName, html);
|
|
try
|
|
{ File.SetCreationTime(fileName, lastModifiedDate); File.SetLastWriteTime(fileName, lastModifiedDate); }
|
|
catch (Exception) { }
|
|
xml = Helper.Background.EdaDCP.GetEdaObjectToDMSGridFormat(edaObjectFile, common, useAlias: false);
|
|
fileName = string.Concat(edaObjectFile.Replace(replace, "DMSGridFormat"), ".xml");
|
|
File.WriteAllText(fileName, xml);
|
|
try
|
|
{ File.SetCreationTime(fileName, lastModifiedDate); File.SetLastWriteTime(fileName, lastModifiedDate); }
|
|
catch (Exception) { }
|
|
xml = Helper.Background.EdaDCP.GetEdaObjectToDMSGridFormat(edaObjectFile, common, useAlias: true);
|
|
fileName = string.Concat(edaObjectFile.Replace(replace, "DMSGridFormat - Alias"), ".xml");
|
|
File.WriteAllText(fileName, xml);
|
|
try
|
|
{ File.SetCreationTime(fileName, lastModifiedDate); File.SetLastWriteTime(fileName, lastModifiedDate); }
|
|
catch (Exception) { }
|
|
csv = Helper.Background.EdaDCP.GetEdaObjectToAPCParameter(edaObjectFile, common);
|
|
fileName = string.Concat(edaObjectFile.Replace(replace, "APCParameter"), ".csv");
|
|
File.WriteAllText(fileName, csv);
|
|
try
|
|
{ File.SetCreationTime(fileName, lastModifiedDate); File.SetLastWriteTime(fileName, lastModifiedDate); }
|
|
catch (Exception) { }
|
|
csv = Helper.Background.EdaDCP.GetEdaObjectToAPCRunKeyNumber(edaObjectFile, common);
|
|
fileName = string.Concat(edaObjectFile.Replace(replace, "APCRunKeyNumber"), ".csv");
|
|
File.WriteAllText(fileName, csv);
|
|
try
|
|
{ File.SetCreationTime(fileName, lastModifiedDate); File.SetLastWriteTime(fileName, lastModifiedDate); }
|
|
catch (Exception) { }
|
|
fileName = string.Concat(edaObjectFile.Replace(replace, "APC"), ".xlsx");
|
|
if (File.Exists(emptyAPC) && !File.Exists(fileName))
|
|
{
|
|
File.Copy(emptyAPC, fileName);
|
|
try
|
|
{ File.SetCreationTime(fileName, lastModifiedDate); File.SetLastWriteTime(fileName, lastModifiedDate); }
|
|
catch (Exception) { }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
try
|
|
{ Directory.SetLastWriteTime(objectTypeDirectory, DateTime.Now); }
|
|
catch (Exception) { }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} |