disk-info-helper

selenium-helper (Not fully tested)

sync-helper (Not fully tested)

.gitignore

@@ -332,3 +332,5 @@ ASALocalRun/
 *.pcl
 *.pdf
 *.raw
+
+.vscode/.UserSecrets/secrets.json

.vscode/.http

@@ -0,0 +1,23 @@
+
+###
+
+GET https://eaf-dev.mes.infineon.com/bob/v1/sync/
+
+###
+
+POST https://eaf-dev.mes.infineon.com/bob/v1/sync/
+Accept: application/json
+
+{
+    "id": "110738",
+    "machineId": "30ef1b54e075c5370ce74eea2042cb750be659696b170f8758d219a8f9a88e10",
+    "page": "time",
+    "site": "MES",
+    "time": "1744339499677",
+    "username": "phares",
+    "value": "3"
+}
+
+###
+
+https://eaf-dev.mes.infineon.com/api/v1/ado/

.vscode/mklink.md

@@ -0,0 +1,5 @@
+# mklink
+
+```bash Wed Jul 24 2024 08:28:01 GMT-0700 (Mountain Standard Time)
+mklink /J "L:\DevOps\Mesa_FI\File-Watcher\.vscode\.UserSecrets" "C:\Users\phares\AppData\Roaming\Microsoft\UserSecrets\6062c774-99a9-4f4a-b42d-a9cb7fcbd8be"
+```

.vscode/settings.json

@@ -12,21 +12,33 @@
   "cSpell.words": [
     "ASPNETCORE",
     "BIRT",
+    "Camstar",
     "CHIL",
     "DEAT",
+    "DEVICEHEIGHTPOINTS",
+    "DEVICEWIDTHPOINTS",
     "endianness",
+    "Exif",
     "FAMC",
     "FAMS",
+    "FIXEDMEDIA",
     "GIVN",
+    "gpcl",
+    "Hmmssfff",
     "HUSB",
     "INDI",
     "Infineon",
     "Kanban",
     "kanbn",
     "Kofax",
+    "linc",
+    "Linc",
+    "NOPAUSE",
     "NSFX",
     "OBJE",
     "onenote",
+    "PDFC",
+    "pdfwrite",
     "PDSF",
     "pged",
     "Phares",

.vscode/tasks.json

@@ -22,7 +22,7 @@
                 "-p",
                 "${workspaceFolder}/File-Watcher.csproj",
                 "set",
-                "asdf",
+                "_UserSecretsId",
                 "6516d19d6569"
             ],
             "problemMatcher": "$msCompile"
@@ -54,6 +54,16 @@
             ],
             "problemMatcher": "$msCompile"
         },
+        {
+            "label": "Format-Whitespaces",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "format",
+                "whitespace"
+            ],
+            "problemMatcher": "$msCompile"
+        },
         {
             "label": "Publish AOT",
             "command": "dotnet",
@@ -72,15 +82,17 @@
             "problemMatcher": "$msCompile"
         },
         {
-            "label": "File-Folder-Helper AOT s V Helpers",
+            "label": "File-Folder-Helper AOT s X Day-Helper-2025-03-20",
             "type": "shell",
-            "command": "L:/DevOps/Mesa_FI/File-Folder-Helper/bin/Release/net8.0/win-x64/publish/File-Folder-Helper.exe s V Helpers",
+            "command": "L:/DevOps/Mesa_FI/File-Folder-Helper/bin/Release/net8.0/win-x64/publish/File-Folder-Helper.exe",
-            "problemMatcher": []
+            "args": [
-        },
+                "s",
-        {
+                "X",
-            "label": "File-Folder-Helper AOT s X Sort",
+                "L:/DevOps/Mesa_FI/File-Watcher",
-            "type": "shell",
+                "Day-Helper-2025-03-20",
-            "command": "L:/DevOps/Mesa_FI/File-Folder-Helper/bin/Release/net8.0/win-x64/publish/File-Folder-Helper.exe s X 'L:/DevOps/Mesa_FI/File-Watcher' Day-Helper-2024-01-08 'L:/DevOps/Mesa_FI/File-Watcher/Helpers'",
+                "false",
+                "4"
+            ],
             "problemMatcher": []
         }
     ]

File-Watcher.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Worker">
+<Project Sdk="Microsoft.NET.Sdk.Worker">
   <PropertyGroup>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
@@ -10,34 +10,28 @@
     <UserSecretsId>6062c774-99a9-4f4a-b42d-a9cb7fcbd8be</UserSecretsId>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Server" Version="8.0.4" />
+    <PackageReference Include="CliWrap" Version="3.8.2" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="8.0.0" />
+    <PackageReference Include="DiscUtils.Iso9660" Version="0.16.13" />
-    <PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" Version="8.0.0" />
+    <PackageReference Include="Nancy.Owin" Version="2.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Owin" Version="4.2.2" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Owin.Cors" Version="4.2.2" />
-    <PackageReference Include="Oracle.ManagedDataAccess.Core" Version="3.21.140" />
+    <PackageReference Include="Microsoft.Owin.Hosting" Version="4.2.2" />
-    <PackageReference Include="runtime.win-x64.Microsoft.DotNet.ILCompiler" Version="8.0.4" />
+    <PackageReference Include="Microsoft.Owin.Host.HttpListener" Version="4.2.2" />
+    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Server" Version="8.0.16" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Logging.EventLog" Version="8.0.1" />
+    <PackageReference Include="Oracle.ManagedDataAccess.Core" Version="23.7.0" />
+    <PackageReference Include="runtime.win-x64.Microsoft.DotNet.ILCompiler" Version="8.0.16" />
+    <PackageReference Include="ShellProgressBar" Version="5.2.0" />
+    <PackageReference Include="System.Data.SqlClient" Version="4.8.6" />
+    <PackageReference Include="System.Drawing.Common" Version="8.0.16" />
     <PackageReference Include="System.IO.Ports" Version="8.0.0" />
-    <PackageReference Include="System.Text.Json" Version="8.0.3" />
+    <PackageReference Include="System.Text.Json" Version="9.0.5" />
-  </ItemGroup>
+    <PackageReference Include="Phares.AA.Shared" Version="8.0.114.12235" />
-  <ItemGroup>
+    <PackageReference Include="Phares.AA.Metadata" Version="8.0.114.12235" />
-      <None Condition="'$(Configuration)' == 'Debug'" Include="\\mestsa003.infineon.com\EC_EAFRepository\Staging\DeploymentStorage\GhostPCL\gpcl6win64\gpcl6dll64.dll">
-          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      </None>
-      <None Condition="'$(Configuration)' == 'Debug'" Include="\\mestsa003.infineon.com\EC_EAFRepository\Staging\DeploymentStorage\GhostPCL\gpcl6win64\gpcl6win64.exe">
-          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      </None>
-      <None Condition="'$(Configuration)' == 'Debug'" Include="\\mestsa003.infineon.com\EC_EAFRepository\Staging\DeploymentStorage\LincPDFC\v2.6.6.21\LincPDFC.exe">
-          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      </None>
-      <None Condition="'$(Configuration)' == 'Release'" Include="\\mesfs.infineon.com\EC_EAFRepository\Staging\DeploymentStorage\GhostPCL\gpcl6win64\gpcl6dll64.dll">
-          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      </None>
-      <None Condition="'$(Configuration)' == 'Release'" Include="\\mesfs.infineon.com\EC_EAFRepository\Staging\DeploymentStorage\GhostPCL\gpcl6win64\gpcl6win64.exe">
-          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      </None>
-      <None Condition="'$(Configuration)' == 'Release'" Include="\\mesfs.infineon.com\EC_EAFRepository\Staging\DeploymentStorage\LincPDFC\v2.6.6.21\LincPDFC.exe">
-          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      </None>
   </ItemGroup>
 </Project>

File-Watcher.yaml

@@ -0,0 +1,45 @@
+trigger:
+  branches:
+    include:
+      - main
+pool:
+  name: eaf
+  demands: eaf-ems-pc
+variables:
+  buildConfiguration: "Release"
+  ASPNETCORE_ENVIRONMENT: "Production"
+jobs:
+  - job: BuildTestPublish
+    steps:
+      - script: |
+          echo repo: $(Build.Repository.Name)
+          echo buildId: $(Build.BuildId)
+          echo build configuration: $(BuildConfiguration)
+        displayName: "Echo Check"
+
+      - task: DotNetCoreCLI@2
+        displayName: "dotnet build"
+        inputs:
+          command: "build"
+          configuration: $(BuildConfiguration)
+
+      - task: DotNetCoreCLI@2
+        displayName: "dotnet test"
+        inputs:
+          command: "test"
+          arguments: "-c $(BuildConfiguration)"
+          publishTestResults: true
+          projects: MesaProveInTests
+
+      - task: DotNetCoreCLI@2
+        displayName: "dotnet publish"
+        inputs:
+          command: "publish"
+          publishWebProjects: true
+          arguments: "-c $(BuildConfiguration) -o $(Build.ArtifactStagingDirectory) -r win-x64 /p:EnvironmentName=$(ASPNETCORE_ENVIRONMENT)"
+
+      - task: CopyFiles@2
+        displayName: "Copy Files"
+        inputs:
+          SourceFolder: "$(Build.ArtifactStagingDirectory)"
+          TargetFolder: 'D:\$(Build.Repository.Name)\$(Build.BuildId)\$(BuildConfiguration)'

Helpers/DeterministicHashCodeHelper.cs

@@ -0,0 +1,363 @@
+using CliWrap;
+using File_Watcher.Models;
+using ShellProgressBar;
+using System.Collections.ObjectModel;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO.Compression;
+using System.Runtime.InteropServices;
+using System.Text.Json;
+using View_by_Distance.Metadata.Models;
+using View_by_Distance.Metadata.Models.Stateless;
+using View_by_Distance.Shared.Models;
+using View_by_Distance.Shared.Models.Stateless;
+
+namespace File_Watcher.Helpers;
+
+internal static partial class DeterministicHashCodeHelper
+{
+
+    private class Windows : IWindows, IDisposable
+    {
+
+        private ProgressBar? _ProgressBar;
+        private readonly ProgressBarOptions _ProgressBarOptions;
+
+        public int CurrentTick { get; internal set; }
+
+        public Windows() =>
+            _ProgressBarOptions = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
+
+        DeterministicHashCode IWindows.GetDeterministicHashCode(HttpClient httpClient, Uri uri) =>
+            GetDeterministicHashCode(httpClient, uri);
+
+        DeterministicHashCode IWindows.GetDeterministicHashCode(HttpClient? httpClient, FilePath filePath)
+        {
+            DeterministicHashCode result;
+            if (httpClient is not null)
+                result = GetDeterministicHashCode(httpClient, new Uri(filePath.FullName));
+            else
+            {
+                Stream stream = File.OpenRead(filePath.FullName);
+                result = GetDeterministicHashCode(stream);
+                stream.Dispose();
+            }
+            return result;
+        }
+
+        private static DeterministicHashCode GetDeterministicHashCode(HttpClient httpClient, Uri uri)
+        {
+            DeterministicHashCode result;
+            Stream stream = GetStream(httpClient, uri);
+            result = GetDeterministicHashCode(stream);
+            stream.Dispose();
+            return result;
+        }
+
+        private static Stream GetStream(HttpClient httpClient, Uri uri)
+        {
+            Stream result;
+            Task<Stream> task = httpClient.GetStreamAsync(uri);
+            task.Wait();
+            result = task.Result;
+            return result;
+        }
+
+        private static DeterministicHashCode GetDeterministicHashCode(Stream stream)
+        {
+            DeterministicHashCode result;
+            int? id;
+            int? width;
+            int? height;
+            try
+            {
+#pragma warning disable CA1416
+                using Image image = Image.FromStream(stream);
+                width = image.Width;
+                height = image.Height;
+                using Bitmap bitmap = new(image);
+                Rectangle rectangle = new(0, 0, image.Width, image.Height);
+                BitmapData bitmapData = bitmap.LockBits(rectangle, ImageLockMode.ReadOnly, bitmap.PixelFormat);
+                IntPtr intPtr = bitmapData.Scan0;
+                int length = bitmapData.Stride * bitmap.Height;
+                byte[] bytes = new byte[length];
+                Marshal.Copy(intPtr, bytes, 0, length);
+                bitmap.UnlockBits(bitmapData);
+#pragma warning restore CA1416
+                id = IId.GetDeterministicHashCode(bytes);
+            }
+            catch (Exception)
+            {
+                id = null;
+                width = null;
+                height = null;
+            }
+            result = new(height, id, width);
+            return result;
+        }
+
+        void IWindows.Tick() =>
+            _ProgressBar?.Tick();
+
+        void IDisposable.Dispose()
+        {
+            _ProgressBar?.Dispose();
+            GC.SuppressFinalize(this);
+        }
+
+        void IWindows.ConstructProgressBar(int maxTicks, string message)
+        {
+            _ProgressBar?.Dispose();
+            _ProgressBar = new(maxTicks, message, _ProgressBarOptions);
+        }
+
+        ReadOnlyCollection<string> IWindows.ConvertAndGetFastForwardMovingPictureExpertsGroupFiles(ResultSettings resultSettings, HttpClient? httpClient, FilePath filePath)
+        {
+            List<string> results = [];
+            bool isValidVideoFormatExtensions = resultSettings.ValidVideoFormatExtensions.Contains(filePath.ExtensionLowered);
+            if (isValidVideoFormatExtensions)
+            {
+                bool check;
+                if (httpClient is not null)
+                    DownloadFile(httpClient, filePath);
+                try
+                {
+                    CommandTask<CommandResult> commandTask = Cli.Wrap("L:/Git/ffmpeg-2024-10-02-git-358fdf3083-full_build/bin/ffmpeg.exe")
+                        .WithArguments(["-i", filePath.FullName, "-vf", "select=eq(n\\,0)", "-q:v", "1", $"{filePath.Name}-%4d.jpg"])
+                        .WithWorkingDirectory(filePath.DirectoryFullPath)
+                        .ExecuteAsync();
+                    commandTask.Task.Wait();
+                    check = true;
+                }
+                catch (Exception)
+                {
+                    check = false;
+                }
+                if (check)
+                {
+                    results.AddRange(Directory.GetFiles(filePath.DirectoryFullPath, $"{filePath.Name}-*.jpg", SearchOption.TopDirectoryOnly));
+                    if (results.Count == 0)
+                        throw new Exception();
+                    File.SetCreationTime(results[0], new(filePath.CreationTicks));
+                    File.SetLastWriteTime(results[0], new(filePath.LastWriteTicks));
+                    Thread.Sleep(100);
+                }
+            }
+            return results.AsReadOnly();
+        }
+
+        private static void DownloadFile(HttpClient httpClient, FilePath filePath)
+        {
+            FileStream fileStream = new(filePath.FullName, FileMode.Truncate);
+            Task<HttpResponseMessage> httpResponseMessage = httpClient.GetAsync(filePath.FullName);
+            httpResponseMessage.Wait();
+            Task task = httpResponseMessage.Result.Content.CopyToAsync(fileStream);
+            task.Wait();
+        }
+
+    }
+
+    internal static bool WindowsWork(AppSettings appSettings, ILogger<Worker>? logger)
+    {
+        string json;
+        string jsonFile;
+        string sourceDirectory;
+        List<string> check = [];
+        string archiveEntryFile;
+        long ticks = DateTime.Now.Ticks;
+        ReadOnlyCollection<FirstPass> collection;
+        string rootDirectory = Path.GetFullPath(appSettings.ResultSettings.RootDirectory);
+        if (!Directory.Exists(rootDirectory))
+            _ = Directory.CreateDirectory(rootDirectory);
+        string[] zipFiles = Directory.GetFiles(rootDirectory, "*.zip", SearchOption.TopDirectoryOnly);
+        if (zipFiles.Length > 0)
+            _ = IPath.DeleteEmptyDirectories(rootDirectory);
+        foreach (string zipFile in zipFiles)
+        {
+            check.Clear();
+            sourceDirectory = zipFile[..^4];
+            jsonFile = $"{sourceDirectory}.json";
+            if (Directory.Exists(sourceDirectory) || File.Exists(jsonFile))
+                continue;
+            _ = Directory.CreateDirectory(sourceDirectory);
+            using ZipArchive zip = ZipFile.Open(zipFile, ZipArchiveMode.Read);
+            foreach (ZipArchiveEntry zipArchiveEntry in zip.Entries)
+            {
+                check.Add(zipArchiveEntry.Name);
+                archiveEntryFile = Path.Combine(sourceDirectory, zipArchiveEntry.Name);
+                zipArchiveEntry.ExtractToFile(archiveEntryFile);
+            }
+            collection = WindowsWork(logger, appSettings, ticks, sourceDirectory);
+            if (check.Count == collection.Count)
+            {
+                json = JsonSerializer.Serialize(collection.ToList(), FirstPassCollectionSourceGenerationContext.Default.ListFirstPass);
+                File.WriteAllText(jsonFile, json);
+            }
+            Directory.Delete(sourceDirectory, recursive: true);
+        }
+        return true;
+    }
+
+    private static ReadOnlyCollection<FirstPass> WindowsWork(ILogger<Worker>? logger, AppSettings appSettings, long ticks, string sourceDirectory)
+    {
+        ReadOnlyCollection<FirstPass> results;
+        Windows windows = new();
+        IWindows windowsInterface = windows;
+        logger?.LogInformation("{Ticks} {RootDirectory}", ticks, sourceDirectory);
+        A_Metadata metadata = new(appSettings.ResultSettings, appSettings.MetadataSettings);
+        int appSettingsMaxDegreeOfParallelism = appSettings.DeterministicHashCodeConfiguration.MaxDegreeOfParallelism;
+        ReadOnlyCollection<string> files = Directory.GetFiles(sourceDirectory, "*", SearchOption.AllDirectories).AsReadOnly();
+        if (files.Count > 0)
+            _ = IPath.DeleteEmptyDirectories(sourceDirectory);
+        int filesCount = appSettingsMaxDegreeOfParallelism == 1 ? files.Count : 123000;
+        windowsInterface.ConstructProgressBar(filesCount, "EnumerateFiles load");
+        if (appSettingsMaxDegreeOfParallelism == 1)
+            results = WindowsSynchronousWork(logger, appSettings, windowsInterface, files, metadata);
+        else
+            results = WindowsAsynchronousWork(appSettings, windows, files, metadata, appSettingsMaxDegreeOfParallelism);
+        return results;
+    }
+
+    private static ReadOnlyCollection<FirstPass> WindowsSynchronousWork(ILogger<Worker>? logger, AppSettings appSettings, IWindows windows, IEnumerable<string> files, A_Metadata metadata)
+    {
+        List<FirstPass> results = [];
+        int index = -1;
+        ReadOnlyDictionary<string, List<FileHolder>> keyValuePairs = IMetadata.GetKeyValuePairs(files);
+        foreach (KeyValuePair<string, List<FileHolder>> keyValuePair in keyValuePairs)
+        {
+            if (keyValuePair.Value.Count > 2)
+                throw new NotSupportedException("Too many sidecar files!");
+            index = WindowsSynchronousWork(logger, appSettings, windows, metadata, results, index, keyValuePair);
+        }
+        return results.AsReadOnly();
+    }
+
+    private static int WindowsSynchronousWork(ILogger<Worker>? logger, AppSettings appSettings, IWindows windows, A_Metadata metadata, List<FirstPass> results, int index, KeyValuePair<string, List<FileHolder>> keyValuePair)
+    {
+        int result = index + 1;
+        windows.Tick();
+        FilePath filePath;
+        FirstPass firstPass;
+        string directoryName;
+        ExifDirectory exifDirectory;
+        HttpClient? httpClient = null;
+        List<FileHolder> sidecarFiles;
+        DeterministicHashCode deterministicHashCode;
+        bool fastForwardMovingPictureExpertsGroupUsed;
+        MinimumYearAndPathCombined minimumYearAndPathCombined;
+        FilePath? fastForwardMovingPictureExpertsGroupFilePath;
+        ReadOnlyCollection<string>? fastForwardMovingPictureExpertsGroupFiles;
+        foreach (FileHolder fileHolder in keyValuePair.Value)
+        {
+            if (appSettings.DeterministicHashCodeConfiguration.SidecarExtensions.Contains(fileHolder.ExtensionLowered))
+                continue;
+            if (appSettings.ResultSettings.IgnoreExtensions.Contains(fileHolder.ExtensionLowered))
+                continue;
+            filePath = FilePath.Get(appSettings.ResultSettings, appSettings.MetadataSettings, fileHolder, result);
+            if (filePath.Id is not null && (filePath.IsIntelligentIdFormat || filePath.SortOrder is not null))
+                continue;
+            if (filePath.Id is not null)
+            {
+                fastForwardMovingPictureExpertsGroupFiles = null;
+                deterministicHashCode = new(null, filePath.Id, null);
+                directoryName = Path.GetFileName(filePath.DirectoryFullPath);
+                if (directoryName.EndsWith(filePath.Id.Value.ToString()))
+                    continue;
+            }
+            else
+            {
+                fastForwardMovingPictureExpertsGroupFiles = windows.ConvertAndGetFastForwardMovingPictureExpertsGroupFiles(appSettings.ResultSettings, httpClient, filePath);
+                fastForwardMovingPictureExpertsGroupFilePath = fastForwardMovingPictureExpertsGroupFiles.Count == 0 ? null : FilePath.Get(appSettings.ResultSettings, appSettings.MetadataSettings, FileHolder.Get(fastForwardMovingPictureExpertsGroupFiles[0]), result);
+                deterministicHashCode = fastForwardMovingPictureExpertsGroupFilePath is null ? windows.GetDeterministicHashCode(httpClient, filePath) : windows.GetDeterministicHashCode(httpClient, fastForwardMovingPictureExpertsGroupFilePath);
+            }
+            sidecarFiles = [];
+            filePath = FilePath.Get(filePath, deterministicHashCode);
+            for (int i = 0; i < keyValuePair.Value.Count; i++)
+            {
+                if (keyValuePair.Value[i].ExtensionLowered == fileHolder.ExtensionLowered)
+                    continue;
+                sidecarFiles.Add(keyValuePair.Value[i]);
+            }
+            try
+            { (minimumYearAndPathCombined, exifDirectory) = metadata.GetMetadataCollection(appSettings.ResultSettings, appSettings.MetadataSettings, httpClient, filePath); }
+            catch (Exception)
+            {
+                logger?.LogWarning("<{filePath}>", filePath.FullName);
+                continue;
+            }
+            fastForwardMovingPictureExpertsGroupUsed = fastForwardMovingPictureExpertsGroupFiles is not null && fastForwardMovingPictureExpertsGroupFiles.Count > 0;
+            if (fastForwardMovingPictureExpertsGroupUsed && fastForwardMovingPictureExpertsGroupFiles is not null)
+            {
+                foreach (string fastForwardMovingPictureExpertsGroupFile in fastForwardMovingPictureExpertsGroupFiles)
+                    File.Delete(fastForwardMovingPictureExpertsGroupFile);
+            }
+            if (!fastForwardMovingPictureExpertsGroupUsed && appSettings.ResultSettings.ValidVideoFormatExtensions.Contains(filePath.ExtensionLowered))
+                fastForwardMovingPictureExpertsGroupUsed = true;
+            firstPass = new(exifDirectory, fastForwardMovingPictureExpertsGroupUsed, minimumYearAndPathCombined, sidecarFiles.ToArray());
+            results.Add(firstPass);
+        }
+        return result;
+    }
+
+    private static ReadOnlyCollection<FirstPass> WindowsAsynchronousWork(AppSettings appSettings, Windows windows, ReadOnlyCollection<string> files, A_Metadata metadata, int appSettingsMaxDegreeOfParallelism)
+    {
+        List<FirstPass> results = [];
+        FirstPass firstPass;
+        List<string> distinct = [];
+        List<MetadataGroup> metadataGroups = [];
+        ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = appSettingsMaxDegreeOfParallelism };
+        files.AsParallel().ForAll(IMetadata.SetExifDirectoryCollection(windows, appSettings.ResultSettings, appSettings.MetadataSettings, metadata, distinct, metadataGroups));
+        if (windows?.CurrentTick != results.Count)
+            throw new NotSupportedException();
+        foreach (MetadataGroup metadataGroup in metadataGroups)
+        {
+            if (metadataGroup.FastForwardMovingPictureExpertsGroupUsed || !appSettings.ResultSettings.ValidVideoFormatExtensions.Contains(metadataGroup.FilePath.ExtensionLowered))
+                firstPass = new(metadataGroup.ExifDirectory, metadataGroup.FastForwardMovingPictureExpertsGroupUsed, metadataGroup.MinimumYearAndPathCombined, metadataGroup.SidecarFiles.ToArray());
+            else
+                firstPass = new(metadataGroup.ExifDirectory, FastForwardMovingPictureExpertsGroupUsed: true, metadataGroup.MinimumYearAndPathCombined, metadataGroup.SidecarFiles.ToArray());
+            results.Add(firstPass);
+        }
+        return results.AsReadOnly();
+    }
+
+    private static ReadOnlyCollection<NginxFileSystem>? GetRecursiveCollection(HttpClient httpClient, string host, string page)
+    {
+        List<NginxFileSystem>? results;
+        Uri uri = new($"http://{host}/{page}");
+        string format = NginxFileSystem.GetFormat();
+        TimeZoneInfo timeZoneInfo = TimeZoneInfo.Local;
+        Task<HttpResponseMessage> taskHttpResponseMessage = httpClient.GetAsync(uri);
+        taskHttpResponseMessage.Wait();
+        if (!taskHttpResponseMessage.Result.IsSuccessStatusCode)
+            results = null;
+        else
+        {
+            Task<string> taskString = taskHttpResponseMessage.Result.Content.ReadAsStringAsync();
+            taskString.Wait();
+            NginxFileSystem[]? nginxFileSystems = JsonSerializer.Deserialize(taskString.Result, NginxFileSystemCollectionSourceGenerationContext.Default.NginxFileSystemArray);
+            if (nginxFileSystems is null)
+                results = null;
+            else
+            {
+                results = [];
+                NginxFileSystem nginxFileSystem;
+                ReadOnlyCollection<NginxFileSystem>? directory;
+                for (int i = 0; i < nginxFileSystems.Length; i++)
+                {
+                    nginxFileSystem = NginxFileSystem.Get(format, timeZoneInfo, uri, nginxFileSystems[i]);
+                    if (nginxFileSystem.Type == "file")
+                        results.Add(nginxFileSystem);
+                    else
+                    {
+                        directory = GetRecursiveCollection(httpClient, host, $"{page}/{nginxFileSystem.Name}");
+                        if (directory is null)
+                            continue;
+                        results.AddRange(directory);
+                    }
+                }
+            }
+        }
+        return results?.AsReadOnly();
+    }
+
+}

