Write index.yml.md

Helper to diff video files
Move matches from directory
Bug fix for DirectoryToISO
Find replace instead of remove
Rename Directory
Amazon
Immich Person
PersonKeyToName
PullIconsForBLM
New links

Day/2024-Q1/Helper-2024-01-07.cs

@@ -33,7 +33,10 @@ internal static partial class Helper20240107
         string destinationDirectory = args[3];
         logger.LogInformation(sourceDirectory);
         if (sourceDirectory == "C:/ProgramData")
+        {
             sourceDirectory = destinationDirectory;
+            destinationDirectory = Path.GetDirectoryName(destinationDirectory) ?? throw new NotSupportedException();
+        }
         bool mapOnly = sourceDirectory.Length == 2;
         if (!Directory.Exists(destinationDirectory))
             _ = Directory.CreateDirectory(destinationDirectory);

Day/2024-Q2/Helper-2024-05-10.cs

@@ -0,0 +1,34 @@
+using Microsoft.Extensions.Logging;
+
+namespace File_Folder_Helper.Day;
+
+internal static partial class Helper20240510
+{
+
+    internal static void PullIconsForBLM(ILogger<Worker> logger, List<string> args)
+    {
+        string fileName;
+        FileInfo fileInfo;
+        string searchPattern = args[4];
+        string sourceDirectory = args[3];
+        string root = Path.GetFullPath(args[0]);
+        string createDirectory = Path.Combine(root, args[2]);
+        if (!Directory.Exists(createDirectory))
+            _ = Directory.CreateDirectory(createDirectory);
+        string[] files = Directory.GetFiles(sourceDirectory, searchPattern, SearchOption.TopDirectoryOnly);
+        foreach (string file in files)
+        {
+            fileName = Path.GetFileName(file);
+            fileInfo = new(Path.Combine(createDirectory, fileName));
+            if (fileInfo.Exists && fileInfo.LastWriteTime == new FileInfo(file).LastWriteTime)
+                continue;
+            File.Copy(file, fileInfo.FullName, overwrite: true);
+            logger.LogInformation("<{fileName}> copied", fileName);
+        }
+        logger.LogWarning("What reactor is this near?");
+        string? reactor = Console.ReadLine();
+        if (!string.IsNullOrEmpty(reactor))
+            _ = Directory.CreateDirectory(Path.Combine(sourceDirectory, Environment.MachineName, reactor));
+    }
+
+}

Day/2024-Q2/Helper-2024-05-13.cs

@@ -0,0 +1,39 @@
+using File_Folder_Helper.Models;
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+
+namespace File_Folder_Helper.Day;
+
+internal static partial class Helper20240513
+{
+
+    internal static void PersonKeyToName(ILogger<Worker> logger, List<string> args)
+    {
+        Person? person;
+        string directoryName;
+        string checkDirectory;
+        string root = Path.GetFullPath(args[0]);
+        string json = File.ReadAllText(args[2]);
+        Dictionary<string, Person> keyValuePairs = [];
+        string[] directories = Directory.GetDirectories(root, "*", SearchOption.TopDirectoryOnly);
+        Dictionary<long, Person> people = JsonSerializer.Deserialize(json, PeopleSourceGenerationContext.Default.DictionaryInt64Person) ?? throw new NullReferenceException();
+        foreach (KeyValuePair<long, Person> keyValuePair in people)
+        {
+            if (keyValuePair.Value.Birth?.Note is null)
+                continue;
+            keyValuePairs.Add(keyValuePair.Value.Birth.Note, keyValuePair.Value);
+        }
+        foreach (string directory in directories)
+        {
+            directoryName = Path.GetFileName(directory);
+            if (!keyValuePairs.TryGetValue(directoryName, out person) || person.Name?.ForwardSlashFull is null)
+                continue;
+            checkDirectory = Path.Combine(root, $"{person.Name.ForwardSlashFull.Replace('/', '-')}{directoryName}-{person.Id}");
+            if (Directory.Exists(checkDirectory))
+                continue;
+            Directory.Move(directory, checkDirectory);
+            logger.LogInformation("<{directory}> was moved", directory);
+        }
+    }
+
+}

