re-organized configurations - II

Metadata/Models/A_Metadata.cs

@@ -12,7 +12,7 @@ public class A_Metadata
 {
 
     private readonly MetadataConfiguration _MetadataConfiguration;
-    private readonly IReadOnlyDictionary<string, string[]> _FileGroups;
+    private readonly ReadOnlyDictionary<int, ReadOnlyDictionary<string, string[]>> _FileGroups;
 
     public A_Metadata(MetadataConfiguration metadataConfiguration)
     {
@@ -26,17 +26,21 @@ public class A_Metadata
         _FileGroups = IPath.GetKeyValuePairs(metadataConfiguration.ResultConfiguration, bResultsFullGroupDirectory, [metadataConfiguration.ResultConfiguration.ResultSingleton]);
     }
 
-    public FileInfo GetFileInfo(FilePath filePath)
+    private FileInfo GetFileInfo(ResultConfiguration resultConfiguration, FilePath filePath)
     {
         FileInfo result;
-        (_, int directoryIndex) = IPath.GetDirectoryNameAndIndex(_MetadataConfiguration.ResultConfiguration.ResultAllInOneSubdirectoryLength, filePath.Name);
+        FileInfo fileInfo = new(filePath.FullName);
-        result = new(Path.Combine(_FileGroups[_MetadataConfiguration.ResultConfiguration.ResultSingleton][directoryIndex], $"{filePath.NameWithoutExtension}{filePath.ExtensionLowered}.json"));
+        (_, int directoryIndex) = IPath.GetDirectoryNameAndIndex(resultConfiguration, filePath);
+        DateTime minimumDateTime = fileInfo.CreationTime < fileInfo.LastWriteTime ? fileInfo.CreationTime : fileInfo.LastWriteTime;
+        int minimumYear = minimumDateTime.Year < resultConfiguration.EpicYear ? resultConfiguration.EpicYear : minimumDateTime.Year;
+        result = new(Path.Combine(_FileGroups[minimumYear][_MetadataConfiguration.ResultConfiguration.ResultSingleton][directoryIndex], $"{filePath.NameWithoutExtension}{filePath.ExtensionLowered}.json"));
         return result;
     }
 
-    public ExifDirectory GetMetadataCollection(MetadataConfiguration metadataConfiguration, FilePath filePath, FileInfo fileInfo, DeterministicHashCode deterministicHashCode)
+    public (FileInfo, ExifDirectory) GetMetadataCollection(MetadataConfiguration metadataConfiguration, FilePath filePath, DeterministicHashCode deterministicHashCode)
     {
         ExifDirectory? results;
+        FileInfo fileInfo = GetFileInfo(metadataConfiguration.ResultConfiguration, filePath);
         if (_MetadataConfiguration.ForceMetadataLastWriteTimeToCreationTime && !fileInfo.Exists && File.Exists(Path.ChangeExtension(fileInfo.FullName, ".delete")))
         {
             File.Move(Path.ChangeExtension(fileInfo.FullName, ".delete"), fileInfo.FullName);
@@ -82,7 +86,7 @@ public class A_Metadata
                 fileInfo.Refresh();
             }
         }
-        return results;
+        return (fileInfo, results);
     }
 
     public static Action<string> SetExifDirectoryCollection(IRename rename, MetadataConfiguration metadataConfiguration, A_Metadata metadata, List<(string, FileInfo, ExifDirectory)> exifDirectories, Action tick)
@@ -103,9 +107,8 @@ public class A_Metadata
                     (ffmpegFiles, ffmpegFilePath) = rename.ConvertAndGetFfmpegFiles(filePath);
                     if (ffmpegFilePath is not null)
                         filePath = ffmpegFilePath;
-                    fileInfo = metadata.GetFileInfo(filePath);
                     deterministicHashCode = filePath.Id is not null ? deterministicHashCode = new(null, filePath.Id, null) : deterministicHashCode = rename.GetDeterministicHashCode(filePath);
-                    exifDirectory = metadata.GetMetadataCollection(metadataConfiguration, filePath, fileInfo, deterministicHashCode);
+                    (fileInfo, exifDirectory) = metadata.GetMetadataCollection(metadataConfiguration, filePath, deterministicHashCode);
                     lock (exifDirectories)
                         exifDirectories.Add(new(file, fileInfo, exifDirectory));
                     foreach (string ffmpegFile in ffmpegFiles)

Metadata/Models/Binder/MetadataConfiguration.cs