Helpers/DiskInfoHelper.cs

@@ -0,0 +1,503 @@
+using File_Watcher.Models;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Helpers;
+
+internal static partial class DiskInfoHelper
+{
+
+    public record DiskDrive(string? Caption,
+                            string? DeviceID,
+                            string? FirmwareRevision,
+                            uint? Index,
+                            string? Model,
+                            string? Name,
+                            uint? Partitions,
+                            DiskPartition[]? PartitionCollection,
+                            string? SerialNumber,
+                            ulong? Size,
+                            string? Status,
+                            string? SystemName,
+                            ulong? TotalCylinders,
+                            ulong? TotalHeads)
+    {
+
+        internal static DiskDrive Get(DiskDrive diskDrive, DiskPartition[] diskPartitions, LogicalDrive[] logicalDrives)
+        {
+            DiskDrive result;
+            DiskPartition[] collection = DiskPartition.Get((from l in diskPartitions where l.DiskIndex == diskDrive.Index select l).ToArray(), logicalDrives);
+            result = new(Caption: diskDrive.Caption,
+                         DeviceID: diskDrive.DeviceID,
+                         FirmwareRevision: diskDrive.FirmwareRevision,
+                         Index: diskDrive.Index,
+                         Model: diskDrive.Model,
+                         Name: diskDrive.Name,
+                         Partitions: diskDrive.Partitions,
+                         PartitionCollection: collection,
+                         SerialNumber: diskDrive.SerialNumber,
+                         Size: diskDrive.Size,
+                         Status: diskDrive.Status,
+                         SystemName: diskDrive.SystemName,
+                         TotalCylinders: diskDrive.TotalCylinders,
+                         TotalHeads: diskDrive.TotalHeads);
+            return result;
+        }
+
+    }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(DiskDrive[]))]
+    private partial class DiskDriveArraySourceGenerationContext : JsonSerializerContext
+    {
+    }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Dictionary<string, object>))]
+    private partial class DictionaryStringObjectSourceGenerationContext : JsonSerializerContext
+    {
+    }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(JsonElement))]
+    private partial class JsonElementSourceGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record DiskPartition(bool? BootPartition,
+                                string? Caption,
+                                string? Description,
+                                string? DeviceID,
+                                uint? DiskIndex,
+                                uint? Index,
+                                LogicalDrive[]? LogicalDrives,
+                                ulong? Size,
+                                ulong? StartingOffset,
+                                string? SystemName,
+                                string? Type)
+    {
+
+        internal static DiskPartition[] Get(DiskPartition[] diskPartitions, LogicalDrive[] logicalDrives)
+        {
+            List<DiskPartition> results = [];
+            ulong lowerMatch;
+            ulong upperMatch;
+            LogicalDrive[] collection;
+            DiskPartition diskPartition;
+            foreach (DiskPartition p in diskPartitions)
+            {
+                if (p.Size is null)
+                    continue;
+                lowerMatch = p.Size.Value - 10240;
+                upperMatch = p.Size.Value + 10240;
+                collection = (from l in logicalDrives where l.DriveType != 4 && l.Size > lowerMatch && l.Size < upperMatch select l).ToArray();
+                diskPartition = new(BootPartition: p.BootPartition,
+                                    Caption: p.Caption,
+                                    Description: p.Description,
+                                    DeviceID: p.DeviceID,
+                                    DiskIndex: p.DiskIndex,
+                                    Index: p.Index,
+                                    LogicalDrives: collection,
+                                    Size: p.Size,
+                                    StartingOffset: p.StartingOffset,
+                                    SystemName: p.SystemName,
+                                    Type: p.Type);
+                results.Add(diskPartition);
+            }
+            return results.ToArray();
+        }
+
+    }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(DiskPartition[]))]
+    private partial class DiskPartitionSourceGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record LogicalDrive(string? Caption,
+                               string? DeviceID,
+                               uint? DriveType,
+                               string? FileSystem,
+                               ulong? FreeSpace,
+                               string? Name,
+                               ulong? PercentageFree,
+                               ulong? PercentageUsed,
+                               string? ProviderName,
+                               ulong? Size,
+                               string? SystemName,
+                               string? VolumeName,
+                               string? VolumeSerialNumber);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(LogicalDrive[]))]
+    private partial class LogicalDriveSourceGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record Record(long AvailableFreeSpace,
+                         string DriveFormat,
+                         string DriveType,
+                         bool IsReady,
+                         char Name,
+                         ulong PercentageFree,
+                         ulong PercentageUsed,
+                         long TotalFreeSpace,
+                         long TotalSize,
+                         string VolumeLabel)
+    {
+
+        public static Record Get(DriveInfo driveInfo) =>
+            new(AvailableFreeSpace: driveInfo.AvailableFreeSpace,
+                DriveFormat: driveInfo.DriveFormat,
+                DriveType: driveInfo.DriveType.ToString(),
+                IsReady: driveInfo.IsReady,
+                Name: driveInfo.Name.ToUpper()[0],
+                PercentageUsed: (ulong)(Math.Round(driveInfo.AvailableFreeSpace / (double)driveInfo.TotalSize, 2) * 100),
+                PercentageFree: (ulong)(Math.Round((driveInfo.TotalSize - driveInfo.AvailableFreeSpace) / (double)driveInfo.TotalSize, 2) * 100),
+                TotalFreeSpace: driveInfo.TotalFreeSpace,
+                TotalSize: driveInfo.TotalSize,
+                VolumeLabel: driveInfo.VolumeLabel);
+    }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Record[]))]
+    private partial class RecordSourceGenerationContext : JsonSerializerContext
+    {
+    }
+
+    private record Win32(string? DiskDrive,
+                         string? Processor,
+                         string? LogicalDisk,
+                         string? DiskPartition,
+                         string? NetworkAdapter);
+
+    internal static bool WriteDiskInfo(AppSettings appSettings, ILogger<Worker> logger)
+    {
+        string? json = WriteRecord();
+        ReadOnlyCollection<DiskDrive> devices = GetDrives(appSettings, logger);
+        string yaml = GetYetAnotherMarkupLanguage(devices);
+        ReadOnlyCollection<string> normalized = GetNormalized(appSettings, logger, devices);
+        string text = string.Join(Environment.NewLine, normalized);
+        string markdown = string.Concat("# ",
+                                        Environment.MachineName.ToUpper(),
+                                        Environment.NewLine,
+                                        Environment.NewLine,
+                                        "## Normalized",
+                                        Environment.NewLine,
+                                        Environment.NewLine,
+                                        "```log",
+                                        Environment.NewLine,
+                                        text,
+                                        Environment.NewLine,
+                                        "```",
+                                        Environment.NewLine,
+                                        Environment.NewLine,
+                                        "## json",
+                                        Environment.NewLine,
+                                        Environment.NewLine,
+                                        "```json",
+                                        Environment.NewLine,
+                                        json,
+                                        Environment.NewLine,
+                                        "```",
+                                        Environment.NewLine,
+                                        Environment.NewLine,
+                                        "## yaml",
+                                        Environment.NewLine,
+                                        Environment.NewLine,
+                                        "```yaml",
+                                        Environment.NewLine,
+                                        yaml,
+                                        Environment.NewLine,
+                                        "```",
+                                        Environment.NewLine);
+        WriteAllText(Path.Combine(appSettings.DiskInfoConfiguration.Destination, $"{Environment.MachineName.ToUpper()}.md"), markdown);
+        return true;
+    }
+
+    private static string WriteRecord()
+    {
+        string result;
+        Record record;
+        List<Record> records = [];
+        DriveInfo[] drives = DriveInfo.GetDrives();
+        foreach (DriveInfo driveInfo in drives)
+        {
+            record = Record.Get(driveInfo);
+            records.Add(record);
+        }
+        result = JsonSerializer.Serialize(records.ToArray(), RecordSourceGenerationContext.Default.RecordArray);
+        return result;
+    }
+
+    private static ReadOnlyCollection<DiskDrive> GetDrives(AppSettings appSettings, ILogger<Worker> logger)
+    {
+#pragma warning disable CA1416
+        List<DiskDrive> results = [];
+        Win32 win32 = GetWin32(appSettings, logger);
+        if (win32.DiskDrive is not null && win32.DiskPartition is not null && win32.LogicalDisk is not null)
+        {
+            DiskDrive diskDrive;
+            string diskDriveJson = win32.DiskDrive[0] == '[' ? win32.DiskDrive : $"[{win32.DiskDrive}]";
+            string logicalDiskJson = win32.LogicalDisk[0] == '[' ? win32.LogicalDisk : $"[{win32.LogicalDisk}]";
+            string diskPartitionJson = win32.DiskPartition[0] == '[' ? win32.DiskPartition : $"[{win32.DiskPartition}]";
+            DiskDrive[] diskDrives = JsonSerializer.Deserialize(diskDriveJson, DiskDriveArraySourceGenerationContext.Default.DiskDriveArray) ??
+                throw new NullReferenceException(nameof(DiskDrive));
+            LogicalDrive[] logicalDrives = JsonSerializer.Deserialize(logicalDiskJson, LogicalDriveSourceGenerationContext.Default.LogicalDriveArray) ??
+                throw new NullReferenceException(nameof(LogicalDrive));
+            DiskPartition[] diskPartitions = JsonSerializer.Deserialize(diskPartitionJson, DiskPartitionSourceGenerationContext.Default.DiskPartitionArray) ??
+                throw new NullReferenceException(nameof(DiskPartition));
+            foreach (DiskDrive d in diskDrives)
+            {
+                diskDrive = DiskDrive.Get(d, diskPartitions, logicalDrives);
+                results.Add(diskDrive);
+            }
+        }
+        return results.AsReadOnly();
+#pragma warning restore
+    }
+
+    private static Win32 GetWin32(AppSettings appSettings, ILogger<Worker> logger)
+    {
+        Win32 win32;
+        Process? process;
+        string[] segments;
+        string standardError;
+        string standardOutput;
+        string? diskDrive = null;
+        string? processor = null;
+        string? logicalDisk = null;
+        string? diskPartition = null;
+        string? networkAdapter = null;
+        ProcessStartInfo processStartInfo;
+        string fileName = "powershell.exe";
+        string date = DateTime.Now.ToString("yyyy-MM-dd");
+        foreach (string className in appSettings.DiskInfoConfiguration.Classes)
+        {
+            segments = className.Split(' ');
+            if (segments[0].Length < 3)
+                continue;
+            processStartInfo = new(fileName, $"-NoProfile -ExecutionPolicy ByPass Get-WmiObject {className} | ConvertTo-JSON")
+            {
+                RedirectStandardError = true,
+                RedirectStandardOutput = true,
+                UseShellExecute = false
+            };
+            try
+            {
+                process = Process.Start(processStartInfo);
+                if (process is not null)
+                {
+                    for (int j = 1; j < 45; j++)
+                    {
+                        _ = process.WaitForExit(1000);
+                        if (process.HasExited)
+                            break;
+                    }
+                    if (!process.HasExited)
+                    {
+                        logger.LogWarning($"// {segments[0]} Never exited!");
+                        if (segments[0] is "Win32_DiskDrive" or "Win32_DiskPartition" or "Win32_LogicalDisk")
+                            break;
+                    }
+                    else
+                    {
+                        standardError = process.StandardError.ReadToEnd();
+                        standardOutput = process.StandardOutput.ReadToEnd();
+                        logger.LogInformation("// {className}{line}{error}{line}{line}// {output}", segments[0], Environment.NewLine, standardError, Environment.NewLine, Environment.NewLine, standardOutput);
+                        if (string.IsNullOrEmpty(standardError))
+                        {
+                            if (segments[0] == "Win32_DiskDrive")
+                                diskDrive = standardOutput;
+                            else if (segments[0] == "Win32_DiskPartition")
+                                diskPartition = standardOutput;
+                            else if (segments[0] == "Win32_LogicalDisk")
+                                logicalDisk = standardOutput;
+                            else if (segments[0] == "Win32_NetworkAdapter")
+                                networkAdapter = standardOutput;
+                            else if (segments[0] == "Win32_Processor")
+                                processor = standardOutput;
+                            WriteAllText(Path.Combine(appSettings.DiskInfoConfiguration.Destination, $"{Environment.MachineName.ToUpper()}-{segments[0]}-{date}.json"), standardOutput);
+                        }
+                    }
+                }
+                process?.Dispose();
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Error:");
+            }
+        }
+        win32 = new(DiskDrive: diskDrive,
+                    Processor: processor,
+                    LogicalDisk: logicalDisk,
+                    DiskPartition: diskPartition,
+                    NetworkAdapter: networkAdapter);
+        return win32;
+    }
+
+    public static Dictionary<string, object> DeserializeAndFlatten(string json, char? remove)
+    {
+        Dictionary<string, object> results = [];
+        JsonElement jsonElement = JsonSerializer.Deserialize(json, JsonElementSourceGenerationContext.Default.JsonElement);
+        FillDictionaryFromJToken(results, jsonElement, string.Empty, remove);
+        return results;
+    }
+
+    private static void FillDictionaryFromJToken(Dictionary<string, object> results, JsonElement jsonElement, string prefix, char? remove)
+    {
+        switch (jsonElement.ValueKind)
+        {
+            case JsonValueKind.Object:
+                foreach (JsonProperty jsonProperty in jsonElement.EnumerateObject())
+                {
+                    FillDictionaryFromJToken(results, jsonProperty.Value, Join(prefix, jsonProperty.Name), remove);
+                }
+                break;
+
+            case JsonValueKind.Array:
+                int index = 0;
+                foreach (JsonElement value in jsonElement.EnumerateArray())
+                {
+                    FillDictionaryFromJToken(results, value, Join(prefix, index.ToString()), remove);
+                    index++;
+                }
+                break;
+
+            case JsonValueKind.String:
+                if (remove is null)
+                {
+                    results.Add(prefix, jsonElement.ToString());
+                }
+                else
+                {
+                    results.Add(prefix, jsonElement.ToString().Replace(remove.Value, '_'));
+                }
+                break;
+
+            case JsonValueKind.True:
+            case JsonValueKind.False:
+            case JsonValueKind.Number:
+                results.Add(prefix, jsonElement.ToString());
+                break;
+        }
+    }
+
+    private static string Join(string prefix, string name) =>
+        string.IsNullOrEmpty(prefix) ? name : prefix + "." + name;
+
+    private static string GetYetAnotherMarkupLanguage(ReadOnlyCollection<DiskDrive> devices)
+    {
+        string result;
+        List<string> results = [];
+        string json = JsonSerializer.Serialize(devices.ToArray(), DiskDriveArraySourceGenerationContext.Default.DiskDriveArray);
+        Dictionary<string, object> keyValuePairs = DeserializeAndFlatten(json, ':');
+        string[] lines = JsonSerializer.Serialize(keyValuePairs, DictionaryStringObjectSourceGenerationContext.Default.DictionaryStringObject).Split(Environment.NewLine);
+        for (int i = 1; i < lines.Length - 1; i++)
+        {
+            results.Add(lines[i].Trim()
+                .Trim(',')
+                .Trim('"')
+                .Replace("\": \"", ": ")
+                .Replace("\": ", ": "));
+        }
+        result = string.Join(Environment.NewLine, results);
+        return result;
+    }
+
+    private static string GetSizeWithSuffix(ulong value)
+    {
+        string result;
+        int i = 0;
+        double displayValue = value * 1f;
+        string[] SizeSuffixes = ["bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+        while (Math.Round(displayValue / 1024f) >= 1)
+        {
+            displayValue /= 1024;
+            i++;
+        }
+        result = string.Format("{0:n1} {1}", displayValue, SizeSuffixes[i]);
+        return result;
+    }
+
+    private static void WriteAllText(string path, string text)
+    {
+        string check = !File.Exists(path) ? string.Empty : File.ReadAllText(path);
+        if (check != text)
+            File.WriteAllText(path, text);
+    }
+
+    private static ReadOnlyCollection<string> GetNormalized(AppSettings appSettings, ILogger<Worker> logger, ReadOnlyCollection<DiskDrive> drives)
+    {
+        List<string> results = [];
+        decimal free;
+        decimal used;
+        string display;
+        int deviceCount;
+        int offsetCount;
+        string deviceSize;
+        int partitionCount;
+        results.Add("Max");
+        string offsetDisplay;
+        string partitionSize;
+        decimal devicePercent;
+        string logicalDriveUsed;
+        string logicalDriveSize;
+        decimal partitionPercent;
+        int logicalDriveFreeCount;
+        int logicalDriveUsedCount;
+        decimal partitionDecimalSize;
+        string logicalDriveFreeSpace;
+        decimal logicalDriveDecimalFreeSpace;
+        DiskInfoConfiguration diskInfoConfiguration = appSettings.DiskInfoConfiguration;
+        results.Add($"{new string('-', diskInfoConfiguration.Bars)} Value of Max Argument");
+        foreach (DiskDrive drive in drives.OrderBy(l => l.Index))
+        {
+            if (drive.Size is null || drive.PartitionCollection is null)
+                continue;
+            devicePercent = drive.Size.Value / diskInfoConfiguration.Max;
+            deviceSize = GetSizeWithSuffix(drive.Size.Value);
+            results.Add($"{drive.DeviceID} - Cylinders: {drive.TotalCylinders} - {drive.Model}");
+            deviceCount = (int)Math.Round(devicePercent * diskInfoConfiguration.Bars);
+            results.Add($"{new string('-', deviceCount)} {Math.Round(devicePercent, 2) * 100:000}% of Max Argument {deviceSize}");
+            foreach (DiskPartition partition in drive.PartitionCollection.OrderBy(l => l.Index))
+            {
+                if (partition.Size is null || partition.StartingOffset is null || partition.LogicalDrives is null)
+                    continue;
+                partitionPercent = partition.Size.Value / diskInfoConfiguration.Max;
+                partitionSize = GetSizeWithSuffix(partition.Size.Value);
+                partitionCount = (int)Math.Round(partitionPercent * diskInfoConfiguration.Bars);
+                offsetCount = (int)Math.Round(partition.StartingOffset.Value / diskInfoConfiguration.Max * diskInfoConfiguration.Bars);
+                offsetDisplay = new string('_', offsetCount);
+                results.Add($"{partition.DeviceID} - {string.Join(", ", partition.LogicalDrives.Select(l => l.DeviceID))}");
+                results.Add($"{offsetDisplay}{new string('-', partitionCount)}{new string('_', diskInfoConfiguration.Bars - offsetCount - partitionCount)} {Math.Round(partitionPercent, 2) * 100:000}% of Disk {partitionSize}");
+                foreach (LogicalDrive logicalDrive in partition.LogicalDrives)
+                {
+                    if (logicalDrive.Size is null || logicalDrive.FreeSpace is null)
+                        continue;
+                    if ((int)Math.Round(logicalDrive.Size.Value / diskInfoConfiguration.Max * diskInfoConfiguration.Bars) != (int)Math.Round(partition.Size.Value / diskInfoConfiguration.Max * diskInfoConfiguration.Bars))
+                    {
+                        logger.LogWarning("logicalDrive.Size !~ partition.Size");
+                        break;
+                    }
+                    partitionDecimalSize = partition.Size.Value;
+                    logicalDriveDecimalFreeSpace = logicalDrive.FreeSpace.Value;
+                    logicalDriveSize = GetSizeWithSuffix(logicalDrive.Size.Value);
+                    logicalDriveFreeSpace = GetSizeWithSuffix(logicalDrive.FreeSpace.Value);
+                    logicalDriveUsed = GetSizeWithSuffix(logicalDrive.Size.Value - logicalDrive.FreeSpace.Value);
+                    logicalDriveFreeCount = (int)Math.Round(logicalDriveDecimalFreeSpace / diskInfoConfiguration.Max * diskInfoConfiguration.Bars);
+                    display = string.IsNullOrEmpty(logicalDrive.DeviceID) ? "Partition" : logicalDrive.DeviceID;
+                    logicalDriveUsedCount = (int)Math.Round((partitionDecimalSize - logicalDriveDecimalFreeSpace) / diskInfoConfiguration.Max * diskInfoConfiguration.Bars);
+                    free = (int)(Math.Round(logicalDriveDecimalFreeSpace / partitionDecimalSize, 2) * 100);
+                    used = (int)(Math.Round((partitionDecimalSize - logicalDriveDecimalFreeSpace) / partitionDecimalSize, 2) * 100);
+                    results.Add($"{offsetDisplay}{new string('-', logicalDriveUsedCount)}{new string('*', logicalDriveFreeCount)}{new string('_', diskInfoConfiguration.Bars - offsetCount - logicalDriveUsedCount - logicalDriveFreeCount)} {used:000}% of [{display}] {logicalDriveUsed} ({free:000}% {logicalDriveFreeSpace} free)");
+                }
+            }
+        }
+        return results.AsReadOnly();
+    }
+
+}