Day/2024-Q2/Helper-2024-05-17.cs

@@ -0,0 +1,334 @@
+using Microsoft.Extensions.Logging;
+using System.Collections.ObjectModel;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Folder_Helper.Day;
+
+internal static partial class Helper20240517
+{
+
+    public record ContentSignature([property: JsonPropertyName("contentSignature")] string Value,
+                                   [property: JsonPropertyName("contentSignatureType")] string ContentSignatureType);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(ContentSignature))]
+    public partial class ContentSignatureGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record Type([property: JsonPropertyName("count")] int Count,
+                       [property: JsonPropertyName("match")] string Match,
+                       [property: JsonPropertyName("searchData")] SearchData SearchData);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Type))]
+    public partial class TypeGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record ImageAmazon([property: JsonPropertyName("colorSpace")] string ColorSpace,
+                              [property: JsonPropertyName("dateTime")] DateTime DateTime,
+                              [property: JsonPropertyName("dateTimeDigitized")] DateTime DateTimeDigitized,
+                              [property: JsonPropertyName("dateTimeOriginal")] DateTime DateTimeOriginal,
+                              [property: JsonPropertyName("exposureMode")] string ExposureMode,
+                              [property: JsonPropertyName("exposureProgram")] string ExposureProgram,
+                              [property: JsonPropertyName("exposureTime")] string ExposureTime,
+                              [property: JsonPropertyName("flash")] string Flash,
+                              [property: JsonPropertyName("focalLength")] string FocalLength,
+                              [property: JsonPropertyName("height")] int Height,
+                              [property: JsonPropertyName("make")] string Make,
+                              [property: JsonPropertyName("meteringMode")] string MeteringMode,
+                              [property: JsonPropertyName("model")] string Model,
+                              [property: JsonPropertyName("orientation")] string Orientation,
+                              [property: JsonPropertyName("resolutionUnit")] string ResolutionUnit,
+                              [property: JsonPropertyName("sensingMethod")] string SensingMethod,
+                              [property: JsonPropertyName("sharpness")] string Sharpness,
+                              [property: JsonPropertyName("software")] string Software,
+                              [property: JsonPropertyName("subSecTime")] string SubSecTime,
+                              [property: JsonPropertyName("subSecTimeDigitized")] string SubSecTimeDigitized,
+                              [property: JsonPropertyName("subSecTimeOriginal")] string SubSecTimeOriginal,
+                              [property: JsonPropertyName("whiteBalance")] string WhiteBalance,
+                              [property: JsonPropertyName("width")] int Width,
+                              [property: JsonPropertyName("apertureValue")] string ApertureValue);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(ImageAmazon))]
+    public partial class ImageAmazonGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record ContentProperties([property: JsonPropertyName("contentDate")] DateTime ContentDate,
+                                    [property: JsonPropertyName("contentSignatures")] IReadOnlyList<ContentSignature> ContentSignatures,
+                                    [property: JsonPropertyName("contentType")] string ContentType,
+                                    [property: JsonPropertyName("extension")] string Extension,
+                                    [property: JsonPropertyName("image")] ImageAmazon Image,
+                                    [property: JsonPropertyName("md5")] string Md5,
+                                    [property: JsonPropertyName("size")] int Size,
+                                    [property: JsonPropertyName("version")] int Version);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(ContentProperties))]
+    public partial class ContentPropertiesGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record XAccntParentMap();
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(XAccntParentMap))]
+    public partial class XAccntParentMapGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record Datum([property: JsonPropertyName("accessRuleIds")] IReadOnlyList<object> AccessRuleIds,
+                        [property: JsonPropertyName("childAssetTypeInfo")] IReadOnlyList<object> ChildAssetTypeInfo,
+                        [property: JsonPropertyName("contentProperties")] ContentProperties ContentProperties,
+                        [property: JsonPropertyName("createdBy")] string CreatedBy,
+                        [property: JsonPropertyName("createdDate")] DateTime CreatedDate,
+                        [property: JsonPropertyName("eTagResponse")] string ETagResponse,
+                        [property: JsonPropertyName("groupPermissions")] IReadOnlyList<object> GroupPermissions,
+                        [property: JsonPropertyName("id")] string Id,
+                        [property: JsonPropertyName("isRoot")] bool IsRoot,
+                        [property: JsonPropertyName("isShared")] bool IsShared,
+                        [property: JsonPropertyName("keywords")] IReadOnlyList<object> Keywords,
+                        [property: JsonPropertyName("kind")] string Kind,
+                        [property: JsonPropertyName("labels")] IReadOnlyList<object> Labels,
+                        [property: JsonPropertyName("modifiedDate")] DateTime ModifiedDate,
+                        [property: JsonPropertyName("name")] string Name,
+                        [property: JsonPropertyName("ownerId")] string OwnerId,
+                        [property: JsonPropertyName("parentMap")] ParentMap ParentMap,
+                        [property: JsonPropertyName("parents")] IReadOnlyList<string> Parents,
+                        [property: JsonPropertyName("protectedFolder")] bool ProtectedFolder,
+                        [property: JsonPropertyName("restricted")] bool Restricted,
+                        [property: JsonPropertyName("status")] string Status,
+                        [property: JsonPropertyName("subKinds")] IReadOnlyList<object> SubKinds,
+                        [property: JsonPropertyName("transforms")] IReadOnlyList<string> Transforms,
+                        [property: JsonPropertyName("version")] int Version,
+                        [property: JsonPropertyName("xAccntParentMap")] XAccntParentMap XAccntParentMap,
+                        [property: JsonPropertyName("xAccntParents")] IReadOnlyList<object> XAccntParents,
+                        [property: JsonPropertyName("match")] bool? Match);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Datum))]
+    public partial class DatumGenerationContext : JsonSerializerContext
+    {
+    }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Dictionary<string, Datum>))]
+    public partial class DictionaryDatumGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record LocationAmazon([property: JsonPropertyName("count")] int Count,
+                                 [property: JsonPropertyName("match")] string Match,
+                                 [property: JsonPropertyName("searchData")] SearchData SearchData);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(LocationAmazon))]
+    public partial class LocationAmazonGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record LocationInfo([property: JsonPropertyName("city")] string City,
+                               [property: JsonPropertyName("country")] string Country,
+                               [property: JsonPropertyName("countryIso3Code")] string CountryIso3Code,
+                               [property: JsonPropertyName("state")] string State,
+                               [property: JsonPropertyName("stateCode")] string StateCode);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(LocationInfo))]
+    public partial class LocationInfoGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record SearchData([property: JsonPropertyName("clusterName")] string ClusterName,
+                             [property: JsonPropertyName("locationId")] string LocationId,
+                             [property: JsonPropertyName("locationInfo")] LocationInfo LocationInfo,
+                             [property: JsonPropertyName("thingId")] string ThingId);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(SearchData))]
+    public partial class SearchDataGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record AllPerson([property: JsonPropertyName("count")] int Count,
+                            [property: JsonPropertyName("match")] string Match,
+                            [property: JsonPropertyName("searchData")] SearchData SearchData);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(AllPerson))]
+    public partial class AllPersonGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record PersonAmazon([property: JsonPropertyName("count")] int Count,
+                               [property: JsonPropertyName("match")] string Match,
+                               [property: JsonPropertyName("searchData")] SearchData SearchData);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(PersonAmazon))]
+    public partial class PersonAmazonGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record ClusterId([property: JsonPropertyName("count")] int Count,
+                            [property: JsonPropertyName("match")] string Match,
+                            [property: JsonPropertyName("searchData")] SearchData SearchData);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(ClusterId))]
+    public partial class ClusterIdGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record Thing([property: JsonPropertyName("count")] int Count,
+                        [property: JsonPropertyName("match")] string Match,
+                        [property: JsonPropertyName("searchData")] SearchData SearchData);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Thing))]
+    public partial class ThingGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record Time([property: JsonPropertyName("count")] int Count,
+                       [property: JsonPropertyName("match")] string Match,
+                       [property: JsonPropertyName("searchData")] SearchData SearchData);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Time))]
+    public partial class TimeGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record ParentMap([property: JsonPropertyName("FOLDER")] IReadOnlyList<string> FOLDER);
+
+    public record Aggregations([property: JsonPropertyName("allPeople")] IReadOnlyList<AllPerson> AllPeople,
+                               [property: JsonPropertyName("clusterId")] IReadOnlyList<ClusterId> ClusterId,
+                               [property: JsonPropertyName("location")] IReadOnlyList<LocationAmazon> Location,
+                               [property: JsonPropertyName("people")] IReadOnlyList<PersonAmazon> People,
+                               [property: JsonPropertyName("things")] IReadOnlyList<Thing> Things,
+                               [property: JsonPropertyName("time")] IReadOnlyList<Time> Time,
+                               [property: JsonPropertyName("type")] IReadOnlyList<Type> Type);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Aggregations))]
+    public partial class AggregationsGenerationContext : JsonSerializerContext
+    {
+    }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(ParentMap))]
+    public partial class ParentMapGenerationContext : JsonSerializerContext
+    {
+    }
+
+    public record RootAmazon([property: JsonPropertyName("aggregations")] Aggregations Aggregations,
+                             [property: JsonPropertyName("count")] int Count,
+                             [property: JsonPropertyName("data")] IReadOnlyList<Datum> Data);
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(RootAmazon))]
+    public partial class RootAmazonGenerationContext : JsonSerializerContext
+    {
+    }
+
+    private static ReadOnlyCollection<(string, string)> GetAggregationLines(string harFile)
+    {
+        List<(string, string)> results = [];
+        if (!File.Exists(harFile))
+            throw new Exception();
+        string lastUrl = string.Empty;
+        string text = "\"text\": \"{";
+        string[] lines = File.ReadAllLines(harFile);
+        foreach (string line in lines)
+        {
+            if (line.Contains("\"url\": \""))
+                lastUrl = line;
+            if (!line.Contains(text))
+                continue;
+            if (!line.Contains("aggregations"))
+                continue;
+            if (lastUrl.Contains("search?asset=NONE"))
+                continue;
+            results.Add(new(lastUrl, line.Trim()[(text.Length - 1)..^1].Replace("\\\"", "\"")));
+            lastUrl = string.Empty;
+        }
+        return new(results);
+    }
+
+    private static void SaveAmazon(IReadOnlyList<Datum> data, string personIdFile)
+    {
+        string json;
+        Dictionary<string, Datum> keyValuePairs = [];
+        foreach (Datum datum in data)
+            _ = keyValuePairs.TryAdd(datum.Name.Split('.')[0], datum);
+        json = JsonSerializer.Serialize(keyValuePairs, DictionaryDatumGenerationContext.Default.DictionaryStringDatum);
+        File.WriteAllText(personIdFile, json);
+    }
+
+    private static void SaveAmazon(string destination, string harFile)
+    {
+        string offset;
+        string personId;
+        RootAmazon amazon;
+        string? personName;
+        string personIdFile;
+        string personDirectory;
+        PersonAmazon personAmazon;
+        Dictionary<string, string> keyValuePairs = [];
+        ReadOnlyCollection<(string Url, string AggregationLine)> aggregationLines = GetAggregationLines(harFile);
+        foreach ((string url, string aggregationLine) in aggregationLines)
+        {
+            if (aggregationLine.Contains(",\"category\":\"allPeople\"}"))
+                continue;
+            amazon = JsonSerializer.Deserialize(aggregationLine, RootAmazonGenerationContext.Default.RootAmazon) ?? throw new Exception();
+            if (amazon.Aggregations?.People is null || amazon.Aggregations.People.Count < 1)
+                continue;
+            personAmazon = amazon.Aggregations.People[0];
+            if (!url.Contains(personAmazon.Match))
+                continue;
+            personDirectory = Path.Combine(destination, personAmazon.SearchData.ClusterName);
+            _ = Directory.CreateDirectory(personDirectory);
+            personIdFile = Path.Combine(personDirectory, $"000) {personAmazon.Match}.json");
+            _ = keyValuePairs.TryAdd(personAmazon.Match, personAmazon.SearchData.ClusterName);
+            SaveAmazon(amazon.Data, personIdFile);
+        }
+        foreach ((string url, string aggregationLine) in aggregationLines)
+        {
+            if (aggregationLine.Contains(",\"category\":\"allPeople\"}"))
+                continue;
+            amazon = JsonSerializer.Deserialize(aggregationLine, RootAmazonGenerationContext.Default.RootAmazon) ?? throw new Exception();
+            if (amazon.Aggregations?.People is not null && amazon.Aggregations.People.Count > 0)
+                continue;
+            if (!url.Contains("offset="))
+                continue;
+            offset = url.Split("offset=")[1];
+            if (!url.Contains("people%3A("))
+                continue;
+            personId = url.Split("people%3A(")[1].Split(')')[0];
+            if (!keyValuePairs.TryGetValue(personId, out personName))
+                continue;
+            personDirectory = Path.Combine(destination, personName);
+            _ = Directory.CreateDirectory(personDirectory);
+            personIdFile = Path.Combine(personDirectory, $"{offset.Split('&')[0]}) {personId}.json");
+            SaveAmazon(amazon.Data, personIdFile);
+        }
+    }
+
+    internal static void SaveAmazon(ILogger<Worker> logger, List<string> args)
+    {
+        string root = Path.GetFullPath(args[0]);
+        string destination = Path.GetFullPath(args[2]);
+        if (string.IsNullOrEmpty(root))
+            throw new NullReferenceException(nameof(root));
+        string[] harFiles = Directory.GetFiles(root, "*.har", SearchOption.TopDirectoryOnly);
+        foreach (string harFile in harFiles)
+            SaveAmazon(destination, harFile);
+        logger?.LogInformation("{harFiles} count", harFiles.Length);
+    }
+
+}

