disk-info-helper

selenium-helper (Not fully tested)

sync-helper (Not fully tested)

.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/

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>
@@ -12,7 +12,12 @@
   <ItemGroup>
     <PackageReference Include="CliWrap" Version="3.8.2" />
     <PackageReference Include="DiscUtils.Iso9660" Version="0.16.13" />
-    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Server" Version="8.0.14" />
+    <PackageReference Include="Nancy.Owin" Version="2.0.0" />
+    <PackageReference Include="Microsoft.Owin" Version="4.2.2" />
+    <PackageReference Include="Microsoft.Owin.Cors" Version="4.2.2" />
+    <PackageReference Include="Microsoft.Owin.Hosting" Version="4.2.2" />
+    <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" />
@@ -20,12 +25,12 @@
     <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.14" />
+    <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.14" />
+    <PackageReference Include="System.Drawing.Common" Version="8.0.16" />
     <PackageReference Include="System.IO.Ports" Version="8.0.0" />
-    <PackageReference Include="System.Text.Json" Version="9.0.3" />
+    <PackageReference Include="System.Text.Json" Version="9.0.5" />
     <PackageReference Include="Phares.AA.Shared" Version="8.0.114.12235" />
     <PackageReference Include="Phares.AA.Metadata" Version="8.0.114.12235" />
   </ItemGroup>

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/HelperCamstarOracle.cs

@@ -68,7 +68,7 @@ internal static partial class HelperCamstarOracle
         return results;
     }
 
-    internal static bool Check(AppSettings appSettings, ILogger<Worker> logger, CancellationToken cancellationToken)
+    internal static bool Check(AppSettings appSettings, IHttpClientFactory httpClientFactory, ILogger<Worker> logger, CancellationToken cancellationToken)
     {
         if (_MonIn is null)
             throw new NullReferenceException(nameof(_MonIn));
@@ -100,6 +100,7 @@ internal static partial class HelperCamstarOracle
         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)

Helpers/HelperInfinityQS.cs

@@ -17,7 +17,7 @@ internal static partial class HelperInfinityQS
         }
     }
 
-    private static void RunMI()
+    private static void RunMI(string decryptedPassword)
     {
 #pragma warning disable CA1416
         string processName = "iispcmi.exe";
@@ -27,7 +27,7 @@ internal static partial class HelperInfinityQS
             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);
@@ -36,10 +36,11 @@ internal static partial class HelperInfinityQS
 #pragma warning restore CA1416
     }
 
-    internal static bool Select(AppSettings appSettings, ILogger<Worker> logger)
+    internal static bool ProcessStart(AppSettings appSettings, ILogger<Worker> logger)
     {
         logger.LogInformation(appSettings.FileWatcherConfiguration.Company);
-        RunMI();
+        string decrypted = RijndaelEncryption.Decrypt(appSettings.InfinityQSConfiguration.EncryptedPassword, appSettings.FileWatcherConfiguration.Company);
+        RunMI(decrypted);
         return true;
     }
 }

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}";
+    }
+}

Models/AppSettings.cs