Helpers/EDA/DCP.cs

@@ -223,6 +223,7 @@ public class DCP
         level += 1;
         foreach (dynamic entry in expandoObject)
         {
+#pragma warning disable IL2026, IL3050
             if (entry.Value is ExpandoObject)
                 TextResolveEntry(result, entry.Value, level, string.Concat(super, " : ", entry.Key), i, group);
             else
@@ -262,6 +263,7 @@ public class DCP
                     i = null;
                 }
             }
+#pragma warning restore IL2026, IL3050
         }
         level -= 1;
         if (level == 0)
@@ -273,6 +275,7 @@ public class DCP
         StringBuilder result = new();
         if (result.Length > 0) //Skipping because System.Text.Json changed the way Expando works 
         {
+#pragma warning disable IL2026, IL3050
             string title = string.Concat(Path.GetFileName(edaObjectFile), " - ", common.Source);
             dynamic? expandoObject = JsonSerializer.Deserialize<ExpandoObject>(json);
             _ = result.AppendLine(title);
@@ -288,6 +291,7 @@ public class DCP
             _ = result.AppendLine(edaObjectFile);
             _ = result.AppendLine();
             TextResolveEntry(result, expandoObject, 0, string.Empty, null, group: true);
+#pragma warning restore IL2026, IL3050
         }
         return result.ToString();
     }

Helpers/HelperCamstarOracle.cs

@@ -0,0 +1,117 @@
+using File_Watcher.Infineon.Monitoring.MonA;
+using File_Watcher.Models;
+using System.Diagnostics;
+using System.Globalization;
+
+namespace File_Watcher.Helpers;
+
+internal static partial class HelperCamstarOracle
+{
+
+    private static IMonIn? _MonIn;
+    private static int? _LastValue;
+    private static Calendar? _Calendar;
+    private static DateTime? _LastUpload;
+
+    internal static void Heartbeat(AppSettings appSettings, IHttpClientFactory httpClientFactory, ILogger<Worker> logger, State state, CancellationToken cancellationToken)
+    {
+        _MonIn ??= MonIn.GetInstance(httpClientFactory);
+        CamstarOracleConfiguration camstarOracleConfiguration = appSettings.CamstarOracleConfiguration;
+        Task<HttpResponseMessage> httpResponseMessage = _MonIn.SendStatus(camstarOracleConfiguration.MonitorApplicationSite, camstarOracleConfiguration.MonitorApplicationResource, "Heartbeat", state);
+        httpResponseMessage.Wait(cancellationToken);
+        if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
+            throw new Exception(httpResponseMessage.Result.StatusCode.ToString());
+        Task<string> body = httpResponseMessage.Result.Content.ReadAsStringAsync(cancellationToken);
+        body.Wait(cancellationToken);
+        logger.LogDebug(body.Result);
+    }
+
+#pragma warning disable CA1416
+
+    private static List<EventLogEntry> GetOracleEventLogEntries(CamstarOracleConfiguration camstarOracleConfiguration, DateTime dateTime, CancellationToken cancellationToken)
+    {
+        List<EventLogEntry> results = [];
+        EventLog[] eventLogs = EventLog.GetEventLogs();
+        long ticks = dateTime.AddMinutes(-camstarOracleConfiguration.RollingMinutes).Ticks;
+        foreach (EventLog eventLog in eventLogs)
+        {
+            if (cancellationToken.IsCancellationRequested)
+                break;
+            if (!eventLog.Log.Contains(camstarOracleConfiguration.LogFilter))
+                continue;
+            foreach (object? item in eventLog.Entries)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                    break;
+                if (item is not EventLogEntry eventLogEntry)
+                    continue;
+                if (eventLogEntry.TimeGenerated.Ticks < ticks)
+                    continue;
+                if (!camstarOracleConfiguration.MessageFilters.Any(eventLogEntry.Message.Contains))
+                    continue;
+                results.Add(eventLogEntry);
+            }
+        }
+        return results;
+    }
+
+    private static List<(DateTime, string)> GetOracleEventLogEntryMessages(CamstarOracleConfiguration camstarOracleConfiguration, DateTime dateTime, CancellationToken cancellationToken)
+    {
+        List<(DateTime, string)> results = [];
+        List<EventLogEntry> collection = GetOracleEventLogEntries(camstarOracleConfiguration, dateTime, cancellationToken);
+        foreach (EventLogEntry eventLogEntry in collection)
+        {
+            if (cancellationToken.IsCancellationRequested)
+                break;
+            results.Add(new(eventLogEntry.TimeGenerated, eventLogEntry.Message));
+        }
+        return results;
+    }
+
+    internal static bool Check(AppSettings appSettings, IHttpClientFactory httpClientFactory, ILogger<Worker> logger, CancellationToken cancellationToken)
+    {
+        if (_MonIn is null)
+            throw new NullReferenceException(nameof(_MonIn));
+        string directory;
+        DateTime dateTime;
+        string weekOfYear;
+        string weekDirectory;
+        string formattedDateTime;
+        List<string> lines = [];
+        _Calendar ??= new CultureInfo("en-US").Calendar;
+        CamstarOracleConfiguration camstarOracleConfiguration = appSettings.CamstarOracleConfiguration;
+        string performanceName = string.Concat(camstarOracleConfiguration.MonitorApplicationResource, "_Count");
+        lines.Clear();
+        dateTime = DateTime.Now;
+        weekOfYear = _Calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
+        weekDirectory = $"{dateTime:yyyy}_Week_{weekOfYear}{@"\"}{dateTime:yyyy-MM-dd}";
+        directory = Path.Combine(camstarOracleConfiguration.Directory, weekDirectory);
+        if (!Directory.Exists(directory))
+            _ = Directory.CreateDirectory(directory);
+        logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
+        List<(DateTime, string)> collection = GetOracleEventLogEntryMessages(camstarOracleConfiguration, dateTime, cancellationToken);
+        foreach ((DateTime timeGenerated, string message) in collection)
+        {
+            if (cancellationToken.IsCancellationRequested)
+                break;
+            formattedDateTime = timeGenerated.ToString(camstarOracleConfiguration.DateFormat);
+            lines.Add($"{formattedDateTime}\t{message}");
+        }
+        File.WriteAllLines(Path.Combine(directory, $"{dateTime.Ticks}.tsv"), lines);
+        if (_LastValue is null || _LastUpload is null || _LastValue.Value != lines.Count || new TimeSpan(dateTime.Ticks - _LastUpload.Value.Ticks).TotalMinutes > 5)
+        {
+            Heartbeat(appSettings, httpClientFactory, logger, State.Up, cancellationToken);
+            Task<HttpResponseMessage> httpResponseMessage = _MonIn.SendPerformanceMessage(camstarOracleConfiguration.MonitorApplicationSite, camstarOracleConfiguration.MonitorApplicationResource, performanceName, value: lines.Count, description: string.Empty);
+            httpResponseMessage.Wait(cancellationToken);
+            if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
+                throw new Exception(httpResponseMessage.Result.StatusCode.ToString());
+            Task<string> body = httpResponseMessage.Result.Content.ReadAsStringAsync(cancellationToken);
+            body.Wait(cancellationToken);
+            logger.LogDebug(body.Result);
+            _LastUpload = DateTime.Now;
+            _LastValue = lines.Count;
+        }
+        return true;
+    }
+
+}

Helpers/HelperCompass.cs

@@ -5,7 +5,7 @@ using System.Text;
 
 namespace File_Watcher.Helpers;
 
-internal static partial class HelperCompass
+internal class HelperCompass
 {
 
     private static bool _FirstRun = true;
@@ -29,7 +29,7 @@ internal static partial class HelperCompass
                 if (string.IsNullOrEmpty(appSettings.DriveConfiguration.Password))
                     decrypted = string.Empty;
                 else
-                    decrypted = RijndaelEncryption.Decrypt(appSettings.DriveConfiguration.Password, appSettings.Company);
+                    decrypted = RijndaelEncryption.Decrypt(appSettings.DriveConfiguration.Password, appSettings.FileWatcherConfiguration.Company);
                 arguments = $"use {appSettings.DriveConfiguration.Letter}: \"{appSettings.DriveConfiguration.Share}\" /p:yes /user:{appSettings.DriveConfiguration.User} {decrypted}";
                 _ = stringBuilder.Clear();
                 segments = arguments.Split(' ');
@@ -83,12 +83,17 @@ internal static partial class HelperCompass
     private static void CopyFiles(AppSettings appSettings, ReadOnlyCollection<string> files)
     {
         string checkFile;
+        string triggerFile;
         foreach (string file in files)
         {
             checkFile = Path.Combine(appSettings.CompassConfiguration.Destination, Path.GetFileName(file));
+            triggerFile = $"{checkFile}{appSettings.CompassConfiguration.TriggerAppendage}";
             if (File.Exists(checkFile))
                 continue;
+            if (File.Exists(triggerFile))
+                continue;
             File.Copy(file, checkFile);
+            File.WriteAllText(triggerFile, string.Empty);
         }
     }
 
@@ -109,7 +114,7 @@ internal static partial class HelperCompass
             if (!Directory.Exists(directory))
                 _ = Directory.CreateDirectory(directory);
             files = GetFiles(appSettings, directory);
-            logger.LogDebug("Found {Files}", files);
+            logger.LogDebug("Found {Files} file(s)", files.Count);
             CopyFiles(appSettings, files);
         }
         return true;

Helpers/HelperEAFLog.cs

