New Token

.gitignore

@@ -335,3 +335,4 @@ ASALocalRun/
 .extensions-vscode
 .extensions-vscode-oss
 .extensions-vscode-insiders
+.vscode/.UserSecrets/secrets.json

.vscode/launch.json

@@ -12,10 +12,16 @@
             "program": "${workspaceFolder}/bin/Debug/net8.0/win-x64/File-Folder-Helper.dll",
             "args": [
                 "s",
-                "M",
+                "X",
-                "L:/Git/Notes-Infineon/.Infineon",
+                "L:/",
-                "-d",
+                "Day-Helper-2024-07-11",
-                "L:/Git/Notes-Infineon/.Infineon/.vscode/helper"
+                "config",
+                "refs/remotes/gitea",
+                "http",
+                "gitea",
+                "https://51f44975c8734522b2dec36c6d9a116276c6bded@gitea.ddns.net/phares3757/",
+                ".git",
+                "master"
             ],
             "cwd": "${workspaceFolder}",
             "console": "integratedTerminal",

.vscode/mklink.md

@@ -22,3 +22,7 @@ mklink /J "L:\DevOps\Mesa_FI\File-Folder-Helper\.extensions-vscode" "C:\Users\ph
 mklink /J "L:\DevOps\Mesa_FI\File-Folder-Helper\.extensions-vscode-oss" "C:\Users\phares\.vscode-oss\extensions\ifx.type-script-helper-1.6.2"
 mklink /J "L:\DevOps\Mesa_FI\File-Folder-Helper\.extensions-vscode-insiders" "C:\Users\phares\.vscode-insiders\extensions\ifx.type-script-helper-1.6.2"
 ```
+
+```bash Thu Jul 18 2024 13:47:40 GMT-0700 (Mountain Standard Time)
+mklink /J "L:\DevOps\Mesa_FI\File-Folder-Helper\.vscode\.UserSecrets" "L:\Git\Notes-User-Secrets\.UserSecrets\8da397d4-13ec-4576-9722-3c79cad25563"
+```

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

@@ -1,3 +1,4 @@
+using File_Folder_Helper.Models;
 using Microsoft.Extensions.Logging;
 using System.Collections.ObjectModel;
 using System.Text;
@@ -9,22 +10,6 @@ namespace File_Folder_Helper.Day;
 internal static partial class Helper20240106
 {
 
-    private record Host([property: JsonPropertyName("a")] string? Id,
-                        [property: JsonPropertyName("b")] string? Colon,
-                        [property: JsonPropertyName("c")] string? Hyphen,
-                        [property: JsonPropertyName("d")] string? Line,
-                        [property: JsonPropertyName("e")] string? Count,
-                        [property: JsonPropertyName("f")] string? Segments,
-                        [property: JsonPropertyName("g")] string? Type,
-                        [property: JsonPropertyName("h")] string? Device,
-                        [property: JsonPropertyName("i")] string? Name);
-
-    [JsonSourceGenerationOptions(WriteIndented = true, AllowTrailingCommas = true)]
-    [JsonSerializable(typeof(Host[]))]
-    private partial class HostSourceGenerationContext : JsonSerializerContext
-    {
-    }
-
     private record Record(string Key, Dictionary<string, string> KeyValuePairs);
 
     [JsonSourceGenerationOptions(WriteIndented = true)]

Day/2024-Q2/Helper-2024-04-03.cs

@@ -13,6 +13,40 @@ internal static partial class Helper20240403
                                                                  string Pattern,
                                                                  string Primary);
 
+    private static void AlertIfNewDeviceIsConnected(DynamicHostConfigurationProtocolConfiguration dynamicHostConfigurationProtocolConfiguration, ILogger<Worker> logger)
+    {
+        string[] files = Directory.GetFiles(dynamicHostConfigurationProtocolConfiguration.Directory, dynamicHostConfigurationProtocolConfiguration.Pattern, SearchOption.TopDirectoryOnly);
+        string? match = GetMatch(dynamicHostConfigurationProtocolConfiguration, files);
+        if (string.IsNullOrEmpty(match))
+            throw new NotSupportedException($"{dynamicHostConfigurationProtocolConfiguration.Primary} doesn't exist!");
+        ReadOnlyDictionary<string, int> keyToCounts = GetKeyToCounts(dynamicHostConfigurationProtocolConfiguration, files);
+        foreach (KeyValuePair<string, int> keyToCount in keyToCounts)
+        {
+            if (keyToCount.Value < 2)
+                continue;
+            logger.LogInformation("{Key}: {Count}", keyToCount.Key, keyToCount.Value);
+        }
+        ReadOnlyDictionary<string, ReadOnlyDictionary<string, ReadOnlyCollection<string>>> keyValuePairs = GetKeyValuePairs(dynamicHostConfigurationProtocolConfiguration, files);
+        foreach (KeyValuePair<string, ReadOnlyDictionary<string, ReadOnlyCollection<string>>> keyValuePair in keyValuePairs)
+        {
+            if (!keyValuePair.Key.EndsWith(dynamicHostConfigurationProtocolConfiguration.Primary))
+                continue;
+        }
+    }
+
+    internal static void AlertIfNewDeviceIsConnected(ILogger<Worker> logger, List<string> args)
+    {
+        string ignore = args[6];
+        string pattern = args[2];
+        string primary = args[3];
+        string keyIndex = args[5];
+        string directory = args[0];
+        logger.LogInformation(directory);
+        string[] columns = args[4].Split('|');
+        DynamicHostConfigurationProtocolConfiguration dynamicHostConfigurationProtocolConfiguration = new(columns, directory, ignore, int.Parse(keyIndex), pattern, primary);
+        AlertIfNewDeviceIsConnected(dynamicHostConfigurationProtocolConfiguration, logger);
+    }
+
     private static string? GetMatch(DynamicHostConfigurationProtocolConfiguration dynamicHostConfigurationProtocolConfiguration, string[] files)
     {
         string? result = null;
@@ -114,38 +148,4 @@ internal static partial class Helper20240403
         return results;
     }
 
-    private static void AlertIfNewDeviceIsConnected(DynamicHostConfigurationProtocolConfiguration dynamicHostConfigurationProtocolConfiguration, ILogger<Worker> logger)
-    {
-        string[] files = Directory.GetFiles(dynamicHostConfigurationProtocolConfiguration.Directory, dynamicHostConfigurationProtocolConfiguration.Pattern, SearchOption.TopDirectoryOnly);
-        string? match = GetMatch(dynamicHostConfigurationProtocolConfiguration, files);
-        if (string.IsNullOrEmpty(match))
-            throw new NotSupportedException($"{dynamicHostConfigurationProtocolConfiguration.Primary} doesn't exist!");
-        ReadOnlyDictionary<string, int> keyToCounts = GetKeyToCounts(dynamicHostConfigurationProtocolConfiguration, files);
-        foreach (KeyValuePair<string, int> keyToCount in keyToCounts)
-        {
-            if (keyToCount.Value < 2)
-                continue;
-            logger.LogInformation("{Key}: {Count}", keyToCount.Key, keyToCount.Value);
-        }
-        ReadOnlyDictionary<string, ReadOnlyDictionary<string, ReadOnlyCollection<string>>> keyValuePairs = GetKeyValuePairs(dynamicHostConfigurationProtocolConfiguration, files);
-        foreach (KeyValuePair<string, ReadOnlyDictionary<string, ReadOnlyCollection<string>>> keyValuePair in keyValuePairs)
-        {
-            if (!keyValuePair.Key.EndsWith(dynamicHostConfigurationProtocolConfiguration.Primary))
-                continue;
-        }
-    }
-
-    internal static void AlertIfNewDeviceIsConnected(ILogger<Worker> logger, List<string> args)
-    {
-        string ignore = args[6];
-        string pattern = args[2];
-        string primary = args[3];
-        string keyIndex = args[5];
-        string directory = args[0];
-        logger.LogInformation(directory);
-        string[] columns = args[4].Split('|');
-        DynamicHostConfigurationProtocolConfiguration dynamicHostConfigurationProtocolConfiguration = new(columns, directory, ignore, int.Parse(keyIndex), pattern, primary);
-        AlertIfNewDeviceIsConnected(dynamicHostConfigurationProtocolConfiguration, logger);
-    }
-
 }

Day/2024-Q2/Helper-2024-04-04.cs

@@ -21,27 +21,6 @@ internal static partial class Helper20240404
                                                      string RegularExpressionPattern,
                                                      string SearchPattern);
 
-    private static MetaData? GetMetaData(CommaSeparatedValuesConfiguration commaSeparatedValuesConfiguration, string fileNameWithoutExtension)
-    {
-        MetaData? result;
-        Match match = Regex.Match(fileNameWithoutExtension, commaSeparatedValuesConfiguration.RegularExpressionPattern);
-        if (!match.Success || match.Groups.Count != commaSeparatedValuesConfiguration.RegularExpressionGroupCount)
-            result = null;
-        else
-        {
-            int deviceId = int.Parse(match.Groups["DeviceId"].Value);
-            int deviceNumber = int.Parse(match.Groups["DeviceNumber"].Value);
-            result = new(deviceId,
-                         match.Groups["DeviceType"].Value,
-                         deviceNumber,
-                         match.Groups["DescriptionName"].Value,
-                         match.Groups["DescriptionTest"].Value,
-                         match.Groups["Frequency"].Value,
-                         match.Groups["Date"].Value);
-        }
-        return result;
-    }
-
     private static void ParseCSV(CommaSeparatedValuesConfiguration commaSeparatedValuesConfiguration, ILogger<Worker> logger)
     {
         string line;
@@ -93,4 +72,25 @@ internal static partial class Helper20240404
         ParseCSV(commaSeparatedValuesConfiguration, logger);
     }
 
+    private static MetaData? GetMetaData(CommaSeparatedValuesConfiguration commaSeparatedValuesConfiguration, string fileNameWithoutExtension)
+    {
+        MetaData? result;
+        Match match = Regex.Match(fileNameWithoutExtension, commaSeparatedValuesConfiguration.RegularExpressionPattern);
+        if (!match.Success || match.Groups.Count != commaSeparatedValuesConfiguration.RegularExpressionGroupCount)
+            result = null;
+        else
+        {
+            int deviceId = int.Parse(match.Groups["DeviceId"].Value);
+            int deviceNumber = int.Parse(match.Groups["DeviceNumber"].Value);
+            result = new(deviceId,
+                         match.Groups["DeviceType"].Value,
+                         deviceNumber,
+                         match.Groups["DescriptionName"].Value,
+                         match.Groups["DescriptionTest"].Value,
+                         match.Groups["Frequency"].Value,
+                         match.Groups["Date"].Value);
+        }
+        return result;
+    }
+
 }

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

@@ -236,40 +236,6 @@ internal static partial class Helper20240517
     {
     }
 
-    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;
@@ -331,4 +297,38 @@ internal static partial class Helper20240517
         logger?.LogInformation("{harFiles} count", harFiles.Length);
     }
 
+    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 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);
+    }
+
 }

Day/2024-Q2/Helper-2024-06-23.cs

@@ -1,4 +1,5 @@
 using Microsoft.Extensions.Logging;
+using System.Collections.ObjectModel;
 
 namespace File_Folder_Helper.Day;
 
@@ -11,9 +12,9 @@ internal static partial class Helper20240623
     {
         List<Record> results = [];
         int? stopLine;
+        string[] lines;
         int? subTasksLine;
         int? codeInsidersLine;
-        string[] lines;
         string[] files = Directory.GetFiles(sourceDirectory, searchPattern, SearchOption.AllDirectories);
         foreach (string file in files)
         {
@@ -52,13 +53,41 @@ internal static partial class Helper20240623
         return results;
     }
 
+    private static ReadOnlyCollection<string> GetSubTasks(string subTasks, string[] tasks, bool? foundDone, string fallbackLine, string checkFile)
+    {
+        List<string> results = [];
+        string? h1 = null;
+        bool foundSubTasks = false;
+        int tasksZeroLength = tasks[0].Length;
+        string[] lines = File.ReadAllLines(checkFile);
+        foreach (string line in lines)
+        {
+            if (line.StartsWith("# "))
+                h1 = line[2..];
+            if (!foundSubTasks && line == subTasks)
+                foundSubTasks = true;
+            if (!foundSubTasks)
+                continue;
+            if (line.Length <= tasksZeroLength || !line.StartsWith(tasks[0]) || line[tasksZeroLength] is not ' ' and not 'x' || line[tasksZeroLength + 1] != ']')
+                continue;
+            results.Add($"  {line}");
+        }
+        if (h1 is null)
+            results.Insert(0, fallbackLine);
+        else
+            results.Insert(0, foundDone is null || !foundDone.Value ? $"- [ ] {h1}" : $"- [x] {h1}");
+        return new(results);
+    }
+
     internal static void UpdateSubTasksInMarkdownFiles(ILogger<Worker> logger, List<string> args)
     {
         int lineCheck;
         bool? foundDone;
+        string checkFile;
         string[] segments;
         List<string> lines;
         string[] indexLines;
+        string fallbackLine;
         string checkDirectory;
         string done = args[7];
         List<string> indexFiles;
@@ -68,6 +97,7 @@ internal static partial class Helper20240623
         string indexFile = args[5];
         string searchPattern = args[2];
         string directoryFilter = args[8];
+        ReadOnlyCollection<string> useLines;
         string[] tasks = args[6].Split(',');
         string codeInsiders = $"{args[4]} \"";
         string sourceDirectory = Path.GetFullPath(args[0]);
@@ -109,6 +139,7 @@ internal static partial class Helper20240623
             newLines.Clear();
             oldLines.Clear();
             indexLines = File.ReadAllLines(indexFiles[0]);
+            checkDirectory = Path.GetDirectoryName(indexFiles[0]) ?? throw new Exception();
             for (int i = 0; i < indexLines.Length; i++)
             {
                 if (indexLines[i] == done)
@@ -116,10 +147,15 @@ internal static partial class Helper20240623
                 segments = indexLines[i].Split(tasks[1]);
                 if (segments.Length > 2 || !segments[0].StartsWith(tasks[0]))
                     continue;
-                if (foundDone is null || !foundDone.Value)
+                fallbackLine = foundDone is null || !foundDone.Value ? $"- [ ] {segments[0][tasks[0].Length..]}" : $"- [x] {segments[0][tasks[0].Length..]}";
-                    newLines.Add($"- [ ] {segments[0][tasks[0].Length..]}");
+                checkFile = Path.GetFullPath(Path.Combine(checkDirectory, segments[1][..^1]));
-                else
+                if (!File.Exists(checkFile))
-                    newLines.Add($"- [x] {segments[0][tasks[0].Length..]}");
+                {
+                    newLines.Add(fallbackLine);
+                    continue;
+                }
+                useLines = GetSubTasks(subTasks, tasks, foundDone, fallbackLine, checkFile);
+                newLines.AddRange(useLines);
             }
             if (newLines.Count == 0)
                 continue;

Day/2024-Q3/Helper-2024-07-11.cs

@@ -8,20 +8,23 @@ internal static partial class Helper20240711
 
     internal static void GitRemoteRemove(ILogger<Worker> logger, List<string> args)
     {
+        string line;
         string[] lines;
         bool branchCheck;
         bool remoteCheck;
         string? directory;
-        string parentDirectoryName;
         string? parentDirectory;
-        string branchName = args[6];
+        string parentDirectoryName;
+        string branchName = args[8];
         string searchPattern = args[2];
-        string remoteToAddUrl = args[5];
+        string remoteToAddUrl = args[6];
         string remoteToRemove = args[3];
-        string remoteToAddName = args[4];
+        string remoteToAddName = args[5];
         ReadOnlyCollection<string> messages;
+        string remoteToRemoveFilter = args[4];
         string sourceDirectory = Path.GetFullPath(args[0]);
         string lastRemoteSegment = remoteToRemove.Split('/')[^1];
+        string extension = args[7].Length > 2 ? args[7] : string.Empty;
         string[] files = Directory.EnumerateFiles(sourceDirectory, searchPattern, new EnumerationOptions() { IgnoreInaccessible = true, RecurseSubdirectories = true, AttributesToSkip = FileAttributes.None }).ToArray();
         logger.LogInformation("Found {files} file(s)", files.Length);
         foreach (string file in files)
@@ -29,15 +32,19 @@ internal static partial class Helper20240711
             branchCheck = false;
             remoteCheck = false;
             lines = File.ReadAllLines(file);
-            foreach (string line in lines)
+            for (int i = 0; i < lines.Length; i++)
             {
+                line = lines[i];
                 if (!line.Contains(remoteToRemove))
                     continue;
+                if (!lines[i - 1].Contains(remoteToRemoveFilter))
+                    continue;
                 remoteCheck = true;
                 break;
             }
-            foreach (string line in lines)
+            for (int i = 0; i < lines.Length; i++)
             {
+                line = lines[i];
                 if (!line.Contains(branchName))
                     continue;
                 branchCheck = true;
@@ -52,17 +59,18 @@ internal static partial class Helper20240711
             if (parentDirectory is null)
                 continue;
             parentDirectoryName = Path.GetFileName(parentDirectory).ToLower();
-            messages = Helpers.HelperGit.RemoteRemove(directory, lastRemoteSegment, CancellationToken.None);
+            messages = Helpers.HelperGit.RemoteRemove(parentDirectory, lastRemoteSegment, CancellationToken.None);
             foreach (string message in messages)
                 logger.LogInformation("{function} => {parentDirectoryName}: [{message}]", nameof(Helpers.HelperGit.RemoteRemove), parentDirectoryName, message);
-            messages = Helpers.HelperGit.RemoteAdd(directory, remoteToAddName, $"{remoteToAddUrl}{parentDirectoryName}.git", CancellationToken.None);
+            messages = Helpers.HelperGit.RemoteAdd(parentDirectory, remoteToAddName, $"{remoteToAddUrl}{parentDirectoryName}{extension}", CancellationToken.None);
             foreach (string message in messages)
                 logger.LogInformation("{function} => {parentDirectoryName}: [{message}]", nameof(Helpers.HelperGit.RemoteAdd), parentDirectoryName, message);
             if (!branchCheck)
                 continue;
             try
-            { messages = Helpers.HelperGit.PushBranch(directory, remoteToAddName, branchName, CancellationToken.None); }
+            { messages = Helpers.HelperGit.PushBranch(parentDirectory, remoteToAddName, branchName, CancellationToken.None); }
-            catch (Exception) { }
+            catch (Exception ex)
+            { messages = new([ex.Message]); }
             foreach (string message in messages)
                 logger.LogInformation("{function} => {parentDirectoryName}: [{message}]", nameof(Helpers.HelperGit.PushBranch), parentDirectoryName, message);
         }

Day/2024-Q3/Helper-2024-07-18.cs

@@ -0,0 +1,84 @@
+using File_Folder_Helper.Models;
+using Microsoft.Extensions.Logging;
+using System.Collections.ObjectModel;
+using System.Text.Json;
+
+namespace File_Folder_Helper.Day;
+
+internal static partial class Helper20240718
+{
+
+    private static Host[] GetHosts(ILogger<Worker> logger, string file)
+    {
+        Host[] results;
+        string lines = File.ReadAllText(file);
+        string json = $"[{lines.Replace("\r\n", ",")}]";
+        logger.LogDebug(lines);
+        results = JsonSerializer.Deserialize(json, HostSourceGenerationContext.Default.HostArray) ?? throw new NullReferenceException();
+        return results;
+    }
+
+    private static ReadOnlyCollection<string> GetLines(Host[] hosts, string title, string wired)
+    {
+        List<string> results = [$"# {title}", string.Empty, "```mermaid", "flowchart TB", $"  subgraph {title}"];
+        int id;
+        string check;
+        List<int> distinct = [];
+        string newLine = $"{Environment.NewLine}    ";
+        foreach (Host host in hosts)
+        {
+            if (host.Id is null || host.Hyphen is null || host.Device is null || host.Name is null || host.Hyphen.Length != 17)
+                continue;
+            if (!int.TryParse(host.Id, out id))
+                throw new NotSupportedException($"{host.Id} is not a number");
+            if (distinct.Contains(id))
+                throw new NotSupportedException($"{id} is not distinct!");
+            distinct.Add(id);
+            results.Add($"    {id}(fa:{host.Type}{newLine}{host.Colon}{newLine}{host.Hyphen}{newLine}{host.Device}{newLine}https://{host.Name}/)");
+        }
+        results.Add("  end");
+        results.Add($"  subgraph {title}");
+        foreach (Host host in from l in hosts orderby l.Location, l.Type, l.Line select l)
+        {
+            if (host.Id is null || host.Hyphen is null || host.Device is null || host.Name is null || host.Hyphen.Length != 17)
+                continue;
+            if (!int.TryParse(host.Id, out id))
+                throw new NotSupportedException($"{host.Id} is not a number");
+            check = host.Type == wired ? "-->" : "-.->";
+            results.Add($"    {id} {check} |{id}| {host.Location}{host.Type}{host.Line}");
+        }
+        results.Add("  end");
+        results.Add($"  subgraph {title}");
+        foreach (Host host in from l in hosts orderby l.Line, l.Location, l.Type select l)
+        {
+            if (host.Id is null || host.Hyphen is null || host.Device is null || host.Name is null || host.Line is null || host.Hyphen.Length != 17)
+                continue;
+            if (!int.TryParse(host.Id, out id))
+                throw new NotSupportedException($"{host.Id} is not a number");
+            check = host.Type == wired ? "-->" : "-.->";
+            results.Add($"    {host.Location}{host.Type}{host.Line} {check} Line{host.Line}");
+        }
+        results.Add("  end");
+        results.Add("```");
+        return results.AsReadOnly();
+    }
+
+    internal static void JsonToMarkdown(ILogger<Worker> logger, List<string> args)
+    {
+        Host[] hosts;
+        string title = args[3];
+        string wired = args[4];
+        string extension = args[5];
+        string searchPattern = args[2];
+        ReadOnlyCollection<string> lines;
+        string sourceDirectory = Path.GetFullPath(args[0]);
+        string[] files = Directory.GetFiles(sourceDirectory, searchPattern, SearchOption.TopDirectoryOnly);
+        foreach (string file in files)
+        {
+            hosts = GetHosts(logger, file);
+            lines = GetLines(hosts, title, wired);
+            File.WriteAllText($"{file}{extension}", string.Join(Environment.NewLine, lines));
+        }
+    }
+
+}