Day/2024-Q2/Helper-2024-05-18.cs

@@ -0,0 +1,35 @@
+using File_Folder_Helper.Models;
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+
+namespace File_Folder_Helper.Day;
+
+internal static partial class Helper20240518
+{
+
+    internal static void PersonKeyToImmichImport(ILogger<Worker> logger, List<string> args)
+    {
+        string name;
+        string birthDate;
+        string ownerId = args[5];
+        List<string> inserts = [];
+        string tableName = args[3];
+        string birthDateFormat = args[6];
+        string[] columns = args[4].Split(',');
+        string json = File.ReadAllText(args[2]);
+        string root = Path.GetFullPath(args[0]);
+        Dictionary<long, Person> people = JsonSerializer.Deserialize(json, PeopleSourceGenerationContext.Default.DictionaryInt64Person) ?? throw new NullReferenceException();
+        foreach (KeyValuePair<long, Person> keyValuePair in people)
+        {
+            if (keyValuePair.Value.Birth?.Note is null || keyValuePair.Value.Name?.ForwardSlashFull is null || keyValuePair.Value.Birth?.Date is null)
+                continue;
+            birthDate = keyValuePair.Value.Birth.Date.Value.ToString(birthDateFormat);
+            name = keyValuePair.Value.Name.ForwardSlashFull.Replace("/", string.Empty);
+            inserts.Add($"insert into \"{tableName}\" (\"{string.Join("\", \"", columns)}\") values ('{ownerId}', '{name}', '{birthDate}');");
+        }
+        string file = Path.Combine(root, $"{DateTime.Now.Ticks}.sql");
+        logger.LogInformation("<{file}> saved", file);
+        File.WriteAllLines(file, inserts);
+    }
+
+}