@@ -7,8 +7,8 @@ internal static partial class HelperEAFLog
 
     internal static bool DeleteFiles(AppSettings appSettings, ILogger<Worker> logger)
     {
-        string[] files = Directory.GetFiles(appSettings.WatchDirectory, appSettings.EAFLogConfiguration.SearchPattern, SearchOption.AllDirectories);
+        string[] files = Directory.GetFiles(appSettings.FileWatcherConfiguration.WatchDirectory, appSettings.EAFLogConfiguration.SearchPattern, SearchOption.AllDirectories);
-        logger.LogInformation("After {MillisecondsDelay} with search pattern '{SearchPattern}' found {files}", appSettings.MillisecondsDelay, appSettings.EAFLogConfiguration.SearchPattern, files.Length);
+        logger.LogInformation("After {MillisecondsDelay} with search pattern '{SearchPattern}' found {files}", appSettings.FileWatcherConfiguration.MillisecondsDelay, appSettings.EAFLogConfiguration.SearchPattern, files.Length);
         foreach (string file in files)
         {
             if (file.EndsWith(".dll"))

Helpers/HelperEAFProgramData.cs

@@ -1,37 +0,0 @@
-using File_Watcher.Models;
-
-namespace File_Watcher.Helpers;
-
-internal static partial class HelperEAFProgramData
-{
-
-    internal static bool MoveFiles(AppSettings appSettings, ILogger<Worker> logger)
-    {
-        string checkFile;
-        string checkDirectory;
-        string source = Path.GetFullPath(appSettings.EAFProgramDataConfiguration.Source);
-        string[] files = Directory.GetFiles(source, "*", SearchOption.AllDirectories);
-        logger.LogInformation("After {MillisecondsDelay} with search pattern '{SearchPattern}' found {files}", appSettings.MillisecondsDelay, appSettings.EAFLogConfiguration.SearchPattern, files.Length);
-        foreach (string file in files)
-        {
-            Thread.Sleep(500);
-            checkFile = file.Replace(source, appSettings.EAFProgramDataConfiguration.Destination);
-            if (checkFile == file)
-                throw new NotSupportedException("Replace failed!");
-            checkDirectory = Path.GetDirectoryName(checkFile) ?? throw new NotSupportedException();
-            try
-            {
-                if (!Directory.Exists(checkDirectory))
-                    _ = Directory.CreateDirectory(checkDirectory);
-                if (File.Exists(checkFile))
-                    continue;
-                File.Move(file, checkFile);
-                Thread.Sleep(500);
-            }
-            catch (Exception ex)
-            { logger.LogInformation(ex, "Inner loop error!"); }
-        }
-        return true;
-    }
-
-}

Helpers/HelperEDADatabase.cs

@@ -1,9 +1,7 @@
 using File_Watcher.Helpers.EDA;
 using File_Watcher.Models;
-using System.Globalization;
 using System.Text;
 using System.Text.Json;
-using System.Text.RegularExpressions;
 using System.Xml;
 using System.Xml.Serialization;
 
@@ -12,12 +10,8 @@ namespace File_Watcher.Helpers;
 internal static partial class HelperEDADatabase
 {
 
-    private static Calendar? _Calendar;
     private static string? _EDADataCollectionPlansLastRun;
 
-    [GeneratedRegex("[a-zA-Z0-9]{1,}")]
-    private static partial Regex RegexAZ09();
-
     private static Stream ToStream(string @this)
     {
         MemoryStream? stream = new();
@@ -35,8 +29,10 @@ internal static partial class HelperEDADatabase
         {
             Stream stream = ToStream(@this.Trim());
             XmlReader? reader = XmlReader.Create(stream, new XmlReaderSettings() { ConformanceLevel = ConformanceLevel.Document });
+#pragma warning disable IL2026, IL2090
             XmlSerializer xmlSerializer = new(typeof(T), typeof(T).GetNestedTypes());
             result = xmlSerializer.Deserialize(reader);
+#pragma warning restore IL2026, IL2090
             stream.Dispose();
         }
         catch (Exception)
@@ -131,7 +127,9 @@ internal static partial class HelperEDADatabase
                         continue;
                     // cSpell:enable
                     common.Update(configuration);
+#pragma warning disable IL2026, IL3050
                     json = JsonSerializer.Serialize(configuration, configuration.GetType(), jsonSerializerOptions);
+#pragma warning restore IL2026, IL3050
                     if (common?.UnitName is null)
                         continue;
                     fileName = string.Concat(edaObjectFile.Replace(replace, "Partial"), ".csv");
@@ -203,7 +201,7 @@ internal static partial class HelperEDADatabase
         }
     }
 
-    private static void DataCollectionPlans(AppSettings appSettings, ILogger<Worker> logger, Calendar calendar, CancellationToken cancellationToken)
+    private static void DataCollectionPlans(AppSettings appSettings, ILogger<Worker> logger, CancellationToken cancellationToken)
     {
         int fieldCount;
         object @object;
@@ -211,9 +209,11 @@ internal static partial class HelperEDADatabase
         List<object> row;
         StringBuilder sql = new();
         string objectTypeDirectory;
+#pragma warning disable IL3050
         Array objectTypes = Enum.GetValues(typeof(ModuleInstanceTypeName));
+#pragma warning restore IL3050
         Dictionary<string, Dictionary<ModuleInstanceTypeName, List<List<object>>>> rows = [];
-        string decrypted = RijndaelEncryption.Decrypt(appSettings.EDADatabaseConfiguration.Password, appSettings.Company);
+        string decrypted = RijndaelEncryption.Decrypt(appSettings.EDADatabaseConfiguration.Password, appSettings.FileWatcherConfiguration.Company);
         string connectionString = $"Data Source={appSettings.EDADatabaseConfiguration.TNS}; User Id={appSettings.EDADatabaseConfiguration.UserName}; Password={decrypted};";
         rows.Add(appSettings.EDADatabaseConfiguration.Name, []);
         foreach (ModuleInstanceTypeName objectType in objectTypes)
@@ -272,8 +272,7 @@ internal static partial class HelperEDADatabase
 
     internal static bool SaveDataCollectionPlans(AppSettings appSettings, ILogger<Worker> logger, CancellationToken cancellationToken)
     {
-        _Calendar ??= new CultureInfo("en-US").Calendar;
+        DataCollectionPlans(appSettings, logger, cancellationToken);
-        DataCollectionPlans(appSettings, logger, _Calendar, cancellationToken);
         return true;
     }
 

Helpers/HelperEventLog.cs

@@ -8,7 +8,7 @@ internal static partial class HelperEventLog
 
     internal static bool ClearEventLogs(AppSettings appSettings, ILogger<Worker> logger)
     {
-        if (Directory.Exists(appSettings.WatchDirectory))
+        if (Directory.Exists(appSettings.FileWatcherConfiguration.WatchDirectory))
         {
 #pragma warning disable CA1416
             using (EventLog eventLog = new("Security", Environment.MachineName))
@@ -26,7 +26,7 @@ internal static partial class HelperEventLog
                 { logger.LogInformation("Error: {logName} - {message}.", eventLog.LogDisplayName, ex.Message); }
             }
 #pragma warning restore CA1416
-            logger.LogCritical("{Company}", appSettings.Company);
+            logger.LogCritical("{Company}", appSettings.FileWatcherConfiguration.Company);
         }
         return true;
     }

Helpers/HelperISO.cs

@@ -0,0 +1,40 @@
+using DiscUtils.Iso9660;
+using File_Watcher.Models;
+
+namespace File_Watcher.Helpers;
+
+internal static partial class HelperISO
+{
+
+    private static void DirectoryToISO(ILogger<Worker> logger, string destinationDirectory, bool mapOnly, string directory)
+    {
+        byte[] bytes = [];
+        string relativePath;
+        string directoryName = Path.GetFileName(directory);
+        CDBuilder builder = new() { UseJoliet = true, VolumeIdentifier = directoryName.Length < 25 ? directoryName : directoryName[..25] };
+        IEnumerable<string> files = Directory.EnumerateFiles(directory, "*", new EnumerationOptions { IgnoreInaccessible = true, RecurseSubdirectories = true });
+        foreach (string file in files)
+        {
+            relativePath = Path.GetRelativePath(directory, file).Replace(';', '_');
+            if (!mapOnly)
+                _ = builder.AddFile(relativePath, file);
+            else
+                _ = builder.AddFile(relativePath, bytes);
+        }
+        logger.LogInformation(destinationDirectory);
+        builder.Build(Path.Combine(destinationDirectory, $"{directoryName}.iso"));
+        logger.LogInformation(directoryName);
+    }
+
+    internal static bool DirectoryToISO(AppSettings appSettings, ILogger<Worker> logger)
+    {
+        IsoConfiguration isoConfiguration = appSettings.IsoConfiguration;
+        logger.LogInformation(isoConfiguration.SourceDirectory);
+        bool mapOnly = isoConfiguration.SourceDirectory.Length == 2;
+        if (!Directory.Exists(isoConfiguration.DestinationDirectory))
+            _ = Directory.CreateDirectory(isoConfiguration.DestinationDirectory);
+        DirectoryToISO(logger, isoConfiguration.DestinationDirectory, mapOnly, isoConfiguration.SourceDirectory);
+        return true;
+    }
+
+}

Helpers/HelperInfinityQS.cs

@@ -6,22 +6,41 @@ namespace File_Watcher.Helpers;
 internal static partial class HelperInfinityQS
 {
 
-    internal static bool RunMI(AppSettings appSettings, ILogger<Worker> logger)
+    private static void KillExisting(string processName)
+    {
+        Process[] processes = Process.GetProcessesByName(processName);
+        foreach (Process process in processes)
+        {
+            try
+            { process.Kill(); }
+            catch (Exception) { }
+        }
+    }
+
+    private static void RunMI(string decryptedPassword)
     {
 #pragma warning disable CA1416
-        logger.LogInformation(appSettings.Company);
+        string processName = "iispcmi.exe";
-        ProcessStartInfo processStartInfo = new("iispcmi.exe")
+        KillExisting(processName);
+        ProcessStartInfo processStartInfo = new(processName)
         {
             Domain = "Infineon",
             UseShellExecute = false,
             UserName = "ecfisysadmin",
-            PasswordInClearText = "j(1(P%xB=g}3w9db",
+            PasswordInClearText = decryptedPassword,
             WorkingDirectory = "C:/Program Files (x86)/InfinityQS International/ProFicient/Applications"
         };
+        TimeSpan timeSpan = new(DateTime.Now.AddDays(7).Ticks - DateTime.Now.Ticks);
         Process process = Process.Start(processStartInfo) ?? throw new NullReferenceException(nameof(Process));
-        process.WaitForExit();
+        _ = process.WaitForExit((int)timeSpan.TotalMilliseconds);
 #pragma warning restore CA1416
-        return true;
     }
 
+    internal static bool ProcessStart(AppSettings appSettings, ILogger<Worker> logger)
+    {
+        logger.LogInformation(appSettings.FileWatcherConfiguration.Company);
+        string decrypted = RijndaelEncryption.Decrypt(appSettings.InfinityQSConfiguration.EncryptedPassword, appSettings.FileWatcherConfiguration.Company);
+        RunMI(decrypted);
+        return true;
+    }
 }

Helpers/HelperNuget.cs

@@ -0,0 +1,153 @@
+using File_Watcher.Models;
+using System.IO.Compression;
+
+namespace File_Watcher.Helpers;
+
+internal class HelperNuget
+{
+
+    private static DateTimeOffset? GetDateTimeOffset(string keyFileExtension, FileInfo fileInfo, FileInfo extractKeyFileInfo)
+    {
+        DateTimeOffset? dateTimeOffset = null;
+        using ZipArchive zip = ZipFile.Open(fileInfo.FullName, ZipArchiveMode.Read);
+        foreach (ZipArchiveEntry zipArchiveEntry in zip.Entries)
+        {
+            if (!zipArchiveEntry.Name.EndsWith(keyFileExtension))
+                continue;
+            dateTimeOffset = zipArchiveEntry.LastWriteTime;
+            if (fileInfo.FullName[0] != '\\')
+            {
+                zipArchiveEntry.ExtractToFile(extractKeyFileInfo.FullName);
+                File.SetCreationTime(extractKeyFileInfo.FullName, fileInfo.CreationTime);
+                File.SetLastWriteTime(extractKeyFileInfo.FullName, dateTimeOffset.Value.LocalDateTime);
+            }
+            break;
+        }
+        return dateTimeOffset;
+    }
+
+    private static void SetLastWriteTimes(ILogger<Worker> logger, NugetConfiguration nugetConfiguration, FileInfo fileInfo, DateTimeOffset dateTimeOffset)
+    {
+        try
+        {
+            string[] files;
+            if (fileInfo.LastWriteTime != dateTimeOffset.LocalDateTime)
+                File.SetLastWriteTime(fileInfo.FullName, dateTimeOffset.LocalDateTime);
+            if (!string.IsNullOrEmpty(nugetConfiguration.KeyFileExtensionB))
+            {
+                if (fileInfo.DirectoryName is null)
+                    throw new NullReferenceException(nameof(fileInfo.DirectoryName));
+                files = Directory.GetFiles(fileInfo.DirectoryName, nugetConfiguration.KeyFileExtensionB, SearchOption.TopDirectoryOnly);
+                foreach (string file in files)
+                {
+                    fileInfo = new(file);
+                    if (fileInfo.LastWriteTime != dateTimeOffset.LocalDateTime)
+                        File.SetLastWriteTime(fileInfo.FullName, dateTimeOffset.LocalDateTime);
+                }
+            }
+            if (!string.IsNullOrEmpty(nugetConfiguration.KeyFileExtensionC))
+            {
+                if (fileInfo.DirectoryName is null)
+                    throw new NullReferenceException(nameof(fileInfo.DirectoryName));
+                files = Directory.GetFiles(fileInfo.DirectoryName, nugetConfiguration.KeyFileExtensionC, SearchOption.TopDirectoryOnly);
+                foreach (string file in files)
+                {
+                    fileInfo = new(file);
+                    if (fileInfo.LastWriteTime != dateTimeOffset.LocalDateTime)
+                        File.SetLastWriteTime(fileInfo.FullName, dateTimeOffset.LocalDateTime);
+                }
+            }
+        }
+        catch (Exception)
+        {
+            string checkFile;
+            logger.LogInformation("<{fileInfo.FullName}> is invalid!", fileInfo.FullName);
+            checkFile = string.Concat(fileInfo.FullName, ".err");
+            for (int e = 0; e < short.MaxValue; e++)
+            {
+                if (!File.Exists(checkFile))
+                    break;
+                checkFile = string.Concat(checkFile, e);
+            }
+            try
+            { File.Move(fileInfo.FullName, checkFile); }
+            catch (Exception) { logger.LogInformation("<{fileInfo.FullName}> couldn't be moved!", fileInfo.FullName); }
+        }
+    }
+
+    private static void ExtractKeyFileAndSetDateFromZipEntry(ILogger<Worker> logger, NugetConfiguration nugetConfiguration, string[] zipFiles)
+    {
+        string[] files;
+        FileInfo fileInfo;
+        string? lowerName;
+        FileInfo extractKeyFileInfo;
+        foreach (string zipFile in zipFiles)
+        {
+            fileInfo = new(zipFile);
+            if (fileInfo.DirectoryName is null)
+                throw new NullReferenceException(nameof(fileInfo.DirectoryName));
+            lowerName = !nugetConfiguration.RenameToLower ? null : Path.Combine(fileInfo.DirectoryName, fileInfo.Name.ToLower());
+            if (nugetConfiguration.RenameToLower && lowerName is not null && lowerName != fileInfo.FullName)
+            {
+                files = Directory.GetFiles(fileInfo.DirectoryName, $"{Path.GetFileNameWithoutExtension(fileInfo.Name)}*", SearchOption.TopDirectoryOnly);
+                foreach (string file in files)
+                    File.Move(file, Path.Combine(fileInfo.DirectoryName, Path.GetFileName(file).ToLower()));
+                fileInfo = new(lowerName);
+                if (fileInfo.DirectoryName is null)
+                    throw new NullReferenceException(nameof(fileInfo.DirectoryName));
+            }
+            extractKeyFileInfo = new(Path.Combine(fileInfo.DirectoryName, $"{Path.GetFileNameWithoutExtension(fileInfo.Name)}{nugetConfiguration.KeyFileExtension}"));
+            if (extractKeyFileInfo.Exists)
+            {
+                if (extractKeyFileInfo.CreationTime.ToString("yyyy-MM-dd") == fileInfo.CreationTime.ToString("yyyy-MM-dd") && extractKeyFileInfo.LastWriteTime.ToString("yyyy-MM-dd") == fileInfo.LastWriteTime.ToString("yyyy-MM-dd"))
+                    continue;
+                File.Delete(extractKeyFileInfo.FullName);
+            }
+            DateTimeOffset? dateTimeOffset = GetDateTimeOffset(nugetConfiguration.KeyFileExtension, fileInfo, extractKeyFileInfo);
+            if (dateTimeOffset is null)
+                continue;
+            SetLastWriteTimes(logger, nugetConfiguration, fileInfo, dateTimeOffset.Value);
+        }
+    }
+
+    private static int CopyFiles(NugetConfiguration nugetConfiguration, string[] files)
+    {
+        int results = 0;
+        FileInfo fileInfo;
+        FileInfo checkFileInfo;
+        foreach (string file in files)
+        {
+            fileInfo = new(file);
+            checkFileInfo = new(Path.Combine(nugetConfiguration.Destination, fileInfo.Name));
+            if (!checkFileInfo.Exists || fileInfo.LastWriteTime != checkFileInfo.LastWriteTime || fileInfo.Length != checkFileInfo.Length)
+            {
+                File.Copy(fileInfo.FullName, checkFileInfo.FullName, overwrite: true);
+                results++;
+            }
+            if (string.IsNullOrEmpty(nugetConfiguration.KeyFileExtension))
+                continue;
+            fileInfo = new(Path.ChangeExtension(file, nugetConfiguration.KeyFileExtension));
+            checkFileInfo = new(Path.Combine(nugetConfiguration.Destination, Path.ChangeExtension(fileInfo.Name, nugetConfiguration.KeyFileExtension)));
+            if (!checkFileInfo.Exists || fileInfo.LastWriteTime != checkFileInfo.LastWriteTime || fileInfo.Length != checkFileInfo.Length)
+                File.Copy(fileInfo.FullName, checkFileInfo.FullName, overwrite: true);
+        }
+        return results;
+    }
+
+    internal static bool Sync(AppSettings appSettings, ILogger<Worker> logger)
+    {
+        NugetConfiguration nugetConfiguration = appSettings.NugetConfiguration;
+        if (!Directory.Exists(nugetConfiguration.Source))
+            _ = Directory.CreateDirectory(nugetConfiguration.Source);
+        if (!Directory.Exists(nugetConfiguration.Destination))
+            _ = Directory.CreateDirectory(nugetConfiguration.Destination);
+        string[] files = Directory.GetFiles(nugetConfiguration.Source, nugetConfiguration.SearchPattern, SearchOption.AllDirectories);
+        logger.LogInformation("Found {Files} file(s)", files.Length);
+        ExtractKeyFileAndSetDateFromZipEntry(logger, nugetConfiguration, files);
+        logger.LogInformation("{Files} file(s) verified", files.Length);
+        int filesCopied = CopyFiles(nugetConfiguration, files);
+        logger.LogInformation("Copied {FilesCopied} file(s)", filesCopied);
+        return true;
+    }
+
+}

Helpers/HelperStratus.cs

@@ -13,13 +13,14 @@ internal static partial class HelperStratus
     private static void TryMoveFile(AppSettings appSettings, string checkFile)
     {
         string line;
+        string checkDirectory;
         string weekYearDirectory;
         List<string> collection = [];
-        DateTime dateTime = DateTime.Now;
+        FileInfo fileInfo = new(checkFile);
         Calendar calendar = new CultureInfo("en-US").Calendar;
         char start = appSettings.StratusConfiguration.FileDelimiterPattern[0];
-        string[] lines = !File.Exists(checkFile) ? [] : File.ReadAllLines(checkFile);
+        string[] lines = !fileInfo.Exists ? [] : File.ReadAllLines(checkFile);
-        string weekOfYear = calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
+        string weekOfYear = calendar.GetWeekOfYear(fileInfo.CreationTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
         for (int i = 0; i < lines.Length; i++)
         {
             line = lines[i];
@@ -28,10 +29,11 @@ internal static partial class HelperStratus
                 continue;
             if (!Regex.Match(line, appSettings.StratusConfiguration.FileDelimiterPattern).Success)
                 continue;
-            weekYearDirectory = Path.Combine(appSettings.WatchDirectory, $"{dateTime.Year}_Week_{weekOfYear}");
+            weekYearDirectory = Path.Combine(appSettings.FileWatcherConfiguration.WatchDirectory, $"{fileInfo.CreationTime.Year}_Week_{weekOfYear}");
-            if (!Directory.Exists(weekYearDirectory))
+            checkDirectory = Path.Combine(weekYearDirectory, fileInfo.CreationTime.ToString("yyyy-MM-dd"));
-                _ = Directory.CreateDirectory(weekYearDirectory);
+            if (!Directory.Exists(checkDirectory))
-            File.WriteAllLines(Path.Combine(weekYearDirectory, $"{dateTime.Ticks}.txt"), collection);
+                _ = Directory.CreateDirectory(checkDirectory);
+            File.WriteAllLines(Path.Combine(checkDirectory, $"{fileInfo.CreationTime.Ticks}.txt"), collection);
             collection.Clear();
             for (int j = i + 1; j < lines.Length; j++)
                 collection.Add(lines[j]);
@@ -41,15 +43,64 @@ internal static partial class HelperStratus
         }
     }
 
+    private static void TryArchiveFilesFramework(string sourceDirectory, string pattern, string archiveDirectory, int days)
+    {
+        string checkFile;
+        FileInfo fileInfo;
+        string weekOfYear;
+        string checkDirectory;
+        string[] directorySegments;
+        DateTime dateTime = DateTime.Now.AddDays(-days);
+        Calendar calendar = new CultureInfo("en-US").Calendar;
+        string[] sourceDirectorySegments = sourceDirectory.Split(Path.DirectorySeparatorChar);
+        string[] files = Directory.GetFiles(sourceDirectory, pattern, SearchOption.AllDirectories);
+        if (sourceDirectorySegments.Length < 2)
+            throw new Exception("Can't be root drive!");
+        foreach (string file in files)
+        {
+            fileInfo = new FileInfo(file);
+            if (string.IsNullOrEmpty(fileInfo.DirectoryName) || fileInfo.LastWriteTime > dateTime)
+                continue;
+            directorySegments = fileInfo.DirectoryName.Split(Path.DirectorySeparatorChar);
+            if (directorySegments.Length < sourceDirectorySegments.Length)
+                continue;
+            weekOfYear = $"{fileInfo.CreationTime.Year}_Week_{calendar.GetWeekOfYear(fileInfo.CreationTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday):00}";
+            checkDirectory = string.Concat(archiveDirectory, Path.DirectorySeparatorChar, weekOfYear);
+            for (int i = sourceDirectorySegments.Length; i < directorySegments.Length; i++)
+                checkDirectory = string.Concat(checkDirectory, Path.DirectorySeparatorChar, directorySegments[i]);
+            checkDirectory = string.Concat(checkDirectory, Path.DirectorySeparatorChar, fileInfo.CreationTime.ToString("yyyy-MM-dd"));
+            if (!Directory.Exists(checkDirectory))
+                _ = Directory.CreateDirectory(checkDirectory);
+            checkFile = Path.Combine(checkDirectory, fileInfo.Name);
+            if (File.Exists(checkFile))
+                continue;
+            File.Move(fileInfo.FullName, checkFile);
+        }
+    }
+
     internal static bool MoveFile(AppSettings appSettings, ILogger<Worker> logger)
     {
-        string checkFile = Path.Combine(appSettings.WatchDirectory, appSettings.StratusConfiguration.WatchFile);
+        // http://10.95.154.10:8081/2023_Week_45/2023-11-08/a.txt
+        string checkFile = Path.Combine(appSettings.FileWatcherConfiguration.WatchDirectory, appSettings.StratusConfiguration.WatchFile);
         try
         { TryMoveFile(appSettings, checkFile); }
         catch (Exception ex)
         {
             logger.LogError(ex, "Inner loop error!");
-            Thread.Sleep(appSettings.MillisecondsDelay * 5);
+            Thread.Sleep(appSettings.FileWatcherConfiguration.MillisecondsDelay * 5);
+        }
+        Console.WriteLine("Hello");
+        int days = appSettings.StratusConfiguration.Days;
+        string pattern = appSettings.StratusConfiguration.FileDelimiterPattern;
+        string sourceDirectory = appSettings.FileWatcherConfiguration.WatchDirectory;
+        int millisecondsDelay = appSettings.FileWatcherConfiguration.MillisecondsDelay;
+        string archiveDirectory = Path.GetFullPath(appSettings.StratusConfiguration.Destination);
+        try
+        { TryArchiveFilesFramework(sourceDirectory, pattern, archiveDirectory, days); }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Inner loop error!");
+            Thread.Sleep(millisecondsDelay * 5);
         }
         return true;
     }

Helpers/HelperTCP.cs

@@ -99,7 +99,7 @@ internal static partial class HelperTCP
     {
         List<byte> results = [];
         byte[] bytes = new byte[1024];
-        string directory = Path.Combine(transmissionControlProtocolConfiguration.Destination, transmissionControlProtocolConfiguration.IPAddress);
+        string directory = Path.GetFullPath(Path.Combine(transmissionControlProtocolConfiguration.Destination, transmissionControlProtocolConfiguration.IPAddress));
         if (!Directory.Exists(directory))
             _ = Directory.CreateDirectory(directory);
         do
@@ -110,7 +110,7 @@ internal static partial class HelperTCP
         }
         while (networkStream.DataAvailable);
         if (results.Count > 0)
-            File.WriteAllBytes(string.Concat(directory, $"-{DateTime.Now.Ticks}{directory[^1]}.raw"), results.ToArray());
+            File.WriteAllBytes(Path.Combine(directory, $"{DateTime.Now.Ticks}{directory[^1]}.raw"), results.ToArray());
     }
 
     internal static bool ReadWrite(AppSettings appSettings, ILogger<Worker> logger)

Helpers/HelperWaferCounter.cs

@@ -11,7 +11,7 @@ internal static partial class HelperWaferCounter
         string checkFile;
         FileInfo fileInfo;
         string checkDirectory;
-        string[] directories = Directory.GetDirectories(appSettings.WatchDirectory, "*", SearchOption.TopDirectoryOnly);
+        string[] directories = Directory.GetDirectories(appSettings.FileWatcherConfiguration.WatchDirectory, "*", SearchOption.TopDirectoryOnly);
         foreach (string directory in directories)
         {
             checkDirectory = !appSettings.WaferCounterConfiguration.MatchPath ? appSettings.WaferCounterConfiguration.Destination : Path.Combine(appSettings.WaferCounterConfiguration.Destination, Path.GetFileName(directory));
@@ -23,7 +23,7 @@ internal static partial class HelperWaferCounter
                 foreach (string file in files)
                 {
                     fileInfo = new(file);
-                    if (new TimeSpan(DateTime.Now.Ticks - fileInfo.LastWriteTime.Ticks).TotalMilliseconds < appSettings.MillisecondsDelay)
+                    if (new TimeSpan(DateTime.Now.Ticks - fileInfo.LastWriteTime.Ticks).TotalMilliseconds < appSettings.FileWatcherConfiguration.MillisecondsDelay)
                         continue;
                     checkFile = Path.Combine(checkDirectory, Path.GetFileName(file));
                     if (File.Exists(checkFile))

Helpers/RijndaelEncryption.cs

@@ -2,10 +2,10 @@ using System.Security.Cryptography;
 using System.Text;
 using System.Text.RegularExpressions;
 
-namespace File_Watcher.Models;
+namespace File_Watcher.Helpers;
 
 public static class RijndaelEncryption
-{
+{ // cSpell:disable
 
     /// <summary>
     /// Change the input key GUID when you use this code in your own program.
@@ -25,7 +25,7 @@ public static class RijndaelEncryption
         string result;
         if (string.IsNullOrEmpty(text))
             throw new ArgumentNullException(nameof(text));
-#pragma warning disable
+#pragma warning disable SYSLIB0022
         RijndaelManaged aesAlg = NewRijndaelManaged(salt);
 #pragma warning restore
         ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
@@ -46,7 +46,7 @@ public static class RijndaelEncryption
     {
         bool result;
         base64String = base64String.Trim();
-#pragma warning disable
+#pragma warning restore
         result = (base64String.Length % 4 == 0) && Regex.IsMatch(base64String, @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None);
 #pragma warning restore
         return result;
@@ -65,7 +65,7 @@ public static class RijndaelEncryption
         if (!IsBase64String(cipherText))
             throw new Exception("The cipherText input parameter is not base64 encoded");
         string text;
-#pragma warning disable
+#pragma warning disable SYSLIB0022
         RijndaelManaged aesAlg = NewRijndaelManaged(salt);
 #pragma warning restore
         ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
@@ -84,11 +84,10 @@ public static class RijndaelEncryption
     /// </summary>
     /// <param name="salt">The password salt</param>
     /// <returns></returns>
-#pragma warning disable
+#pragma warning disable SYSLIB0022, SYSLIB0041, CA5379
     private static RijndaelManaged NewRijndaelManaged(string salt)
     {
-        if (salt == null)
+        ArgumentNullException.ThrowIfNull(salt);
-            throw new ArgumentNullException(nameof(salt));
         byte[] saltBytes = Encoding.ASCII.GetBytes(salt);
         Rfc2898DeriveBytes key = new(_InputKey, saltBytes);
         RijndaelManaged aesAlg = new();

Helpers/SeleniumHelper.cs

@@ -0,0 +1,45 @@
+using File_Watcher.Models;
+#if Selenium
+using OpenQA.Selenium;
+using OpenQA.Selenium.Edge;
+#endif
+
+namespace File_Watcher.Helpers;
+
+internal static partial class SeleniumHelper
+{
+
+    // <PackageReference Include="Selenium.WebDriver" Version="4.31.0" />
+    // <PackageReference Include="Selenium.WebDriver.MSEdgeDriver" Version="135.0.3179.85" />
+
+    internal static bool HyperTextMarkupLanguageToPortableNetworkGraphics(AppSettings appSettings, ILogger<Worker> logger)
+    {
+        if (!string.IsNullOrEmpty(appSettings.SeleniumConfiguration.UniformResourceLocator))
+            logger.LogInformation("This helper is disabled!");
+#if Selenium
+        EdgeOptions edgeOptions = new();
+        foreach (string edgeOption in appSettings.SeleniumConfiguration.EdgeOptions)
+            edgeOptions.AddArgument(edgeOption);
+        EdgeDriver edgeDriver = new(edgeOptions);
+        string outputFile = Path.Combine(appSettings.SeleniumConfiguration.DestinationDirectory, $"{DateTime.Now:yyyy-MM-dd;HH-mi-ss-fff}.png");
+        try
+        {
+            edgeDriver.Navigate().GoToUrl(appSettings.SeleniumConfiguration.UniformResourceLocator);
+#pragma warning disable CS8602, CS8604
+            int fullWidth = int.Parse(edgeDriver.ExecuteScript("return document.body.parentNode.scrollWidth").ToString());
+            int fullHeight = int.Parse(edgeDriver.ExecuteScript("return document.body.parentNode.scrollHeight").ToString());
+#pragma warning restore CS8602, CS8604
+            edgeDriver.Manage().Window.Size = new(fullWidth, fullHeight);
+            Screenshot screenshot = edgeDriver.GetScreenshot();
+            screenshot.SaveAsFile(outputFile);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, ex.Message);
+        }
+        edgeDriver.Close();
+#endif
+        return true;
+    }
+
+}

Helpers/SyncHelper.cs

@@ -0,0 +1,51 @@
+using File_Watcher.Models;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Helpers;
+
+internal static partial class SyncHelper
+{
+
+    private record Record(string RelativePath,
+                          long Size,
+                          long Ticks);
+
+    private record RelativePath(string Path,
+                                Record[] Records);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(RelativePath))]
+    private partial class RelativePathSourceGenerationContext : JsonSerializerContext
+    {
+    }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Dictionary<string, object>))]
+    private partial class DictionaryStringObjectBSourceGenerationContext : JsonSerializerContext
+    {
+    }
+
+    internal static bool Check(AppSettings _, ILogger<Worker> __) =>
+        true;
+
+    internal static string GetReply(string body, Dictionary<string, object> keyValuePairs)
+    {
+        string? json;
+        RelativePath? relativePath;
+        if (!string.IsNullOrEmpty(body) && body[0] == '{')
+        {
+            File.WriteAllText(".json", body);
+            relativePath = JsonSerializer.Deserialize(body, RelativePathSourceGenerationContext.Default.RelativePath) ?? throw new NullReferenceException();
+        }
+        else
+        {
+            json = JsonSerializer.Serialize(keyValuePairs, DictionaryStringObjectBSourceGenerationContext.Default.DictionaryStringObject);
+            File.WriteAllText(".json", json);
+            relativePath = JsonSerializer.Deserialize(json, RelativePathSourceGenerationContext.Default.RelativePath) ?? throw new NullReferenceException();
+        }
+        if (relativePath is null)
+        { }
+        return $"wait-{relativePath?.Records.Length}";
+    }
+}

Infineon/Monitoring/MonA/IMonIn.cs

@@ -0,0 +1,145 @@
+namespace File_Watcher.Infineon.Monitoring.MonA;
+
+public interface IMonIn
+{
+    Task<HttpResponseMessage> SendStatus(string site, string resource, string stateName, State state);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         DateTime timeStamp,
+                                         string resource,
+                                         string stateName,
+                                         State state);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         string resource,
+                                         string stateName,
+                                         State state,
+                                         string description);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         DateTime timeStamp,
+                                         string resource,
+                                         string stateName,
+                                         State state,
+                                         string description);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         string resource,
+                                         string subResource,
+                                         string stateName,
+                                         State state);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         DateTime timeStamp,
+                                         string resource,
+                                         string subResource,
+                                         string stateName,
+                                         State state);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         string resource,
+                                         string subResource,
+                                         string stateName,
+                                         State state,
+                                         string description);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         DateTime? timeStamp,
+                                         string resource,
+                                         string subResource,
+                                         string stateName,
+                                         State state,
+                                         string description);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string description);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string description);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value,
+                                                     int? interval);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     string resource,
+                                                     DateTime? timeStamp,
+                                                     string performanceName,
+                                                     double value,
+                                                     string unit);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string unit,
+                                                     int? interval);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string description);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value,
+                                                     int? interval);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string unit);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string description,
+                                                     string unit,
+                                                     int? interval);
+}