@@ -7,6 +7,7 @@ namespace File_Watcher.Models;
 public record AppSettings(CamstarOracleConfiguration CamstarOracleConfiguration,
                           CompassConfiguration CompassConfiguration,
                           DeterministicHashCodeConfiguration DeterministicHashCodeConfiguration,
+                          DiskInfoConfiguration DiskInfoConfiguration,
                           DriveConfiguration DriveConfiguration,
                           EAFLogConfiguration EAFLogConfiguration,
                           EDADatabaseConfiguration EDADatabaseConfiguration,
@@ -17,8 +18,10 @@ public record AppSettings(CamstarOracleConfiguration CamstarOracleConfiguration,
                           MetrologyConfiguration MetrologyConfiguration,
                           NugetConfiguration NugetConfiguration,
                           ResultSettings ResultSettings,
+                          SeleniumConfiguration SeleniumConfiguration,
                           SerialConfiguration SerialConfiguration,
                           StratusConfiguration StratusConfiguration,
+                          SyncConfiguration SyncConfiguration,
                           TransmissionControlProtocolConfiguration TransmissionControlProtocolConfiguration,
                           WaferCounterConfiguration WaferCounterConfiguration)
 {
@@ -29,6 +32,7 @@ public record AppSettings(CamstarOracleConfiguration CamstarOracleConfiguration,
 #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>();
@@ -40,14 +44,17 @@ public record AppSettings(CamstarOracleConfiguration CamstarOracleConfiguration,
         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
@@ -58,8 +65,10 @@ public record AppSettings(CamstarOracleConfiguration CamstarOracleConfiguration,
             || 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)
@@ -78,6 +87,7 @@ public record AppSettings(CamstarOracleConfiguration CamstarOracleConfiguration,
         result = new(camstarOracleConfiguration,
                      compassConfiguration,
                      deterministicHashCodeConfiguration,
+                     diskInfoConfiguration,
                      driveConfiguration,
                      eafLogConfiguration,
                      edaDatabaseConfiguration,
@@ -88,8 +98,10 @@ public record AppSettings(CamstarOracleConfiguration CamstarOracleConfiguration,
                      metrologyConfiguration,
                      nugetConfiguration,
                      resultSettings,
+                     seleniumConfiguration,
                      serialConfiguration,
                      stratusConfiguration,
+                     syncConfiguration,
                      transmissionControlProtocolConfiguration,
                      waferCounterConfiguration);
         Verify(result);

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/InfinityQSConfiguration.cs

@@ -3,17 +3,9 @@ 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
-{
-}
-
 public record InfinityQSConfiguration(string ConnectionString,
                                       string DestinationDirectory,
+                                      string EncryptedPassword,
                                       long SubGroupTime,
                                       string TestsFile,
                                       Test[] Tests)

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/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;
+        });
+    }
+
+}

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

@@ -1,4 +1,4 @@
-using File_Watcher.Models;
+using File_Watcher.Models;
 using Microsoft.Extensions.Hosting.WindowsServices;
 using System.Data;
 
@@ -7,7 +7,6 @@ namespace File_Watcher;
 public partial class Worker : BackgroundService
 {
 
-    private bool? _First;
     private readonly bool _IsWindowsService;
     private readonly ILogger<Worker> _Logger;
     private readonly AppSettings _AppSettings;
@@ -22,8 +21,12 @@ public partial class Worker : BackgroundService
         try
         { logger.LogInformation("<{folder}>", Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)); }
         catch (Exception) { }
-        _First = null;
         _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);
+        }
     }
 
     public override Task StopAsync(CancellationToken cancellationToken)
@@ -35,6 +38,7 @@ public partial class Worker : BackgroundService
 
     protected override async Task ExecuteAsync(CancellationToken cancellationToken) =>
         await Body(cancellationToken);
+
     private async Task Body(CancellationToken cancellationToken)
     {
         if (!_IsWindowsService)
@@ -52,40 +56,43 @@ public partial class Worker : BackgroundService
         }
         while (_IsWindowsService && !cancellationToken.IsCancellationRequested)
         {
-            BodyInner(cancellationToken);
+            try
-            await Task.Delay(_AppSettings.FileWatcherConfiguration.MillisecondsDelay, cancellationToken);
+            {
+                BodyInner(cancellationToken);
+                await Task.Delay(_AppSettings.FileWatcherConfiguration.MillisecondsDelay, cancellationToken);
+            }
+            catch (Exception ex) { _Logger.LogError(ex, "Unexpected Error!"); }
         }
     }
 
     private void BodyInner(CancellationToken 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 (_First is null || _First.Value)
-        {
-            _First = false;
-            if (_AppSettings.FileWatcherConfiguration.Helper == nameof(Helpers.HelperCamstarOracle))
-                Helpers.HelperCamstarOracle.Heartbeat(_AppSettings, _HttpClientFactory, _Logger, Infineon.Monitoring.MonA.State.Up, cancellationToken);
-        }
         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.HelperInfinityQS) => Helpers.HelperInfinityQS.Select(_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.HelperCamstarOracle) => Helpers.HelperCamstarOracle.Check(_AppSettings, _Logger, cancellationToken),
                 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()
             };
         }