JsonSerializer.Deserialize for AppSettings

Rename/Models/AppSettings.cs

@@ -1,9 +1,13 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using View_by_Distance.Shared.Models;
 
 namespace View_by_Distance.Rename.Models;
 
-public record AppSettings(string Company,
+public record AppSettings(MetadataConfiguration MetadataConfiguration,
+                          RenameConfiguration RenameConfiguration,
+                          ResultConfiguration ResultConfiguration,
+                          string Company,
                           int MaxDegreeOfParallelism,
                           bool RequireRootDirectoryExists)
 {

Rename/Models/Binder/AppSettings.cs

@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Configuration;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using View_by_Distance.Shared.Models;
 
 namespace View_by_Distance.Rename.Models.Binder;
 
@@ -8,6 +9,9 @@ public class AppSettings
 {
 
     public string? Company { get; set; }
+    public string[]? ConfigurationDirectoryNames { get; set; }
+    public string? ConfigurationFileName { get; set; }
+    public int? ConfigurationSpecialFolder { get; set; }
     public int? MaxDegreeOfParallelism { get; set; }
     public bool? RequireRootDirectoryExists { get; set; }
 
@@ -38,7 +42,10 @@ public class AppSettings
     {
     }
 
-    private static Models.AppSettings Get(AppSettings? appSettings)
+    private static Models.AppSettings Get(AppSettings? appSettings,
+                                          MetadataConfiguration metadataConfiguration,
+                                          Models.RenameConfiguration renameConfiguration,
+                                          ResultConfiguration resultConfiguration)
     {
         Models.AppSettings result;
         if (appSettings is null) throw new NullReferenceException(nameof(appSettings));
@@ -46,12 +53,46 @@ public class AppSettings
         if (appSettings.MaxDegreeOfParallelism is null) throw new NullReferenceException(nameof(appSettings.MaxDegreeOfParallelism));
         if (appSettings.RequireRootDirectoryExists is null) throw new NullReferenceException(nameof(appSettings.RequireRootDirectoryExists));
         Verify(appSettings);
-        result = new(appSettings.Company,
+        result = new(metadataConfiguration,
+                     renameConfiguration,
+                     resultConfiguration,
+                     appSettings.Company,
                      appSettings.MaxDegreeOfParallelism.Value,
                      appSettings.RequireRootDirectoryExists.Value);
         return result;
     }
 
+    private static Models.AppSettings Get(AppSettings? appSettings)
+    {
+        Models.AppSettings? results;
+        string? json;
+        if (appSettings is null || appSettings.ConfigurationFileName is null)
+            throw new NotSupportedException($"{nameof(appSettings.ConfigurationFileName)} must be set!");
+        string jsonFile = Path.Combine(AppContext.BaseDirectory, appSettings.ConfigurationFileName);
+        if (File.Exists(jsonFile))
+            json = File.ReadAllText(jsonFile);
+        else
+        {
+            json = null;
+            string applicationData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
+            List<string> collection = [applicationData];
+            if (appSettings?.ConfigurationDirectoryNames is not null)
+                collection.AddRange(appSettings.ConfigurationDirectoryNames);
+            if (appSettings?.ConfigurationFileName is not null)
+                collection.Add(appSettings.ConfigurationFileName);
+            jsonFile = Path.Combine(collection.ToArray());
+        }
+        if (string.IsNullOrEmpty(json) && File.Exists(jsonFile))
+            json = File.ReadAllText(jsonFile);
+        results = (string.IsNullOrEmpty(json) ? null : results = JsonSerializer.Deserialize(json, AppSettingsSourceGenerationContext.Default.AppSettings)) ??
+            throw new NullReferenceException(nameof(Models.AppSettings));
+        results = Get(appSettings,
+                      results.MetadataConfiguration,
+                      results.RenameConfiguration,
+                      results.ResultConfiguration);
+        return results;
+    }
+
     public static Models.AppSettings Get(IConfigurationRoot configurationRoot)
     {
         Models.AppSettings result;

Rename/Program.cs

@@ -28,7 +28,7 @@ public class Program
             if (args is null)
                 throw new Exception("args is null!");
             Shared.Models.Console console = new();
-            _ = new Rename(args, logger, configurationRoot, appSettings, silentIndex > -1, console);
+            _ = new Rename(args, logger, appSettings, silentIndex > -1, console);
         }
         catch (Exception ex)
         {

Rename/Rename.cs

@@ -1,5 +1,4 @@
 using CliWrap;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using ShellProgressBar;
 using System.Collections.ObjectModel;
@@ -28,7 +27,7 @@ public partial class Rename : IRename, IDisposable
 
     private ProgressBar? _ProgressBar;
 
-    public Rename(List<string> args, ILogger<Program>? logger, IConfigurationRoot configurationRoot, AppSettings appSettings, bool isSilent, IConsole console)
+    public Rename(List<string> args, ILogger<Program>? logger, AppSettings appSettings, bool isSilent, IConsole console)
     {
         if (isSilent)
         { }
@@ -38,10 +37,7 @@ public partial class Rename : IRename, IDisposable
             throw new NullReferenceException(nameof(console));
         IRename rename = this;
         long ticks = DateTime.Now.Ticks;
-        ResultConfiguration resultConfiguration = Metadata.Models.Binder.ResultConfiguration.Get(configurationRoot, appSettings.RequireRootDirectoryExists);
+        RenameWork(logger, appSettings, rename, ticks);
-        MetadataConfiguration metadataConfiguration = Metadata.Models.Binder.MetadataConfiguration.Get(configurationRoot, resultConfiguration);
-        RenameConfiguration renameConfiguration = Models.Binder.RenameConfiguration.Get(configurationRoot, metadataConfiguration);
-        RenameWork(logger, appSettings, rename, ticks, renameConfiguration);
     }
 
     void IRename.Tick() =>
@@ -315,6 +311,25 @@ public partial class Rename : IRename, IDisposable
         return results;
     }
 
+    private static bool? GetDirectoryCheck(RenameConfiguration renameConfiguration)
+    {
+        bool? result = null;
+        foreach (string directory in Directory.GetDirectories(renameConfiguration.MetadataConfiguration.ResultConfiguration.RootDirectory, "*", SearchOption.TopDirectoryOnly))
+        {
+            foreach (string _ in Directory.EnumerateFiles(directory, "*", SearchOption.AllDirectories))
+            {
+                if (result is null)
+                    result = false;
+                else if (result.Value)
+                    result = true;
+                break;
+            }
+            if (result is not null && result.Value)
+                break;
+        }
+        return result;
+    }
+
     private static ReadOnlyCollection<ToDo> GetToDoCollection(RenameConfiguration renameConfiguration, Identifier[]? identifiers, ReadOnlyCollection<RecordB> recordBCollection)
     {
         List<ToDo> results = [];
@@ -329,25 +344,11 @@ public partial class Rename : IRename, IDisposable
         const string jpg = ".jpg";
         string checkFileExtension;
         List<string> distinct = [];
-        bool? directoryCheck = null;
         const string jpeg = ".jpeg";
         string jsonFileSubDirectory;
-        bool multipleDirectoriesWithFiles;
+        bool? directoryCheck = GetDirectoryCheck(renameConfiguration);
-        foreach (string directory in Directory.GetDirectories(renameConfiguration.MetadataConfiguration.ResultConfiguration.RootDirectory, "*", SearchOption.TopDirectoryOnly))
-        {
-            foreach (string _ in Directory.EnumerateFiles(directory, "*", SearchOption.AllDirectories))
-            {
-                if (directoryCheck is null)
-                    directoryCheck = false;
-                else if (directoryCheck.Value)
-                    directoryCheck = true;
-                break;
-            }
-            if (directoryCheck is not null && directoryCheck.Value)
-                break;
-        }
         VerifyIntMinValueLength(renameConfiguration.MetadataConfiguration, recordBCollection);
-        multipleDirectoriesWithFiles = directoryCheck is not null && directoryCheck.Value;
+        bool multipleDirectoriesWithFiles = directoryCheck is not null && directoryCheck.Value;
         ResultConfiguration resultConfiguration = renameConfiguration.MetadataConfiguration.ResultConfiguration;
         ReadOnlyCollection<int> ids = identifiers is null ? new([]) : new((from l in identifiers select l.Id).ToArray());
         ReadOnlyCollection<RecordB> sorted = new((from l in recordBCollection orderby l.DateTime select l).ToArray());
@@ -451,15 +452,17 @@ public partial class Rename : IRename, IDisposable
         _ = IPath.WriteAllText(Path.Combine(aMetadataCollectionDirectory, $"{ticks}.json"), json, updateDateWhenMatches: false, compareBeforeWrite: true, updateToWhenMatches: null);
     }
 
-    private void RenameWork(ILogger<Program>? logger, AppSettings appSettings, IRename rename, long ticks, RenameConfiguration renameConfiguration)
+    private void RenameWork(ILogger<Program>? logger, AppSettings appSettings, IRename rename, long ticks)
     {
-        string aMetadataCollectionDirectory = IResult.GetResultsDateGroupDirectory(renameConfiguration.MetadataConfiguration.ResultConfiguration, nameof(A_Metadata), renameConfiguration.MetadataConfiguration.ResultConfiguration.ResultCollection);
+        RenameConfiguration renameConfiguration = appSettings.RenameConfiguration;
+        MetadataConfiguration metadataConfiguration = renameConfiguration.MetadataConfiguration;
+        string aMetadataCollectionDirectory = IResult.GetResultsDateGroupDirectory(metadataConfiguration.ResultConfiguration, nameof(A_Metadata), metadataConfiguration.ResultConfiguration.ResultCollection);
         string? propertyCollectionFile = string.IsNullOrEmpty(renameConfiguration.RelativePropertyCollectionFile) ? null : Path.GetFullPath(Path.Combine(aMetadataCollectionDirectory, renameConfiguration.RelativePropertyCollectionFile));
         string? json = !File.Exists(propertyCollectionFile) ? null : File.ReadAllText(propertyCollectionFile);
         Identifier[]? identifiers = json is null ? null : JsonSerializer.Deserialize(json, IdentifierCollectionSourceGenerationContext.Default.IdentifierArray);
         if (identifiers is null && !string.IsNullOrEmpty(renameConfiguration.RelativePropertyCollectionFile))
             throw new Exception($"Invalid {nameof(renameConfiguration.RelativePropertyCollectionFile)}");
-        DirectoryInfo directoryInfo = new(Path.GetFullPath(renameConfiguration.MetadataConfiguration.ResultConfiguration.RootDirectory));
+        DirectoryInfo directoryInfo = new(Path.GetFullPath(metadataConfiguration.ResultConfiguration.RootDirectory));
         logger?.LogInformation("{Ticks} {RootDirectory}", ticks, directoryInfo.FullName);
         ReadOnlyCollection<RecordB> recordBCollection = GetRecordBCollection(logger, rename, appSettings, renameConfiguration, directoryInfo);
         SaveIdentifiersToDisk(ticks, renameConfiguration, aMetadataCollectionDirectory, recordBCollection);