Infineon/Monitoring/MonA/MonIn.cs

@@ -0,0 +1,266 @@
+using System.Globalization;
+using System.Text;
+
+namespace File_Watcher.Infineon.Monitoring.MonA;
+
+public class MonIn : IMonIn
+{
+    private readonly string _MonInUrl;
+    private readonly HttpClient _HttpClient;
+    private static CultureInfo? _CultureInfo;
+    private static readonly Dictionary<string, MonIn> _Instances = [];
+    public const string MonInUrl = "http://moninhttp.{0}.infineon.com/input/text";
+    private static readonly DateTime _Utc1970DateTime = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+    public static MonIn GetInstance(IHttpClientFactory httpClientFactory, string url = MonInUrl)
+    {
+        MonIn instance;
+        if (_Instances.ContainsKey(url))
+        {
+            instance = _Instances[url];
+        }
+        else
+        {
+            lock (_Instances)
+            {
+                if (!_Instances.ContainsKey(url))
+                {
+                    instance = new MonIn(httpClientFactory, url);
+                    _Instances.Add(url, instance);
+                }
+                else
+                    instance = _Instances[url];
+            }
+        }
+        return instance;
+    }
+
+    private MonIn(IHttpClientFactory httpClientFactory, string url)
+    {
+        _MonInUrl = url;
+        _CultureInfo = new CultureInfo("en-US");
+        _HttpClient = httpClientFactory.CreateClient();
+    }
+
+    public Task<HttpResponseMessage> SendStatus(string site, string resource, string stateName, State state) =>
+        SendStatus(site, new DateTime?(), resource, string.Empty, stateName, state, string.Empty);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                DateTime timeStamp,
+                                                string resource,
+                                                string stateName,
+                                                State state) =>
+        SendStatus(site, new DateTime?(timeStamp), resource, string.Empty, stateName, state, string.Empty);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                string resource,
+                                                string stateName,
+                                                State state,
+                                                string description) =>
+        SendStatus(site, new DateTime?(), resource, string.Empty, stateName, state, description);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                DateTime timeStamp,
+                                                string resource,
+                                                string stateName,
+                                                State state,
+                                                string description) =>
+        SendStatus(site, new DateTime?(timeStamp), resource, string.Empty, stateName, state, description);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                string resource,
+                                                string subResource,
+                                                string stateName,
+                                                State state) =>
+        SendStatus(site, new DateTime?(), resource, subResource, stateName, state, string.Empty);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                DateTime timeStamp,
+                                                string resource,
+                                                string subResource,
+                                                string stateName,
+                                                State state) =>
+        SendStatus(site, new DateTime?(timeStamp), resource, subResource, stateName, state, string.Empty);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                string resource,
+                                                string subResource,
+                                                string stateName,
+                                                State state,
+                                                string description) =>
+        SendStatus(site, new DateTime?(), resource, subResource, stateName, state, description);
+
+    public Task<HttpResponseMessage> SendStatus(
+      string site,
+      DateTime? timeStamp,
+      string resource,
+      string subResource,
+      string stateName,
+      State state,
+      string description)
+    {
+        string statusMessage = CreateStatusMessage(site, timeStamp, resource, subResource, stateName, state.ToString(), description);
+        StringContent stringContent = new(statusMessage, Encoding.UTF8, "application/text");
+        lock (_HttpClient)
+            return _HttpClient.PostAsync(string.Format(_MonInUrl, site), stringContent);
+    }
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value) =>
+        SendPerformanceMessage(site, new DateTime?(), resource, string.Empty, performanceName, value, string.Empty, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value) =>
+        SendPerformanceMessage(site, timeStamp, resource, string.Empty, performanceName, value, string.Empty, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string description) =>
+        SendPerformanceMessage(site, new DateTime?(), resource, string.Empty, performanceName, value, description, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string description) =>
+        SendPerformanceMessage(site, timeStamp, resource, string.Empty, performanceName, value, description, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value,
+                                                            int? interval) =>
+        SendPerformanceMessage(site, timeStamp, resource, string.Empty, performanceName, value, string.Empty, string.Empty, interval);
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            string resource,
+                                                            DateTime? timeStamp,
+                                                            string performanceName,
+                                                            double value,
+                                                            string unit) =>
+        SendPerformanceMessage(site, timeStamp, resource, string.Empty, performanceName, value, string.Empty, unit, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string unit,
+                                                            int? interval) =>
+        SendPerformanceMessage(site, timeStamp, resource, string.Empty, performanceName, value, string.Empty, unit, interval);
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value) =>
+        SendPerformanceMessage(site, new DateTime?(), resource, subResource, performanceName, value, string.Empty, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value) =>
+        SendPerformanceMessage(site, timeStamp, resource, subResource, performanceName, value, string.Empty, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string description) =>
+        SendPerformanceMessage(site, new DateTime?(), resource, subResource, performanceName, value, description, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value,
+                                                            int? interval) =>
+        SendPerformanceMessage(site, timeStamp, resource, subResource, performanceName, value, string.Empty, string.Empty, interval);
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string unit) =>
+        SendPerformanceMessage(site, timeStamp, resource, subResource, performanceName, value, string.Empty, unit, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string description,
+                                                            string unit,
+                                                            int? interval)
+    {
+        string performanceMessage = CreatePerformanceMessage(site, timeStamp, resource, subResource, performanceName, value, description, unit, interval);
+        StringContent stringContent = new(performanceMessage, Encoding.UTF8, "application/text");
+        lock (_HttpClient)
+            return _HttpClient.PostAsync(string.Format(_MonInUrl, site), stringContent);
+    }
+
+    private static string CreateStatusMessage(string site,
+                                              DateTime? timeStamp,
+                                              string resource,
+                                              string subResource,
+                                              string stateName,
+                                              string state,
+                                              string description)
+    {
+        StringBuilder stringBuilder = new();
+        if (string.IsNullOrEmpty(subResource))
+            _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" {4} \n{5}", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), stateName.Trim(), state.Trim(), description.Trim());
+        else
+            _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" \"{4}\" {5} \n{6}", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), subResource.Trim(), stateName.Trim(), state.Trim(), description.Trim());
+        return stringBuilder.ToString();
+    }
+
+    private static string CreatePerformanceMessage(string site,
+                                                   DateTime? timeStamp,
+                                                   string resource,
+                                                   string subResource,
+                                                   string performanceName,
+                                                   double value,
+                                                   string description,
+                                                   string unit,
+                                                   int? interval)
+    {
+        StringBuilder stringBuilder = new();
+        if (string.IsNullOrEmpty(subResource))
+        {
+            if (unit.Equals(string.Empty) && !interval.HasValue)
+                _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" {4} \n{5}", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), performanceName.Trim(), value, description.Trim());
+            else
+                _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" {4} {5} {{interval={6}, unit={7}}}\n", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), performanceName.Trim(), value, description.Trim(), interval.HasValue ? interval.Value.ToString() : (object)string.Empty, unit.Trim());
+        }
+        else if (unit.Equals(string.Empty) && !interval.HasValue)
+            _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" \"{4}\" {5} \n{6}", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), subResource.Trim(), performanceName.Trim(), value, description.Trim());
+        else
+            _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" \"{4}\" {5} {6} {{interval={7}, unit={8}}}\n", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), subResource.Trim(), performanceName.Trim(), value, description.Trim(), interval.HasValue ? interval.Value.ToString() : (object)string.Empty, unit.Trim());
+        return stringBuilder.ToString();
+    }
+
+    private static string GetDateTimeNowAsPosix(DateTime timeStamp)
+    {
+        if (timeStamp > DateTime.Now)
+            timeStamp = DateTime.Now;
+        return ((int)timeStamp.ToUniversalTime().Subtract(_Utc1970DateTime).TotalSeconds).ToString(CultureInfo.InvariantCulture);
+    }
+
+}

