HelperEDADatabase

HelperEAFProgramData
HelperCompass
HelperInfinityQS
HelperSerial
HelperTCP
dotnet_analyzer_diagnostic

Models/AppSettings.cs

@@ -4,8 +4,14 @@ using System.Text.Json.Serialization;
 namespace File_Watcher.Models;
 
 public record AppSettings(EAFLogConfiguration EAFLogConfiguration,
+                          EAFProgramDataConfiguration EAFProgramDataConfiguration,
+                          EDADatabaseConfiguration EDADatabaseConfiguration,
+                          CompassConfiguration CompassConfiguration,
+                          DriveConfiguration DriveConfiguration,
                           MetrologyConfiguration MetrologyConfiguration,
+                          SerialConfiguration SerialConfiguration,
                           StratusConfiguration StratusConfiguration,
+                          TransmissionControlProtocolConfiguration TransmissionControlProtocolConfiguration,
                           WaferCounterConfiguration WaferCounterConfiguration,
                           string BuildNumber,
                           string Company,

Models/Binder/AppSettings.cs

@@ -23,17 +23,16 @@ public class 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;
-                if (!physicalFileProvider.Root.Contains("UserSecrets"))
-                    continue;
-                throw new NotSupportedException(physicalFileProvider.Root);
+                paths.Add(physicalFileProvider.Root);
             }
-            throw new NotSupportedException("Not Found!");
+            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
         }
     }
 
@@ -42,9 +41,15 @@ public class 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;
@@ -57,8 +62,14 @@ public class AppSettings
         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,
@@ -70,10 +81,16 @@ public class AppSettings
     }
 
     public static Models.AppSettings Get(IConfigurationRoot configurationRoot,
-                                          Models.EAFLogConfiguration eafLogConfiguration,
-                                          Models.MetrologyConfiguration metrologyConfiguration,
-                                          Models.StratusConfiguration stratusConfiguration,
-                                          Models.WaferCounterConfiguration waferCounterConfiguration)
+                                         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
@@ -81,9 +98,15 @@ public class AppSettings
 #pragma warning restore IL3050, IL2026
         PreVerify(configurationRoot, appSettings);
         result = Get(appSettings,
+                     driveConfiguration,
+                     compassConfiguration,
                      eafLogConfiguration,
+                     eafProgramDataConfiguration,
+                     edaDatabaseConfiguration,
                      metrologyConfiguration,
+                     serialConfiguration,
                      stratusConfiguration,
+                     transmissionControlProtocolConfiguration,
                      waferCounterConfiguration);
         return result;
     }

Models/Binder/CompassConfiguration.cs

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,78 @@
+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

@@ -18,17 +18,16 @@ public class EAFLogConfiguration
     {
         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;
-                if (!physicalFileProvider.Root.Contains("UserSecrets"))
-                    continue;
-                throw new NotSupportedException(physicalFileProvider.Root);
+                paths.Add(physicalFileProvider.Root);
             }
-            throw new NotSupportedException("Not Found!");
+            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
         }
     }
 

Models/Binder/EAFProgramDataConfiguration.cs

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -21,17 +21,16 @@ public class MetrologyConfiguration
     {
         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;
-                if (!physicalFileProvider.Root.Contains("UserSecrets"))
-                    continue;
-                throw new NotSupportedException(physicalFileProvider.Root);
+                paths.Add(physicalFileProvider.Root);
             }
-            throw new NotSupportedException("Not Found!");
+            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
         }
     }
 

Models/Binder/SerialConfiguration.cs

@@ -0,0 +1,74 @@
+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

@@ -20,17 +20,16 @@ public class StratusConfiguration
     {
         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;
-                if (!physicalFileProvider.Root.Contains("UserSecrets"))
-                    continue;
-                throw new NotSupportedException(physicalFileProvider.Root);
+                paths.Add(physicalFileProvider.Root);
             }
-            throw new NotSupportedException("Not Found!");
+            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
         }
     }
 

Models/Binder/TransmissionControlProtocolConfiguration.cs

@@ -0,0 +1,89 @@
+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

@@ -19,17 +19,16 @@ public class WaferCounterConfiguration
     {
         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;
-                if (!physicalFileProvider.Root.Contains("UserSecrets"))
-                    continue;
-                throw new NotSupportedException(physicalFileProvider.Root);
+                paths.Add(physicalFileProvider.Root);
             }
-            throw new NotSupportedException("Not Found!");
+            throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
         }
     }
 

Models/CompassConfiguration.cs

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

Models/DriveConfiguration.cs

@@ -0,0 +1,25 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record DriveConfiguration(string Letter,
+                                 string Password,
+                                 string Share,
+                                 bool? Use,
+                                 string User)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, DriveConfigurationSourceGenerationContext.Default.DriveConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(DriveConfiguration))]
+internal partial class DriveConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}

Models/EAFProgramDataConfiguration.cs

