624 lines
29 KiB
C#
624 lines
29 KiB
C#
using CliWrap;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Phares.Shared;
|
|
using Serilog;
|
|
using ShellProgressBar;
|
|
using System.Text.Json;
|
|
using View_by_Distance.Property.Models;
|
|
using View_by_Distance.Rename.Models;
|
|
using View_by_Distance.Shared.Models;
|
|
using View_by_Distance.Shared.Models.Methods;
|
|
|
|
namespace View_by_Distance.Rename;
|
|
|
|
public class Rename
|
|
{
|
|
|
|
private readonly AppSettings _AppSettings;
|
|
private readonly string _WorkingDirectory;
|
|
private readonly IsEnvironment _IsEnvironment;
|
|
private readonly Models.Configuration _Configuration;
|
|
private readonly IConfigurationRoot _ConfigurationRoot;
|
|
private readonly Property.Models.Configuration _PropertyConfiguration;
|
|
|
|
public Rename(List<string> args, IsEnvironment isEnvironment, IConfigurationRoot configurationRoot, AppSettings appSettings, string workingDirectory, bool isSilent, IConsole console)
|
|
{
|
|
if (isSilent)
|
|
{ }
|
|
if (console is null)
|
|
{ }
|
|
bool any = false;
|
|
_AppSettings = appSettings;
|
|
_IsEnvironment = isEnvironment;
|
|
long ticks = DateTime.Now.Ticks;
|
|
_WorkingDirectory = workingDirectory;
|
|
_ConfigurationRoot = configurationRoot;
|
|
ILogger? log = Log.ForContext<Rename>();
|
|
Dictionary<long, Dictionary<long, List<string>>> fileSizeToCollection = new();
|
|
Property.Models.Configuration propertyConfiguration = Property.Models.Binder.Configuration.Get(isEnvironment, configurationRoot);
|
|
Models.Configuration configuration = Models.Binder.Configuration.Get(isEnvironment, configurationRoot, propertyConfiguration);
|
|
_PropertyConfiguration = propertyConfiguration;
|
|
_Configuration = configuration;
|
|
propertyConfiguration.Update();
|
|
string? comparePathRoot = Path.GetDirectoryName(appSettings.ComparePathsFile);
|
|
if (comparePathRoot is null || comparePathRoot == propertyConfiguration.RootDirectory)
|
|
throw new Exception("Nested isn't allowed!");
|
|
log.Information(propertyConfiguration.RootDirectory);
|
|
Verify();
|
|
log.Information(appSettings.ComparePathsFile);
|
|
string json = File.ReadAllText(appSettings.ComparePathsFile);
|
|
MatchNginx[]? matchNginxCollection = JsonSerializer.Deserialize<MatchNginx[]>(json);
|
|
if (matchNginxCollection is null)
|
|
throw new NullReferenceException(nameof(matchNginxCollection));
|
|
if (matchNginxCollection.Any())
|
|
{
|
|
bool deleted;
|
|
for (int i = 1; i < 5; i++)
|
|
{
|
|
deleted = Shared.Models.Stateless.Methods.IPath.DeleteEmptyDirectories(matchNginxCollection.First().ConvertedPath);
|
|
if (deleted && !any)
|
|
any = true;
|
|
}
|
|
}
|
|
if (!any)
|
|
{
|
|
if (matchNginxCollection.Length == 0 && matchNginxCollection[0].ConvertedPath.Contains("~~~"))
|
|
MoveMatches(matchNginxCollection[0]);
|
|
else if (matchNginxCollection.All(l => l.Name.StartsWith("#")) || matchNginxCollection.All(l => l.Name.StartsWith(" #")) || matchNginxCollection.All(l => l.Name.StartsWith("=20")) || matchNginxCollection.All(l => l.Name.StartsWith("#20")))
|
|
Rename2000(log, matchNginxCollection);
|
|
else if (matchNginxCollection.All(l => l.Name.Length > 4) && matchNginxCollection.All(l => l.Name[0..3] is "198" or "199" or "200" or "201"))
|
|
RenameByDateTaken(log, matchNginxCollection);
|
|
else if (matchNginxCollection.Any())
|
|
{
|
|
log.Information(matchNginxCollection.First().ConvertedPath);
|
|
List<string> lines = RenameFilesInDirectories(log, matchNginxCollection);
|
|
File.WriteAllLines($"D:/Tmp/Phares/{DateTime.Now.Ticks}.tsv", lines);
|
|
if (comparePathRoot != Path.GetPathRoot(matchNginxCollection[0].ConvertedPath))
|
|
_ = Shared.Models.Stateless.Methods.IPath.DeleteEmptyDirectories(comparePathRoot);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Verify()
|
|
{
|
|
if (_AppSettings is null)
|
|
{ }
|
|
if (_IsEnvironment is null)
|
|
{ }
|
|
if (_Configuration is null)
|
|
{ }
|
|
if (_ConfigurationRoot is null)
|
|
{ }
|
|
if (_WorkingDirectory is null)
|
|
{ }
|
|
if (_PropertyConfiguration is null)
|
|
{ }
|
|
}
|
|
|
|
private static void MoveMatches(MatchNginx matchNginx)
|
|
{
|
|
string moveDirectory;
|
|
string checkDirectory;
|
|
string compareDirectory = "D:/";
|
|
int length = matchNginx.ConvertedPath.Length;
|
|
string[] directories = Directory.GetDirectories(matchNginx.ConvertedPath, "*", SearchOption.TopDirectoryOnly);
|
|
foreach (string directory in directories)
|
|
{
|
|
if (!string.IsNullOrEmpty(directory))
|
|
continue;
|
|
checkDirectory = string.Concat(compareDirectory, directory[length..]);
|
|
if (!Directory.Exists(checkDirectory))
|
|
continue;
|
|
moveDirectory = string.Concat(compareDirectory[..^1], directory[length..]);
|
|
Directory.Move(checkDirectory, moveDirectory);
|
|
}
|
|
}
|
|
|
|
private static List<(FileHolder, string, string)> GetRenameUndoToDoCollection(ProgressBar progressBar, string[] files)
|
|
{
|
|
List<(FileHolder, string, string)> results = new();
|
|
string[] lines;
|
|
string fileName;
|
|
string? directory;
|
|
FileHolder fileHolder;
|
|
List<string> distinct = new();
|
|
foreach (string file in files)
|
|
{
|
|
progressBar.Tick();
|
|
directory = Path.GetDirectoryName(file);
|
|
if (string.IsNullOrEmpty(directory))
|
|
continue;
|
|
fileName = Path.GetFileName(file);
|
|
if (!fileName.EndsWith(".id"))
|
|
continue;
|
|
lines = File.ReadAllLines(file);
|
|
if (lines.Length < 2)
|
|
continue;
|
|
if (distinct.Contains(lines[1]))
|
|
continue;
|
|
distinct.Add(lines[1]);
|
|
fileHolder = new(lines[0]);
|
|
results.Add(new(fileHolder, directory, lines[1]));
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private List<(FileHolder, string, string)> GetToDoCollection(ProgressBar progressBar, string[] files, bool nefPresent)
|
|
{
|
|
List<(FileHolder, string, string)> results = new();
|
|
int? id;
|
|
int season;
|
|
string? message;
|
|
string checkFile;
|
|
DateTime dateTime;
|
|
string seasonName;
|
|
string? directory;
|
|
bool? isWrongYear;
|
|
TimeSpan? timeSpan;
|
|
string directoryName;
|
|
DateTime?[] dateTimes;
|
|
FileHolder fileHolder;
|
|
string[]? ffmpegFiles;
|
|
bool isIgnoreExtension;
|
|
string? seasonDirectory;
|
|
const string jpg = ".jpg";
|
|
DateTime? minimumDateTime;
|
|
string checkFileExtension;
|
|
DateTime? dateTimeFromName;
|
|
DateTime? dateTimeOriginal;
|
|
const string jpeg = ".jpeg";
|
|
List<string> distinct = new();
|
|
string[] directoryNameSegments;
|
|
bool isValidImageFormatExtension;
|
|
bool nameWithoutExtensionIsIdFormat;
|
|
DateTime? metadataMinimumDateTime = null;
|
|
IReadOnlyList<MetadataExtractor.Directory> directories;
|
|
foreach (string file in files)
|
|
{
|
|
progressBar.Tick();
|
|
fileHolder = new(file);
|
|
if (!fileHolder.Exists)
|
|
continue;
|
|
directory = Path.GetDirectoryName(file);
|
|
if (string.IsNullOrEmpty(directory))
|
|
continue;
|
|
if (file.EndsWith(".rename"))
|
|
{
|
|
checkFile = Path.Combine(directory, $"rename_{Path.GetFileName(file[..^7])}");
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
if (distinct.Contains(checkFile))
|
|
continue;
|
|
distinct.Add(checkFile);
|
|
results.Add(new(fileHolder, directory, checkFile));
|
|
if (nefPresent)
|
|
results.Add(new(new($"{fileHolder.FullName[..^4]}.tif"), directory, $"{checkFile[..^4]}.tif"));
|
|
if (nefPresent)
|
|
results.Add(new(new($"{fileHolder.FullName[..^4]}.nef"), directory, $"{checkFile[..^4]}.nef"));
|
|
continue;
|
|
}
|
|
if (file.EndsWith(".jpg.del"))
|
|
{
|
|
checkFile = file[..^4];
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
if (distinct.Contains(checkFile))
|
|
continue;
|
|
distinct.Add(checkFile);
|
|
results.Add(new(fileHolder, directory, checkFile));
|
|
if (nefPresent)
|
|
results.Add(new(new($"{fileHolder.FullName[..^4]}.tif"), directory, $"{checkFile[..^4]}.tif"));
|
|
if (nefPresent)
|
|
results.Add(new(new($"{fileHolder.FullName[..^4]}.nef"), directory, $"{checkFile[..^4]}.nef"));
|
|
continue;
|
|
}
|
|
if (fileHolder.ExtensionLowered == ".id" || fileHolder.ExtensionLowered == ".lsv" || fileHolder.DirectoryName is null)
|
|
continue;
|
|
if (files.Contains($"{fileHolder.FullName}.id"))
|
|
continue;
|
|
nameWithoutExtensionIsIdFormat = Shared.Models.Stateless.Methods.IProperty.NameWithoutExtensionIsIdFormat(fileHolder);
|
|
if (nameWithoutExtensionIsIdFormat)
|
|
continue;
|
|
isValidImageFormatExtension = _PropertyConfiguration.ValidImageFormatExtensions.Contains(fileHolder.ExtensionLowered);
|
|
isIgnoreExtension = isValidImageFormatExtension && _PropertyConfiguration.IgnoreExtensions.Contains(fileHolder.ExtensionLowered);
|
|
if (!isIgnoreExtension && isValidImageFormatExtension)
|
|
ffmpegFiles = null;
|
|
else
|
|
{
|
|
try
|
|
{ directories = MetadataExtractor.ImageMetadataReader.ReadMetadata(file); }
|
|
catch (Exception) { continue; }
|
|
CommandTask<CommandResult> result = Cli.Wrap("ffmpeg.exe")
|
|
// .WithArguments(new[] { "-ss", "00:00:00", "-t", "00:00:00", "-i", file, "-qscale:v", "2", "-r", "0.01", $"{fileHolder.Name}-%4d.jpg" })
|
|
.WithArguments(new[] { "-i", file, "-vframes", "1", $"{fileHolder.Name}-%4d.jpg" })
|
|
.WithWorkingDirectory(fileHolder.DirectoryName)
|
|
.ExecuteAsync();
|
|
result.Task.Wait();
|
|
ffmpegFiles = Directory.GetFiles(fileHolder.DirectoryName, $"{fileHolder.Name}-*.jpg", SearchOption.TopDirectoryOnly);
|
|
if (!ffmpegFiles.Any())
|
|
continue;
|
|
fileHolder = new(ffmpegFiles.First());
|
|
if (!fileHolder.Name.EndsWith("-0001.jpg"))
|
|
throw new Exception();
|
|
isValidImageFormatExtension = _PropertyConfiguration.ValidImageFormatExtensions.Contains(fileHolder.ExtensionLowered);
|
|
isIgnoreExtension = isValidImageFormatExtension && _PropertyConfiguration.IgnoreExtensions.Contains(fileHolder.ExtensionLowered);
|
|
if (isIgnoreExtension || !isValidImageFormatExtension)
|
|
continue;
|
|
if (fileHolder.DirectoryName is null)
|
|
continue;
|
|
}
|
|
if (fileHolder.ExtensionLowered == jpeg)
|
|
{
|
|
if (!isIgnoreExtension && isValidImageFormatExtension)
|
|
{
|
|
if (File.Exists($"{fileHolder.FullName}.id"))
|
|
{
|
|
checkFile = Path.Combine(fileHolder.DirectoryName, $"{fileHolder.NameWithoutExtension}{jpg}.id");
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
if (distinct.Contains(checkFile))
|
|
continue;
|
|
distinct.Add(checkFile);
|
|
results.Add(new(new($"{fileHolder.FullName}.id"), directory, checkFile));
|
|
}
|
|
checkFile = Path.Combine(fileHolder.DirectoryName, $"{fileHolder.NameWithoutExtension}{jpg}");
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
if (distinct.Contains(checkFile))
|
|
continue;
|
|
distinct.Add(checkFile);
|
|
results.Add(new(fileHolder, directory, checkFile));
|
|
if (nefPresent)
|
|
results.Add(new(new($"{fileHolder.FullName[..^4]}.tif"), directory, $"{checkFile[..^4]}.tif"));
|
|
if (nefPresent)
|
|
results.Add(new(new($"{fileHolder.FullName[..^4]}.nef"), directory, $"{checkFile[..^4]}.nef"));
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
File.Move(fileHolder.FullName, checkFile);
|
|
fileHolder = new(checkFile);
|
|
if (fileHolder.DirectoryName is null)
|
|
continue;
|
|
}
|
|
}
|
|
dateTimeFromName = Shared.Models.Stateless.Methods.IProperty.GetDateTimeFromName(fileHolder);
|
|
(dateTimeOriginal, dateTimes, id, message) = Shared.Models.Stateless.Methods.IProperty.Get(fileHolder, isIgnoreExtension, isValidImageFormatExtension, _PropertyConfiguration.PopulatePropertyId);
|
|
minimumDateTime = dateTimes.Min();
|
|
if (minimumDateTime is null)
|
|
break;
|
|
if (dateTimeOriginal is not null && dateTimeFromName is not null)
|
|
{
|
|
timeSpan = new(Math.Abs(dateTimeOriginal.Value.Ticks - dateTimeFromName.Value.Ticks));
|
|
timeSpan = timeSpan.Value.TotalMinutes > _AppSettings.MaxMinutesDelta ? null : new(Math.Abs(minimumDateTime.Value.Ticks - new long[] { dateTimeOriginal.Value.Ticks, dateTimeFromName.Value.Ticks }.Min()));
|
|
}
|
|
else if (dateTimeFromName is not null)
|
|
timeSpan = new(Math.Abs(minimumDateTime.Value.Ticks - dateTimeFromName.Value.Ticks));
|
|
else if (dateTimeOriginal is not null)
|
|
timeSpan = new(Math.Abs(minimumDateTime.Value.Ticks - dateTimeOriginal.Value.Ticks));
|
|
else
|
|
{
|
|
if (_PropertyConfiguration.IgnoreExtensions.Contains(fileHolder.ExtensionLowered))
|
|
continue;
|
|
try
|
|
{ directories = MetadataExtractor.ImageMetadataReader.ReadMetadata(file); }
|
|
catch (Exception) { continue; }
|
|
metadataMinimumDateTime = Metadata.Models.Stateless.Methods.IMetadata.GetMinimumDateTime(directories);
|
|
if (metadataMinimumDateTime is null)
|
|
timeSpan = null;
|
|
else
|
|
timeSpan = new(Math.Abs(minimumDateTime.Value.Ticks - metadataMinimumDateTime.Value.Ticks));
|
|
}
|
|
if (timeSpan is null || timeSpan.Value.TotalMinutes > _AppSettings.MaxMinutesDelta)
|
|
(isWrongYear, seasonDirectory) = (null, null);
|
|
else
|
|
{
|
|
directoryName = Path.GetFileName(fileHolder.DirectoryName);
|
|
directoryNameSegments = directoryName.Split(' ');
|
|
(isWrongYear, _) = Shared.Models.Stateless.Methods.IProperty.IsWrongYear(directoryNameSegments, string.Empty);
|
|
dateTime = minimumDateTime.Value.AddTicks(timeSpan.Value.Ticks);
|
|
(season, seasonName) = Shared.Models.Stateless.Methods.IProperty.GetSeason(dateTime.DayOfYear);
|
|
seasonDirectory = Path.Combine(fileHolder.DirectoryName, $"{dateTime.Year}.{season} {seasonName}");
|
|
}
|
|
if (seasonDirectory is null || (isWrongYear is not null && isWrongYear.Value))
|
|
{
|
|
if (metadataMinimumDateTime is null)
|
|
continue;
|
|
checkFileExtension = fileHolder.ExtensionLowered == jpeg ? jpg : fileHolder.ExtensionLowered;
|
|
checkFile = Path.Combine(fileHolder.DirectoryName, $"{metadataMinimumDateTime.Value:yyyy-MM-dd}.{metadataMinimumDateTime.Value.Ticks}.{fileHolder.Length}{checkFileExtension}");
|
|
if (checkFile == fileHolder.FullName)
|
|
continue;
|
|
if (distinct.Contains(checkFile))
|
|
continue;
|
|
distinct.Add(checkFile);
|
|
results.Add(new(fileHolder, directory, checkFile));
|
|
if (nefPresent)
|
|
results.Add(new(new($"{fileHolder.FullName[..^4]}.tif"), directory, $"{checkFile[..^4]}.tif"));
|
|
if (nefPresent)
|
|
results.Add(new(new($"{fileHolder.FullName[..^4]}.nef"), directory, $"{checkFile[..^4]}.nef"));
|
|
if (ffmpegFiles is not null)
|
|
{
|
|
foreach (string ffmpegFile in ffmpegFiles)
|
|
File.Delete(ffmpegFile);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (id is null)
|
|
continue;
|
|
if (ffmpegFiles is not null)
|
|
{
|
|
foreach (string ffmpegFile in ffmpegFiles)
|
|
File.Delete(ffmpegFile);
|
|
fileHolder = new(file);
|
|
}
|
|
checkFileExtension = fileHolder.ExtensionLowered == jpeg ? jpg : fileHolder.ExtensionLowered;
|
|
checkFile = Path.Combine(seasonDirectory, $"{id.Value}{checkFileExtension}");
|
|
if (checkFile == fileHolder.FullName)
|
|
continue;
|
|
if (File.Exists(checkFile))
|
|
{
|
|
checkFile = string.Concat(checkFile, ".del");
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
}
|
|
if (distinct.Contains(checkFile))
|
|
continue;
|
|
distinct.Add(checkFile);
|
|
results.Add(new(fileHolder, seasonDirectory, checkFile));
|
|
if (nefPresent)
|
|
results.Add(new(new($"{fileHolder.FullName[..^4]}.tif"), seasonDirectory, $"{checkFile[..^4]}.tif"));
|
|
if (nefPresent)
|
|
results.Add(new(new($"{fileHolder.FullName[..^4]}.nef"), seasonDirectory, $"{checkFile[..^4]}.nef"));
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private static void Rename2000(ILogger log, MatchNginx[] matchNginxCollection)
|
|
{
|
|
string name;
|
|
string check;
|
|
string? directoryName;
|
|
log.Information("Enter a suffix if any");
|
|
string? suffix = System.Console.ReadLine();
|
|
foreach (MatchNginx matchNginx in matchNginxCollection)
|
|
{
|
|
name = matchNginx.Name.Trim();
|
|
if (name.Length < 1 || (!name.StartsWith("zzz =20") && !name.StartsWith("=20") && !name.StartsWith("#20")))
|
|
continue;
|
|
directoryName = Path.GetDirectoryName(matchNginx.ConvertedPath);
|
|
if (directoryName is null)
|
|
continue;
|
|
if (name.StartsWith("=20") || name.StartsWith("#20"))
|
|
check = Path.Combine(directoryName, $"{name[1..]}{suffix}");
|
|
else
|
|
check = Path.Combine(directoryName, $"zzz {name[5..]}");
|
|
if (Directory.Exists(check) || File.Exists(check))
|
|
continue;
|
|
if (!Directory.Exists(matchNginx.ConvertedPath))
|
|
File.Move(matchNginx.ConvertedPath, check);
|
|
else
|
|
Directory.Move(matchNginx.ConvertedPath, check);
|
|
}
|
|
}
|
|
|
|
private static List<string> GetAllFiles(MatchNginx[] matchNginxCollection)
|
|
{
|
|
List<string> allFiles = new();
|
|
string[] files;
|
|
string directoryName;
|
|
ReadOnlySpan<char> span;
|
|
foreach (MatchNginx matchNginx in matchNginxCollection)
|
|
{
|
|
if (matchNginx.ConvertedPath.Length < 6)
|
|
continue;
|
|
directoryName = Path.GetFileName(matchNginx.ConvertedPath);
|
|
if (matchNginx.ConvertedPath.Contains("!---"))
|
|
span = "0";
|
|
else
|
|
span = matchNginx.ConvertedPath.AsSpan(matchNginx.ConvertedPath.Length - 5, 3);
|
|
if (directoryName.Length == 1 && int.TryParse(span, out int age))
|
|
continue;
|
|
if (File.Exists(matchNginx.ConvertedPath))
|
|
continue;
|
|
if (!Directory.Exists(matchNginx.ConvertedPath))
|
|
continue;
|
|
files = Directory.GetFiles(matchNginx.ConvertedPath, "*", SearchOption.AllDirectories);
|
|
if (files.All(l => l.EndsWith(".id")))
|
|
{
|
|
foreach (string file in files)
|
|
File.Delete(file);
|
|
continue;
|
|
}
|
|
allFiles.AddRange(files);
|
|
}
|
|
return allFiles;
|
|
}
|
|
|
|
private static void CreateDirectories(List<string> directories)
|
|
{
|
|
foreach (string directory in directories)
|
|
{
|
|
if (Directory.Exists(directory))
|
|
continue;
|
|
_ = Directory.CreateDirectory(directory);
|
|
}
|
|
}
|
|
|
|
private static List<string> Move(ILogger log, List<(FileHolder, string)> verifiedToDoCollection)
|
|
{
|
|
List<string> results = new();
|
|
ConsoleKey? consoleKey = null;
|
|
log.Information($"Ready to Move {verifiedToDoCollection.Count} file(s)?");
|
|
for (int y = 0; y < int.MaxValue; y++)
|
|
{
|
|
log.Information("Press \"Y\" key to move file(s), \"N\" key to log file(s) or close console to not move files");
|
|
consoleKey = System.Console.ReadKey().Key;
|
|
if (consoleKey is ConsoleKey.Y or ConsoleKey.N)
|
|
break;
|
|
}
|
|
log.Information(". . .");
|
|
if (consoleKey is null || consoleKey.Value != ConsoleKey.Y)
|
|
log.Information("Nothing moved!");
|
|
else
|
|
{
|
|
foreach ((FileHolder fileHolder, string to) in verifiedToDoCollection)
|
|
{
|
|
results.Add(fileHolder.NameWithoutExtension);
|
|
try
|
|
{ File.Move(fileHolder.FullName, to); }
|
|
catch (Exception) { }
|
|
}
|
|
log.Information("Done Moving");
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private List<string> RenameFilesInDirectories(ILogger log, MatchNginx[] matchNginxCollection)
|
|
{
|
|
List<string> results = new();
|
|
string[] files;
|
|
string message;
|
|
bool nefPresent;
|
|
List<string> allFiles;
|
|
ProgressBar progressBar;
|
|
List<string> distinctDirectories = new();
|
|
allFiles = GetAllFiles(matchNginxCollection);
|
|
List<(FileHolder, string, string)> toDoCollection;
|
|
List<(FileHolder, string)> verifiedToDoCollection;
|
|
ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
|
|
for (int i = 1; i < 3; i++)
|
|
{
|
|
distinctDirectories.Clear();
|
|
if (!allFiles.Any())
|
|
continue;
|
|
message = $"{i}) Renaming files";
|
|
if (_AppSettings.RenameUndo && i == 1)
|
|
continue;
|
|
files = i == 2 ? allFiles.ToArray() : (from l in allFiles where l.Contains("Rename", StringComparison.OrdinalIgnoreCase) select l).ToArray();
|
|
progressBar = new(files.Length, message, options);
|
|
if (!files.Any())
|
|
continue;
|
|
if (_AppSettings.RenameUndo)
|
|
toDoCollection = GetRenameUndoToDoCollection(progressBar, files);
|
|
else
|
|
{
|
|
nefPresent = files.Any(l => l.EndsWith(".NEF"));
|
|
if (nefPresent)
|
|
files = (from l in files where l.EndsWith(".JPG") select l).ToArray();
|
|
if (!files.Any())
|
|
continue;
|
|
toDoCollection = GetToDoCollection(progressBar, files, nefPresent);
|
|
}
|
|
progressBar.Dispose();
|
|
verifiedToDoCollection = new();
|
|
foreach ((FileHolder fileHolder, string directory, string to) in toDoCollection)
|
|
{
|
|
if (distinctDirectories.Contains(directory))
|
|
continue;
|
|
distinctDirectories.Add(directory);
|
|
}
|
|
foreach (string distinctDirectory in distinctDirectories)
|
|
{
|
|
if (!Directory.Exists(distinctDirectory))
|
|
_ = Directory.CreateDirectory(distinctDirectory);
|
|
}
|
|
foreach ((FileHolder fileHolder, string directory, string to) in toDoCollection)
|
|
{
|
|
if (File.Exists(to))
|
|
continue;
|
|
verifiedToDoCollection.Add(new(fileHolder, to));
|
|
File.WriteAllText($"{to}.id", $"{to}{Environment.NewLine}{fileHolder.FullName}");
|
|
}
|
|
if (!verifiedToDoCollection.Any())
|
|
continue;
|
|
results.AddRange(Move(log, verifiedToDoCollection));
|
|
allFiles = GetAllFiles(matchNginxCollection);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private void RenameByDateTakenB(MatchNginx[] matchNginxCollection, string aPropertySingletonDirectory, string[] jsonFiles)
|
|
{
|
|
string json;
|
|
string[] files;
|
|
string fileName;
|
|
string checkFile;
|
|
string extension;
|
|
string[] matches;
|
|
DateTime dateTime;
|
|
string[] segments;
|
|
string directoryName;
|
|
string? subdirectory;
|
|
string checkDirectory;
|
|
string? checkFileName;
|
|
Shared.Models.Property? property;
|
|
foreach (MatchNginx matchNginx in matchNginxCollection)
|
|
{
|
|
if (File.Exists(matchNginx.ConvertedPath))
|
|
continue;
|
|
if (!Directory.Exists(matchNginx.ConvertedPath))
|
|
continue;
|
|
subdirectory = Path.GetDirectoryName(matchNginx.ConvertedPath);
|
|
if (string.IsNullOrEmpty(subdirectory))
|
|
continue;
|
|
files = Directory.GetFiles(matchNginx.ConvertedPath, "*", SearchOption.AllDirectories);
|
|
for (int i = 65; i < 91; i++)
|
|
{
|
|
checkDirectory = Path.Combine(subdirectory, nameof(Rename), ((char)i).ToString());
|
|
if (!Directory.Exists(checkDirectory))
|
|
_ = Directory.CreateDirectory(checkDirectory);
|
|
}
|
|
foreach (string file in files)
|
|
{
|
|
fileName = Path.GetFileName(file);
|
|
segments = fileName.Split('.');
|
|
extension = Path.GetExtension(file);
|
|
(directoryName, _) = Shared.Models.Stateless.Methods.IPath.GetDirectoryNameAndIndex(_Configuration.PropertyConfiguration.ResultAllInOneSubdirectoryLength, fileName);
|
|
checkFileName = $"{segments.First()}{Path.GetExtension(Path.GetFileNameWithoutExtension(file))}.json";
|
|
checkDirectory = Path.Combine(aPropertySingletonDirectory, _PropertyConfiguration.ResultAllInOne, directoryName);
|
|
checkFile = Path.Combine(checkDirectory, checkFileName);
|
|
matches = jsonFiles.Where(l => l == checkFile).ToArray();
|
|
if (!matches.Any())
|
|
{
|
|
matches = jsonFiles.Where(l => l.EndsWith(checkFileName)).ToArray();
|
|
if (!matches.Any())
|
|
continue;
|
|
}
|
|
json = File.ReadAllText(matches.First());
|
|
property = JsonSerializer.Deserialize<Shared.Models.Property>(json);
|
|
if (property is null)
|
|
continue;
|
|
checkFileName = null;
|
|
dateTime = property.DateTimeOriginal is not null ? property.DateTimeOriginal.Value : Shared.Models.Stateless.Methods.IProperty.GetMinimumDateTime(property);
|
|
for (int i = 65; i < 91; i++)
|
|
{
|
|
if (checkFileName is not null && !File.Exists(checkFileName))
|
|
break;
|
|
checkFileName = Path.Combine(subdirectory, nameof(Rename), ((char)i).ToString(), $"{dateTime.Ticks}{extension}");
|
|
}
|
|
if (checkFileName is null || File.Exists(checkFileName))
|
|
continue;
|
|
File.Move(file, checkFileName);
|
|
}
|
|
_ = Shared.Models.Stateless.Methods.IPath.DeleteEmptyDirectories(subdirectory);
|
|
}
|
|
}
|
|
|
|
private void RenameByDateTaken(ILogger log, MatchNginx[] matchNginxCollection)
|
|
{
|
|
string aResultsFullGroupDirectory = Property.Models.Stateless.IResult.GetResultsFullGroupDirectory(
|
|
_PropertyConfiguration,
|
|
nameof(A_Property),
|
|
string.Empty,
|
|
includeResizeGroup: false,
|
|
includeModel: false,
|
|
includePredictorModel: false);
|
|
string aPropertySingletonDirectory = Path.GetFullPath(Path.Combine(aResultsFullGroupDirectory, "{}"));
|
|
string[] jsonFiles = !Directory.Exists(aPropertySingletonDirectory) ? Array.Empty<string>() : Directory.GetFiles(aPropertySingletonDirectory, "*.json", SearchOption.AllDirectories);
|
|
if (!jsonFiles.Any())
|
|
log.Information($"No json file(s) found! Check directoryName <{aPropertySingletonDirectory}>");
|
|
else
|
|
RenameByDateTakenB(matchNginxCollection, aPropertySingletonDirectory, jsonFiles);
|
|
}
|
|
|
|
} |