Infineon/Monitoring/MonA/State.cs

@@ -0,0 +1,11 @@
+namespace File_Watcher.Infineon.Monitoring.MonA;
+
+public enum State
+{
+    Up,
+    Ok,
+    Warning,
+    Critical,
+    Down,
+    Unknown,
+}

Models/AppSettings.cs

@@ -1,26 +1,119 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using View_by_Distance.Shared.Models;
 
 namespace File_Watcher.Models;
 
-public record AppSettings(EAFLogConfiguration EAFLogConfiguration,
+public record AppSettings(CamstarOracleConfiguration CamstarOracleConfiguration,
-                          EAFProgramDataConfiguration EAFProgramDataConfiguration,
-                          EDADatabaseConfiguration EDADatabaseConfiguration,
                           CompassConfiguration CompassConfiguration,
+                          DeterministicHashCodeConfiguration DeterministicHashCodeConfiguration,
+                          DiskInfoConfiguration DiskInfoConfiguration,
                           DriveConfiguration DriveConfiguration,
+                          EAFLogConfiguration EAFLogConfiguration,
+                          EDADatabaseConfiguration EDADatabaseConfiguration,
+                          FileWatcherConfiguration FileWatcherConfiguration,
+                          InfinityQSConfiguration InfinityQSConfiguration,
+                          IsoConfiguration IsoConfiguration,
+                          MetadataSettings MetadataSettings,
                           MetrologyConfiguration MetrologyConfiguration,
+                          NugetConfiguration NugetConfiguration,
+                          ResultSettings ResultSettings,
+                          SeleniumConfiguration SeleniumConfiguration,
                           SerialConfiguration SerialConfiguration,
                           StratusConfiguration StratusConfiguration,
+                          SyncConfiguration SyncConfiguration,
                           TransmissionControlProtocolConfiguration TransmissionControlProtocolConfiguration,
-                          WaferCounterConfiguration WaferCounterConfiguration,
+                          WaferCounterConfiguration WaferCounterConfiguration)
-                          string BuildNumber,
-                          string Company,
-                          string GitCommitSeven,
-                          string Helper,
-                          int MillisecondsDelay,
-                          string WatchDirectory)
 {
 
+    public static AppSettings Get(IConfigurationRoot configurationRoot)
+    {
+        AppSettings result;
+#pragma warning disable IL3050, IL2026
+        CamstarOracleConfiguration? camstarOracleConfiguration = configurationRoot.GetSection(nameof(CamstarOracleConfiguration)).Get<CamstarOracleConfiguration>();
+        CompassConfiguration? compassConfiguration = configurationRoot.GetSection(nameof(CompassConfiguration)).Get<CompassConfiguration>();
+        DiskInfoConfiguration? diskInfoConfiguration = configurationRoot.GetSection(nameof(DiskInfoConfiguration)).Get<DiskInfoConfiguration>();
+        DeterministicHashCodeConfiguration? deterministicHashCodeConfiguration = configurationRoot.GetSection(nameof(DeterministicHashCodeConfiguration)).Get<DeterministicHashCodeConfiguration>();
+        DriveConfiguration? driveConfiguration = configurationRoot.GetSection(nameof(DriveConfiguration)).Get<DriveConfiguration>();
+        EAFLogConfiguration? eafLogConfiguration = configurationRoot.GetSection(nameof(EAFLogConfiguration)).Get<EAFLogConfiguration>();
+        EDADatabaseConfiguration? edaDatabaseConfiguration = configurationRoot.GetSection(nameof(EDADatabaseConfiguration)).Get<EDADatabaseConfiguration>();
+        FileWatcherConfiguration? fileWatcherConfiguration = configurationRoot.GetSection(nameof(FileWatcherConfiguration)).Get<FileWatcherConfiguration>();
+        InfinityQSConfiguration? infinityQSConfiguration = configurationRoot.GetSection(nameof(InfinityQSConfiguration)).Get<InfinityQSConfiguration>();
+        IsoConfiguration? isoConfiguration = configurationRoot.GetSection(nameof(IsoConfiguration)).Get<IsoConfiguration>();
+        MetadataSettings? metadataSettings = configurationRoot.GetSection(nameof(MetadataSettings)).Get<MetadataSettings>();
+        MetrologyConfiguration? metrologyConfiguration = configurationRoot.GetSection(nameof(MetrologyConfiguration)).Get<MetrologyConfiguration>();
+        NugetConfiguration? nugetConfiguration = configurationRoot.GetSection(nameof(NugetConfiguration)).Get<NugetConfiguration>();
+        ResultSettings? resultSettings = configurationRoot.GetSection(nameof(ResultSettings)).Get<ResultSettings>();
+        SeleniumConfiguration? seleniumConfiguration = configurationRoot.GetSection(nameof(SeleniumConfiguration)).Get<SeleniumConfiguration>();
+        SerialConfiguration? serialConfiguration = configurationRoot.GetSection(nameof(SerialConfiguration)).Get<SerialConfiguration>();
+        StratusConfiguration? stratusConfiguration = configurationRoot.GetSection(nameof(StratusConfiguration)).Get<StratusConfiguration>();
+        SyncConfiguration? syncConfiguration = configurationRoot.GetSection(nameof(SyncConfiguration)).Get<SyncConfiguration>();
+        TransmissionControlProtocolConfiguration? transmissionControlProtocolConfiguration = configurationRoot.GetSection(nameof(TransmissionControlProtocolConfiguration)).Get<TransmissionControlProtocolConfiguration>();
+        WaferCounterConfiguration? waferCounterConfiguration = configurationRoot.GetSection(nameof(WaferCounterConfiguration)).Get<WaferCounterConfiguration>();
+#pragma warning restore IL3050, IL2026
+        if (camstarOracleConfiguration is null
+            || compassConfiguration is null
+            || deterministicHashCodeConfiguration is null
+            || diskInfoConfiguration is null
+            || driveConfiguration is null
+            || eafLogConfiguration is null
+            || edaDatabaseConfiguration is null
+            || fileWatcherConfiguration is null
+            || infinityQSConfiguration is null
+            || isoConfiguration is null
+            || metadataSettings is null
+            || metrologyConfiguration is null
+            || nugetConfiguration is null
+            || resultSettings is null
+            || seleniumConfiguration is null
+            || serialConfiguration is null
+            || stratusConfiguration is null
+            || syncConfiguration is null
+            || transmissionControlProtocolConfiguration is null
+            || waferCounterConfiguration is null
+            || fileWatcherConfiguration?.Company is null)
+        {
+            List<string> paths = [];
+            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
+            {
+                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
+                    continue;
+                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
+                    continue;
+                paths.Add(physicalFileProvider.Root);
+            }
+            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
+        }
+        result = new(camstarOracleConfiguration,
+                     compassConfiguration,
+                     deterministicHashCodeConfiguration,
+                     diskInfoConfiguration,
+                     driveConfiguration,
+                     eafLogConfiguration,
+                     edaDatabaseConfiguration,
+                     fileWatcherConfiguration,
+                     infinityQSConfiguration,
+                     isoConfiguration,
+                     metadataSettings,
+                     metrologyConfiguration,
+                     nugetConfiguration,
+                     resultSettings,
+                     seleniumConfiguration,
+                     serialConfiguration,
+                     stratusConfiguration,
+                     syncConfiguration,
+                     transmissionControlProtocolConfiguration,
+                     waferCounterConfiguration);
+        Verify(result);
+        return result;
+    }
+
+    private static void Verify(AppSettings appSettings)
+    {
+        if (appSettings.DeterministicHashCodeConfiguration.MaxDegreeOfParallelism > Environment.ProcessorCount)
+            throw new Exception($"Environment.ProcessorCount must be larger or equal to {nameof(appSettings.DeterministicHashCodeConfiguration.MaxDegreeOfParallelism)}");
+    }
+
     public override string ToString()
     {
         string result = JsonSerializer.Serialize(this, AppSettingsSourceGenerationContext.Default.AppSettings);

Models/Binder/.editorconfig

@@ -1,2 +0,0 @@
-[*.cs]
-csharp_preserve_single_line_statements = true

Models/Binder/AppSettings.cs

@@ -1,120 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models.Binder;
-
-public class AppSettings
-{
-
-    public string? BuildNumber { get; set; }
-    public string? Company { get; set; }
-    public string? GitCommitSeven { get; set; }
-    public string? Helper { get; set; }
-    public int? MillisecondsDelay { get; set; }
-    public string? WatchDirectory { get; set; }
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, BinderAppSettingsSourceGenerationContext.Default.AppSettings);
-        return result;
-    }
-
-    private static void PreVerify(IConfigurationRoot configurationRoot, AppSettings? appSettings)
-    {
-        if (appSettings?.BuildNumber is null)
-        {
-            List<string> paths = [];
-            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
-            {
-                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
-                    continue;
-                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
-                    continue;
-                paths.Add(physicalFileProvider.Root);
-            }
-            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
-        }
-    }
-
-    private static void Verify(AppSettings _)
-    {
-    }
-
-    private static Models.AppSettings Get(AppSettings? appSettings,
-                                          Models.DriveConfiguration driveConfiguration,
-                                          Models.CompassConfiguration compassConfiguration,
-                                          Models.EAFLogConfiguration eafLogConfiguration,
-                                          Models.EAFProgramDataConfiguration eafProgramDataConfiguration,
-                                          Models.EDADatabaseConfiguration edaDatabaseConfiguration,
-                                          Models.MetrologyConfiguration metrologyConfiguration,
-                                          Models.SerialConfiguration serialConfiguration,
-                                          Models.StratusConfiguration stratusConfiguration,
-                                          Models.TransmissionControlProtocolConfiguration transmissionControlProtocolConfiguration,
-                                          Models.WaferCounterConfiguration waferCounterConfiguration)
-    {
-        Models.AppSettings result;
-        if (appSettings is null) throw new NullReferenceException(nameof(appSettings));
-        if (appSettings.BuildNumber is null) throw new NullReferenceException(nameof(BuildNumber));
-        if (appSettings.Company is null) throw new NullReferenceException(nameof(Company));
-        if (appSettings.GitCommitSeven is null) throw new NullReferenceException(nameof(GitCommitSeven));
-        if (appSettings.Helper is null) throw new NullReferenceException(nameof(Helper));
-        if (appSettings.MillisecondsDelay is null) throw new NullReferenceException(nameof(MillisecondsDelay));
-        if (appSettings.WatchDirectory is null) throw new NullReferenceException(nameof(WatchDirectory));
-        Verify(appSettings);
-        result = new(eafLogConfiguration,
-                     eafProgramDataConfiguration,
-                     edaDatabaseConfiguration,
-                     compassConfiguration,
-                     driveConfiguration,
-                     metrologyConfiguration,
-                     serialConfiguration,
-                     stratusConfiguration,
-                     transmissionControlProtocolConfiguration,
-                     waferCounterConfiguration,
-                     appSettings.BuildNumber,
-                     appSettings.Company,
-                     appSettings.GitCommitSeven,
-                     appSettings.Helper,
-                     appSettings.MillisecondsDelay.Value,
-                     appSettings.WatchDirectory);
-        return result;
-    }
-
-    public static Models.AppSettings Get(IConfigurationRoot configurationRoot,
-                                         Models.CompassConfiguration compassConfiguration,
-                                         Models.DriveConfiguration driveConfiguration,
-                                         Models.EAFLogConfiguration eafLogConfiguration,
-                                         Models.EAFProgramDataConfiguration eafProgramDataConfiguration,
-                                         Models.EDADatabaseConfiguration edaDatabaseConfiguration,
-                                         Models.MetrologyConfiguration metrologyConfiguration,
-                                         Models.SerialConfiguration serialConfiguration,
-                                         Models.StratusConfiguration stratusConfiguration,
-                                         Models.TransmissionControlProtocolConfiguration transmissionControlProtocolConfiguration,
-                                         Models.WaferCounterConfiguration waferCounterConfiguration)
-    {
-        Models.AppSettings result;
-#pragma warning disable IL3050, IL2026
-        AppSettings? appSettings = configurationRoot.Get<AppSettings>();
-#pragma warning restore IL3050, IL2026
-        PreVerify(configurationRoot, appSettings);
-        result = Get(appSettings,
-                     driveConfiguration,
-                     compassConfiguration,
-                     eafLogConfiguration,
-                     eafProgramDataConfiguration,
-                     edaDatabaseConfiguration,
-                     metrologyConfiguration,
-                     serialConfiguration,
-                     stratusConfiguration,
-                     transmissionControlProtocolConfiguration,
-                     waferCounterConfiguration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(AppSettings))]
-internal partial class BinderAppSettingsSourceGenerationContext : JsonSerializerContext
-{
-}

Models/Binder/CompassConfiguration.cs

@@ -1,81 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models.Binder;
-
-public class CompassConfiguration
-{
-
-    public string? Destination { get; set; }
-    public int? HoursBack { get; set; }
-    public string? MonthPattern { get; set; }
-    public string? Pattern { get; set; }
-    public string? Source { get; set; }
-    public string? YearPattern { get; set; }
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, BinderCompassConfigurationSourceGenerationContext.Default.CompassConfiguration);
-        return result;
-    }
-
-    private static void PreVerify(IConfigurationRoot configurationRoot, CompassConfiguration? configuration)
-    {
-        if (configuration?.Destination is null)
-        {
-            List<string> paths = [];
-            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
-            {
-                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
-                    continue;
-                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
-                    continue;
-                paths.Add(physicalFileProvider.Root);
-            }
-            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
-        }
-    }
-
-    private static void Verify(CompassConfiguration _)
-    {
-    }
-
-    private static Models.CompassConfiguration Get(CompassConfiguration? configuration)
-    {
-        Models.CompassConfiguration result;
-        if (configuration is null) throw new NullReferenceException(nameof(configuration));
-        if (configuration.Destination is null) throw new NullReferenceException(nameof(configuration.Destination));
-        if (configuration.HoursBack is null) throw new NullReferenceException(nameof(configuration.HoursBack));
-        if (configuration.MonthPattern is null) throw new NullReferenceException(nameof(configuration.MonthPattern));
-        if (configuration.Pattern is null) throw new NullReferenceException(nameof(configuration.Pattern));
-        if (configuration.Source is null) throw new NullReferenceException(nameof(configuration.Source));
-        if (configuration.YearPattern is null) throw new NullReferenceException(nameof(configuration.YearPattern));
-        Verify(configuration);
-        result = new(configuration.Destination,
-                     configuration.HoursBack.Value,
-                     configuration.MonthPattern,
-                     configuration.Pattern,
-                     configuration.Source,
-                     configuration.YearPattern);
-        return result;
-    }
-
-    public static Models.CompassConfiguration Get(IConfigurationRoot configurationRoot)
-    {
-        Models.CompassConfiguration result;
-        IConfigurationSection configurationSection = configurationRoot.GetSection(nameof(Models.CompassConfiguration));
-#pragma warning disable IL3050, IL2026
-        CompassConfiguration? configuration = configurationSection.Get<CompassConfiguration>();
-#pragma warning restore IL3050, IL2026
-        PreVerify(configurationRoot, configuration);
-        result = Get(configuration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(CompassConfiguration))]
-internal partial class BinderCompassConfigurationSourceGenerationContext : JsonSerializerContext
-{
-}

Models/Binder/DriveConfiguration.cs

@@ -1,78 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models.Binder;
-
-public class DriveConfiguration
-{
-
-    public string? Letter { get; set; }
-    public string? Password { get; set; }
-    public string? Share { get; set; }
-    public bool? Use { get; set; }
-    public string? User { get; set; }
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, BinderDriveConfigurationSourceGenerationContext.Default.DriveConfiguration);
-        return result;
-    }
-
-    private static void PreVerify(IConfigurationRoot configurationRoot, DriveConfiguration? driveConfiguration)
-    {
-        if (driveConfiguration?.Letter is null)
-        {
-            List<string> paths = [];
-            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
-            {
-                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
-                    continue;
-                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
-                    continue;
-                paths.Add(physicalFileProvider.Root);
-            }
-            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
-        }
-    }
-
-    private static void Verify(DriveConfiguration _)
-    {
-    }
-
-    private static Models.DriveConfiguration Get(DriveConfiguration? driveConfiguration)
-    {
-        Models.DriveConfiguration result;
-        if (driveConfiguration?.Letter is null)
-            throw new NullReferenceException(nameof(Letter));
-        if (driveConfiguration?.Password is null)
-            throw new NullReferenceException(nameof(Password));
-        if (driveConfiguration?.Share is null)
-            throw new NullReferenceException(nameof(Share));
-        if (driveConfiguration?.Use is null)
-            throw new NullReferenceException(nameof(Use));
-        if (driveConfiguration?.User is null)
-            throw new NullReferenceException(nameof(User));
-        Verify(driveConfiguration);
-        result = new(driveConfiguration.Letter, driveConfiguration.Password, driveConfiguration.Share, driveConfiguration.Use.Value, driveConfiguration.User);
-        return result;
-    }
-
-    public static Models.DriveConfiguration Get(IConfigurationRoot configurationRoot)
-    {
-        Models.DriveConfiguration result;
-        IConfigurationSection configurationSection = configurationRoot.GetSection(nameof(Models.DriveConfiguration));
-#pragma warning disable IL3050, IL2026
-        DriveConfiguration? driveConfiguration = configurationSection.Get<DriveConfiguration>();
-#pragma warning restore IL3050, IL2026
-        PreVerify(configurationRoot, driveConfiguration);
-        result = Get(driveConfiguration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(DriveConfiguration))]
-internal partial class BinderDriveConfigurationSourceGenerationContext : JsonSerializerContext
-{
-}

Models/Binder/EAFLogConfiguration.cs

@@ -1,66 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models.Binder;
-
-public class EAFLogConfiguration
-{
-
-    public string? SearchPattern { get; set; }
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, BinderEAFLogConfigurationSourceGenerationContext.Default.EAFLogConfiguration);
-        return result;
-    }
-
-    private static void PreVerify(IConfigurationRoot configurationRoot, EAFLogConfiguration? configuration)
-    {
-        if (configuration?.SearchPattern is null)
-        {
-            List<string> paths = [];
-            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
-            {
-                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
-                    continue;
-                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
-                    continue;
-                paths.Add(physicalFileProvider.Root);
-            }
-            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
-        }
-    }
-
-    private static void Verify(EAFLogConfiguration _)
-    {
-    }
-
-    private static Models.EAFLogConfiguration Get(EAFLogConfiguration? configuration)
-    {
-        Models.EAFLogConfiguration result;
-        if (configuration is null) throw new NullReferenceException(nameof(configuration));
-        if (configuration.SearchPattern is null) throw new NullReferenceException(nameof(configuration.SearchPattern));
-        Verify(configuration);
-        result = new(configuration.SearchPattern);
-        return result;
-    }
-
-    public static Models.EAFLogConfiguration Get(IConfigurationRoot configurationRoot)
-    {
-        Models.EAFLogConfiguration result;
-        IConfigurationSection configurationSection = configurationRoot.GetSection(nameof(Models.EAFLogConfiguration));
-#pragma warning disable IL3050, IL2026
-        EAFLogConfiguration? configuration = configurationSection.Get<EAFLogConfiguration>();
-#pragma warning restore IL3050, IL2026
-        PreVerify(configurationRoot, configuration);
-        result = Get(configuration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(EAFLogConfiguration))]
-internal partial class BinderEAFLogConfigurationSourceGenerationContext : JsonSerializerContext
-{
-}