@@ -8,6 +8,7 @@ public class MetadataConfiguration
 {
 
     public bool? ForceMetadataLastWriteTimeToCreationTime { get; set; }
+    public string[]? IgnoreRulesKeyWords { get; set; }
     public int? Offset { get; set; }
     public bool? PropertiesChangedForMetadata { get; set; }
 
@@ -34,8 +35,9 @@ public class MetadataConfiguration
         }
     }
 
-    private static void Verify(MetadataConfiguration _)
+    private static void Verify(MetadataConfiguration configuration)
     {
+        if (configuration.IgnoreRulesKeyWords is null || configuration.IgnoreRulesKeyWords.Length == 0) throw new NullReferenceException(nameof(configuration.IgnoreRulesKeyWords));
     }
 
     private static Shared.Models.MetadataConfiguration Get(MetadataConfiguration? configuration, Shared.Models.ResultConfiguration resultConfiguration)
@@ -43,11 +45,13 @@ public class MetadataConfiguration
         Shared.Models.MetadataConfiguration result;
         if (configuration is null) throw new NullReferenceException(nameof(configuration));
         if (configuration.ForceMetadataLastWriteTimeToCreationTime is null) throw new NullReferenceException(nameof(configuration.ForceMetadataLastWriteTimeToCreationTime));
+        if (configuration.IgnoreRulesKeyWords is null) throw new NullReferenceException(nameof(configuration.IgnoreRulesKeyWords));
         if (configuration.Offset is null) throw new NullReferenceException(nameof(configuration.Offset));
         if (configuration.PropertiesChangedForMetadata is null) throw new NullReferenceException(nameof(configuration.PropertiesChangedForMetadata));
         Verify(configuration);
         result = new(resultConfiguration,
                      configuration.ForceMetadataLastWriteTimeToCreationTime.Value,
+                     configuration.IgnoreRulesKeyWords,
                      configuration.Offset.Value,
                      configuration.PropertiesChangedForMetadata.Value);
         return result;

Metadata/Models/Binder/ResultConfiguration.cs

@@ -8,16 +8,16 @@ public class ResultConfiguration
 {
 
     public string? DateGroup { get; set; }
+    public int? EpicYear { get; set; }
     public string? ModelName { get; set; }
     public int? NumberOfJitters { get; set; }
     public int? NumberOfTimesToUpsample { get; set; }
     public string? PredictorModelName { get; set; }
-    public string? ResultAllInOne { get; set; }
     public int? ResultAllInOneSubdirectoryLength { get; set; }
     public string? ResultCollection { get; set; }
     public string? ResultContent { get; set; }
-    public string? RootDirectory { get; set; }
     public string? ResultSingleton { get; set; }
+    public string? RootDirectory { get; set; }
 
     public override string ToString()
     {
@@ -53,28 +53,28 @@ public class ResultConfiguration
         Shared.Models.ResultConfiguration result;
         if (configuration is null) throw new NullReferenceException(nameof(configuration));
         if (configuration.DateGroup is null) throw new NullReferenceException(nameof(configuration.DateGroup));
+        if (configuration.EpicYear is null) throw new NullReferenceException(nameof(configuration.EpicYear));
         // if (configuration.ModelName is null) throw new NullReferenceException(nameof(configuration.ModelName));
         // if (configuration.NumberOfJitters is null) throw new NullReferenceException(nameof(configuration.NumberOfJitters));
         // if (configuration.NumberOfTimesToUpsample is null) throw new NullReferenceException(nameof(configuration.NumberOfTimesToUpsample));
         // if (configuration.PredictorModelName is null) throw new NullReferenceException(nameof(configuration.PredictorModelName));
-        if (configuration.ResultAllInOne is null) throw new NullReferenceException(nameof(configuration.ResultAllInOne));
         if (configuration.ResultAllInOneSubdirectoryLength is null) throw new NullReferenceException(nameof(configuration.ResultAllInOneSubdirectoryLength));
         if (configuration.ResultCollection is null) throw new NullReferenceException(nameof(configuration.ResultCollection));
         if (configuration.ResultContent is null) throw new NullReferenceException(nameof(configuration.ResultContent));
-        if (configuration.RootDirectory is null) throw new NullReferenceException(nameof(configuration.RootDirectory));
         if (configuration.ResultSingleton is null) throw new NullReferenceException(nameof(configuration.ResultSingleton));
+        if (configuration.RootDirectory is null) throw new NullReferenceException(nameof(configuration.RootDirectory));
         Verify(configuration, requireRootDirectoryExists);
         result = new(configuration.DateGroup,
+                     configuration.EpicYear.Value,
                      configuration.ModelName,
                      configuration.NumberOfJitters,
                      configuration.NumberOfTimesToUpsample,
                      configuration.PredictorModelName,
-                     configuration.ResultAllInOne,
                      configuration.ResultAllInOneSubdirectoryLength.Value,
                      configuration.ResultCollection,
                      configuration.ResultContent,
-                     Path.GetFullPath(configuration.RootDirectory),
+                     configuration.ResultSingleton,
-                     configuration.ResultSingleton);
+                     Path.GetFullPath(configuration.RootDirectory));
         return result;
     }
 

