231 lines
12 KiB
C#
231 lines
12 KiB
C#
using Microsoft.Extensions.Logging;
|
|
using System.Collections.ObjectModel;
|
|
using System.Text;
|
|
|
|
namespace File_Folder_Helper.Day.Q42023;
|
|
|
|
internal static partial class Helper20231222
|
|
{
|
|
|
|
private record Record(string File,
|
|
string DestinationDirectory,
|
|
string DestinationFile);
|
|
|
|
private record IntelligentIdRecord(int Key,
|
|
ReadOnlyCollection<char> ResultAllInOneSubdirectoryChars,
|
|
string Reverse);
|
|
|
|
private record FilePath(long CreationTicks,
|
|
string DirectoryName,
|
|
string ExtensionLowered,
|
|
string FileNameFirstSegment,
|
|
string FullName,
|
|
int? Id,
|
|
bool IsIntelligentIdFormat,
|
|
long LastWriteTicks,
|
|
long Length,
|
|
string Name,
|
|
string NameWithoutExtension,
|
|
int? SortOrder);
|
|
|
|
public record MetadataConfiguration(int ResultAllInOneSubdirectoryLength, int Offset, int IntMinValueLength);
|
|
|
|
private static short GetSortOrderOnlyLengthIndex(MetadataConfiguration metadataConfiguration) =>
|
|
(short)metadataConfiguration.Offset.ToString().Length;
|
|
|
|
private static bool NameWithoutExtensionIsIntelligentIdFormat(MetadataConfiguration metadataConfiguration, string fileNameFirstSegment) =>
|
|
fileNameFirstSegment.Length - 1 == metadataConfiguration.IntMinValueLength && fileNameFirstSegment[^1] is '1' or '2' or '8' or '9' && fileNameFirstSegment.All(char.IsNumber);
|
|
|
|
private static bool NameWithoutExtensionIsPaddedIntelligentIdFormat(MetadataConfiguration metadataConfiguration, short sortOrderOnlyLengthIndex, string fileNameFirstSegment) =>
|
|
fileNameFirstSegment.Length == metadataConfiguration.IntMinValueLength + sortOrderOnlyLengthIndex + 1
|
|
&& fileNameFirstSegment[^1] is '1' or '2' or '8' or '9'
|
|
&& fileNameFirstSegment.All(char.IsNumber);
|
|
|
|
private static bool NameWithoutExtensionIsIdFormat(MetadataConfiguration metadataConfiguration, string fileNameFirstSegment)
|
|
{
|
|
bool result;
|
|
if (fileNameFirstSegment.Length < 5 || fileNameFirstSegment.Length > metadataConfiguration.IntMinValueLength)
|
|
result = false;
|
|
else
|
|
{
|
|
bool skipOneAllAreNumbers = fileNameFirstSegment[1..].All(char.IsNumber);
|
|
result = (skipOneAllAreNumbers && fileNameFirstSegment[0] == '-') || (skipOneAllAreNumbers && char.IsNumber(fileNameFirstSegment[0]));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static FilePath GetFilePath(MetadataConfiguration metadataConfiguration, FileInfo fileInfo, int? index)
|
|
{
|
|
FilePath result;
|
|
int? id;
|
|
int? sortOder;
|
|
string fileNameFirstSegment = fileInfo.Name.Split('.')[0];
|
|
short sortOrderOnlyLengthIndex = GetSortOrderOnlyLengthIndex(metadataConfiguration);
|
|
string fileDirectoryName = fileInfo.DirectoryName ?? throw new NullReferenceException();
|
|
bool fileNameFirstSegmentIsIntelligentIdFormat = NameWithoutExtensionIsIntelligentIdFormat(metadataConfiguration, fileNameFirstSegment);
|
|
bool fileNameFirstSegmentIsPaddedIntelligentIdFormat = NameWithoutExtensionIsPaddedIntelligentIdFormat(metadataConfiguration, sortOrderOnlyLengthIndex, fileNameFirstSegment);
|
|
bool fileNameFirstSegmentIsIdFormat = !fileNameFirstSegmentIsPaddedIntelligentIdFormat && !fileNameFirstSegmentIsIntelligentIdFormat && NameWithoutExtensionIsIdFormat(metadataConfiguration, fileNameFirstSegment);
|
|
if (fileNameFirstSegmentIsIdFormat)
|
|
{
|
|
if (index is null)
|
|
throw new NullReferenceException(nameof(index));
|
|
if (!int.TryParse(fileNameFirstSegment, out int valueOfFileNameFirstSegment))
|
|
throw new NotSupportedException();
|
|
(id, sortOder) = (valueOfFileNameFirstSegment, metadataConfiguration.Offset + index);
|
|
}
|
|
else if (!fileNameFirstSegmentIsIntelligentIdFormat && !fileNameFirstSegmentIsPaddedIntelligentIdFormat)
|
|
(id, sortOder) = (null, null);
|
|
else if (fileNameFirstSegmentIsIntelligentIdFormat)
|
|
(id, sortOder) = (GetId(metadataConfiguration, fileNameFirstSegment), null);
|
|
else if (fileNameFirstSegmentIsPaddedIntelligentIdFormat)
|
|
{
|
|
if (!int.TryParse(fileNameFirstSegment[..sortOrderOnlyLengthIndex], out int absoluteValueOfSortOrder))
|
|
(id, sortOder) = (null, null);
|
|
else
|
|
(id, sortOder) = (GetId(metadataConfiguration, fileNameFirstSegment[sortOrderOnlyLengthIndex..]), absoluteValueOfSortOrder);
|
|
}
|
|
else
|
|
throw new NotSupportedException();
|
|
result = new(fileInfo.CreationTime.Ticks,
|
|
fileDirectoryName,
|
|
fileInfo.Extension.ToLower(),
|
|
fileNameFirstSegment,
|
|
fileInfo.FullName,
|
|
id,
|
|
fileNameFirstSegmentIsIntelligentIdFormat,
|
|
fileInfo.LastWriteTime.Ticks,
|
|
fileInfo.Length,
|
|
fileInfo.Name,
|
|
Path.GetFileNameWithoutExtension(fileInfo.Name),
|
|
sortOder);
|
|
return result;
|
|
}
|
|
|
|
private static IntelligentIdRecord GetIntelligentIdRecord(MetadataConfiguration metadataConfiguration, long id, bool ignore)
|
|
{
|
|
IntelligentIdRecord result;
|
|
StringBuilder stringBuilder = new();
|
|
if (metadataConfiguration.IntMinValueLength < (metadataConfiguration.ResultAllInOneSubdirectoryLength + 2))
|
|
throw new NotSupportedException();
|
|
int key;
|
|
string value;
|
|
List<char> chars = [];
|
|
if (id > -1)
|
|
{
|
|
key = ignore ? 8 : 9;
|
|
value = id.ToString().PadLeft(metadataConfiguration.IntMinValueLength, '0');
|
|
}
|
|
else
|
|
{
|
|
key = ignore ? 2 : 1;
|
|
value = id.ToString()[1..].PadLeft(metadataConfiguration.IntMinValueLength, '0');
|
|
}
|
|
for (int i = value.Length - metadataConfiguration.ResultAllInOneSubdirectoryLength - 1; i > -1; i--)
|
|
_ = stringBuilder.Append(value[i]);
|
|
for (int i = value.Length - metadataConfiguration.ResultAllInOneSubdirectoryLength; i < value.Length; i++)
|
|
chars.Add(value[i]);
|
|
result = new(key, new(chars), stringBuilder.ToString());
|
|
return result;
|
|
}
|
|
|
|
private static string GetIntelligentId(IntelligentIdRecord intelligentId) =>
|
|
$"{intelligentId.Reverse}{string.Join(string.Empty, intelligentId.ResultAllInOneSubdirectoryChars)}{intelligentId.Key}";
|
|
|
|
private static int GetId(MetadataConfiguration metadataConfiguration, string intelligentId)
|
|
{
|
|
int result;
|
|
StringBuilder results = new();
|
|
if (metadataConfiguration.IntMinValueLength < (metadataConfiguration.ResultAllInOneSubdirectoryLength + 2))
|
|
throw new NotSupportedException();
|
|
for (int i = intelligentId.Length - (metadataConfiguration.ResultAllInOneSubdirectoryLength + 2); i > -1; i--)
|
|
_ = results.Append(intelligentId[i]);
|
|
_ = results.Append(intelligentId[^3]).Append(intelligentId[^2]);
|
|
result = int.Parse(results.ToString());
|
|
if (intelligentId[^1] is '1' or '2')
|
|
result *= -1;
|
|
else if (intelligentId[^1] is not '9' and not '8')
|
|
throw new NotSupportedException();
|
|
return result;
|
|
}
|
|
|
|
private static ReadOnlyCollection<Record> GetRecords(MetadataConfiguration metadataConfiguration, string sourceDirectory, string searchPattern)
|
|
{
|
|
List<Record> results = [];
|
|
int check;
|
|
int index = -1;
|
|
FileInfo fileInfo;
|
|
FilePath filePath;
|
|
string? directory;
|
|
string[] segments;
|
|
bool ignore = false;
|
|
string directoryName;
|
|
string intelligentId;
|
|
string? parentDirectory;
|
|
IntelligentIdRecord intelligentIdRecord;
|
|
string sourceParentDirectory = Path.GetDirectoryName(sourceDirectory) ?? throw new NotSupportedException();
|
|
string[] files = Directory.GetFiles(sourceDirectory, searchPattern, SearchOption.AllDirectories);
|
|
foreach (string file in files)
|
|
{
|
|
index += 1;
|
|
directory = Path.GetDirectoryName(file);
|
|
if (directory is null)
|
|
continue;
|
|
parentDirectory = Path.GetDirectoryName(directory);
|
|
if (parentDirectory is null)
|
|
continue;
|
|
fileInfo = new(file);
|
|
directoryName = Path.GetFileName(directory);
|
|
filePath = GetFilePath(metadataConfiguration, fileInfo, index);
|
|
if (filePath.Id is null)
|
|
continue;
|
|
intelligentIdRecord = GetIntelligentIdRecord(metadataConfiguration, filePath.Id.Value, ignore);
|
|
intelligentId = GetIntelligentId(intelligentIdRecord);
|
|
check = GetId(metadataConfiguration, intelligentId);
|
|
if (check != filePath.Id.Value)
|
|
throw new NotSupportedException();
|
|
segments = Path.GetFileName(file).Split('.');
|
|
if (segments.Length == 2)
|
|
{
|
|
if (filePath.SortOrder is not null)
|
|
results.Add(new(file, directory, $"{filePath.SortOrder.Value}{intelligentId}.{segments[1]}"));
|
|
else
|
|
results.Add(new(file, Path.Combine(sourceParentDirectory, intelligentIdRecord.Key.ToString(), string.Join(string.Empty, intelligentIdRecord.ResultAllInOneSubdirectoryChars)), $"{intelligentId}.{segments[1]}"));
|
|
}
|
|
else if (segments.Length == 3)
|
|
results.Add(new(file, Path.Combine(sourceParentDirectory, intelligentIdRecord.Key.ToString(), string.Join(string.Empty, intelligentIdRecord.ResultAllInOneSubdirectoryChars)), $"{intelligentId}.{segments[1]}.{segments[2]}"));
|
|
else if (segments.Length == 4)
|
|
{
|
|
if (directoryName != segments[0])
|
|
results.Add(new(file, directory, $"{intelligentId}.{segments[1]}.{segments[2]}.{segments[3]}"));
|
|
else
|
|
results.Add(new(file, Path.Combine(sourceParentDirectory, intelligentIdRecord.Key.ToString(), string.Join(string.Empty, intelligentIdRecord.ResultAllInOneSubdirectoryChars), intelligentId), $"{intelligentId}.{segments[1]}.{segments[2]}.{segments[3]}"));
|
|
}
|
|
else if (segments.Length == 5)
|
|
results.Add(new(file, directory, $"{intelligentId}.{segments[1]}.{segments[2]}.{segments[3]}.{segments[4]}"));
|
|
else
|
|
continue;
|
|
}
|
|
return new(results);
|
|
}
|
|
|
|
internal static void ConvertId(ILogger<Worker> logger, List<string> args)
|
|
{
|
|
List<string> distinct = [];
|
|
string searchPattern = args[2];
|
|
string sourceDirectory = args[0];
|
|
logger.LogInformation("{sourceDirectory}", sourceDirectory);
|
|
MetadataConfiguration metadataConfiguration = new(2, 1000000, int.MinValue.ToString().Length);
|
|
ReadOnlyCollection<Record> records = GetRecords(metadataConfiguration, sourceDirectory, searchPattern);
|
|
foreach (Record record in records)
|
|
{
|
|
if (distinct.Contains(record.DestinationDirectory))
|
|
continue;
|
|
distinct.Add(record.DestinationDirectory);
|
|
if (!Directory.Exists(record.DestinationDirectory))
|
|
_ = Directory.CreateDirectory(record.DestinationDirectory);
|
|
}
|
|
foreach (Record record in records)
|
|
File.Move(record.File, Path.Combine(record.DestinationDirectory, record.DestinationFile));
|
|
}
|
|
|
|
} |