Models/Binder/EAFProgramDataConfiguration.cs

@@ -1,68 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models.Binder;
-
-public class EAFProgramDataConfiguration
-{
-
-    public string? Destination { get; set; }
-    public string? Source { get; set; }
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, BinderEAFProgramDataConfigurationSourceGenerationContext.Default.EAFProgramDataConfiguration);
-        return result;
-    }
-
-    private static void PreVerify(IConfigurationRoot configurationRoot, EAFProgramDataConfiguration? configuration)
-    {
-        if (configuration?.Destination is null)
-        {
-            List<string> paths = [];
-            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
-            {
-                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
-                    continue;
-                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
-                    continue;
-                paths.Add(physicalFileProvider.Root);
-            }
-            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
-        }
-    }
-
-    private static void Verify(EAFProgramDataConfiguration _)
-    {
-    }
-
-    private static Models.EAFProgramDataConfiguration Get(EAFProgramDataConfiguration? configuration)
-    {
-        Models.EAFProgramDataConfiguration result;
-        if (configuration is null) throw new NullReferenceException(nameof(configuration));
-        if (configuration.Destination is null) throw new NullReferenceException(nameof(configuration.Destination));
-        if (configuration.Source is null) throw new NullReferenceException(nameof(configuration.Source));
-        Verify(configuration);
-        result = new(configuration.Destination, configuration.Source);
-        return result;
-    }
-
-    public static Models.EAFProgramDataConfiguration Get(IConfigurationRoot configurationRoot)
-    {
-        Models.EAFProgramDataConfiguration result;
-        IConfigurationSection configurationSection = configurationRoot.GetSection(nameof(Models.EAFProgramDataConfiguration));
-#pragma warning disable IL3050, IL2026
-        EAFProgramDataConfiguration? configuration = configurationSection.Get<EAFProgramDataConfiguration>();
-#pragma warning restore IL3050, IL2026
-        PreVerify(configurationRoot, configuration);
-        result = Get(configuration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(EAFProgramDataConfiguration))]
-internal partial class BinderEAFProgramDataConfigurationSourceGenerationContext : JsonSerializerContext
-{
-}

Models/Binder/EDADatabaseConfiguration.cs

@@ -1,84 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models.Binder;
-
-public class EDADatabaseConfiguration
-{
-
-    public string? CSharpDateTimeFormat { get; set; }
-    public string? FileShare { get; set; }
-    public string? Name { get; set; }
-    public string? OracleDateTimeFormat { get; set; }
-    public string? Password { get; set; }
-    public string? TNS { get; set; }
-    public string? UserName { get; set; }
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, BinderEDADatabaseConfigurationSourceGenerationContext.Default.EDADatabaseConfiguration);
-        return result;
-    }
-
-    private static void PreVerify(IConfigurationRoot configurationRoot, EDADatabaseConfiguration? configuration)
-    {
-        if (configuration?.CSharpDateTimeFormat is null)
-        {
-            List<string> paths = [];
-            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
-            {
-                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
-                    continue;
-                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
-                    continue;
-                paths.Add(physicalFileProvider.Root);
-            }
-            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
-        }
-    }
-
-    private static void Verify(EDADatabaseConfiguration _)
-    {
-    }
-
-    private static Models.EDADatabaseConfiguration Get(EDADatabaseConfiguration? configuration)
-    {
-        Models.EDADatabaseConfiguration result;
-        if (configuration is null) throw new NullReferenceException(nameof(configuration));
-        if (configuration.CSharpDateTimeFormat is null) throw new NullReferenceException(nameof(configuration.CSharpDateTimeFormat));
-        if (configuration.FileShare is null) throw new NullReferenceException(nameof(configuration.FileShare));
-        if (configuration.Name is null) throw new NullReferenceException(nameof(configuration.Name));
-        if (configuration.OracleDateTimeFormat is null) throw new NullReferenceException(nameof(configuration.OracleDateTimeFormat));
-        if (configuration.Password is null) throw new NullReferenceException(nameof(configuration.Password));
-        if (configuration.TNS is null) throw new NullReferenceException(nameof(configuration.TNS));
-        if (configuration.UserName is null) throw new NullReferenceException(nameof(configuration.UserName));
-        Verify(configuration);
-        result = new(configuration.CSharpDateTimeFormat,
-                     configuration.FileShare,
-                     configuration.Name,
-                     configuration.OracleDateTimeFormat,
-                     configuration.Password,
-                     configuration.TNS,
-                     configuration.UserName);
-        return result;
-    }
-
-    public static Models.EDADatabaseConfiguration Get(IConfigurationRoot configurationRoot)
-    {
-        Models.EDADatabaseConfiguration result;
-        IConfigurationSection configurationSection = configurationRoot.GetSection(nameof(Models.EDADatabaseConfiguration));
-#pragma warning disable IL3050, IL2026
-        EDADatabaseConfiguration? configuration = configurationSection.Get<EDADatabaseConfiguration>();
-#pragma warning restore IL3050, IL2026
-        PreVerify(configurationRoot, configuration);
-        result = Get(configuration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(EDADatabaseConfiguration))]
-internal partial class BinderEDADatabaseConfigurationSourceGenerationContext : JsonSerializerContext
-{
-}

Models/Binder/MetrologyConfiguration.cs

@@ -1,75 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models.Binder;
-
-public class MetrologyConfiguration
-{
-
-    public int? DirectoriesBack { get; set; }
-    public int? DeleteOlderThanWeeks { get; set; }
-    public string[]? HardcodedValues { get; set; }
-    public string[]? SourceDirectories { get; set; }
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, BinderMetrologyConfigurationSourceGenerationContext.Default.MetrologyConfiguration);
-        return result;
-    }
-
-    private static void PreVerify(IConfigurationRoot configurationRoot, MetrologyConfiguration? configuration)
-    {
-        if (configuration?.DirectoriesBack is null)
-        {
-            List<string> paths = [];
-            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
-            {
-                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
-                    continue;
-                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
-                    continue;
-                paths.Add(physicalFileProvider.Root);
-            }
-            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
-        }
-    }
-
-    private static void Verify(MetrologyConfiguration _)
-    {
-    }
-
-    private static Models.MetrologyConfiguration Get(MetrologyConfiguration? configuration)
-    {
-        Models.MetrologyConfiguration result;
-        if (configuration is null) throw new NullReferenceException(nameof(configuration));
-        if (configuration.DirectoriesBack is null) throw new NullReferenceException(nameof(configuration.DirectoriesBack));
-        if (configuration.DeleteOlderThanWeeks is null) throw new NullReferenceException(nameof(configuration.DeleteOlderThanWeeks));
-        if (configuration.HardcodedValues is null) throw new NullReferenceException(nameof(configuration.HardcodedValues));
-        if (configuration.SourceDirectories is null) throw new NullReferenceException(nameof(configuration.SourceDirectories));
-        Verify(configuration);
-        result = new(configuration.DirectoriesBack.Value,
-                     configuration.DeleteOlderThanWeeks.Value,
-                     configuration.HardcodedValues,
-                     configuration.SourceDirectories);
-        return result;
-    }
-
-    public static Models.MetrologyConfiguration Get(IConfigurationRoot configurationRoot)
-    {
-        Models.MetrologyConfiguration result;
-        IConfigurationSection configurationSection = configurationRoot.GetSection(nameof(Models.MetrologyConfiguration));
-#pragma warning disable IL3050, IL2026
-        MetrologyConfiguration? configuration = configurationSection.Get<MetrologyConfiguration>();
-#pragma warning restore IL3050, IL2026
-        PreVerify(configurationRoot, configuration);
-        result = Get(configuration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(MetrologyConfiguration))]
-internal partial class BinderMetrologyConfigurationSourceGenerationContext : JsonSerializerContext
-{
-}

Models/Binder/SerialConfiguration.cs

@@ -1,74 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models.Binder;
-
-public class SerialConfiguration
-{
-
-    public string? Destination { get; set; }
-    public string? GhostPCLFileName { get; set; }
-    public string? LincPDFCFileName { get; set; }
-    public string? PortName { get; set; }
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, BinderSerialConfigurationSourceGenerationContext.Default.SerialConfiguration);
-        return result;
-    }
-
-    private static void PreVerify(IConfigurationRoot configurationRoot, SerialConfiguration? configuration)
-    {
-        if (configuration?.Destination is null)
-        {
-            List<string> paths = [];
-            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
-            {
-                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
-                    continue;
-                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
-                    continue;
-                paths.Add(physicalFileProvider.Root);
-            }
-            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
-        }
-    }
-
-    private static void Verify(SerialConfiguration _)
-    { }
-
-    private static Models.SerialConfiguration Get(SerialConfiguration? configuration)
-    {
-        Models.SerialConfiguration result;
-        if (configuration is null) throw new NullReferenceException(nameof(configuration));
-        if (configuration.Destination is null) throw new NullReferenceException(nameof(configuration.Destination));
-        if (configuration.GhostPCLFileName is null) throw new NullReferenceException(nameof(configuration.GhostPCLFileName));
-        if (configuration.LincPDFCFileName is null) throw new NullReferenceException(nameof(configuration.LincPDFCFileName));
-        if (configuration.PortName is null) throw new NullReferenceException(nameof(configuration.PortName));
-        Verify(configuration);
-        result = new(configuration.Destination,
-                     configuration.GhostPCLFileName,
-                     configuration.LincPDFCFileName,
-                     configuration.PortName);
-        return result;
-    }
-
-    public static Models.SerialConfiguration Get(IConfigurationRoot configurationRoot)
-    {
-        Models.SerialConfiguration result;
-        IConfigurationSection configurationSection = configurationRoot.GetSection(nameof(Models.SerialConfiguration));
-#pragma warning disable IL3050, IL2026
-        SerialConfiguration? configuration = configurationSection.Get<SerialConfiguration>();
-#pragma warning restore IL3050, IL2026
-        PreVerify(configurationRoot, configuration);
-        result = Get(configuration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(SerialConfiguration))]
-internal partial class BinderSerialConfigurationSourceGenerationContext : JsonSerializerContext
-{
-}

Models/Binder/StratusConfiguration.cs

@@ -1,72 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models.Binder;
-
-public class StratusConfiguration
-{
-
-    public string? Destination { get; set; }
-    public string? FileDelimiterPattern { get; set; }
-    public string? WatchFile { get; set; }
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, BinderStratusConfigurationSourceGenerationContext.Default.StratusConfiguration);
-        return result;
-    }
-
-    private static void PreVerify(IConfigurationRoot configurationRoot, StratusConfiguration? configuration)
-    {
-        if (configuration?.Destination is null)
-        {
-            List<string> paths = [];
-            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
-            {
-                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
-                    continue;
-                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
-                    continue;
-                paths.Add(physicalFileProvider.Root);
-            }
-            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
-        }
-    }
-
-    private static void Verify(StratusConfiguration _)
-    {
-    }
-
-    private static Models.StratusConfiguration Get(StratusConfiguration? configuration)
-    {
-        Models.StratusConfiguration result;
-        if (configuration is null) throw new NullReferenceException(nameof(configuration));
-        if (configuration.Destination is null) throw new NullReferenceException(nameof(configuration.Destination));
-        if (configuration.FileDelimiterPattern is null) throw new NullReferenceException(nameof(configuration.FileDelimiterPattern));
-        if (configuration.WatchFile is null) throw new NullReferenceException(nameof(configuration.WatchFile));
-        Verify(configuration);
-        result = new(configuration.Destination,
-                     configuration.FileDelimiterPattern,
-                     configuration.WatchFile);
-        return result;
-    }
-
-    public static Models.StratusConfiguration Get(IConfigurationRoot configurationRoot)
-    {
-        Models.StratusConfiguration result;
-        IConfigurationSection configurationSection = configurationRoot.GetSection(nameof(Models.StratusConfiguration));
-#pragma warning disable IL3050, IL2026
-        StratusConfiguration? configuration = configurationSection.Get<StratusConfiguration>();
-#pragma warning restore IL3050, IL2026
-        PreVerify(configurationRoot, configuration);
-        result = Get(configuration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(StratusConfiguration))]
-internal partial class BinderStratusConfigurationSourceGenerationContext : JsonSerializerContext
-{
-}

Models/Binder/TransmissionControlProtocolConfiguration.cs

@@ -1,89 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models.Binder;
-
-public class TransmissionControlProtocolConfiguration
-{
-
-    public string? Destination { get; set; }
-    public string? GhostPCLFileName { get; set; }
-    public string? IPAddress { get; set; }
-    public int? Port { get; set; }
-    public bool? Server { get; set; }
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, BinderTransmissionControlProtocolConfigurationSourceGenerationContext.Default.TransmissionControlProtocolConfiguration);
-        return result;
-    }
-
-    private static void PreVerify(IConfigurationRoot configurationRoot, TransmissionControlProtocolConfiguration? configuration)
-    {
-        if (configuration?.Destination is null)
-        {
-            List<string> paths = [];
-            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
-            {
-                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
-                    continue;
-                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
-                    continue;
-                paths.Add(physicalFileProvider.Root);
-            }
-            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
-        }
-    }
-
-    private static void Verify(TransmissionControlProtocolConfiguration _)
-    {
-        // if (transmissionControlProtocolConfiguration.IPAddresses is null) throw new NullReferenceException(nameof(transmissionControlProtocolConfiguration.IPAddresses));
-        // foreach (KeyValuePair<string, string[]> keyValuePair in transmissionControlProtocolConfiguration.IPAddresses)
-        // {
-        //     if (string.IsNullOrEmpty(keyValuePair.Key))
-        //         throw new Exception(nameof(IPAddresses));
-        //     foreach (string value in keyValuePair.Value)
-        //     {
-        //         if (string.IsNullOrEmpty(value))
-        //             throw new Exception(nameof(IPAddresses));
-        //     }
-        // }
-    }
-
-    private static Models.TransmissionControlProtocolConfiguration Get(TransmissionControlProtocolConfiguration? configuration)
-    {
-        Models.TransmissionControlProtocolConfiguration result;
-        if (configuration is null) throw new NullReferenceException(nameof(configuration));
-        if (configuration.Destination is null) throw new NullReferenceException(nameof(configuration.Destination));
-        if (configuration.GhostPCLFileName is null) throw new NullReferenceException(nameof(configuration.GhostPCLFileName));
-        if (configuration.IPAddress is null) throw new NullReferenceException(nameof(configuration.IPAddress));
-        if (configuration.Port is null) throw new NullReferenceException(nameof(configuration.Port));
-        if (configuration.Server is null) throw new NullReferenceException(nameof(configuration.Server));
-        Verify(configuration);
-        result = new(configuration.Destination,
-                     configuration.GhostPCLFileName,
-                     configuration.IPAddress,
-                     configuration.Port.Value,
-                     configuration.Server.Value);
-        return result;
-    }
-
-    public static Models.TransmissionControlProtocolConfiguration Get(IConfigurationRoot configurationRoot)
-    {
-        Models.TransmissionControlProtocolConfiguration result;
-        IConfigurationSection configurationSection = configurationRoot.GetSection(nameof(Models.TransmissionControlProtocolConfiguration));
-#pragma warning disable IL3050, IL2026
-        TransmissionControlProtocolConfiguration? configuration = configurationSection.Get<TransmissionControlProtocolConfiguration>();
-#pragma warning restore IL3050, IL2026
-        PreVerify(configurationRoot, configuration);
-        result = Get(configuration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(TransmissionControlProtocolConfiguration))]
-internal partial class BinderTransmissionControlProtocolConfigurationSourceGenerationContext : JsonSerializerContext
-{
-}

Models/Binder/WaferCounterConfiguration.cs

@@ -1,69 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models.Binder;
-
-public class WaferCounterConfiguration
-{
-
-    public string? Destination { get; set; }
-    public bool? MatchPath { get; set; }
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, BinderWaferCounterConfigurationSourceGenerationContext.Default.WaferCounterConfiguration);
-        return result;
-    }
-
-    private static void PreVerify(IConfigurationRoot configurationRoot, WaferCounterConfiguration? configuration)
-    {
-        if (configuration?.Destination is null)
-        {
-            List<string> paths = [];
-            foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
-            {
-                if (configurationProvider is not Microsoft.Extensions.Configuration.Json.JsonConfigurationProvider jsonConfigurationProvider)
-                    continue;
-                if (jsonConfigurationProvider.Source.FileProvider is not Microsoft.Extensions.FileProviders.PhysicalFileProvider physicalFileProvider)
-                    continue;
-                paths.Add(physicalFileProvider.Root);
-            }
-            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
-        }
-    }
-
-    private static void Verify(WaferCounterConfiguration _)
-    {
-    }
-
-    private static Models.WaferCounterConfiguration Get(WaferCounterConfiguration? configuration)
-    {
-        Models.WaferCounterConfiguration result;
-        if (configuration is null) throw new NullReferenceException(nameof(configuration));
-        if (configuration.Destination is null) throw new NullReferenceException(nameof(configuration.Destination));
-        if (configuration.MatchPath is null) throw new NullReferenceException(nameof(configuration.MatchPath));
-        Verify(configuration);
-        result = new(configuration.Destination,
-                     configuration.MatchPath.Value);
-        return result;
-    }
-
-    public static Models.WaferCounterConfiguration Get(IConfigurationRoot configurationRoot)
-    {
-        Models.WaferCounterConfiguration result;
-        IConfigurationSection configurationSection = configurationRoot.GetSection(nameof(Models.WaferCounterConfiguration));
-#pragma warning disable IL3050, IL2026
-        WaferCounterConfiguration? configuration = configurationSection.Get<WaferCounterConfiguration>();
-#pragma warning restore IL3050, IL2026
-        PreVerify(configurationRoot, configuration);
-        result = Get(configuration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(WaferCounterConfiguration))]
-internal partial class BinderWaferCounterConfigurationSourceGenerationContext : JsonSerializerContext
-{
-}

Models/CamstarOracleConfiguration.cs

@@ -0,0 +1,28 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record CamstarOracleConfiguration(string DateFormat,
+                                         string Directory,
+                                         string LogFilter,
+                                         string[] MessageFilters,
+                                         string MonitorApplicationResource,
+                                         string MonitorApplicationSite,
+                                         int MillisecondsDelay,
+                                         int RollingMinutes)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, CamstarOracleConfigurationSourceGenerationContext.Default.CamstarOracleConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(CamstarOracleConfiguration))]
+internal partial class CamstarOracleConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}

Models/CompassConfiguration.cs

@@ -8,6 +8,7 @@ public record CompassConfiguration(string Destination,
                                    string MonthPattern,
                                    string Pattern,
                                    string Source,
+                                   string TriggerAppendage,
                                    string YearPattern)
 {
 

Models/DeterministicHashCodeConfiguration.cs

@@ -0,0 +1,22 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record DeterministicHashCodeConfiguration(int MaxDegreeOfParallelism,
+                                                 string[] SidecarExtensions)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, DeterministicHashCodeConfigurationSourceGenerationContext.Default.DeterministicHashCodeConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(DeterministicHashCodeConfiguration))]
+internal partial class DeterministicHashCodeConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}

Models/DiskInfoConfiguration.cs

@@ -0,0 +1,24 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record DiskInfoConfiguration(int Bars,
+                                    string[] Classes,
+                                    string Destination,
+                                    decimal Max)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, DiskInfoConfigurationSourceGenerationContext.Default.DiskInfoConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(DiskInfoConfiguration))]
+internal partial class DiskInfoConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}

Models/EAFProgramDataConfiguration.cs