Day/2024-Q3/Helper-2024-07-24.cs

@@ -0,0 +1,211 @@
+using Microsoft.Extensions.Logging;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Text.Json;
+
+namespace File_Folder_Helper.Day;
+
+internal static partial class Helper20240724
+{
+
+    private record NginxFileSystem(string Name,
+                                   string Type,
+                                   string MTime,
+                                   float Size);
+
+    private record FileConnectorConfigurationSystem(string AlternateTargetFolder,
+                                                    string FileAgeThreshold,
+                                                    string[] SourceFileFilters,
+                                                    string TargetFileLocation);
+
+#pragma warning disable IDE0028, IDE0056, IDE0300, IDE0240, IDE0241
+
+    private static readonly HttpClient _HttpClient = new();
+    private static readonly string _StaticFileServer = "localhost:5054";
+    private static readonly FileConnectorConfigurationSystem _FileConnectorConfiguration = new(
+        "D:/Tmp/Phares/AlternateTargetFolder",
+        "000:20:00:01",
+        [".txt"],
+        "D:/Tmp/Phares/TargetFileLocation");
+
+    private static DateTime GetFileAgeThresholdDateTime(string fileAgeThreshold)
+    {
+        DateTime result = DateTime.Now;
+        string[] segments = fileAgeThreshold.Split(':');
+        for (int i = 0; i < segments.Length; i++)
+        {
+            result = i switch
+            {
+                0 => result.AddDays(double.Parse(segments[i]) * -1),
+                1 => result.AddHours(double.Parse(segments[i]) * -1),
+                2 => result.AddMinutes(double.Parse(segments[i]) * -1),
+                3 => result.AddSeconds(double.Parse(segments[i]) * -1),
+                _ => throw new Exception(),
+            };
+        }
+        return result;
+    }
+
+    private static string[] GetValidWeeks(DateTime fileAgeThresholdDateTime)
+    {
+        DateTime dateTime = DateTime.Now;
+        Calendar calendar = new CultureInfo("en-US").Calendar;
+        string weekOfYear = $"{dateTime:yyyy}_Week_{calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday):00}";
+        string lastWeekOfYear = $"{fileAgeThresholdDateTime:yyyy}_Week_{calendar.GetWeekOfYear(fileAgeThresholdDateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday):00}";
+        return new string[] { weekOfYear, lastWeekOfYear }.Distinct().ToArray();
+    }
+
+    private static string[] GetValidDays(DateTime fileAgeThresholdDateTime)
+    {
+        DateTime dateTime = DateTime.Now;
+        return new string[] { dateTime.ToString("yyyy-MM-dd"), fileAgeThresholdDateTime.ToString("yyyy-MM-dd") }.Distinct().ToArray();
+    }
+
+    private static ReadOnlyCollection<NginxFileSystem> GetDayNginxFileSystemCollection(DateTime fileAgeThresholdDateTime, string week, string day, string dayUrl, NginxFileSystem[] dayNginxFileSystemCollection)
+    {
+        List<NginxFileSystem> results = new();
+        DateTime dateTime;
+        string nginxFormat = "ddd, dd MMM yyyy HH:mm:ss zzz";
+        foreach (NginxFileSystem dayNginxFileSystem in dayNginxFileSystemCollection)
+        {
+            if (!DateTime.TryParseExact(dayNginxFileSystem.MTime.Replace("GMT", "+00:00"), nginxFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
+                continue;
+            if (dateTime < fileAgeThresholdDateTime)
+                continue;
+            results.Add(new(
+                Path.GetFullPath(Path.Combine(_FileConnectorConfiguration.TargetFileLocation, week, day, dayNginxFileSystem.Name)),
+                string.Concat(dayUrl, '/', dayNginxFileSystem.Name),
+                dateTime.ToString(),
+                dayNginxFileSystem.Size));
+        }
+        return results.AsReadOnly();
+    }
+
+    private static ReadOnlyCollection<NginxFileSystem> GetDayNginxFileSystemCollection(DateTime fileAgeThresholdDateTime)
+    {
+#nullable enable
+        List<NginxFileSystem> results = new();
+        string dayUrl;
+        string dayJson;
+        string weekJson;
+        string checkWeek;
+        Task<HttpResponseMessage> task;
+        NginxFileSystem[]? dayNginxFileSystemCollection;
+        NginxFileSystem[]? weekNginxFileSystemCollection;
+        string[] days = GetValidDays(fileAgeThresholdDateTime);
+        string[] weeks = GetValidWeeks(fileAgeThresholdDateTime);
+        JsonSerializerOptions propertyNameCaseInsensitiveJsonSerializerOptions = new() { PropertyNameCaseInsensitive = true };
+        foreach (string week in weeks)
+        {
+            checkWeek = string.Concat("http://", _StaticFileServer, '/', week);
+            task = _HttpClient.GetAsync(checkWeek);
+            task.Wait();
+            if (!task.Result.IsSuccessStatusCode)
+                continue;
+            weekJson = _HttpClient.GetStringAsync(checkWeek).Result;
+            weekNginxFileSystemCollection = JsonSerializer.Deserialize<NginxFileSystem[]>(weekJson, propertyNameCaseInsensitiveJsonSerializerOptions);
+            if (weekNginxFileSystemCollection is null)
+                continue;
+            foreach (NginxFileSystem weekNginxFileSystem in weekNginxFileSystemCollection)
+            {
+                if (!(from l in days where weekNginxFileSystem.Name == l select false).Any())
+                    continue;
+                dayUrl = string.Concat(checkWeek, '/', weekNginxFileSystem.Name);
+                dayJson = _HttpClient.GetStringAsync(dayUrl).Result;
+                dayNginxFileSystemCollection = JsonSerializer.Deserialize<NginxFileSystem[]>(dayJson, propertyNameCaseInsensitiveJsonSerializerOptions);
+                if (dayNginxFileSystemCollection is null)
+                    continue;
+                results.AddRange(GetDayNginxFileSystemCollection(fileAgeThresholdDateTime, week, weekNginxFileSystem.Name, dayUrl, dayNginxFileSystemCollection));
+            }
+        }
+        return results.AsReadOnly();
+#nullable disable
+    }
+
+    private static ReadOnlyCollection<Tuple<DateTime, FileInfo, FileInfo, string>> GetPossible()
+    {
+        List<Tuple<DateTime, FileInfo, FileInfo, string>> results = new();
+        DateTime dateTime;
+        FileInfo targetFileInfo;
+        FileInfo alternateFileInfo;
+        DateTime fileAgeThresholdDateTime = GetFileAgeThresholdDateTime(_FileConnectorConfiguration.FileAgeThreshold);
+        ReadOnlyCollection<NginxFileSystem> dayNginxFileSystemCollection = GetDayNginxFileSystemCollection(fileAgeThresholdDateTime);
+        foreach (NginxFileSystem nginxFileSystem in dayNginxFileSystemCollection)
+        {
+            targetFileInfo = new FileInfo(nginxFileSystem.Name);
+            if (targetFileInfo.Directory is null)
+                continue;
+            if (!Directory.Exists(targetFileInfo.Directory.FullName))
+                _ = Directory.CreateDirectory(targetFileInfo.Directory.FullName);
+            if (!DateTime.TryParse(nginxFileSystem.MTime, out dateTime))
+                continue;
+            if (targetFileInfo.Exists && targetFileInfo.LastWriteTime == dateTime)
+                continue;
+            alternateFileInfo = new(Path.Combine(_FileConnectorConfiguration.AlternateTargetFolder, nginxFileSystem.Name));
+            results.Add(new(dateTime, targetFileInfo, alternateFileInfo, nginxFileSystem.Type));
+        }
+        return (from l in results orderby l.Item1 select l).ToList().AsReadOnly();
+    }
+
+    private static void Test()
+    {
+#nullable enable
+        if (_HttpClient is null)
+            throw new Exception();
+        if (string.IsNullOrEmpty(_StaticFileServer))
+            throw new Exception();
+        if (string.IsNullOrEmpty(_StaticFileServer))
+        {
+            ReadOnlyCollection<Tuple<DateTime, FileInfo, FileInfo, string>> possibleDownload = GetPossible();
+            if (possibleDownload.Count > 0)
+            {
+                string targetFileName = possibleDownload[0].Item4;
+                FileInfo targetFileInfo = possibleDownload[0].Item2;
+                FileInfo alternateFileInfo = possibleDownload[0].Item3;
+                DateTime matchNginxFileSystemDateTime = possibleDownload[0].Item1;
+                // if (alternateFileInfo.Exists)
+                //     File.Delete(alternateFileInfo.FullName);
+                if (targetFileInfo.Exists)
+                    File.Delete(targetFileInfo.FullName);
+                string targetJson = _HttpClient.GetStringAsync(targetFileName).Result;
+                File.WriteAllText(targetFileInfo.FullName, targetJson);
+                targetFileInfo.LastWriteTime = matchNginxFileSystemDateTime;
+                // File.Copy(targetFileInfo.FullName, alternateFileInfo.FullName);
+                File.AppendAllText(alternateFileInfo.FullName, targetJson);
+            }
+        }
+#nullable disable
+    }
+
+    internal static void CopyDirectories(ILogger<Worker> logger, List<string> args)
+    {
+        Test();
+        string[] files;
+        Process process;
+        string checkDirectory;
+        string filter = args[3];
+        string replaceWith = args[4];
+        string searchPattern = args[2];
+        string sourceDirectory = Path.GetFullPath(args[0]);
+        string[] foundDirectories = Directory.GetDirectories(sourceDirectory, searchPattern, SearchOption.AllDirectories);
+        logger.LogInformation($"Found {foundDirectories.Length} directories");
+        foreach (string foundDirectory in foundDirectories)
+        {
+            if (!foundDirectory.Contains(filter))
+                continue;
+            logger.LogDebug(foundDirectory);
+            checkDirectory = foundDirectory.Replace(filter, replaceWith);
+            if (Directory.Exists(checkDirectory))
+            {
+                files = Directory.GetFiles(checkDirectory, "*", SearchOption.AllDirectories);
+                if (files.Length > 0)
+                    continue;
+                Directory.Delete(checkDirectory);
+            }
+            process = Process.Start("cmd.exe", $"/c xCopy \"{foundDirectory}\" \"{checkDirectory}\" /S /E /I /H /Y");
+            process.WaitForExit();
+        }
+    }
+
+}

Day/HelperDay.cs

@@ -79,6 +79,10 @@ internal static class HelperDay
             Day.Helper20240624.MoveUpOneDirectory(logger, args);
         else if (args[1] == "Day-Helper-2024-07-11")
             Day.Helper20240711.GitRemoteRemove(logger, args);
+        else if (args[1] == "Day-Helper-2024-07-18")
+            Day.Helper20240718.JsonToMarkdown(logger, args);
+        else if (args[1] == "Day-Helper-2024-07-24")
+            Day.Helper20240724.CopyDirectories(logger, args);
         else
             throw new Exception(appSettings.Company);
     }

File-Folder-Helper.csproj

@@ -16,10 +16,10 @@
         <PackageReference Include="DiscUtils.Iso9660" Version="0.16.13" />
         <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
         <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.0" />
-        <PackageReference Include="runtime.win-x64.Microsoft.DotNet.ILCompiler" Version="8.0.6" />
+        <PackageReference Include="runtime.win-x64.Microsoft.DotNet.ILCompiler" Version="8.0.7" />
-        <PackageReference Include="System.Text.Json" Version="8.0.3" />
+        <PackageReference Include="System.Text.Json" Version="8.0.4" />
         <PackageReference Include="TextCopy" Version="6.2.1" />
         <PackageReference Include="WindowsShortcutFactory" Version="1.2.0" />
-        <PackageReference Include="YamlDotNet" Version="15.3.0" />
+        <PackageReference Include="YamlDotNet" Version="16.0.0" />
     </ItemGroup>
 </Project>

Helpers/HelperMarkdown.cs

@@ -369,7 +369,9 @@ internal static partial class HelperMarkdown
     private static ReadOnlyDictionary<string, object> GetFromMatterYaml(List<string> lines, LineNumber lineNumber)
     {
         Dictionary<string, object> results = [];
+#pragma warning disable IL3050
         IDeserializer deserializer = new DeserializerBuilder().Build();
+#pragma warning restore IL3050
         ReadOnlyCollection<string> frontMatterYamlLines = GetFromMatterYamlLines(lines, lineNumber);
         string frontMatterYaml = string.Join(Environment.NewLine, frontMatterYamlLines);
         Dictionary<string, object>? keyValuePairs = deserializer.Deserialize<Dictionary<string, object>>(frontMatterYaml);
@@ -693,7 +695,9 @@ internal static partial class HelperMarkdown
         string frontMatterYaml;
         MarkdownFile markdownFile;
         string[] frontMatterYamlLines;
+#pragma warning disable IL3050
         ISerializer serializer = new SerializerBuilder().WithIndentedSequences().Build();
+#pragma warning restore IL3050
         foreach (KeyValuePair<string, MarkdownFileAndLines> relativeTo in relativeToCollection)
         {
             results.Clear();

Models/Host.cs

@@ -0,0 +1,20 @@
+using System.Text.Json.Serialization;
+
+namespace File_Folder_Helper.Models;
+
+public record Host([property: JsonPropertyName("a")] string? Id,
+                   [property: JsonPropertyName("b")] string? Colon,
+                   [property: JsonPropertyName("c")] string? Hyphen,
+                   [property: JsonPropertyName("d")] string? Line,
+                   [property: JsonPropertyName("e")] string? Count,
+                   [property: JsonPropertyName("f")] string? Segments,
+                   [property: JsonPropertyName("g")] string? Type,
+                   [property: JsonPropertyName("h")] string? Device,
+                   [property: JsonPropertyName("i")] string? Name,
+                   [property: JsonPropertyName("j")] string? Location);
+
+[JsonSourceGenerationOptions(WriteIndented = true, AllowTrailingCommas = true)]
+[JsonSerializable(typeof(Host[]))]
+public partial class HostSourceGenerationContext : JsonSerializerContext
+{
+}

Program.cs

@@ -12,7 +12,7 @@ internal class Program
     public static void Main(string[] args)
     {
 #pragma warning disable IL3050
-        HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
+        HostApplicationBuilder builder = Microsoft.Extensions.Hosting.Host.CreateApplicationBuilder(args);
 #pragma warning restore IL3050
         _ = builder.Configuration.AddEnvironmentVariables();
         _ = builder.Configuration.AddUserSecrets<Program>();