phares3757/file-folder-helper
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

log-to-trace (Day-Helper-2025-11-23)

Browse Source 
move-back (Day-Helper-2025-11-22)

stratus-split (Day-Helper-2025-11-18)

Set last write time for renamed files in Rename method
This commit is contained in:
Mike Phares
2025-11-22 16:46:16 -07:00
parent 1010bcb772
commit 90608efa85
7 changed files with 364 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
.vscode/launch.json vendored
View File

@ -11,6 +11,25 @@
"preLaunchTask": "Build",
"program": "${workspaceFolder}/bin/Debug/net10.0/win-x64/File-Folder-Helper.dll",
"args": [
"s",
"X",
"\\\\mesfs.infineon.com\\EC_EAFLog\\Production\\Logs\\EAF-Info-Warn-002-059-000",
"Day-Helper-2025-11-23",
"EAF_R*.info",
"yyyy-MM-dd~HH:mm:ss,fff",
"13",
"EAF Version~Shutdown triggered~Lost connection~EAF Backbone terminating~Publishing Connection Lost Transaction",
"2025-05-25 00:00:00,232",
"256",
"\\\\mesfs.infineon.com\\EC_EAFLog\\Production\\Logs\\EAF-Info-Warn-002-059-000-Trace",
".trc",
"s",
"X",
"D:/ProgramData/EC_Characterization_Si/Dummy/Stratus",
"Day-Helper-2025-11-18",
"Bad.txt",
"Elapsed",
"DataBiorad",
"s",
"X",
"D:/Tmp",

92
ADO2025/PI6/Helper-2025-07-10.cs
View File

@ -1,98 +1,10 @@
using Microsoft.Extensions.Logging;
using System.Collections.ObjectModel;
using System.Text.RegularExpressions;
namespace File_Folder_Helper.ADO2025.PI6;
internal static partial class Helper20250710 {
[GeneratedRegex(@"^(?<stream>S[0-9]{1,2})(?<function>F[0-9]{1,2}) W-Bit=(?<wait>[01])")]
private static partial Regex StreamFunction();
internal static void StripLog(ILogger<Worker> logger, List<string> args) {
logger.LogInformation(args[0]);
logger.LogInformation(args[1]);
logger.LogInformation(args[2]);
logger.LogInformation(args[3]);
string searchPattern = args[3];
string directoryPattern = args[2];
string sourceDirectory = Path.GetFullPath(args[0].Split('~')[0]);
string[] directories = Directory.GetDirectories(sourceDirectory, directoryPattern, SearchOption.TopDirectoryOnly);
LogToTrace(logger, searchPattern, directories.AsReadOnly());
Helpers.HelperDeleteEmptyDirectories.DeleteEmptyDirectories(logger, sourceDirectory);
}
private static void LogToTrace(ILogger<Worker> logger, string searchPattern, ReadOnlyCollection<string> directories) {
string[] lines;
string[] files;
string checkFile;
FileInfo fileInfo;
string? directoryName;
const string extension = ".trc";
foreach (string directory in directories) {
files = Directory.GetFiles(directory, searchPattern, SearchOption.TopDirectoryOnly);
foreach (string file in files) {
fileInfo = new(file);
if (fileInfo.LastWriteTime > DateTime.Now.AddSeconds(-5)) {
continue;
}
directoryName = Path.GetFileName(fileInfo.DirectoryName);
if (string.IsNullOrEmpty(directoryName)) {
continue;
}
checkFile = Path.Combine(directoryName, $"{fileInfo.Name}{extension}");
if (File.Exists(checkFile)) {
continue;
}
lines = File.ReadAllLines(fileInfo.FullName);
LogToTrace(logger, fileInfo, lines, checkFile);
}
}
}
private static void LogToTrace(ILogger<Worker> logger, FileInfo fileInfo, string[] lines, string checkFile) {
string line;
Match match;
string body;
string[] segments;
List<string> log = [];
for (int i = 1; i < lines.Length - 1; i++) {
line = lines[i];
if (!line.StartsWith('S')) {
continue;
}
match = StreamFunction().Match(line);
if (!match.Success) {
continue;
}
segments = lines[i - 1].Split(" ");
if (segments.Length < 2) {
continue;
}
if (!segments[0].Contains(' ')) {
continue;
}
body = GetBody(lines, i, segments[0].Split(' '));
log.Add($"{segments[0]} {line} ~ {body}");
}
if (log.Count > 0) {
File.WriteAllText(checkFile, string.Join(Environment.NewLine, log));
File.SetLastWriteTime(checkFile, fileInfo.LastWriteTime);
logger.LogInformation("<{checkFile}> was written", checkFile);
}
}
private static string GetBody(string[] lines, int i, string[] segments) {
string result;
List<string> results = [];
for (int j = i + 1; j < lines.Length; j++) {
if (lines[j].StartsWith(segments[0])) {
break;
}
results.Add(lines[j].Trim());
}
result = string.Join('_', results);
return result;
}
internal static void StripLog(ILogger<Worker> _, List<string> args) =>
throw new NotImplementedException($"This method has been moved to PI8 version. {string.Join(Environment.NewLine, args)}");
}

78
ADO2025/PI7/Helper-2025-09-26.cs
View File

@ -14,22 +14,22 @@ internal static partial class Helper20250926 {
logger.LogInformation(args[5]);
const char star = '*';
const char underscore = '_';
string dateFormat = args[4];
string searchString = args[3];
string dateTimeFormat = args[4];
int seconds = int.Parse(args[5]);
string[] searchPatterns = args[2].Split('~');
string key = searchString.ToLower().Split(' ')[0];
string[] sourceDirectories = Path.GetFullPath(args[0]).Split('~');
if (args.Count == 999) {
Redo(logger, star, underscore, dateFormat, searchString, key, searchPatterns, sourceDirectories);
Redo(logger, star, underscore, dateTimeFormat, searchString, key, searchPatterns, sourceDirectories);
}
Rename(logger, star, underscore, dateFormat, searchString, key, searchPatterns, sourceDirectories);
Rename(logger, star, underscore, dateTimeFormat, searchString, key, searchPatterns, sourceDirectories);
if (seconds > 0) {
FindFirstAndLast(logger, star, underscore, dateFormat, searchString, seconds, searchPatterns, sourceDirectories);
FindFirstAndLast(logger, star, underscore, dateTimeFormat, searchString, seconds, searchPatterns, sourceDirectories);
}
}
private static void Redo(ILogger<Worker> logger, char star, char underscore, string dateFormat, string searchString, string key, string[] searchPatterns, string[] sourceDirectories) {
private static void Redo(ILogger<Worker> logger, char star, char underscore, string dateTimeFormat, string searchString, string key, string[] searchPatterns, string[] sourceDirectories) {
bool found;
string check;
string[] files;
@ -68,11 +68,11 @@ internal static partial class Helper20250926 {
if (!found && line.Contains(searchString)) {
found = true;
}
if (line.Length < dateFormat.Length) {
if (line.Length < dateTimeFormat.Length) {
continue;
}
check = line[..dateFormat.Length];
if (!DateTime.TryParseExact(check, dateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime logDate)) {
check = line[..dateTimeFormat.Length];
if (!DateTime.TryParseExact(check, dateTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime logDate)) {
continue;
}
if (firstDate == DateTime.MinValue) {
@ -93,6 +93,7 @@ internal static partial class Helper20250926 {
} else {
logger.LogInformation("rename to '{checkPath}'", checkPath);
File.Move(file, checkPath);
File.SetLastWriteTime(checkPath, lastDate);
continue;
}
} catch {
@ -104,9 +105,11 @@ internal static partial class Helper20250926 {
}
}
private static void Rename(ILogger<Worker> logger, char star, char underscore, string dateFormat, string searchString, string key, string[] searchPatterns, string[] sourceDirectories) {
private static void Rename(ILogger<Worker> logger, char star, char underscore, string dateTimeFormat, string searchString, string key, string[] searchPatterns, string[] sourceDirectories) {
bool found;
string app;
string check;
string level;
string[] files;
string[] lines;
string checkFile;
@ -114,10 +117,8 @@ internal static partial class Helper20250926 {
DateTime lastDate;
string[] segments;
DateTime firstDate;
string[] segmentsB;
string directoryName;
string[] directories;
string destinationDirectory;
string destinationDirectoryB;
FileInfo[] fileInfoCollection;
foreach (string sourceDirectory in sourceDirectories) {
@ -126,18 +127,8 @@ internal static partial class Helper20250926 {
if (!searchPattern.Contains(underscore) || !searchPattern.Contains(star)) {
throw new Exception($"{nameof(searchPattern)} must contain {underscore} and {star}");
}
segments = searchPattern.Split(star);
segmentsB = segments[0].Split(underscore);
foreach (string directory in directories) {
directoryName = Path.GetFileName(directory);
destinationDirectory = Path.Combine(directory, segmentsB[0], segmentsB[1]);
if (!Directory.Exists(destinationDirectory)) {
_ = Directory.CreateDirectory(destinationDirectory);
}
destinationDirectoryB = Path.Combine(directory, segmentsB[0], "DUP");
if (!Directory.Exists(destinationDirectoryB)) {
_ = Directory.CreateDirectory(destinationDirectoryB);
}
files = Directory.GetFiles(directory, searchPattern, SearchOption.TopDirectoryOnly);
logger.LogInformation("With search pattern '{SearchPattern}' found {files} file(s)", searchPattern, files.Length);
fileInfoCollection = files.Select(f => new FileInfo(f)).ToArray();
@ -152,17 +143,24 @@ internal static partial class Helper20250926 {
found = false;
lastDate = DateTime.MinValue;
firstDate = DateTime.MinValue;
segments = fileInfo.Name.Split('_');
if (segments.Length < 2) {
logger.LogWarning("File name does not contain expected segments: {fileName}", fileInfo.Name);
continue;
}
app = segments[0];
level = segments[1].Split('.')[0].ToLower();
try {
lines = File.ReadAllLines(fileInfo.FullName);
foreach (string line in lines) {
if (!found && line.Contains(searchString)) {
found = true;
}
if (line.Length < dateFormat.Length) {
if (line.Length < dateTimeFormat.Length) {
continue;
}
check = line[..dateFormat.Length];
if (!DateTime.TryParseExact(check, dateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime logDate)) {
check = line[..dateTimeFormat.Length];
if (!DateTime.TryParseExact(check, dateTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime logDate)) {
continue;
}
if (firstDate == DateTime.MinValue) {
@ -171,26 +169,34 @@ internal static partial class Helper20250926 {
lastDate = logDate;
}
if (!found) {
checkFile = $"{directoryName}_{firstDate:yyyy-MM-dd_HH-mm-ss}---{lastDate:yyyy-MM-dd_HH-mm-ss}.log";
checkFile = $"{app}_{directoryName}_{firstDate:yyyy-MM-dd_HH-mm-ss}---{lastDate:yyyy-MM-dd_HH-mm-ss}.{level}";
} else {
checkFile = $"{directoryName}_{firstDate:yyyy-MM-dd_HH-mm-ss}---{lastDate:yyyy-MM-dd_HH-mm-ss}~~~{key}.log";
checkFile = $"{app}_{directoryName}_{firstDate:yyyy-MM-dd_HH-mm-ss}---{lastDate:yyyy-MM-dd_HH-mm-ss}~~~{key}.{level}";
}
checkPath = Path.Combine(destinationDirectory, checkFile);
checkPath = Path.Combine(directory, checkFile);
if (checkFile == fileInfo.Name) {
logger.LogDebug("skipped (match) '{checkFile}'", checkFile);
} else if (File.Exists(checkPath)) {
continue;
}
if (!File.Exists(checkPath)) {
logger.LogInformation("rename to '{checkPath}'", checkPath);
File.Move(fileInfo.FullName, checkPath);
File.SetLastWriteTime(checkPath, lastDate);
continue;
} else {
destinationDirectoryB = Path.Combine(directory, "DUP");
if (!Directory.Exists(destinationDirectoryB)) {
_ = Directory.CreateDirectory(destinationDirectoryB);
}
checkPath = Path.Combine(destinationDirectoryB, checkFile);
if (File.Exists(checkPath)) {
logger.LogInformation("skipped (exists) '{checkPath}'", checkPath);
} else {
logger.LogInformation("rename to '{checkPath}'", checkPath);
File.Move(fileInfo.FullName, checkPath);
File.SetLastWriteTime(checkPath, lastDate);
continue;
}
} else {
logger.LogInformation("rename to '{checkPath}'", checkPath);
File.Move(fileInfo.FullName, checkPath);
continue;
}
} catch {
logger.LogWarning("skipped (error) {TotalHours} hour(s) -> '{FileInfo}'", (DateTime.Now - fileInfo.LastWriteTime).TotalHours, fileInfo.FullName);
@ -202,7 +208,7 @@ internal static partial class Helper20250926 {
}
}
private static void FindFirstAndLast(ILogger<Worker> logger, char star, char underscore, string dateFormat, string searchString, int seconds, string[] searchPatterns, string[] sourceDirectories) {
private static void FindFirstAndLast(ILogger<Worker> logger, char star, char underscore, string dateTimeFormat, string searchString, int seconds, string[] searchPatterns, string[] sourceDirectories) {
string line;
string check;
string[] files;
@ -252,11 +258,11 @@ internal static partial class Helper20250926 {
lines = File.ReadAllLines(fileInfo.FullName);
for (int i = 0; i < lines.Length; i++) {
line = lines[i];
if (!line.Contains(searchString) || lines[i - 1].Length < dateFormat.Length) {
if (!line.Contains(searchString) || lines[i - 1].Length < dateTimeFormat.Length) {
continue;
}
check = lines[i - 1][..dateFormat.Length];
if (!DateTime.TryParseExact(check, dateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out logDate)) {
check = lines[i - 1][..dateTimeFormat.Length];
if (!DateTime.TryParseExact(check, dateTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out logDate)) {
continue;
}
timeSpan = logDate - lastDate;

41
ADO2025/PI8/Helper-2025-11-18.cs Normal file
View File

@ -0,0 +1,41 @@
using Microsoft.Extensions.Logging;
namespace File_Folder_Helper.ADO2025.PI8;
internal static partial class Helper20251118 {
internal static void StratusSplit(ILogger<Worker> logger, List<string> args) {
logger.LogInformation(args[0]);
logger.LogInformation(args[1]);
logger.LogInformation(args[2]);
logger.LogInformation(args[3]);
logger.LogInformation(args[4]);
string split = args[3];
string fileName = args[4];
string sourceDirectory = Path.GetFullPath(args[0].Split('~')[0]);
string checkFile = Path.Combine(sourceDirectory, args[2]);
if (!File.Exists(checkFile)) {
logger.LogWarning("File does not exist: {checkFile}", checkFile);
} else {
int i = 0;
string text;
string path;
List<string> collection = [];
string[] lines = File.ReadAllLines(checkFile);
foreach (string line in lines) {
if (!line.Contains(split)) {
collection.Add(line);
} else {
i++;
collection.Add(line);
text = string.Join(Environment.NewLine, collection);
collection.Clear();
path = Path.Combine(sourceDirectory, $"{fileName}{i}.txt");
File.WriteAllText(path, text);
logger.LogInformation("Wrote file: {path}", path);
}
}
}
}
}

51
ADO2025/PI8/Helper-2025-11-22.cs Normal file
View File

@ -0,0 +1,51 @@
using Microsoft.Extensions.Logging;
namespace File_Folder_Helper.ADO2025.PI8;
internal static partial class Helper20251122 {
internal static void MoveBack(ILogger<Worker> logger, List<string> args) {
logger.LogInformation(args[0]);
logger.LogInformation(args[1]);
logger.LogInformation(args[2]);
logger.LogInformation(args[3]);
string fileName;
string directory;
string extension;
string checkFile;
string[] segments;
string checkDirectory;
string parentDirectory;
string parentDirectoryName;
string searchPattern = args[2];
string sourceDirectory = Path.GetFullPath(args[0].Split('~')[0]);
string destinationDirectory = Path.GetFullPath(args[3].Split('~')[0]);
string[] files = Directory.GetFiles(sourceDirectory, searchPattern, SearchOption.AllDirectories);
foreach (string file in files) {
directory = Path.GetDirectoryName(file) ?? throw new Exception("Directory name is null");
parentDirectory = Path.GetDirectoryName(directory) ?? throw new Exception("Parent directory is null");
parentDirectoryName = Path.GetFileName(parentDirectory);
fileName = Path.GetFileNameWithoutExtension(file);
extension = Path.GetFileName(directory).ToLower();
segments = fileName.Split('_');
if (segments.Length < 2) {
logger.LogWarning("File name does not contain expected segments: {fileName}", fileName);
continue;
}
checkDirectory = Path.Combine(destinationDirectory, segments[0]);
if (!Directory.Exists(checkDirectory)) {
_ = Directory.CreateDirectory(checkDirectory);
}
checkFile = Path.Combine(checkDirectory, $"{parentDirectoryName}_{fileName}.{extension.ToLower()}");
if (File.Exists(checkFile)) {
logger.LogWarning("File already exists at destination: {checkFile}", checkFile);
continue;
} else {
File.Move(file, checkFile);
logger.LogInformation("Moved file to: {checkFile}", checkFile);
}
}
Helpers.HelperDeleteEmptyDirectories.DeleteEmptyDirectories(logger, destinationDirectory);
}
}

203
ADO2025/PI8/Helper-2025-11-23.cs Normal file
View File

@ -0,0 +1,203 @@
using Microsoft.Extensions.Logging;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Text.RegularExpressions;
namespace File_Folder_Helper.ADO2025.PI8;
internal static partial class Helper20251123 {
[GeneratedRegex(@"^(?<stream>S[0-9]{1,2})(?<function>F[0-9]{1,2}) W-Bit=(?<wait>[01])")]
private static partial Regex StreamFunction();
private record Record(long Ticks, string Line);
internal static void LogToTrace(ILogger<Worker> logger, List<string> args) {
logger.LogInformation(args[0]);
logger.LogInformation(args[1]);
logger.LogInformation(args[2]);
logger.LogInformation(args[3]);
logger.LogInformation(args[4]);
logger.LogInformation(args[5]);
logger.LogInformation(args[6]);
logger.LogInformation(args[7]);
logger.LogInformation(args[8]);
logger.LogInformation(args[9]);
string extension = args[9];
string searchPattern = args[2];
int dateTimeFormatUse = int.Parse(args[4]);
int maximumLineLength = int.Parse(args[7]);
string[] containPhrases = args[5].Split('~');
string dateTimeFormat = args[3].Replace('~', ' ');
string sourceDirectory = Path.GetFullPath(args[0].Split('~')[0]);
string destinationDirectory = Path.GetFullPath(args[8].Split('~')[0]);
string directorySearchPattern = $"{searchPattern.Split('*')[0].Split('_')[1]}*";
DateTime dateTime = DateTime.ParseExact(args[6], dateTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.None);
List<string> directories = Directory.GetDirectories(sourceDirectory, directorySearchPattern, SearchOption.TopDirectoryOnly).ToList();
if (directories.Count == 0) {
directories.Add(sourceDirectory);
}
ReadOnlyDictionary<string, ReadOnlyCollection<string>> keyValuePairs = GetFiles(searchPattern, directories);
if (keyValuePairs.Count == 0 || keyValuePairs.All(l => l.Value.Count == 0)) {
logger.LogWarning("No files found with pattern {searchPattern} in {sourceDirectory}", searchPattern, sourceDirectory);
} else {
LogToTrace(logger, dateTimeFormat, dateTimeFormatUse, dateTime, maximumLineLength, destinationDirectory, extension, containPhrases, keyValuePairs);
}
}
private static ReadOnlyDictionary<string, ReadOnlyCollection<string>> GetFiles(string searchPattern, List<string> directories) {
Dictionary<string, ReadOnlyCollection<string>> results = [];
string[] files;
List<string> collection;
foreach (string directory in directories) {
collection = [];
files = Directory.GetFiles(directory, searchPattern, SearchOption.TopDirectoryOnly);
foreach (string file in files) {
collection.Add(file);
}
results.Add(directory, collection.AsReadOnly());
}
return results.AsReadOnly();
}
private static void LogToTrace(ILogger<Worker> logger, string dateTimeFormat, int dateTimeFormatUse, DateTime dateTime, int maximumLineLength, string destinationDirectory, string extension, string[] containPhrases, ReadOnlyDictionary<string, ReadOnlyCollection<string>> keyValuePairs) {
string key;
Dictionary<string, List<Record>> filtered;
foreach (KeyValuePair<string, ReadOnlyCollection<string>> keyValuePair in keyValuePairs) {
filtered = [];
key = Path.GetFileName(keyValuePair.Key);
foreach (string path in keyValuePair.Value) {
AddFiltered(dateTimeFormat, dateTimeFormatUse, dateTime, containPhrases, filtered, path);
}
LogToTrace(logger, maximumLineLength, destinationDirectory, extension, filtered, key);
}
}
private static void AddFiltered(string dateTimeFormat, int dateTimeFormatUse, DateTime dateTime, string[] containPhrases, Dictionary<string, List<Record>> results, string path) {
string key;
DateTime dateTimeCheck;
List<Record>? collection;
string[] lines = File.ReadAllLines(path);
string keyDateTimeFormat = dateTimeFormat[..dateTimeFormatUse].Replace(' ', '_');
ReadOnlyCollection<Record> records = GetRecords(dateTimeFormat, containPhrases, lines);
foreach (Record record in records) {
dateTimeCheck = new DateTime(record.Ticks);
if (dateTimeCheck < dateTime) {
continue;
}
key = dateTimeCheck.ToString(keyDateTimeFormat);
if (!results.TryGetValue(key, out collection)) {
results.Add(key, []);
}
if (!results.TryGetValue(key, out collection)) {
throw new InvalidOperationException("Collection should exist");
}
collection.Add(record);
}
}
private static ReadOnlyCollection<Record> GetRecords(string dateTimeFormat, string[] containPhrases, string[] lines) {
Record[] results;
string line;
Match match;
string body;
string check;
string checkB;
Record record;
DateTime dateTime;
string[] segments;
List<Record> records = [];
for (int i = 1; i < lines.Length - 1; i++) {
line = lines[i];
if (containPhrases.Any(phrase => line.Contains(phrase))) {
if (line.Length < dateTimeFormat.Length) {
continue;
}
check = line[..dateTimeFormat.Length];
if (!DateTime.TryParseExact(check, dateTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime)) {
continue;
}
record = new Record(dateTime.Ticks, line);
records.Add(record);
continue;
}
if (!line.StartsWith('S')) {
continue;
}
match = StreamFunction().Match(line);
if (!match.Success) {
continue;
}
segments = lines[i - 1].Split(" ");
if (segments.Length < 2) {
continue;
}
checkB = segments[0];
if (!checkB.Contains(' ')) {
continue;
}
if (checkB.Length < dateTimeFormat.Length) {
continue;
}
check = checkB[..dateTimeFormat.Length];
if (!DateTime.TryParseExact(check, dateTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime)) {
continue;
}
body = GetBody(lines, i, checkB.Split(' '));
record = new Record(dateTime.Ticks, $"{checkB} {line} ~ {body}");
records.Add(record);
}
results = (from l in records orderby l.Ticks select l).ToArray();
return results.AsReadOnly();
}
private static string GetBody(string[] lines, int i, string[] segments) {
string result;
List<string> results = [];
for (int j = i + 1; j < lines.Length; j++) {
if (lines[j].StartsWith(segments[0])) {
break;
}
results.Add(lines[j].Trim());
}
result = string.Join('_', results);
return result;
}
private static void LogToTrace(ILogger<Worker> logger, int maximumLineLength, string destinationDirectory, string extension, Dictionary<string, List<Record>> filtered, string key) {
string text;
string[] lines;
string? oldText;
string checkFile;
Record[] records;
string weekOfYear;
DateTime dateTime;
string checkDirectory;
Calendar calendar = new CultureInfo("en-US").Calendar;
foreach (KeyValuePair<string, List<Record>> keyValuePair in filtered) {
records = (from l in keyValuePair.Value orderby l.Ticks select l).ToArray();
if (records.Length == 0) {
logger.LogInformation("No records for {key}_{dateKey}", key, keyValuePair.Key);
continue;
}
dateTime = new DateTime(records[^1].Ticks);
weekOfYear = $"{dateTime.Year}_Week_{calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday):00}";
lines = (from l in records select l.Line.Length < maximumLineLength ? l.Line : l.Line[..maximumLineLength]).ToArray();
text = string.Join(Environment.NewLine, lines);
checkDirectory = Path.Combine(destinationDirectory, key, weekOfYear);
if (!Directory.Exists(checkDirectory)) {
_ = Directory.CreateDirectory(checkDirectory);
}
checkFile = Path.Combine(checkDirectory, $"{key}_{keyValuePair.Key}{extension}");
oldText = File.Exists(checkFile) ? File.ReadAllText(checkFile) : null;
if (!string.IsNullOrEmpty(oldText) && oldText == text) {
logger.LogInformation("{fileName} has no changes", checkFile);
} else {
File.WriteAllText(checkFile, text);
File.SetLastWriteTime(checkFile, dateTime);
logger.LogInformation("<{checkFile}> was written", checkFile);
}
}
}
}

6
Day/HelperDay.cs
View File

@ -197,6 +197,12 @@ internal static class HelperDay
ADO2025.PI8.Helper20251113.Parse(logger, args);
else if (args[1] == "Day-Helper-2025-11-14")
ADO2025.PI8.Helper20251114.ZipRunDirectories(logger, args);
else if (args[1] == "Day-Helper-2025-11-18")
ADO2025.PI8.Helper20251118.StratusSplit(logger, args);
else if (args[1] == "Day-Helper-2025-11-22")
ADO2025.PI8.Helper20251122.MoveBack(logger, args);
else if (args[1] == "Day-Helper-2025-11-23")
ADO2025.PI8.Helper20251123.LogToTrace(logger, args);
else
throw new Exception(appSettings.Company);
}