@@ -1,21 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace File_Watcher.Models;
-
-public record EAFProgramDataConfiguration(string Destination, string Source)
-{
-
-    public override string ToString()
-    {
-        string result = JsonSerializer.Serialize(this, EAFProgramDataConfigurationSourceGenerationContext.Default.EAFProgramDataConfiguration);
-        return result;
-    }
-
-}
-
-[JsonSourceGenerationOptions(WriteIndented = true)]
-[JsonSerializable(typeof(EAFProgramDataConfiguration))]
-internal partial class EAFProgramDataConfigurationSourceGenerationContext : JsonSerializerContext
-{
-}

Models/FileWatcherConfiguration.cs

@@ -0,0 +1,24 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record FileWatcherConfiguration(string Company,
+                                       string Helper,
+                                       int MillisecondsDelay,
+                                       string WatchDirectory)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, FileWatcherConfigurationSourceGenerationContext.Default.FileWatcherConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(FileWatcherConfiguration))]
+internal partial class FileWatcherConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}

Models/InfinityQSConfiguration.cs

@@ -0,0 +1,26 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record InfinityQSConfiguration(string ConnectionString,
+                                      string DestinationDirectory,
+                                      string EncryptedPassword,
+                                      long SubGroupTime,
+                                      string TestsFile,
+                                      Test[] Tests)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, InfinityQSConfigurationSourceGenerationContext.Default.InfinityQSConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(InfinityQSConfiguration))]
+internal partial class InfinityQSConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}

Models/IsoConfiguration.cs

@@ -0,0 +1,22 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record IsoConfiguration(string DestinationDirectory,
+                               string SourceDirectory)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, IsoConfigurationSourceGenerationContext.Default.IsoConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(IsoConfiguration))]
+internal partial class IsoConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}

Models/NugetConfiguration.cs

@@ -0,0 +1,27 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record NugetConfiguration(string Destination,
+                                 string KeyFileExtension,
+                                 string KeyFileExtensionB,
+                                 string KeyFileExtensionC,
+                                 bool RenameToLower,
+                                 string SearchPattern,
+                                 string Source)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, NugetConfigurationSourceGenerationContext.Default.NugetConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(NugetConfiguration))]
+internal partial class NugetConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}

Models/SeleniumConfiguration.cs

@@ -0,0 +1,23 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record SeleniumConfiguration(string DestinationDirectory,
+                                    string[] EdgeOptions,
+                                    string UniformResourceLocator)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, SeleniumConfigurationSourceGenerationContext.Default.SeleniumConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(SeleniumConfiguration))]
+internal partial class SeleniumConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}

Models/StratusConfiguration.cs

@@ -3,7 +3,8 @@ using System.Text.Json.Serialization;
 
 namespace File_Watcher.Models;
 
-public record StratusConfiguration(string Destination,
+public record StratusConfiguration(int Days,
+                                   string Destination,
                                    string FileDelimiterPattern,
                                    string WatchFile)
 {

Models/SyncConfiguration.cs

@@ -0,0 +1,21 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record SyncConfiguration(string UniformResourceLocator)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, SyncConfigurationSourceGenerationContext.Default.SyncConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(SyncConfiguration))]
+internal partial class SyncConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}

Models/Test.cs

@@ -0,0 +1,12 @@
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record Test(string Name,
+                   long Value);
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(Test[]))]
+internal partial class TestCollectionSourceGenerationContext : JsonSerializerContext
+{
+}

NancyModules/SyncModule.cs

@@ -0,0 +1,51 @@
+using Nancy;
+using Nancy.Extensions;
+
+namespace File_Watcher.NancyModules;
+
+public class SyncModule : NancyModule
+{
+
+    public SyncModule()
+    {
+        Get("/bob/v1/sync/", _ =>
+        {
+            string? result;
+            try
+            {
+                string query = Request.Url.Query;
+                IDictionary<string, IEnumerable<string>> collection = Nancy.Helpers.HttpUtility.ParseQueryString(query).ToDictionary();
+                result = collection is null ? "null" : collection.ToString();
+            }
+            catch (Exception ex)
+            {
+                result = ex.Message;
+            }
+            return result;
+        });
+        Post("/bob/v1/sync/", _ =>
+        {
+            string result;
+            // Notification notification;
+            // ILog log = LogManager.GetLogger(typeof(SyncModule));
+            // log.Info($"Enter-{nameof(Post)}");
+            try
+            {
+                string body = Request.Body.AsString();
+                DynamicDictionary form = Request.Form;
+                Dictionary<string, object> keyValuePairs = form.ToDictionary();
+                string reply = Helpers.SyncHelper.GetReply(body, keyValuePairs);
+                result = reply;
+            }
+            catch (Exception ex)
+            {
+                // log.Fatal($"Exception-{nameof(Post)}{Environment.NewLine}{ex.Message}{Environment.NewLine}{Environment.NewLine}{ex.StackTrace}");
+                result = ex.Message;
+                throw;
+            }
+            // log.Info($"Return-{nameof(Post)}");
+            return result;
+        });
+    }
+
+}

Program.cs

@@ -14,32 +14,17 @@ public class Program
         WebApplicationBuilder webApplicationBuilder = WebApplication.CreateBuilder(args);
 #pragma warning restore IL3050
         _ = webApplicationBuilder.Configuration.AddUserSecrets<Program>();
-        DriveConfiguration driveConfiguration = Models.Binder.DriveConfiguration.Get(webApplicationBuilder.Configuration);
+        AppSettings appSettings = AppSettings.Get(webApplicationBuilder.Configuration);
-        EAFLogConfiguration eafLogConfiguration = Models.Binder.EAFLogConfiguration.Get(webApplicationBuilder.Configuration);
+        if (string.IsNullOrEmpty(appSettings.FileWatcherConfiguration.Company))
-        EAFProgramDataConfiguration eafProgramDataConfiguration = Models.Binder.EAFProgramDataConfiguration.Get(webApplicationBuilder.Configuration);
-        EDADatabaseConfiguration edaDatabaseConfiguration = Models.Binder.EDADatabaseConfiguration.Get(webApplicationBuilder.Configuration);
-        SerialConfiguration serialConfiguration = Models.Binder.SerialConfiguration.Get(webApplicationBuilder.Configuration);
-        StratusConfiguration stratusConfiguration = Models.Binder.StratusConfiguration.Get(webApplicationBuilder.Configuration);
-        CompassConfiguration compassConfiguration = Models.Binder.CompassConfiguration.Get(webApplicationBuilder.Configuration);
-        MetrologyConfiguration metrologyConfiguration = Models.Binder.MetrologyConfiguration.Get(webApplicationBuilder.Configuration);
-        WaferCounterConfiguration waferCounterConfiguration = Models.Binder.WaferCounterConfiguration.Get(webApplicationBuilder.Configuration);
-        TransmissionControlProtocolConfiguration transmissionControlProtocolConfiguration = Models.Binder.TransmissionControlProtocolConfiguration.Get(webApplicationBuilder.Configuration);
-        AppSettings appSettings = Models.Binder.AppSettings.Get(webApplicationBuilder.Configuration,
-                                                                compassConfiguration,
-                                                                driveConfiguration,
-                                                                eafLogConfiguration,
-                                                                eafProgramDataConfiguration,
-                                                                edaDatabaseConfiguration,
-                                                                metrologyConfiguration,
-                                                                serialConfiguration,
-                                                                stratusConfiguration,
-                                                                transmissionControlProtocolConfiguration,
-                                                                waferCounterConfiguration);
-        if (string.IsNullOrEmpty(appSettings.Company))
             throw new Exception("Company name must have a value!");
         try
         {
-            List<string> collection = [];
+            List<string> collection =
+            [
+                $"BuildNumber:{webApplicationBuilder.Configuration.GetValue<string>("BuildNumber")};",
+                $"GitCommitSeven:{webApplicationBuilder.Configuration.GetValue<string>("GitCommitSeven")};"
+            ];
+            _ = webApplicationBuilder.Services.AddHttpClient();
             _ = webApplicationBuilder.Services.AddHostedService<Worker>();
             _ = webApplicationBuilder.Services.AddSingleton(collection);
             _ = webApplicationBuilder.Services.AddSingleton(appSettings);
@@ -57,13 +42,13 @@ public class Program
             }
             using WebApplication webApplication = webApplicationBuilder.Build();
             logger = webApplication.Services.GetRequiredService<ILogger<Program>>();
-            if (string.IsNullOrEmpty(appSettings.Company))
+            if (string.IsNullOrEmpty(appSettings.FileWatcherConfiguration.Company))
             {
                 Environment.ExitCode = -1;
                 _ = webApplication.StopAsync();
             }
             logger.LogInformation("Starting Web Application");
-            logger.LogCritical("{Company}", appSettings.Company);
+            logger.LogCritical("{Company}", appSettings.FileWatcherConfiguration.Company);
             await webApplication.RunAsync();
         }
         catch (Exception ex)

Startup.cs

@@ -0,0 +1,19 @@
+using Microsoft.Owin.Cors;
+using Nancy.Owin;
+using Owin;
+
+namespace File_Watcher;
+
+public class Startup
+{
+
+    public Startup()
+    { }
+
+    public void Configuration(IAppBuilder app)
+    {
+        _ = app.UseCors(CorsOptions.AllowAll);
+        _ = app.UseNancy();
+    }
+
+}

Worker.cs

@@ -10,63 +10,93 @@ public partial class Worker : BackgroundService
     private readonly bool _IsWindowsService;
     private readonly ILogger<Worker> _Logger;
     private readonly AppSettings _AppSettings;
+    private readonly IHttpClientFactory _HttpClientFactory;
 
-    public Worker(IServiceProvider serviceProvider, ILogger<Worker> logger, AppSettings appSettings, List<string> collection)
+    public Worker(IHttpClientFactory httpClientFactory, ILogger<Worker> logger, IServiceProvider serviceProvider, AppSettings appSettings, List<string> collection)
     {
         _Logger = logger;
         _AppSettings = appSettings;
-        logger.LogInformation("{buildNumber}-{gitCommitSeven}", _AppSettings.BuildNumber, _AppSettings.GitCommitSeven);
+        _HttpClientFactory = httpClientFactory;
+        logger.LogInformation(string.Join(Environment.NewLine, collection));
         try
         { logger.LogInformation("<{folder}>", Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)); }
         catch (Exception) { }
         _IsWindowsService = collection.Contains(nameof(WindowsServiceLifetime));
+        if (appSettings.FileWatcherConfiguration.Helper == nameof(Helpers.SyncHelper))
+        {
+            _ = Microsoft.Owin.Hosting.WebApp.Start<Startup>(appSettings.SyncConfiguration.UniformResourceLocator);
+            logger.LogInformation("Server running on {url}", appSettings.SyncConfiguration.UniformResourceLocator);
+        }
     }
 
-    private void BodyInner(CancellationToken cancellationToken)
+    public override Task StopAsync(CancellationToken cancellationToken)
     {
-        _Logger.LogInformation("A) Next execute will be at {date}", DateTime.Now.AddMilliseconds(_AppSettings.MillisecondsDelay).ToString("yyyy-MM-dd hh:mm:ss.fff tt"));
+        if (_AppSettings.FileWatcherConfiguration.Helper == nameof(Helpers.HelperCamstarOracle))
-        if (!Directory.Exists(_AppSettings.WatchDirectory))
+            Helpers.HelperCamstarOracle.Heartbeat(_AppSettings, _HttpClientFactory, _Logger, Infineon.Monitoring.MonA.State.Down, cancellationToken);
-            _ = Directory.CreateDirectory(_AppSettings.WatchDirectory);
+        return base.StopAsync(cancellationToken);
-        else
-        {
-            _ = _AppSettings.Helper switch
-            {
-                nameof(Helpers.HelperTCP) => Helpers.HelperTCP.ReadWrite(_AppSettings, _Logger),
-                nameof(Helpers.HelperCompass) => Helpers.HelperCompass.CopyFile(_AppSettings, _Logger),
-                nameof(Helpers.HelperStratus) => Helpers.HelperStratus.MoveFile(_AppSettings, _Logger),
-                nameof(Helpers.HelperEAFLog) => Helpers.HelperEAFLog.DeleteFiles(_AppSettings, _Logger),
-                nameof(Helpers.HelperInfinityQS) => Helpers.HelperInfinityQS.RunMI(_AppSettings, _Logger),
-                nameof(Helpers.HelperEventLog) => Helpers.HelperEventLog.ClearEventLogs(_AppSettings, _Logger),
-                nameof(Helpers.HelperWaferCounter) => Helpers.HelperWaferCounter.MoveFile(_AppSettings, _Logger),
-                nameof(Helpers.HelperEAFProgramData) => Helpers.HelperEAFProgramData.MoveFiles(_AppSettings, _Logger),
-                nameof(Helpers.HelperSerial) => Helpers.HelperSerial.ReadWrite(_AppSettings, _Logger, cancellationToken),
-                nameof(Helpers.HelperMetrologyFiles) => Helpers.HelperMetrologyFiles.SortAndDelete(_AppSettings, _Logger),
-                nameof(Helpers.HelperEDADatabase) => Helpers.HelperEDADatabase.SaveDataCollectionPlans(_AppSettings, _Logger, cancellationToken),
-                _ => throw new NotSupportedException()
-            };
-        }
-        _Logger.LogInformation("B) Next execute will be at {date}", DateTime.Now.AddMilliseconds(_AppSettings.MillisecondsDelay).ToString("yyyy-MM-dd hh:mm:ss.fff tt"));
     }
 
+    protected override async Task ExecuteAsync(CancellationToken cancellationToken) =>
+        await Body(cancellationToken);
+
     private async Task Body(CancellationToken cancellationToken)
     {
         if (!_IsWindowsService)
-            throw new EvaluateException("Set break point and skip!");
+        {
+            _Logger.LogInformation("Set break point and skip to run {_AppSettings.FileWatcherConfiguration.Helper}!", _AppSettings.FileWatcherConfiguration.Helper);
+            throw new EvaluateException($"Set break point and skip to run {_AppSettings.FileWatcherConfiguration.Helper}!");
+        }
         if (!_IsWindowsService)
         {
             for (int i = 0; i < int.MaxValue; i++)
             {
                 BodyInner(cancellationToken);
-                Thread.Sleep(500);
+                Thread.Sleep(_AppSettings.FileWatcherConfiguration.MillisecondsDelay);
             }
         }
         while (_IsWindowsService && !cancellationToken.IsCancellationRequested)
+        {
+            try
             {
                 BodyInner(cancellationToken);
-            await Task.Delay(_AppSettings.MillisecondsDelay, cancellationToken);
+                await Task.Delay(_AppSettings.FileWatcherConfiguration.MillisecondsDelay, cancellationToken);
+            }
+            catch (Exception ex) { _Logger.LogError(ex, "Unexpected Error!"); }
         }
     }
 
-    protected override async Task ExecuteAsync(CancellationToken cancellationToken) =>
+    private void BodyInner(CancellationToken cancellationToken)
-        await Body(cancellationToken);
+    {
+        _Logger.LogInformation("A) Next execute will be at {date}", DateTime.Now.AddMilliseconds(_AppSettings.FileWatcherConfiguration.MillisecondsDelay).ToString("yyyy-MM-dd hh:mm:ss.fff tt"));
+        if (!Directory.Exists(_AppSettings.FileWatcherConfiguration.WatchDirectory))
+            _ = Directory.CreateDirectory(_AppSettings.FileWatcherConfiguration.WatchDirectory);
+        else
+        {
+            _ = _AppSettings.FileWatcherConfiguration.Helper switch
+            {
+                nameof(Helpers.SyncHelper) => Helpers.SyncHelper.Check(_AppSettings, _Logger),
+                nameof(Helpers.HelperNuget) => Helpers.HelperNuget.Sync(_AppSettings, _Logger),
+                nameof(Helpers.HelperTCP) => Helpers.HelperTCP.ReadWrite(_AppSettings, _Logger),
+                nameof(Helpers.HelperISO) => Helpers.HelperISO.DirectoryToISO(_AppSettings, _Logger),
+                nameof(Helpers.HelperCompass) => Helpers.HelperCompass.CopyFile(_AppSettings, _Logger),
+                nameof(Helpers.HelperStratus) => Helpers.HelperStratus.MoveFile(_AppSettings, _Logger),
+                nameof(Helpers.HelperEAFLog) => Helpers.HelperEAFLog.DeleteFiles(_AppSettings, _Logger),
+                nameof(Helpers.DiskInfoHelper) => Helpers.DiskInfoHelper.WriteDiskInfo(_AppSettings, _Logger),
+                nameof(Helpers.HelperEventLog) => Helpers.HelperEventLog.ClearEventLogs(_AppSettings, _Logger),
+                nameof(Helpers.HelperInfinityQS) => Helpers.HelperInfinityQS.ProcessStart(_AppSettings, _Logger),
+                nameof(Helpers.HelperWaferCounter) => Helpers.HelperWaferCounter.MoveFile(_AppSettings, _Logger),
+                nameof(Helpers.HelperSerial) => Helpers.HelperSerial.ReadWrite(_AppSettings, _Logger, cancellationToken),
+                nameof(Helpers.HelperMetrologyFiles) => Helpers.HelperMetrologyFiles.SortAndDelete(_AppSettings, _Logger),
+                nameof(Helpers.DeterministicHashCodeHelper) => Helpers.DeterministicHashCodeHelper.WindowsWork(_AppSettings, _Logger),
+#if Selenium
+                nameof(Helpers.SeleniumHelper) => Helpers.SeleniumHelper.HyperTextMarkupLanguageToPortableNetworkGraphics(_AppSettings, _Logger),
+#endif
+                nameof(Helpers.HelperEDADatabase) => Helpers.HelperEDADatabase.SaveDataCollectionPlans(_AppSettings, _Logger, cancellationToken),
+                nameof(Helpers.HelperCamstarOracle) => Helpers.HelperCamstarOracle.Check(_AppSettings, _HttpClientFactory, _Logger, cancellationToken),
+                _ => throw new NotSupportedException()
+            };
+        }
+        _Logger.LogInformation("B) Next execute will be at {date}", DateTime.Now.AddMilliseconds(_AppSettings.FileWatcherConfiguration.MillisecondsDelay).ToString("yyyy-MM-dd hh:mm:ss.fff tt"));
+    }
+
 }

package-lock.json

@@ -1,35 +0,0 @@
-{
-    "name": "File-Watcher",
-    "lockfileVersion": 2,
-    "requires": true,
-    "packages": {
-        "": {
-            "devDependencies": {
-                "prettier": "3.0.0"
-            }
-        },
-        "node_modules/prettier": {
-            "version": "3.0.0",
-            "resolved": "http://localhost:4873/prettier/-/prettier-3.0.0.tgz",
-            "integrity": "sha512-zBf5eHpwHOGPC47h0zrPyNn+eAEIdEzfywMoYn2XPi0P44Zp0tSq64rq0xAREh4auw2cJZHo9QUob+NqCQky4g==",
-            "dev": true,
-            "bin": {
-                "prettier": "bin/prettier.cjs"
-            },
-            "engines": {
-                "node": ">=14"
-            },
-            "funding": {
-                "url": "https://github.com/prettier/prettier?sponsor=1"
-            }
-        }
-    },
-    "dependencies": {
-        "prettier": {
-            "version": "3.0.0",
-            "resolved": "http://localhost:4873/prettier/-/prettier-3.0.0.tgz",
-            "integrity": "sha512-zBf5eHpwHOGPC47h0zrPyNn+eAEIdEzfywMoYn2XPi0P44Zp0tSq64rq0xAREh4auw2cJZHo9QUob+NqCQky4g==",
-            "dev": true
-        }
-    }
-}

package.json

@@ -1,10 +0,0 @@
-{
-    "scripts": {
-        "prettier.check": "prettier . --check",
-        "prettier.write": "prettier . --write",
-        "garbage-collect": "git gc"
-    },
-    "devDependencies": {
-      "prettier": "3.0.0"
-    }
-}