Metadata/Models/Stateless/Exif.cs

@@ -354,4 +354,14 @@ internal abstract class Exif
         return results;
     }
 
+    internal static string GetMaker(Shared.Models.ExifDirectoryBase exifDirectoryBase)
+    {
+        string result;
+        if (string.IsNullOrEmpty(exifDirectoryBase.Make))
+            result = "Unknown";
+        else
+            result = $"{exifDirectoryBase.Make[0].ToString().ToUpper()}{exifDirectoryBase.Make[1..]}".Trim();
+        return result;
+    }
+
 }

Metadata/Models/Stateless/Methods/IMetadata.cs

@@ -11,6 +11,11 @@ public interface IMetadata
         Meters
     }
 
+    string TestStatic_GetMaker(Shared.Models.ExifDirectoryBase exifDirectoryBase) =>
+        GetMaker(exifDirectoryBase);
+    static string GetMaker(Shared.Models.ExifDirectoryBase exifDirectoryBase) =>
+        Exif.GetMaker(exifDirectoryBase);
+
     double? TestStatic_GetDistance(double originLatitude, double originLongitude, double destinationLatitude, double destinationLongitude, int decimalPlaces = 1, DistanceUnit distanceUnit = DistanceUnit.Miles) =>
         GetDistance(originLatitude, originLongitude, destinationLatitude, destinationLongitude, decimalPlaces, distanceUnit);
     static double? GetDistance(double originLatitude, double originLongitude, double destinationLatitude, double destinationLongitude, int decimalPlaces = 1, DistanceUnit distanceUnit = DistanceUnit.Miles) =>

Rename/Models/Binder/RenameConfiguration.cs