@@ -0,0 +1,21 @@
+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/EDADatabaseConfiguration.cs

@@ -0,0 +1,27 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record EDADatabaseConfiguration(string CSharpDateTimeFormat,
+                                       string FileShare,
+                                       string Name,
+                                       string OracleDateTimeFormat,
+                                       string Password,
+                                       string TNS,
+                                       string UserName)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, EDADatabaseConfigurationSourceGenerationContext.Default.EDADatabaseConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(EDADatabaseConfiguration))]
+internal partial class EDADatabaseConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}

Models/RijndaelEncryption.cs

@@ -0,0 +1,101 @@
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace File_Watcher.Models;
+
+public static class RijndaelEncryption
+{
+
+    /// <summary>
+    /// Change the input key GUID when you use this code in your own program.
+    /// Keep this input key very safe and prevent someone from decoding it some way!!
+    /// Generated 2021-08-10
+    /// </summary>
+    internal const string _InputKey = "970CCEF6-4307-4F6A-9AC8-377DADB889BD";
+
+    /// <summary>
+    /// Encrypt the given text and give the byte array back as a BASE64 string
+    /// </summary>
+    /// <param name="text">The text to encrypt</param>
+    /// <param name="salt">The password salt</param>
+    /// <returns>The encrypted text</returns>
+    public static string Encrypt(string text, string salt)
+    {
+        string result;
+        if (string.IsNullOrEmpty(text))
+            throw new ArgumentNullException(nameof(text));
+#pragma warning disable
+        RijndaelManaged aesAlg = NewRijndaelManaged(salt);
+#pragma warning restore
+        ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
+        MemoryStream msEncrypt = new();
+        using (CryptoStream csEncrypt = new(msEncrypt, encryptor, CryptoStreamMode.Write))
+        using (StreamWriter swEncrypt = new(csEncrypt))
+            swEncrypt.Write(text);
+        result = Convert.ToBase64String(msEncrypt.ToArray());
+        return result;
+    }
+
+    /// <summary>
+    /// Checks if a string is base64 encoded
+    /// </summary>
+    /// <param name="base64String">The base64 encoded string</param>
+    /// <returns></returns>
+    public static bool IsBase64String(string base64String)
+    {
+        bool result;
+        base64String = base64String.Trim();
+#pragma warning disable
+        result = (base64String.Length % 4 == 0) && Regex.IsMatch(base64String, @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None);
+#pragma warning restore
+        return result;
+    }
+
+    /// <summary>
+    /// Decrypts the given text
+    /// </summary>
+    /// <param name="cipherText">The encrypted BASE64 text</param>
+    /// <param name="salt">The password salt</param>
+    /// <returns>De gedecrypte text</returns>
+    public static string Decrypt(string cipherText, string salt)
+    {
+        if (string.IsNullOrEmpty(cipherText))
+            throw new ArgumentNullException(nameof(cipherText));
+        if (!IsBase64String(cipherText))
+            throw new Exception("The cipherText input parameter is not base64 encoded");
+        string text;
+#pragma warning disable
+        RijndaelManaged aesAlg = NewRijndaelManaged(salt);
+#pragma warning restore
+        ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
+        byte[] cipher = Convert.FromBase64String(cipherText);
+        using (MemoryStream msDecrypt = new(cipher))
+        {
+            using CryptoStream csDecrypt = new(msDecrypt, decryptor, CryptoStreamMode.Read);
+            using StreamReader srDecrypt = new(csDecrypt);
+            text = srDecrypt.ReadToEnd();
+        }
+        return text;
+    }
+
+    /// <summary>
+    /// Create a new RijndaelManaged class and initialize it
+    /// </summary>
+    /// <param name="salt">The password salt</param>
+    /// <returns></returns>
+#pragma warning disable
+    private static RijndaelManaged NewRijndaelManaged(string salt)
+    {
+        if (salt == null)
+            throw new ArgumentNullException(nameof(salt));
+        byte[] saltBytes = Encoding.ASCII.GetBytes(salt);
+        Rfc2898DeriveBytes key = new(_InputKey, saltBytes);
+        RijndaelManaged aesAlg = new();
+#pragma warning restore
+        aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
+        aesAlg.IV = key.GetBytes(aesAlg.BlockSize / 8);
+        return aesAlg;
+    }
+
+}

Models/SerialConfiguration.cs

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

Models/TransmissionControlProtocolConfiguration.cs

@@ -0,0 +1,25 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Watcher.Models;
+
+public record TransmissionControlProtocolConfiguration(string Destination,
+                                                       string GhostPCLFileName,
+                                                       string IPAddress,
+                                                       int Port,
+                                                       bool Server)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, TransmissionControlProtocolConfigurationSourceGenerationContext.Default.TransmissionControlProtocolConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(TransmissionControlProtocolConfiguration))]
+internal partial class TransmissionControlProtocolConfigurationSourceGenerationContext : JsonSerializerContext
+{
+}