Day/2024-Q2/Helper-2024-05-19.cs

@@ -0,0 +1,80 @@
+using File_Folder_Helper.Helpers;
+using Microsoft.Extensions.Logging;
+using System.Collections.ObjectModel;
+
+namespace File_Folder_Helper.Day;
+
+internal static partial class Helper20240519
+{
+
+    private record Record(long Length, long Ticks);
+
+    private static ReadOnlyDictionary<string, Record> GetKeyValuePairs(string source, string[] sourceFiles)
+    {
+        Dictionary<string, Record> results = [];
+        string key;
+        Record? record;
+        FileInfo fileInfo;
+        int sourceLength = source.Length;
+        foreach (string sourceFile in sourceFiles)
+        {
+            fileInfo = new(sourceFile);
+            key = sourceFile[sourceLength..];
+            if (results.TryGetValue(key, out record))
+                throw new NotSupportedException();
+            results.Add(key, new(fileInfo.Length, fileInfo.LastWriteTime.Ticks));
+        }
+        return new(results);
+    }
+
+    internal static void FindReplaceDirectoryName(ILogger<Worker> logger, List<string> args)
+    {
+        string checkDirectory;
+        string replaceText = args[3];
+        string[] findTexts = args[2].Split(',');
+        string root = Path.GetFullPath(args[0]);
+        string[] directories = Directory.GetDirectories(root, "*", SearchOption.TopDirectoryOnly);
+        foreach (string directory in directories)
+        {
+            checkDirectory = directory;
+            foreach (string findText in findTexts)
+                checkDirectory = checkDirectory.Replace(findText, replaceText);
+            if (checkDirectory == directory)
+                continue;
+            if (Directory.Exists(checkDirectory))
+                continue;
+            logger.LogInformation("<{directory}> to <{checkDirectory}>", directory, checkDirectory);
+            Directory.Move(directory, checkDirectory);
+        }
+        string key;
+        Record? record;
+        string checkFile;
+        FileInfo fileInfo;
+        string target = Path.GetFullPath(args[6]);
+        string source = Path.GetFullPath(args[4]);
+        string compare = Path.GetFullPath(args[5]);
+        string[] sourceFiles = Directory.GetFiles(source, "*", SearchOption.AllDirectories);
+        ReadOnlyDictionary<string, Record> keyValuePairs = GetKeyValuePairs(source, sourceFiles);
+        string[] compareFiles = Directory.GetFiles(compare, "*", SearchOption.AllDirectories);
+        int compareLength = compare.Length;
+        foreach (string compareFile in compareFiles)
+        {
+            fileInfo = new(compareFile);
+            key = compareFile[compareLength..];
+            if (!keyValuePairs.TryGetValue(key, out record))
+                continue;
+            if (fileInfo.Length != record.Length || fileInfo.LastWriteTime.Ticks != record.Ticks)
+                continue;
+            checkFile = $"{target}{key}";
+            checkDirectory = Path.GetDirectoryName(checkFile) ?? throw new NotSupportedException();
+            if (!Directory.Exists(checkDirectory))
+                _ = Directory.CreateDirectory(checkDirectory);
+            if (File.Exists(checkFile))
+                continue;
+            logger.LogInformation("<{compareFile}> to <{checkFile}>", compareFile, checkFile);
+            File.Move(compareFile, checkFile);
+        }
+        HelperDeleteEmptyDirectories.DeleteEmptyDirectories(logger, compare);
+    }
+
+}