@@ -7,9 +7,7 @@ namespace View_by_Distance.Rename.Models.Binder;
 public class RenameConfiguration
 {
 
-    public int? EpicYear { get; set; }
     public string[]? IgnoreExtensions { get; set; }
-    public string[]? IgnoreRulesKeyWords { get; set; }
     public string[]? ValidImageFormatExtensions { get; set; }
 
     public override string ToString()
@@ -20,7 +18,7 @@ public class RenameConfiguration
 
     private static void PreVerify(IConfigurationRoot configurationRoot, RenameConfiguration? configuration)
     {
-        if (configuration?.EpicYear is null)
+        if (configuration?.IgnoreExtensions is null)
         {
             foreach (IConfigurationProvider configurationProvider in configurationRoot.Providers)
             {
@@ -38,7 +36,6 @@ public class RenameConfiguration
     private static void Verify(RenameConfiguration configuration)
     {
         if (configuration.IgnoreExtensions is null || configuration.IgnoreExtensions.Length == 0) throw new NullReferenceException(nameof(configuration.IgnoreExtensions));
-        if (configuration.IgnoreRulesKeyWords is null || configuration.IgnoreRulesKeyWords.Length == 0) throw new NullReferenceException(nameof(configuration.IgnoreRulesKeyWords));
         if (configuration.ValidImageFormatExtensions is null || configuration.ValidImageFormatExtensions.Length == 0) throw new NullReferenceException(nameof(configuration.ValidImageFormatExtensions));
     }
 
@@ -46,15 +43,11 @@ public class RenameConfiguration
     {
         Models.RenameConfiguration result;
         if (configuration is null) throw new NullReferenceException(nameof(configuration));
-        if (configuration.EpicYear is null) throw new NullReferenceException(nameof(configuration.EpicYear));
         if (configuration.IgnoreExtensions is null) throw new NullReferenceException(nameof(configuration.IgnoreExtensions));
-        if (configuration.IgnoreRulesKeyWords is null) throw new NullReferenceException(nameof(configuration.IgnoreRulesKeyWords));
         if (configuration.ValidImageFormatExtensions is null) throw new NullReferenceException(nameof(configuration.ValidImageFormatExtensions));
         Verify(configuration);
         result = new(metadataConfiguration,
-                     configuration.EpicYear.Value,
                      configuration.IgnoreExtensions,
-                     configuration.IgnoreRulesKeyWords,
                      configuration.ValidImageFormatExtensions);
         return result;
     }

Rename/Models/RenameConfiguration.cs

@@ -5,9 +5,7 @@ using System.Text.Json.Serialization;
 namespace View_by_Distance.Rename.Models;
 
 public record RenameConfiguration(Shared.Models.MetadataConfiguration MetadataConfiguration,
-                                  int EpicYear,
                                   string[] IgnoreExtensions,
-                                  string[] IgnoreRulesKeyWords,
                                   string[] ValidImageFormatExtensions)
 {
 

Rename/Rename.cs

@@ -7,6 +7,7 @@ using System.Drawing;
 using System.Drawing.Imaging;
 using System.Runtime.InteropServices;
 using View_by_Distance.Metadata.Models;
+using View_by_Distance.Metadata.Models.Stateless.Methods;
 using View_by_Distance.Rename.Models;
 using View_by_Distance.Shared.Models;
 using View_by_Distance.Shared.Models.Stateless.Methods;
@@ -60,8 +61,8 @@ public class Rename : IRename
         else
         {
             CommandTask<CommandResult> commandTask = Cli.Wrap("ffmpeg.exe")
-                // .WithArguments(new[] { "-ss", "00:00:00", "-t", "00:00:00", "-i", files[i], "-qscale:v", "2", "-r", "0.01", $"{fileHolder.Name}-%4d.jpg" })
+                // .WithArguments(new[] { "-ss", "00:00:00", "-t", "00:00:00", "-i", files[i], "-qScale:v", "2", "-r", "0.01", $"{fileHolder.Name}-%4d.jpg" })
-                .WithArguments(new[] { "-i", filePath.FullName, "-vframes", "1", $"{filePath.Name}-%4d.jpg" })
+                .WithArguments(new[] { "-i", filePath.FullName, "-vFrames", "1", $"{filePath.Name}-%4d.jpg" })
                 .WithWorkingDirectory(filePath.DirectoryName)
                 .ExecuteAsync();
             commandTask.Task.Wait();
@@ -136,12 +137,11 @@ public class Rename : IRename
             (ffmpegFiles, ffmpegFilePath) = rename.ConvertAndGetFfmpegFiles(filePath);
             if (ffmpegFilePath is not null)
                 filePath = ffmpegFilePath;
-            fileInfo = metadata.GetFileInfo(filePath);
             if (filePath.Id is not null)
                 deterministicHashCode = new(null, filePath.Id, null);
             else
                 deterministicHashCode = rename.GetDeterministicHashCode(filePath);
-            exifDirectory = metadata.GetMetadataCollection(_RenameConfiguration.MetadataConfiguration, filePath, fileInfo, deterministicHashCode);
+            (fileInfo, exifDirectory) = metadata.GetMetadataCollection(_RenameConfiguration.MetadataConfiguration, filePath, deterministicHashCode);
             exifDirectories.Add(new(file, fileInfo, exifDirectory));
             foreach (string ffmpegFile in ffmpegFiles)
                 File.Delete(ffmpegFile);
@@ -198,17 +198,20 @@ public class Rename : IRename
     {
         List<ToDo> results = [];
         int season;
+        string maker;
         Record record;
+        string jsonFile;
         string paddedId;
         string checkFile;
         string seasonName;
+        string directoryName;
         FileHolder fileHolder;
-        string? seasonDirectory;
+        string? checkDirectory;
-        string jsonFileDirectory;
         const string jpg = ".jpg";
         string checkFileExtension;
         List<string> distinct = [];
         const string jpeg = ".jpeg";
+        string jsonFileSubDirectory;
         int intMinValueLength = int.MinValue.ToString().Length;
         VerifyIntMinValueLength(exifDirectories, intMinValueLength);
         ReadOnlyCollection<Record> records = new((from l in exifDirectories orderby l.DateTime select l).ToArray());
@@ -220,12 +223,13 @@ public class Rename : IRename
             fileHolder = new(record.File);
             if (fileHolder.DirectoryName is null)
                 continue;
+            maker = IMetadata.GetMaker(record.ExifDirectory.ExifDirectoryBase);
             (season, seasonName) = IDate.GetSeason(record.DateTime.DayOfYear);
-            jsonFileDirectory = Path.GetDirectoryName(record.JsonFile) ?? throw new Exception();
             checkFileExtension = fileHolder.ExtensionLowered == jpeg ? jpg : fileHolder.ExtensionLowered;
-            seasonDirectory = Path.Combine(fileHolder.DirectoryName, $"{record.DateTime.Year}.{season} {seasonName}");
+            checkDirectory = Path.Combine(fileHolder.DirectoryName, $"{record.DateTime.Year}.{season} {seasonName}{maker}");
+            jsonFileSubDirectory = Path.GetDirectoryName(Path.GetDirectoryName(record.JsonFile)) ?? throw new Exception();
             paddedId = IId.GetPaddedId(intMinValueLength, _RenameConfiguration.MetadataConfiguration.Offset + i, record.ExifDirectory.Id.Value);
-            checkFile = Path.Combine(seasonDirectory, $"{paddedId}{checkFileExtension}");
+            checkFile = Path.Combine(checkDirectory, $"{paddedId}{checkFileExtension}");
             if (checkFile == fileHolder.FullName)
                 continue;
             if (File.Exists(checkFile))
@@ -234,11 +238,14 @@ public class Rename : IRename
                 if (File.Exists(checkFile))
                     continue;
             }
-            results.Add(new(null, new(record.JsonFile), Path.Combine(jsonFileDirectory, $"{record.ExifDirectory.Id.Value}{checkFileExtension}.json"), JsonFile: true));
+            (directoryName, _) = IPath.GetDirectoryNameAndIndex(_RenameConfiguration.MetadataConfiguration.ResultConfiguration, record.ExifDirectory.Id.Value);
+            jsonFile = Path.Combine(jsonFileSubDirectory, directoryName, $"{record.ExifDirectory.Id.Value}{checkFileExtension}.json");
+            if (record.JsonFile != jsonFile)
+                results.Add(new(null, new(record.JsonFile), jsonFile, JsonFile: true));
             if (distinct.Contains(checkFile))
                 continue;
             distinct.Add(checkFile);
-            results.Add(new(seasonDirectory, fileHolder, checkFile, JsonFile: false));
+            results.Add(new(checkDirectory, fileHolder, checkFile, JsonFile: false));
         }
         return new(results);
     }
@@ -263,11 +270,17 @@ public class Rename : IRename
         foreach (ToDo toDo in toDoCollection)
         {
             if (toDo.JsonFile)
+            {
+                if (File.Exists(toDo.File))
+                    File.Delete(toDo.File);
                 File.Move(toDo.FileHolder.FullName, toDo.File);
+            }
             else if (toDo.Directory is null)
                 throw new NotSupportedException();
             else
             {
+                if (File.Exists(toDo.File))
+                    File.Delete(toDo.File);
                 File.Move(toDo.FileHolder.FullName, toDo.File);
                 results.Add($"{toDo.FileHolder.FullName}\t{toDo.File}");
             }

Shared/Models/MetadataConfiguration.cs

@@ -5,6 +5,7 @@ namespace View_by_Distance.Shared.Models;
 
 public record MetadataConfiguration(ResultConfiguration ResultConfiguration,
                                     bool ForceMetadataLastWriteTimeToCreationTime,
+                                    string[] IgnoreRulesKeyWords,
                                     int Offset,
                                     bool PropertiesChangedForMetadata)
 {

Shared/Models/ResultConfiguration.cs

@@ -4,16 +4,16 @@ using System.Text.Json.Serialization;
 namespace View_by_Distance.Shared.Models;
 
 public record ResultConfiguration(string DateGroup,
+                                  int EpicYear,
                                   string? ModelName,
                                   int? NumberOfJitters,
                                   int? NumberOfTimesToUpsample,
                                   string? PredictorModelName,
-                                  string ResultAllInOne,
                                   int ResultAllInOneSubdirectoryLength,
                                   string ResultCollection,
                                   string ResultContent,
-                                  string RootDirectory,
+                                  string ResultSingleton,
-                                  string ResultSingleton)
+                                  string RootDirectory)
 {
 
     public override string ToString()

Shared/Models/Stateless/Methods/IPath.cs

@@ -1,3 +1,5 @@
+using System.Collections.ObjectModel;
+
 namespace View_by_Distance.Shared.Models.Stateless.Methods;
 
 public interface IPath
@@ -59,14 +61,24 @@ public interface IPath
     static string GetDirectory(string sourceDirectory, int level, string directoryName) =>
         XPath.GetDirectory(sourceDirectory, level, directoryName);
 
-    (string, int) TestStatic_GetDirectoryNameAndIndex(int resultAllInOneSubdirectoryLength, string fileName) =>
+    (string, int) TestStatic_GetDirectoryNameAndIndex(ResultConfiguration resultConfiguration, FileHolder fileHolder) =>
-        GetDirectoryNameAndIndex(resultAllInOneSubdirectoryLength, fileName);
+        GetDirectoryNameAndIndex(resultConfiguration, fileHolder);
-    static (string, int) GetDirectoryNameAndIndex(int resultAllInOneSubdirectoryLength, string fileName) =>
+    static (string, int) GetDirectoryNameAndIndex(ResultConfiguration resultConfiguration, FileHolder fileHolder) =>
-        XPath.GetDirectoryNameAndIndex(resultAllInOneSubdirectoryLength, fileName);
+        XPath.GetDirectoryNameAndIndex(resultConfiguration, fileHolder);
 
-    Dictionary<string, string[]> TestStatic_GetKeyValuePairs(ResultConfiguration resultConfiguration, string? resultsFullGroupDirectory, string[]? directories) =>
+    (string, int) TestStatic_GetDirectoryNameAndIndex(ResultConfiguration resultConfiguration, FilePath filePath) =>
+        GetDirectoryNameAndIndex(resultConfiguration, filePath);
+    static (string, int) GetDirectoryNameAndIndex(ResultConfiguration resultConfiguration, FilePath filePath) =>
+        XPath.GetDirectoryNameAndIndex(resultConfiguration, filePath);
+
+    (string, int) TestStatic_GetDirectoryNameAndIndex(ResultConfiguration resultConfiguration, int id) =>
+        GetDirectoryNameAndIndex(resultConfiguration, id);
+    static (string, int) GetDirectoryNameAndIndex(ResultConfiguration resultConfiguration, int id) =>
+        XPath.GetDirectoryNameAndIndex(resultConfiguration, id);
+
+    ReadOnlyDictionary<int, ReadOnlyDictionary<string, string[]>> TestStatic_GetKeyValuePairs(ResultConfiguration resultConfiguration, string? resultsFullGroupDirectory, string[]? directories) =>
         GetKeyValuePairs(resultConfiguration, resultsFullGroupDirectory, directories);
-    static Dictionary<string, string[]> GetKeyValuePairs(ResultConfiguration resultConfiguration, string? resultsFullGroupDirectory, string[]? directories) =>
+    static ReadOnlyDictionary<int, ReadOnlyDictionary<string, string[]>> GetKeyValuePairs(ResultConfiguration resultConfiguration, string? resultsFullGroupDirectory, string[]? directories) =>
         XPath.GetKeyValuePairs(resultConfiguration, resultsFullGroupDirectory, directories);
 
 }

Shared/Models/Stateless/XPath.cs

@@ -1,3 +1,5 @@
+using System.Collections.ObjectModel;
+
 namespace View_by_Distance.Shared.Models.Stateless;
 
 internal abstract class XPath
@@ -263,11 +265,12 @@ internal abstract class XPath
         }
     }
 
-    internal static (string, int) GetDirectoryNameAndIndex(int resultAllInOneSubdirectoryLength, string fileName)
+    private static (string, int) GetDirectoryNameAndIndex(int resultAllInOneSubdirectoryLength, string fileNameWithoutExtension)
     {
         int converted;
         string result;
-        string check = fileName.Length < resultAllInOneSubdirectoryLength ? new('-', resultAllInOneSubdirectoryLength) : fileName.Split('.')[0][^resultAllInOneSubdirectoryLength..];
+        string fileNameBeforeFirst = fileNameWithoutExtension.Split('.')[0];
+        string check = fileNameBeforeFirst.Length < resultAllInOneSubdirectoryLength ? new('-', resultAllInOneSubdirectoryLength) : fileNameBeforeFirst[^resultAllInOneSubdirectoryLength..];
         if (check.Any(l => !char.IsNumber(l)))
         {
             result = new('-', resultAllInOneSubdirectoryLength);
@@ -281,49 +284,97 @@ internal abstract class XPath
         return (result, converted);
     }
 
-    internal static Dictionary<string, string[]> GetKeyValuePairs(ResultConfiguration resultConfiguration, string? resultsFullGroupDirectory, string[]? directories)
+    internal static (string, int) GetDirectoryNameAndIndex(ResultConfiguration resultConfiguration, int id)
     {
-        Dictionary<string, string[]> results = [];
+        (string result, int converted) = GetDirectoryNameAndIndex(resultConfiguration.ResultAllInOneSubdirectoryLength, id.ToString());
+        return (result, converted);
+    }
+
+    internal static (string, int) GetDirectoryNameAndIndex(ResultConfiguration resultConfiguration, FileHolder fileHolder)
+    {
+        (string result, int converted) = GetDirectoryNameAndIndex(resultConfiguration.ResultAllInOneSubdirectoryLength, fileHolder.NameWithoutExtension);
+        return (result, converted);
+    }
+
+    internal static (string, int) GetDirectoryNameAndIndex(ResultConfiguration resultConfiguration, FilePath filePath)
+    {
+        string result;
+        int converted;
+        if (filePath.Id is not null)
+            (result, converted) = GetDirectoryNameAndIndex(resultConfiguration.ResultAllInOneSubdirectoryLength, filePath.Id.Value.ToString());
+        else
+            (result, converted) = GetDirectoryNameAndIndex(resultConfiguration.ResultAllInOneSubdirectoryLength, filePath.NameWithoutExtension);
+        return (result, converted);
+    }
+
+    private static ReadOnlyCollection<int> GetYears(ResultConfiguration resultConfiguration)
+    {
+        List<int> results = [];
+        int currentYear = DateTime.Now.Year;
+        for (int i = resultConfiguration.EpicYear; i < currentYear + 1; i++)
+            results.Add(i);
+        return new(results);
+    }
+
+    private static ReadOnlyDictionary<int, ReadOnlyDictionary<string, string[]>> Convert(Dictionary<int, Dictionary<string, string[]>> collection)
+    {
+        Dictionary<int, ReadOnlyDictionary<string, string[]>> results = [];
+        foreach (KeyValuePair<int, Dictionary<string, string[]>> keyValuePair in collection)
+            results.Add(keyValuePair.Key, new(keyValuePair.Value));
+        return new(results);
+    }
+
+    internal static ReadOnlyDictionary<int, ReadOnlyDictionary<string, string[]>> GetKeyValuePairs(ResultConfiguration resultConfiguration, string? resultsFullGroupDirectory, string[]? directories)
+    {
+        Dictionary<int, Dictionary<string, string[]>> results = [];
         string directory;
         string checkDirectory;
+        Dictionary<string, string[]>? keyValuePairs;
+        ReadOnlyCollection<int> years = GetYears(resultConfiguration);
         int converted = int.Parse($"1{new string('0', resultConfiguration.ResultAllInOneSubdirectoryLength)}");
         int plusOne = converted + 1;
         List<string> collection = [];
-        if (directories is not null)
+        foreach (int year in years)
         {
-            foreach (string key in directories)
+            results.Add(year, []);
+            if (!results.TryGetValue(year, out keyValuePairs))
+                throw new NullReferenceException(nameof(keyValuePairs));
+            if (directories is not null)
             {
-                if (resultsFullGroupDirectory is null)
+                foreach (string key in directories)
-                    continue;
-                collection.Clear();
-                for (int i = 0; i < plusOne; i++)
                 {
-                    if (string.IsNullOrEmpty(key))
+                    if (resultsFullGroupDirectory is null)
+                        continue;
+                    collection.Clear();
+                    for (int i = 0; i < plusOne; i++)
                     {
-                        if (i == converted)
+                        if (string.IsNullOrEmpty(key))
-                            checkDirectory = Path.GetFullPath(Path.Combine(resultsFullGroupDirectory, new('-', resultConfiguration.ResultAllInOneSubdirectoryLength)));
+                        {
+                            if (i == converted)
+                                checkDirectory = Path.GetFullPath(Path.Combine(resultsFullGroupDirectory, new('-', resultConfiguration.ResultAllInOneSubdirectoryLength)));
+                            else
+                                checkDirectory = Path.GetFullPath(Path.Combine(resultsFullGroupDirectory, i.ToString().PadLeft(resultConfiguration.ResultAllInOneSubdirectoryLength, '0')));
+                        }
                         else
-                            checkDirectory = Path.GetFullPath(Path.Combine(resultsFullGroupDirectory, i.ToString().PadLeft(resultConfiguration.ResultAllInOneSubdirectoryLength, '0')));
+                        {
+                            directory = Path.Combine(resultsFullGroupDirectory, key, year.ToString());
+                            if (i == converted)
+                                checkDirectory = Path.GetFullPath(Path.Combine(directory, new('-', resultConfiguration.ResultAllInOneSubdirectoryLength)));
+                            else
+                                checkDirectory = Path.GetFullPath(Path.Combine(directory, i.ToString().PadLeft(resultConfiguration.ResultAllInOneSubdirectoryLength, '0')));
+                        }
+                        if (!Directory.Exists(checkDirectory))
+                            _ = Directory.CreateDirectory(checkDirectory);
+                        collection.Add(checkDirectory);
                     }
+                    if (!string.IsNullOrEmpty(key))
+                        keyValuePairs.Add(key, collection.ToArray());
                     else
-                    {
+                        keyValuePairs.Add(year.ToString(), collection.ToArray());
-                        directory = Path.Combine(resultsFullGroupDirectory, key, resultConfiguration.ResultAllInOne);
-                        if (i == converted)
-                            checkDirectory = Path.GetFullPath(Path.Combine(directory, new('-', resultConfiguration.ResultAllInOneSubdirectoryLength)));
-                        else
-                            checkDirectory = Path.GetFullPath(Path.Combine(directory, i.ToString().PadLeft(resultConfiguration.ResultAllInOneSubdirectoryLength, '0')));
-                    }
-                    if (!Directory.Exists(checkDirectory))
-                        _ = Directory.CreateDirectory(checkDirectory);
-                    collection.Add(checkDirectory);
                 }
-                if (!string.IsNullOrEmpty(key))
-                    results.Add(key, collection.ToArray());
-                else
-                    results.Add(resultConfiguration.ResultAllInOne, collection.ToArray());
             }
         }
-        return results;
+        return Convert(results);
     }
 
 }

Shared/Models/Stateless/XResult.cs

@@ -25,49 +25,53 @@ internal abstract class XResult
         return result;
     }
 
-    private static void CheckContent(ResultConfiguration resultConfiguration, string dateGroupDirectory, string contentDescription, string result)
+    private static void VerifyDirectories(ResultConfiguration resultConfiguration, string dateGroupDirectory, string key)
     {
         string checkDirectory;
-        checkDirectory = Path.Combine(dateGroupDirectory, resultConfiguration.ResultContent, resultConfiguration.ResultAllInOne);
+        int currentYear = DateTime.Now.Year;
-        if (!Directory.Exists(checkDirectory))
+        for (int i = resultConfiguration.EpicYear; i < currentYear + 1; i++)
-            _ = Directory.CreateDirectory(checkDirectory);
+        {
+            checkDirectory = Path.Combine(dateGroupDirectory, key, i.ToString());
+            if (!Directory.Exists(checkDirectory))
+                _ = Directory.CreateDirectory(checkDirectory);
+        }
+    }
+
+    private static void CheckContent(ResultConfiguration resultConfiguration, string dateGroupDirectory, string contentDescription, string result)
+    {
+        VerifyDirectories(resultConfiguration, dateGroupDirectory, resultConfiguration.ResultContent);
         string contentDirectory = new(result.Replace("<>", resultConfiguration.ResultContent));
         if (!Directory.Exists(contentDirectory))
             _ = Directory.CreateDirectory(contentDirectory);
-        checkDirectory = Path.Combine(dateGroupDirectory, string.Concat("() - ", contentDescription));
+        string checkDirectory = Path.Combine(dateGroupDirectory, string.Concat("() - ", contentDescription));
         if (!Directory.Exists(checkDirectory))
             _ = Directory.CreateDirectory(checkDirectory);
     }
 
     private static void CheckSingleton(ResultConfiguration resultConfiguration, string dateGroupDirectory, string singletonDescription, bool converted, string result)
     {
-        string checkDirectory;
+        VerifyDirectories(resultConfiguration, dateGroupDirectory, resultConfiguration.ResultSingleton);
-        checkDirectory = Path.Combine(dateGroupDirectory, resultConfiguration.ResultSingleton, resultConfiguration.ResultAllInOne);
-        if (!Directory.Exists(checkDirectory))
-            _ = Directory.CreateDirectory(checkDirectory);
         if (!converted)
         {
             string singletonDirectory = new(result.Replace("<>", resultConfiguration.ResultSingleton));
             if (!Directory.Exists(singletonDirectory))
                 _ = Directory.CreateDirectory(singletonDirectory);
         }
-        checkDirectory = Path.Combine(dateGroupDirectory, string.Concat("{} - ", singletonDescription));
+        string checkDirectory = Path.Combine(dateGroupDirectory, string.Concat("{} - ", singletonDescription));
         if (!Directory.Exists(checkDirectory))
             _ = Directory.CreateDirectory(checkDirectory);
     }
 
     private static void CheckCollection(ResultConfiguration resultConfiguration, string dateGroupDirectory, string collectionDescription, bool converted, string result)
     {
-        string checkDirectory = Path.Combine(dateGroupDirectory, resultConfiguration.ResultCollection, resultConfiguration.ResultAllInOne);
+        VerifyDirectories(resultConfiguration, dateGroupDirectory, resultConfiguration.ResultCollection);
-        if (!Directory.Exists(checkDirectory))
-            _ = Directory.CreateDirectory(checkDirectory);
         if (!converted)
         {
             string collectionDirectory = new(result.Replace("<>", resultConfiguration.ResultCollection));
             if (!Directory.Exists(collectionDirectory))
                 _ = Directory.CreateDirectory(collectionDirectory);
         }
-        checkDirectory = Path.Combine(dateGroupDirectory, string.Concat("[] - ", collectionDescription));
+        string checkDirectory = Path.Combine(dateGroupDirectory, string.Concat("[] - ", collectionDescription));
         if (!Directory.Exists(checkDirectory))
             _ = Directory.CreateDirectory(checkDirectory);
     }