Day/2024-Q2/Helper-2024-05-20.cs

@@ -0,0 +1,160 @@
+using File_Folder_Helper.Helpers;
+using Microsoft.Extensions.Logging;
+using System.Collections.ObjectModel;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace File_Folder_Helper.Day;
+
+internal static partial class Helper20240520
+{
+
+    private record RecordA(string Directory, string Extension, string SourceFile, Identifier Identifier);
+
+    private record RecordB(ReadOnlyDictionary<int, Identifier> IdTo, ReadOnlyDictionary<long, Identifier> LengthTo, ReadOnlyDictionary<string, Identifier> PaddedTo);
+
+    internal sealed record Identifier(int Id, long Length, string PaddedId, long Ticks)
+    {
+
+        public override string ToString()
+        {
+            string result = JsonSerializer.Serialize(this, IdentifierSourceGenerationContext.Default.Identifier);
+            return result;
+        }
+
+    }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Identifier))]
+    internal partial class IdentifierSourceGenerationContext : JsonSerializerContext
+    {
+    }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Identifier[]))]
+    internal partial class IdentifierCollectionSourceGenerationContext : JsonSerializerContext
+    {
+    }
+
+    private static RecordB GetRecordB(string jsonFile)
+    {
+        RecordB result;
+        Dictionary<int, Identifier> idTo = [];
+        Dictionary<long, Identifier> lengthTo = [];
+        Dictionary<string, Identifier> paddedTo = [];
+        string? json = !File.Exists(jsonFile) ? null : File.ReadAllText(jsonFile);
+        Identifier[]? identifiers = json is null ? null : JsonSerializer.Deserialize(json, IdentifierCollectionSourceGenerationContext.Default.IdentifierArray);
+        if (identifiers is null && !string.IsNullOrEmpty(jsonFile))
+            throw new Exception($"Invalid {nameof(jsonFile)}");
+        if (identifiers is not null)
+        {
+            foreach (Identifier identifier in identifiers)
+            {
+                idTo.Add(identifier.Id, identifier);
+                paddedTo.Add(identifier.PaddedId, identifier);
+                if (lengthTo.ContainsKey(identifier.Length))
+                {
+                    _ = lengthTo.Remove(identifier.Length);
+                    continue;
+                }
+                lengthTo.Add(identifier.Length, identifier);
+            }
+        }
+        result = new(new(idTo), new(lengthTo), new(paddedTo));
+        return result;
+    }
+
+    internal static void IdentifierRename(ILogger<Worker> logger, List<string> args)
+    {
+        int id;
+        string key;
+        RecordA recordA;
+        string checkFile;
+        FileInfo fileInfo;
+        string checkDirectory;
+        Identifier? identifier;
+        string offset = args[5];
+        string option = args[7];
+        string jsonFile = args[4];
+        string fileNameWithoutExtension;
+        List<RecordA> recordACollection = [];
+        RecordB recordB = GetRecordB(jsonFile);
+        string deterministicHashCode = args[3];
+        string source = Path.GetFullPath(args[0]);
+        int intMinValueLength = int.Parse(args[2]);
+        string destination = Path.GetFullPath(args[6]);
+        bool isOffsetDeterministicHashCode = offset == deterministicHashCode;
+        string[] sourceFiles = Directory.GetFiles(source, "*", SearchOption.AllDirectories);
+        logger.LogInformation("Found {files}(s)", sourceFiles.Length);
+        int sourceLength = source.Length;
+        foreach (string sourceFile in sourceFiles)
+        {
+            fileInfo = new(sourceFile);
+            fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileInfo.FullName);
+            if (fileInfo.Directory is null)
+                throw new NotSupportedException();
+            if (option == "Padded")
+            {
+                if (fileNameWithoutExtension.Length < intMinValueLength)
+                    continue;
+                key = fileNameWithoutExtension;
+                if (recordB.PaddedTo.TryGetValue(key, out identifier))
+                {
+                    recordACollection.Add(new($"{destination}{fileInfo.Directory.FullName[sourceLength..]}", fileInfo.Extension, fileInfo.FullName, identifier));
+                    continue;
+                }
+            }
+            if (option == "Length")
+            {
+                if (recordB.LengthTo.TryGetValue(fileInfo.Length, out identifier))
+                {
+                    checkDirectory = $"{destination}{fileInfo.Directory.FullName[sourceLength..]}";
+                    if (!Directory.Exists(checkDirectory))
+                        _ = Directory.CreateDirectory(checkDirectory);
+                    checkFile = Path.Combine(checkDirectory, $"{identifier.PaddedId}{fileInfo.Extension}");
+                    if (File.Exists(checkFile))
+                        continue;
+                    File.Copy(fileInfo.FullName, checkFile);
+                    logger.LogInformation("<{fileInfo.FullName}> was moved to <{checkFile}>", fileInfo.FullName, checkFile);
+                    continue;
+                }
+            }
+            if (option == "Id")
+            {
+                if (int.TryParse(fileNameWithoutExtension, out id))
+                {
+                    if (recordB.IdTo.TryGetValue(id, out identifier))
+                    {
+                        checkDirectory = $"{destination}{fileInfo.Directory.FullName[sourceLength..]}";
+                        if (!Directory.Exists(checkDirectory))
+                            _ = Directory.CreateDirectory(checkDirectory);
+                        checkFile = Path.Combine(checkDirectory, $"{identifier.PaddedId}{fileInfo.Extension}");
+                        if (File.Exists(checkFile))
+                            continue;
+                        File.Move(fileInfo.FullName, checkFile);
+                        logger.LogInformation("<{fileInfo.FullName}> was moved to <{checkFile}>", fileInfo.FullName, checkFile);
+                        continue;
+                    }
+                }
+            }
+        }
+        if (option == "Padded")
+        {
+            if (!isOffsetDeterministicHashCode)
+                recordACollection = (from l in recordACollection orderby l.Identifier.Ticks select l).ToList();
+            for (int i = 0; i < recordACollection.Count; i++)
+            {
+                recordA = recordACollection[i];
+                if (!Directory.Exists(recordA.Directory))
+                    _ = Directory.CreateDirectory(recordA.Directory);
+                checkFile = Path.Combine(recordA.Directory, isOffsetDeterministicHashCode ? $"{recordA.Identifier.PaddedId}{recordA.Extension}" : $"{offset + i}{recordA.Identifier.PaddedId}{recordA.Extension}");
+                if (File.Exists(checkFile))
+                    continue;
+                File.Move(recordA.SourceFile, checkFile);
+                logger.LogInformation("<{recordA.SourceFile}> was moved to <{checkFile}>", recordA.SourceFile, checkFile);
+            }
+        }
+        HelperDeleteEmptyDirectories.DeleteEmptyDirectories(logger, source);
+    }
+
+}

Day/HelperDay.cs

@@ -60,6 +60,18 @@ internal static class HelperDay
             Day.Helper20240427.Immich(appSettings, logger, args);
         else if (args[1] == "Day-Helper-2024-04-29")
             Day.Helper20240429.GitConfigCleanUp(logger, args);
+        else if (args[1] == "Day-Helper-2024-05-10")
+            Day.Helper20240510.PullIconsForBLM(logger, args);
+        else if (args[1] == "Day-Helper-2024-05-13")
+            Day.Helper20240513.PersonKeyToName(logger, args);
+        else if (args[1] == "Day-Helper-2024-05-17")
+            Day.Helper20240517.SaveAmazon(logger, args);
+        else if (args[1] == "Day-Helper-2024-05-18")
+            Day.Helper20240518.PersonKeyToImmichImport(logger, args);
+        else if (args[1] == "Day-Helper-2024-05-19")
+            Day.Helper20240519.FindReplaceDirectoryName(logger, args);
+        else if (args[1] == "Day-Helper-2024-05-20")
+            Day.Helper20240520.IdentifierRename(logger, args);
         else
             throw new Exception(appSettings.Company);
     }