Mike Phares
c9dbce3b57
Filtered => ValidImage GetMappings => if (face.FaceEncoding is null || face.Location is null || face.OutputResolution is null) PreFilter skip done Removed sort Better names break out RootAmazon FilteredOriginalImage DeleteContinueFiles AppSetting PreVerify Settings Tasks
1391 lines
85 KiB
C#
1391 lines
85 KiB
C#
using Humanizer;
|
|
using ShellProgressBar;
|
|
using System.Buffers;
|
|
using System.Collections.ObjectModel;
|
|
using System.Globalization;
|
|
using System.Text.Json;
|
|
using System.Text.RegularExpressions;
|
|
using View_by_Distance.Map.Models.Stateless.Methods;
|
|
using View_by_Distance.Shared.Models;
|
|
using View_by_Distance.Shared.Models.Stateless.Methods;
|
|
using WindowsShortcutFactory;
|
|
|
|
namespace View_by_Distance.Map.Models;
|
|
|
|
public partial class MapLogic : Shared.Models.Methods.IMapLogic
|
|
{
|
|
|
|
[GeneratedRegex("[\\\\,\\/,\\:,\\*,\\?,\\\",\\<,\\>,\\|]")]
|
|
private static partial Regex FileSystemSafe();
|
|
|
|
internal record Record(string? DebugDirectory,
|
|
string? Directory,
|
|
long? Ticks,
|
|
string? PersonDirectory);
|
|
|
|
internal record FilteredOriginalImage(int Id,
|
|
FilePath FilePath,
|
|
int ApproximateYears,
|
|
string PersonKeyFormatted,
|
|
string Directory,
|
|
string PersonDirectory,
|
|
string CheckFile);
|
|
|
|
public void SaveContainers(int? updated, List<SaveContainer> saveContainers)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
string fileName;
|
|
string checkFile;
|
|
string sourceFile;
|
|
List<string> distinct = [];
|
|
WindowsShortcut windowsShortcut;
|
|
string[] directories = (from l in saveContainers select l.Directory).Distinct().ToArray();
|
|
int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - _Ticks).TotalSeconds);
|
|
string message;
|
|
if (updated is null)
|
|
message = $") {saveContainers.Count:000} save(s) - {totalSeconds} total second(s)";
|
|
else
|
|
message = $") {saveContainers.Count:000} save(s) - {updated} Updated - {totalSeconds} total second(s)";
|
|
ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
|
|
foreach (string directory in directories)
|
|
{
|
|
if (string.IsNullOrEmpty(directory))
|
|
continue;
|
|
if (!Directory.Exists(directory))
|
|
_ = Directory.CreateDirectory(directory);
|
|
}
|
|
using ProgressBar progressBar = new(saveContainers.Count, message, options);
|
|
foreach (SaveContainer saveContainer in saveContainers)
|
|
{
|
|
progressBar.Tick();
|
|
if (string.IsNullOrEmpty(saveContainer.Directory) || string.IsNullOrEmpty(saveContainer.CheckFile) || saveContainer.FaceFileHolder is null)
|
|
continue;
|
|
if (saveContainer.FacePartsFileHolder is null && saveContainer.HiddenFaceFileHolder is null && saveContainer.ResizedFileHolder is null)
|
|
{
|
|
checkFile = saveContainer.CheckFile;
|
|
sourceFile = saveContainer.FaceFileHolder.FullName;
|
|
}
|
|
else if (!saveContainer.FaceFileHolder.Exists && saveContainer.ResizedFileHolder is not null && saveContainer.ResizedFileHolder.Exists)
|
|
{
|
|
checkFile = saveContainer.CheckFile;
|
|
sourceFile = saveContainer.ResizedFileHolder.FullName;
|
|
}
|
|
else if (saveContainer.FaceFileHolder.Exists)
|
|
{
|
|
sourceFile = saveContainer.FaceFileHolder.FullName;
|
|
checkFile = $"{saveContainer.CheckFile}{_Configuration.FacesFileNameExtension}";
|
|
}
|
|
else
|
|
continue;
|
|
if (_Configuration.SaveIndividually)
|
|
{
|
|
fileName = Path.GetFileName(checkFile);
|
|
if (distinct.Contains(fileName))
|
|
continue;
|
|
distinct.Add(fileName);
|
|
}
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
File.Copy(sourceFile, checkFile);
|
|
if (_Configuration.SaveIndividually)
|
|
continue;
|
|
if (saveContainer.MakeAllHidden)
|
|
File.SetAttributes(checkFile, FileAttributes.Hidden);
|
|
if (saveContainer.HiddenFaceFileHolder is not null && saveContainer.HiddenFaceFileHolder.Exists)
|
|
{
|
|
sourceFile = saveContainer.HiddenFaceFileHolder.FullName;
|
|
checkFile = $"{saveContainer.CheckFile}{_Configuration.FacesHiddenFileNameExtension}";
|
|
}
|
|
else if (saveContainer.FacePartsFileHolder is not null && saveContainer.FacePartsFileHolder.Exists)
|
|
{
|
|
sourceFile = saveContainer.FacePartsFileHolder.FullName;
|
|
checkFile = $"{saveContainer.CheckFile}{_Configuration.FacePartsFileNameExtension}";
|
|
}
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
File.Copy(sourceFile, checkFile);
|
|
if (saveContainer.MakeAllHidden)
|
|
File.SetAttributes(checkFile, FileAttributes.Hidden);
|
|
}
|
|
if (updated is null)
|
|
{
|
|
foreach (SaveContainer saveContainer in saveContainers)
|
|
{
|
|
if (string.IsNullOrEmpty(saveContainer.Directory) || string.IsNullOrEmpty(saveContainer.CheckFile) || saveContainer.ResizedFileHolder is null || !saveContainer.ResizedFileHolder.Exists)
|
|
continue;
|
|
checkFile = saveContainer.CheckFile;
|
|
sourceFile = saveContainer.ResizedFileHolder.FullName;
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
File.Copy(sourceFile, checkFile);
|
|
if (saveContainer.MakeAllHidden)
|
|
File.SetAttributes(checkFile, FileAttributes.Hidden);
|
|
}
|
|
}
|
|
foreach (SaveContainer saveContainer in saveContainers)
|
|
{
|
|
if (string.IsNullOrEmpty(saveContainer.Directory) || string.IsNullOrEmpty(saveContainer.ShortcutFile) || saveContainer.ResizedFileHolder is null || !saveContainer.ResizedFileHolder.Exists)
|
|
continue;
|
|
try
|
|
{
|
|
string description;
|
|
if (saveContainer.FaceFileHolder is not null && saveContainer.FaceFileHolder.Name.StartsWith(saveContainer.ResizedFileHolder.Name))
|
|
description = saveContainer.FaceFileHolder.Name;
|
|
else
|
|
description = saveContainer.ResizedFileHolder.Name;
|
|
windowsShortcut = new() { Path = saveContainer.ResizedFileHolder.FullName, Description = description };
|
|
windowsShortcut.Save(saveContainer.ShortcutFile);
|
|
windowsShortcut.Dispose();
|
|
if (saveContainer.MakeAllHidden)
|
|
File.SetAttributes(saveContainer.ShortcutFile, FileAttributes.Hidden);
|
|
}
|
|
catch (Exception)
|
|
{ }
|
|
}
|
|
}
|
|
|
|
private List<SaveShortcutsForOutputResolutions> GetCollectionForSaveShortcutsForOutputResolutionsPreMapLogic(string eDistanceContentDirectory, ReadOnlyDictionary<long, List<int>> personKeyToIds, ReadOnlyCollection<Mapping> distinctValidImageMappingCollection)
|
|
{
|
|
List<SaveShortcutsForOutputResolutions> results = [];
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
int season;
|
|
string fileName;
|
|
string directory;
|
|
string weekOfYear;
|
|
DateTime dateTime;
|
|
string description;
|
|
string directoryName;
|
|
List<long>? personKeys;
|
|
string personKeyFormatted;
|
|
Calendar calendar = new CultureInfo("en-US").Calendar;
|
|
ReadOnlyDictionary<int, List<long>> idToPersonKeys = IMapLogic.GetIdToPersonKeys(personKeyToIds);
|
|
foreach (Mapping mapping in distinctValidImageMappingCollection)
|
|
{
|
|
dateTime = mapping.MappingFromItem.GetDateTimeOriginalThenMinimumDateTime();
|
|
description = mapping.MappingFromLocation is null ? mapping.MappingFromItem.Id.ToString() : mapping.MappingFromLocation.DeterministicHashCodeKey;
|
|
(season, _) = IProperty.GetSeason(dateTime.DayOfYear);
|
|
weekOfYear = calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
|
|
directory = Path.Combine($"{eDistanceContentDirectory}---", "Date Shortcuts", $"{dateTime.Year}.{season}-MM{dateTime.Month:00}-WW{weekOfYear}");
|
|
fileName = Path.Combine(directory, $"{mapping.MappingFromItem.FilePath.Name}.lnk");
|
|
results.Add(new(mapping.MappingFromItem.FilePath.FullName, directory, dateTime, fileName, description, MakeAllHidden: false));
|
|
if (mapping.MappingFromItem.FilePath.DirectoryName is null)
|
|
continue;
|
|
directoryName = Path.GetFileName(mapping.MappingFromItem.FilePath.DirectoryName);
|
|
if (!string.IsNullOrEmpty(mapping.MappingFromItem.Model) && !string.IsNullOrEmpty(mapping.MappingFromItem.Model.Trim()))
|
|
{
|
|
// Remove-Item -LiteralPath "\\?\D:\Tmp\a\EX-Z70 "
|
|
directory = Path.Combine($"{eDistanceContentDirectory}---", "Model Shortcuts", FileSystemSafe().Replace(mapping.MappingFromItem.Model.Trim(), "_"), directoryName);
|
|
fileName = Path.Combine(directory, $"{mapping.MappingFromItem.FilePath.Name}.lnk");
|
|
results.Add(new(mapping.MappingFromItem.FilePath.FullName, directory, dateTime, fileName, description, MakeAllHidden: false));
|
|
}
|
|
if (mapping.MappingFromPerson is null)
|
|
continue;
|
|
if (!idToPersonKeys.TryGetValue(mapping.MappingFromItem.Id, out personKeys))
|
|
continue;
|
|
if (!personKeys.Contains(mapping.MappingFromPerson.PersonKey))
|
|
continue;
|
|
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, mapping.MappingFromPerson.PersonKey);
|
|
directory = Path.Combine($"{eDistanceContentDirectory}---", "Person Key Shortcuts", personKeyFormatted, directoryName);
|
|
fileName = Path.Combine(directory, $"{mapping.MappingFromItem.FilePath.Name}.lnk");
|
|
results.Add(new(mapping.MappingFromItem.FilePath.FullName, directory, dateTime, fileName, description, MakeAllHidden: false));
|
|
if (IPerson.IsDefaultName(mapping.MappingFromPerson))
|
|
continue;
|
|
directory = Path.Combine($"{eDistanceContentDirectory}---", "Name Shortcuts", mapping.MappingFromPerson.DisplayDirectoryName, directoryName);
|
|
fileName = Path.Combine(directory, $"{mapping.MappingFromItem.FilePath.Name}.lnk");
|
|
results.Add(new(mapping.MappingFromItem.FilePath.FullName, directory, dateTime, fileName, description, MakeAllHidden: false));
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private void LookForAbandoned(Property.Models.Configuration propertyConfiguration, List<int> distinctFilteredIds)
|
|
{
|
|
List<string> renameCollection = [];
|
|
foreach (KeyValuePair<int, List<LocationContainer>> keyValuePair in _IdToLocationContainers)
|
|
{
|
|
if (distinctFilteredIds.Contains(keyValuePair.Key))
|
|
continue;
|
|
foreach (LocationContainer locationContainer in keyValuePair.Value)
|
|
{
|
|
if (locationContainer.FilePath.FullName.Contains('!'))
|
|
continue;
|
|
renameCollection.Add(locationContainer.FilePath.FullName);
|
|
}
|
|
}
|
|
if (renameCollection.Count > 0)
|
|
IDirectory.MoveFiles(renameCollection, propertyConfiguration.ResultContent, "(abd)");
|
|
}
|
|
|
|
private readonly long _Ticks;
|
|
private readonly Configuration? _Configuration;
|
|
private readonly string _EDistanceContentTicksDirectory;
|
|
private readonly ReadOnlyDictionary<long, int> _PersonKeyToCount;
|
|
private readonly List<PersonContainer> _NotMappedPersonContainers;
|
|
private readonly ReadOnlyDictionary<int, List<int>> _SkipCollection;
|
|
private readonly ReadOnlyDictionary<int, List<int>> _SkipNotSkipCollection;
|
|
private readonly Shared.Models.Properties.IPropertyConfiguration _PropertyConfiguration;
|
|
private readonly ReadOnlyDictionary<int, List<LocationContainer>> _IdToLocationContainers;
|
|
private readonly ReadOnlyDictionary<int, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>> _IdThenWholePercentagesToPersonContainers;
|
|
|
|
public MapLogic(int maxDegreeOfParallelism, Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, Configuration? configuration, Shared.Models.Methods.IDistance distance, ReadOnlyCollection<PersonContainer> personContainers, long ticks, string? a2PeopleContentDirectory, string a2PeopleSingletonDirectory, string eDistanceContentDirectory)
|
|
{
|
|
_Ticks = ticks;
|
|
_Configuration = configuration;
|
|
_PropertyConfiguration = propertyConfiguration;
|
|
List<LocationContainer> locationContainers = [];
|
|
List<PersonContainer> notMappedPersonContainers = [];
|
|
ReadOnlyDictionary<long, int> readOnlyPersonKeyToCount;
|
|
Dictionary<int, List<(string, int)>> skipCollection = [];
|
|
Dictionary<int, List<(string, int)>> skipNotSkipCollection = [];
|
|
ReadOnlyDictionary<int, List<(string, int)>> readOnlySkipCollection;
|
|
string? rootDirectoryParent = Path.GetDirectoryName(propertyConfiguration.RootDirectory);
|
|
string eDistanceContentTicksDirectory = Path.Combine(eDistanceContentDirectory, ticks.ToString());
|
|
ReadOnlyDictionary<int, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>> idThenWholePercentagesToPersonContainers;
|
|
if (string.IsNullOrEmpty(rootDirectoryParent))
|
|
throw new NullReferenceException(nameof(rootDirectoryParent));
|
|
if (!Directory.Exists(eDistanceContentDirectory))
|
|
_ = Directory.CreateDirectory(eDistanceContentDirectory);
|
|
if (configuration is null)
|
|
{
|
|
readOnlyPersonKeyToCount = new(new Dictionary<long, int>());
|
|
idThenWholePercentagesToPersonContainers = new(new Dictionary<int, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>>());
|
|
}
|
|
else
|
|
{
|
|
ReadOnlyCollection<string> readOnlyPersonKeyFormattedCollection;
|
|
ReadOnlyDictionary<string, string> readOnlyPersonKeyFormattedToNewestPersonKeyFormatted;
|
|
ReadOnlyDictionary<string, PersonContainer> readOnlyPersonKeyFormattedToPersonContainer;
|
|
ReadOnlyDictionary<long, List<PersonContainer>> readOnlyPersonKeyToPersonContainerCollection;
|
|
int copied = Stateless.MapLogic.CopyManualFiles(configuration, ticks, personContainers, eDistanceContentTicksDirectory);
|
|
if (copied > 0)
|
|
throw new Exception("Confirm Manual files and then restart!");
|
|
Stateless.MapLogic.SetSkipCollections(configuration, personContainers, a2PeopleSingletonDirectory, skipCollection, skipNotSkipCollection);
|
|
{
|
|
List<string> personKeyFormattedCollection = [];
|
|
Dictionary<string, string> personKeyFormattedToNewestPersonKeyFormatted = [];
|
|
Stateless.MapLogic.SetPersonCollections(configuration, personContainers, personKeyFormattedToNewestPersonKeyFormatted, personKeyFormattedCollection);
|
|
readOnlyPersonKeyFormattedCollection = new(personKeyFormattedCollection);
|
|
readOnlyPersonKeyFormattedToNewestPersonKeyFormatted = new(personKeyFormattedToNewestPersonKeyFormatted);
|
|
}
|
|
List<Stateless.Record> records = Stateless.DistanceLogic.DeleteEmptyDirectoriesAndGetCollection(propertyConfiguration, configuration, ticks, eDistanceContentDirectory, readOnlyPersonKeyFormattedToNewestPersonKeyFormatted, readOnlyPersonKeyFormattedCollection);
|
|
ReadOnlyCollection<(Stateless.MapLogic.PersonKeyFormattedIdThenWholePercentages, PersonContainer)> readOnlyPossiblyNewPersonDisplayDirectoryNamesAndPersonContainer;
|
|
ReadOnlyCollection<Stateless.MapLogic.PersonKeyFormattedIdThenWholePercentages> personKeyFormattedIdThenWholePercentagesCollection = Stateless.MapLogic.GetPersonKeyFormattedIdThenWholePercentages(configuration, ticks, records);
|
|
//
|
|
{
|
|
Dictionary<long, int> personKeyToCount = [];
|
|
Dictionary<long, PersonContainer> personKeyToPersonContainer = [];
|
|
Dictionary<string, PersonContainer> personKeyFormattedToPersonContainer = [];
|
|
Dictionary<long, List<PersonContainer>> personKeyToPersonContainerCollection = [];
|
|
List<(Stateless.MapLogic.PersonKeyFormattedIdThenWholePercentages, PersonContainer)> possiblyNewPersonDisplayDirectoryNamesAndPersonContainer = [];
|
|
Stateless.MapLogic.SetKeyValuePairsAndAddToCollections(configuration,
|
|
personContainers,
|
|
personKeyToPersonContainer,
|
|
personKeyFormattedIdThenWholePercentagesCollection,
|
|
personKeyToCount,
|
|
personKeyFormattedToPersonContainer,
|
|
personKeyToPersonContainerCollection,
|
|
possiblyNewPersonDisplayDirectoryNamesAndPersonContainer);
|
|
readOnlyPersonKeyToCount = new(personKeyToCount);
|
|
readOnlyPersonKeyFormattedToPersonContainer = new(personKeyFormattedToPersonContainer);
|
|
readOnlyPersonKeyToPersonContainerCollection = new(personKeyToPersonContainerCollection);
|
|
readOnlyPossiblyNewPersonDisplayDirectoryNamesAndPersonContainer = new(possiblyNewPersonDisplayDirectoryNamesAndPersonContainer);
|
|
Stateless.MapLogic.SetPersonKeyToPersonContainer(configuration,
|
|
personContainers,
|
|
readOnlyPersonKeyToCount,
|
|
personKeyToPersonContainer,
|
|
readOnlyPersonKeyToPersonContainerCollection);
|
|
}
|
|
Stateless.MapLogic.PossiblyRebuildPersonContainers(configuration,
|
|
ticks,
|
|
a2PeopleSingletonDirectory,
|
|
readOnlyPersonKeyToCount,
|
|
readOnlyPossiblyNewPersonDisplayDirectoryNamesAndPersonContainer);
|
|
idThenWholePercentagesToPersonContainers = Stateless.MapLogic.GetIdThenWholePercentagesToPersonContainers(configuration,
|
|
skipCollection,
|
|
readOnlyPersonKeyFormattedToPersonContainer,
|
|
personKeyFormattedIdThenWholePercentagesCollection);
|
|
readOnlySkipCollection = new(skipCollection);
|
|
notMappedPersonContainers.AddRange(Stateless.MapLogic.GetNotMappedPersonContainers(configuration,
|
|
ticks,
|
|
personContainers,
|
|
readOnlyPersonKeyToCount));
|
|
locationContainers.AddRange(Stateless.MapLogic.GetLocationContainers(maxDegreeOfParallelism,
|
|
propertyConfiguration,
|
|
configuration,
|
|
ticks,
|
|
personContainers,
|
|
readOnlySkipCollection,
|
|
records));
|
|
int lossCount = records.Count - locationContainers.Count;
|
|
int unableToMatchCount = records.Count - personKeyFormattedIdThenWholePercentagesCollection.Count;
|
|
if (lossCount != 0 || unableToMatchCount != 0)
|
|
if (lossCount != 0 || unableToMatchCount != 0)
|
|
{ }
|
|
if (!string.IsNullOrEmpty(a2PeopleContentDirectory) && configuration.LocationContainerDistanceTolerance is not null)
|
|
Stateless.RelationLogic.SaveMappedRelations(configuration, distance, a2PeopleContentDirectory, eDistanceContentDirectory, ticks, locationContainers, readOnlyPersonKeyFormattedToPersonContainer, readOnlyPersonKeyToPersonContainerCollection);
|
|
if (!string.IsNullOrEmpty(configuration.LocationContainerDebugDirectory))
|
|
throw new Exception($"{nameof(configuration.LocationContainerDebugDirectory)} is not IsNullOrEmpty!");
|
|
}
|
|
_PersonKeyToCount = readOnlyPersonKeyToCount;
|
|
_EDistanceContentTicksDirectory = eDistanceContentTicksDirectory;
|
|
_SkipCollection = Stateless.MapLogic.ConvertSkip(skipCollection);
|
|
Stateless.MapLogic.CheckCollection(propertyConfiguration, rootDirectoryParent);
|
|
_IdThenWholePercentagesToPersonContainers = idThenWholePercentagesToPersonContainers;
|
|
_SkipNotSkipCollection = Stateless.MapLogic.ConvertSkipNotSkip(skipNotSkipCollection);
|
|
_IdToLocationContainers = Stateless.MapLogic.ConvertLocationContainers(locationContainers);
|
|
_NotMappedPersonContainers = new(notMappedPersonContainers.OrderByDescending(l => l.Key).ToArray());
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string result = JsonSerializer.Serialize(this, new JsonSerializerOptions() { WriteIndented = true });
|
|
return result;
|
|
}
|
|
|
|
public ReadOnlyCollection<LocationContainer> GetLocationContainers(Item item)
|
|
{
|
|
LocationContainer[] results;
|
|
if (item.Property?.Id is null)
|
|
results = [];
|
|
else
|
|
{
|
|
List<LocationContainer>? locationContainers;
|
|
if (_IdToLocationContainers.TryGetValue(item.Property.Id.Value, out locationContainers))
|
|
results = locationContainers.ToArray();
|
|
else
|
|
results = [];
|
|
}
|
|
return new(results);
|
|
}
|
|
|
|
public ReadOnlyDictionary<long, List<int>> GetPersonKeyToIds()
|
|
{
|
|
Dictionary<long, List<int>> results = [];
|
|
long personKey;
|
|
const int zero = 0;
|
|
List<int>? collection;
|
|
PersonBirthday personBirthday;
|
|
List<string> shouldMove = [];
|
|
foreach (KeyValuePair<int, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>> idToCollection in _IdThenWholePercentagesToPersonContainers)
|
|
{
|
|
foreach (KeyValuePair<int, ReadOnlyCollection<PersonContainer>> wholePercentagesToPersonContainers in idToCollection.Value)
|
|
{
|
|
foreach (PersonContainer personContainer in wholePercentagesToPersonContainers.Value)
|
|
{
|
|
if (personContainer.Key is null || personContainer.Birthdays is null || personContainer.Birthdays.Length == 0)
|
|
continue;
|
|
if (personContainer.DisplayDirectoryName.Contains(@"{}\~\"))
|
|
shouldMove.Add(personContainer.DisplayDirectoryName);
|
|
personBirthday = personContainer.Birthdays[zero];
|
|
personKey = personBirthday.Value.Ticks;
|
|
if (!results.TryGetValue(personKey, out collection))
|
|
{
|
|
results.Add(personKey, []);
|
|
if (!results.TryGetValue(personKey, out collection))
|
|
throw new Exception();
|
|
}
|
|
if (collection.Contains(idToCollection.Key))
|
|
continue;
|
|
collection.Add(idToCollection.Key);
|
|
}
|
|
}
|
|
}
|
|
if (shouldMove.Count > 0)
|
|
throw new Exception(string.Join(Environment.NewLine, shouldMove));
|
|
return new(results);
|
|
}
|
|
|
|
(bool, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>?) Shared.Models.Methods.IMapLogic.GetWholePercentagesToPersonContainers(int id)
|
|
{
|
|
bool result = _IdThenWholePercentagesToPersonContainers.TryGetValue(id, out ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers);
|
|
return new(result, wholePercentagesToPersonContainers);
|
|
}
|
|
|
|
public int UpdateMappingFromPerson(ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers, Mapping mapping)
|
|
{
|
|
int result = 0;
|
|
if (mapping.MappingFromLocation is not null)
|
|
{
|
|
if (wholePercentagesToPersonContainers is null)
|
|
result += 1;
|
|
else
|
|
{
|
|
ReadOnlyCollection<PersonContainer>? personContainers;
|
|
if (!wholePercentagesToPersonContainers.TryGetValue(mapping.MappingFromLocation.WholePercentages, out personContainers))
|
|
result += 1;
|
|
else
|
|
{
|
|
const int zero = 0;
|
|
string mappingSegmentB;
|
|
PersonBirthday personBirthday;
|
|
foreach (PersonContainer personContainer in personContainers)
|
|
{
|
|
if (personContainer.Key is null || personContainer.Birthdays is null || personContainer.Birthdays.Length == 0)
|
|
continue;
|
|
personBirthday = personContainer.Birthdays[zero];
|
|
mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, mapping.MappingFromItem);
|
|
mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, personContainer.DisplayDirectoryName, personContainer.Key.Value, mappingSegmentB);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private SaveContainer? GetMatchSaveContainer(string dFacesContentDirectory, string d2FacePartsContentDirectory, string directory, Mapping mapping)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
SaveContainer? result;
|
|
if (mapping.MappingFromLocation is null)
|
|
result = null;
|
|
else
|
|
{
|
|
string checkFile;
|
|
string facesDirectory = Stateless.MapLogic.GetFacesDirectory(_PropertyConfiguration, dFacesContentDirectory, mapping.FilePath, mapping.MappingFromItem);
|
|
FileHolder faceFileHolder = IFileHolder.Get(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}{_Configuration.FacesFileNameExtension}"));
|
|
if (!faceFileHolder.Exists)
|
|
result = null;
|
|
else
|
|
{
|
|
string shortcutFile = string.Empty;
|
|
string facePartsDirectory = Stateless.MapLogic.GetFacePartsDirectory(_PropertyConfiguration, d2FacePartsContentDirectory, mapping.FilePath, mapping.MappingFromItem);
|
|
checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}");
|
|
FileHolder hiddenFaceFileHolder = IFileHolder.Get(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}{_Configuration.FacesHiddenFileNameExtension}"));
|
|
FileHolder facePartsFileHolder = IFileHolder.Get(Path.Combine(facePartsDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}{_Configuration.FacePartsFileNameExtension}"));
|
|
result = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private (long?, string?) GetDirectory(Configuration configuration, bool saveIndividually, int padLeft, string? segmentC, string by, MappingFromItem mappingFromItem)
|
|
{
|
|
long? ticks = null;
|
|
const int zero = 0;
|
|
string mappingSegmentB;
|
|
string? directory = null;
|
|
string personKeyFormatted;
|
|
PersonBirthday personBirthday;
|
|
PersonContainer personContainer;
|
|
for (int i = _NotMappedPersonContainers.Count - 1; i > 0; i--)
|
|
{
|
|
personContainer = _NotMappedPersonContainers[i];
|
|
if (personContainer.Key is null || personContainer.Birthdays is null || personContainer.Birthdays.Length == 0)
|
|
continue;
|
|
personBirthday = personContainer.Birthdays[zero];
|
|
ticks = personBirthday.Value.Ticks;
|
|
mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, mappingFromItem);
|
|
personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, personBirthday);
|
|
if (!saveIndividually || segmentC is null)
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, mappingSegmentB);
|
|
else
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, by, segmentC.PadLeft(padLeft, '0'), personKeyFormatted, mappingSegmentB);
|
|
_NotMappedPersonContainers.RemoveAt(i);
|
|
break;
|
|
}
|
|
return (ticks, directory);
|
|
}
|
|
|
|
private static bool PreAndPostContinue(Configuration configuration, Mapping mapping, Mapping keyMapping)
|
|
{
|
|
bool result = true;
|
|
if (result && mapping.MappingFromFilterPre.InSkipCollection is not null && mapping.MappingFromFilterPre.InSkipCollection.Value)
|
|
result = false;
|
|
if (result && mapping.MappingFromFilterPre.IsFocusModel is not null && !mapping.MappingFromFilterPre.IsFocusModel.Value)
|
|
result = false;
|
|
if (result && mapping.MappingFromFilterPre.IsFocusRelativePath is not null && !mapping.MappingFromFilterPre.IsFocusRelativePath.Value)
|
|
result = false;
|
|
if (result && mapping.MappingFromFilterPost.InSkipCollection is not null && mapping.MappingFromFilterPost.InSkipCollection.Value)
|
|
result = false;
|
|
if (result && mapping.MappingFromFilterPost.IsFocusPerson is not null && !mapping.MappingFromFilterPost.IsFocusPerson.Value)
|
|
result = false;
|
|
if (result && keyMapping.MappingFromFilterPost.CanReMap is not null && !configuration.ReMap)
|
|
result = false;
|
|
if (result && keyMapping.MappingFromFilterPost.CanReMap is not null && (!keyMapping.MappingFromFilterPost.CanReMap.Value || (mapping.MappingFromPerson is not null && IPerson.IsDefaultName(mapping.MappingFromPerson.DisplayDirectoryName))))
|
|
result = false;
|
|
if (result && keyMapping.MappingFromFilterPost.InSkipCollection is not null && keyMapping.MappingFromFilterPost.InSkipCollection.Value)
|
|
result = false;
|
|
if (result && keyMapping.MappingFromFilterPost.IsFocusPerson is not null && keyMapping.MappingFromFilterPost.IsFocusPerson.Value)
|
|
result = false;
|
|
return result;
|
|
}
|
|
|
|
private Record Get(Configuration configuration, bool saveIndividually, string by, Mapping question, int padLeft)
|
|
{
|
|
long? ticks;
|
|
string? directory;
|
|
string? debugDirectory;
|
|
string? personDirectory;
|
|
if (question.MappingFromPerson is null)
|
|
{
|
|
debugDirectory = null;
|
|
(ticks, directory) = GetDirectory(configuration, saveIndividually, padLeft, question.SegmentC, by, question.MappingFromItem);
|
|
personDirectory = directory is null ? null : Path.Combine(directory, $"X+{ticks}");
|
|
}
|
|
else
|
|
{
|
|
ticks = null;
|
|
string personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, question.MappingFromPerson.PersonKey);
|
|
debugDirectory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, question.MappingFromPerson.DisplayDirectoryName);
|
|
if (string.IsNullOrEmpty(question.SegmentC))
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, question.MappingFromPerson.SegmentB);
|
|
else if (!saveIndividually)
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, $"Z-{question.MappingFromPerson.SegmentB}-{question.SegmentC}");
|
|
else
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, by, question.SegmentC.PadLeft(padLeft, '0'), personKeyFormatted, question.MappingFromPerson.SegmentB);
|
|
personDirectory = Path.Combine(directory, question.MappingFromPerson.DisplayDirectoryName, "lnk");
|
|
}
|
|
return new(debugDirectory, directory, ticks, personDirectory);
|
|
}
|
|
|
|
private List<SaveContainer> GetSaveContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, ReadOnlyCollection<Mapping> distinctValidImageMappingCollection, ReadOnlyDictionary<int, ReadOnlyDictionary<int, Mapping>> idToWholePercentagesToMapping, ReadOnlyDictionary<long, List<int>> personKeyToIds, int? useFiltersCounter, bool saveMapped, bool saveIndividually, bool sortingContainersAny)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
List<SaveContainer> results = [];
|
|
string by;
|
|
Record record;
|
|
List<int>? ids;
|
|
bool isByMapping;
|
|
bool isBySorting;
|
|
Sorting? sorting;
|
|
string checkFile;
|
|
Mapping? question;
|
|
string? directory;
|
|
string shortcutFile;
|
|
string facesDirectory;
|
|
FileHolder faceFileHolder;
|
|
string facePartsDirectory;
|
|
SaveContainer? saveContainer;
|
|
int? distancePermyriad = null;
|
|
FileHolder facePartsFileHolder;
|
|
FileHolder hiddenFaceFileHolder;
|
|
ReadOnlyDictionary<int, Mapping>? wholePercentagesToMapping;
|
|
int padLeft = _Configuration.FaceDistancePermyriad.ToString().Length;
|
|
string forceSingleImageHumanized = nameof(Shared.Models.Stateless.IMapLogic.ForceSingleImage).Humanize(LetterCasing.Title);
|
|
foreach (Mapping mapping in distinctValidImageMappingCollection)
|
|
{
|
|
if (mapping.MappingFromLocation is null)
|
|
continue;
|
|
if (mapping.MappingFromFilterPre.InSkipCollection is not null && mapping.MappingFromFilterPre.InSkipCollection.Value)
|
|
continue;
|
|
if (mapping.MappingFromFilterPre.IsFocusModel is not null && !mapping.MappingFromFilterPre.IsFocusModel.Value)
|
|
continue;
|
|
if (mapping.MappingFromFilterPre.IsFocusRelativePath is not null && !mapping.MappingFromFilterPre.IsFocusRelativePath.Value)
|
|
continue;
|
|
if (mapping.MappingFromFilterPost.InSkipCollection is not null && mapping.MappingFromFilterPost.InSkipCollection.Value)
|
|
continue;
|
|
if (mapping.MappingFromFilterPost.IsFocusPerson is not null && !mapping.MappingFromFilterPost.IsFocusPerson.Value)
|
|
continue;
|
|
(by, isByMapping, isBySorting) = Stateless.MapLogic.Get(useFiltersCounter, saveIndividually, sortingContainersAny, forceSingleImageHumanized, distancePermyriad, mapping);
|
|
if (isByMapping && !saveMapped)
|
|
continue;
|
|
if (!isBySorting || mapping.SortingContainer is null)
|
|
(sorting, question) = (null, null);
|
|
else
|
|
{
|
|
sorting = mapping.SortingContainer.Sorting;
|
|
if (!idToWholePercentagesToMapping.TryGetValue(sorting.Id, out wholePercentagesToMapping))
|
|
throw new NotSupportedException();
|
|
if (!wholePercentagesToMapping.TryGetValue(sorting.WholePercentages, out question))
|
|
throw new NotSupportedException();
|
|
if (!PreAndPostContinue(_Configuration, mapping, question))
|
|
continue;
|
|
}
|
|
record = Get(_Configuration, saveIndividually, by, mapping, padLeft);
|
|
if (string.IsNullOrEmpty(record.Directory) || string.IsNullOrEmpty(record.PersonDirectory))
|
|
continue;
|
|
directory = record.Directory;
|
|
if (mapping.MappingFromPerson is not null)
|
|
{
|
|
if (saveIndividually)
|
|
{
|
|
directory = Path.Combine(directory, mapping.MappingFromItem.Id.ToString());
|
|
results.Add(new(Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName)));
|
|
}
|
|
if (isByMapping && personKeyToIds.TryGetValue(mapping.MappingFromPerson.PersonKey, out ids))
|
|
results.Add(new(Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName, $"{ids.Count} Face(s)")));
|
|
}
|
|
else
|
|
{
|
|
if (!_Configuration.SaveSortingWithoutPerson)
|
|
continue;
|
|
if (record.Ticks is null)
|
|
continue;
|
|
if (saveIndividually)
|
|
{
|
|
directory = Path.Combine(directory, mapping.MappingFromItem.Id.ToString());
|
|
results.Add(new(Path.Combine(directory, $"X+{record.Ticks}")));
|
|
}
|
|
}
|
|
results.Add(new(record.PersonDirectory));
|
|
if (question is not null)
|
|
{
|
|
if (question.MappingFromLocation is null)
|
|
continue;
|
|
if (saveIndividually && question.MappingFromLocation.WholePercentages == mapping.MappingFromLocation.WholePercentages)
|
|
results.Add(new(Path.Combine(directory, "Maybe")));
|
|
}
|
|
facesDirectory = Stateless.MapLogic.GetFacesDirectory(_PropertyConfiguration, dFacesContentDirectory, mapping.FilePath, mapping.MappingFromItem);
|
|
faceFileHolder = IFileHolder.Get(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}{_Configuration.FacesFileNameExtension}"));
|
|
if (!faceFileHolder.Exists)
|
|
continue;
|
|
if (isByMapping)
|
|
{
|
|
checkFile = Path.Combine(record.PersonDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}");
|
|
saveContainer = new(checkFile, directory, faceFileHolder);
|
|
}
|
|
else if (saveIndividually)
|
|
{
|
|
facePartsDirectory = Stateless.MapLogic.GetFacePartsDirectory(_PropertyConfiguration, d2FacePartsContentDirectory, mapping.FilePath, mapping.MappingFromItem);
|
|
facePartsFileHolder = IFileHolder.Get(Path.Combine(facePartsDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}{_Configuration.FacePartsFileNameExtension}"));
|
|
(saveContainer, SaveContainer? extraSaveContainer) = Stateless.MapLogic.GetContainers(_Configuration.FacesFileNameExtension, _Configuration.FacePartsFileNameExtension, directory, faceFileHolder, facePartsFileHolder, mapping);
|
|
if (extraSaveContainer is not null)
|
|
results.Add(extraSaveContainer);
|
|
}
|
|
else
|
|
{
|
|
facePartsDirectory = Stateless.MapLogic.GetFacePartsDirectory(_PropertyConfiguration, d2FacePartsContentDirectory, mapping.FilePath, mapping.MappingFromItem);
|
|
shortcutFile = Path.Combine(record.PersonDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}.lnk");
|
|
checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}");
|
|
hiddenFaceFileHolder = IFileHolder.Get(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}{_Configuration.FacesHiddenFileNameExtension}"));
|
|
facePartsFileHolder = IFileHolder.Get(Path.Combine(facePartsDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}{_Configuration.FacePartsFileNameExtension}"));
|
|
saveContainer = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
|
|
}
|
|
results.Add(saveContainer);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
public void SaveMapped(string dFacesContentDirectory, string d2FacePartsContentDirectory, string d2FacePartsContentCollectionDirectory, ReadOnlyDictionary<long, List<int>> personKeyToIds, ReadOnlyCollection<Mapping> distinctValidImageMappingCollection, ReadOnlyDictionary<int, ReadOnlyDictionary<int, Mapping>> idToWholePercentagesToMapping)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
int? updated = null;
|
|
bool saveMapped = true;
|
|
int? useFiltersCounter = null;
|
|
string mappingDirectory = Path.Combine(_EDistanceContentTicksDirectory, nameof(Shared.Models.Stateless.IMapLogic.Mapping));
|
|
List<SaveContainer> saveContainers = GetSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, distinctValidImageMappingCollection, idToWholePercentagesToMapping, personKeyToIds, useFiltersCounter, saveMapped, sortingContainersAny: true, saveIndividually: false);
|
|
SaveContainers(updated, saveContainers);
|
|
if (!string.IsNullOrEmpty(_EDistanceContentTicksDirectory) && Directory.Exists(mappingDirectory))
|
|
Stateless.MapLogic.SaveMappingShortcuts(mappingDirectory);
|
|
}
|
|
|
|
public List<Sorting> GetSortingCollection(Shared.Models.Methods.IDistanceLimits distanceLimits, int i, Face face, FaceDistance faceDistanceEncoding, List<FaceDistance> faceDistanceLengths)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
List<Sorting> results = [];
|
|
Sorting sorting;
|
|
FaceDistance faceDistanceLength;
|
|
for (int j = 0; j < faceDistanceLengths.Count; j++)
|
|
{
|
|
if (faceDistanceEncoding.WholePercentages is null)
|
|
throw new NotSupportedException();
|
|
if (face.Mapping?.MappingFromFilterPost is null)
|
|
throw new NotSupportedException();
|
|
if (j == i)
|
|
continue;
|
|
if (face.Mapping.MappingFromFilterPre.InSkipCollection is not null && face.Mapping.MappingFromFilterPre.InSkipCollection.Value)
|
|
throw new NotSupportedException(nameof(Shared.Models.Methods.IDistance));
|
|
if (face.Mapping.MappingFromFilterPre.IsFocusModel is not null && !face.Mapping.MappingFromFilterPre.IsFocusModel.Value)
|
|
throw new NotSupportedException(nameof(Shared.Models.Methods.IDistance));
|
|
if (face.Mapping.MappingFromFilterPre.IsFocusRelativePath is not null && !face.Mapping.MappingFromFilterPre.IsFocusRelativePath.Value)
|
|
throw new NotSupportedException(nameof(Shared.Models.Methods.IDistance));
|
|
if (face.Mapping.MappingFromFilterPost.InSkipCollection is not null && face.Mapping.MappingFromFilterPost.InSkipCollection.Value)
|
|
throw new NotSupportedException(nameof(Shared.Models.Methods.IDistance));
|
|
if (face.Mapping.MappingFromFilterPost.IsFocusPerson is not null && !face.Mapping.MappingFromFilterPost.IsFocusPerson.Value)
|
|
throw new NotSupportedException(nameof(Shared.Models.Methods.IDistance));
|
|
if (face.Mapping.MappingFromFilterPost.InSkipCollection is not null && face.Mapping.MappingFromFilterPost.InSkipCollection.Value)
|
|
throw new NotSupportedException(nameof(Shared.Models.Methods.IDistance));
|
|
faceDistanceLength = faceDistanceLengths[j];
|
|
if (faceDistanceLength.WholePercentages is null || faceDistanceLength.Length is null)
|
|
throw new NotSupportedException();
|
|
if (faceDistanceLength.Length == 0)
|
|
continue;
|
|
if (faceDistanceLength.Id == faceDistanceEncoding.Id)
|
|
continue;
|
|
if (faceDistanceLength.MappingFromFilterPost is null)
|
|
throw new NotSupportedException();
|
|
if (faceDistanceLength.MappingFromFilterPost.CanReMap is not null && !_Configuration.ReMap)
|
|
continue;
|
|
if (faceDistanceLength.MappingFromFilterPost.CanReMap is not null && !faceDistanceLength.MappingFromFilterPost.CanReMap.Value)
|
|
continue;
|
|
if (faceDistanceLength.MappingFromFilterPost.InSkipCollection is not null && faceDistanceLength.MappingFromFilterPost.InSkipCollection.Value)
|
|
continue;
|
|
if (faceDistanceLength.MappingFromFilterPost.IsFocusPerson is not null && !faceDistanceLength.MappingFromFilterPost.IsFocusPerson.Value)
|
|
continue;
|
|
sorting = ISorting.Get(_Configuration.FaceDistancePermyriad, faceDistanceEncoding, faceDistanceLength);
|
|
if (sorting.DistancePermyriad == 0)
|
|
continue;
|
|
if (sorting.Id == faceDistanceEncoding.Id)
|
|
{
|
|
if (sorting.WholePercentages == faceDistanceEncoding.WholePercentages.Value)
|
|
continue;
|
|
continue;
|
|
}
|
|
results.Add(sorting);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
public int UpdateFromSortingContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, string d2FacePartsContentCollectionDirectory, ReadOnlyDictionary<int, ReadOnlyDictionary<int, Mapping>> idToWholePercentagesToMapping, ReadOnlyCollection<SortingContainer> sortingContainers)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
int result = 0;
|
|
string key;
|
|
string segmentB;
|
|
string? segmentC;
|
|
string personKeyFormatted;
|
|
MappingFromPerson mappingFromPerson;
|
|
Dictionary<string, int> keyToCount = [];
|
|
foreach (SortingContainer sortingContainer in sortingContainers)
|
|
{
|
|
if (sortingContainer.Question is null)
|
|
continue;
|
|
if (sortingContainer.Source.MappingFromPerson is null)
|
|
{
|
|
sortingContainer.Question.UpdateMappingFromUnknownPerson(_Configuration.SaveIndividually, sortingContainer);
|
|
result += 1;
|
|
}
|
|
else
|
|
{
|
|
mappingFromPerson = sortingContainer.Source.MappingFromPerson;
|
|
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, mappingFromPerson.PersonKey);
|
|
segmentB = IMapLogic.GetDecade(sortingContainer.Question.MappingFromItem);
|
|
key = string.Concat(personKeyFormatted, '\t', segmentB);
|
|
if (!keyToCount.ContainsKey(key))
|
|
keyToCount.Add(key, new());
|
|
_ = keyToCount.TryAdd(key, 0);
|
|
keyToCount[key]++;
|
|
if (!_Configuration.SaveIndividually && keyToCount[key] <= _Configuration.SortingMaximumPerKey)
|
|
segmentC = null;
|
|
else
|
|
segmentC = sortingContainer.Sorting.DistancePermyriad.ToString();
|
|
sortingContainer.Question.UpdateMappingFromPerson(mappingFromPerson.ApproximateYears, mappingFromPerson.DisplayDirectoryName, mappingFromPerson.PersonKey, segmentB, segmentC, sortingContainer);
|
|
result += 1;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public List<SaveContainer> GetSaveContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, string d2FacePartsContentCollectionDirectory, ReadOnlyDictionary<int, ReadOnlyDictionary<int, Mapping>> idToWholePercentagesToMapping, Shared.Models.Methods.IDistanceLimits distanceLimits, int? useFiltersCounter, ReadOnlyCollection<SortingContainer> sortingContainers)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
if (distanceLimits is not null)
|
|
{
|
|
string counts = distanceLimits.GetCounts();
|
|
_ = Directory.CreateDirectory(Path.Combine(_EDistanceContentTicksDirectory, counts));
|
|
}
|
|
List<SaveContainer> results = [];
|
|
string by;
|
|
Record record;
|
|
bool isBySorting;
|
|
string checkFile;
|
|
Mapping? question;
|
|
string? directory;
|
|
string shortcutFile;
|
|
string facesDirectory;
|
|
bool isCounterPersonYear;
|
|
string facePartsDirectory;
|
|
FileHolder? faceFileHolder;
|
|
SaveContainer? saveContainer;
|
|
FileHolder? facePartsFileHolder;
|
|
FileHolder? hiddenFaceFileHolder;
|
|
bool sortingContainersAny = sortingContainers.Count > 0;
|
|
int padLeft = _Configuration.FaceDistancePermyriad.ToString().Length;
|
|
string forceSingleImageHumanized = nameof(Shared.Models.Stateless.IMapLogic.ForceSingleImage).Humanize(LetterCasing.Title);
|
|
foreach (SortingContainer sortingContainer in sortingContainers)
|
|
{
|
|
if (sortingContainer.Question is null)
|
|
throw new NotSupportedException();
|
|
isCounterPersonYear = sortingContainer.Source.MappingFromPerson is not null && IPersonBirthday.IsCounterPersonYear(sortingContainer.Source.MappingFromPerson.PersonKey);
|
|
(by, _, isBySorting) = Stateless.MapLogic.Get(useFiltersCounter, _Configuration.SaveIndividually, sortingContainersAny, forceSingleImageHumanized, sortingContainer.Sorting.DistancePermyriad, sortingContainer.Question);
|
|
question = sortingContainer.Question.MappingFromPerson is null ? sortingContainer.Source : sortingContainer.Question;
|
|
if (question is null)
|
|
throw new NotSupportedException();
|
|
if (question.MappingFromLocation is null)
|
|
continue;
|
|
record = Get(_Configuration, _Configuration.SaveIndividually, by, question, padLeft);
|
|
if (string.IsNullOrEmpty(record.Directory) || string.IsNullOrEmpty(record.PersonDirectory))
|
|
continue;
|
|
directory = record.Directory;
|
|
if (!string.IsNullOrEmpty(record.DebugDirectory))
|
|
results.Add(new(record.DebugDirectory));
|
|
if (question.MappingFromPerson is not null)
|
|
{
|
|
if (_Configuration.SaveIndividually)
|
|
{
|
|
directory = Path.Combine(directory, question.MappingFromItem.Id.ToString());
|
|
results.Add(new(Path.Combine(directory, question.MappingFromPerson.DisplayDirectoryName)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!_Configuration.SaveSortingWithoutPerson)
|
|
throw new NotSupportedException();
|
|
if (record.Ticks is null)
|
|
continue;
|
|
if (_Configuration.SaveIndividually)
|
|
{
|
|
directory = Path.Combine(directory, question.MappingFromItem.Id.ToString());
|
|
results.Add(new(Path.Combine(directory, $"X+{record.Ticks}")));
|
|
}
|
|
}
|
|
results.Add(new(record.PersonDirectory));
|
|
if (_Configuration.SaveIndividually && question.MappingFromLocation.WholePercentages == question.MappingFromLocation.WholePercentages)
|
|
results.Add(new(Path.Combine(directory, "Maybe")));
|
|
facesDirectory = Stateless.MapLogic.GetFacesDirectory(_PropertyConfiguration, dFacesContentDirectory, question.FilePath, question.MappingFromItem);
|
|
faceFileHolder = IFileHolder.Get(Path.Combine(facesDirectory, $"{question.MappingFromLocation.DeterministicHashCodeKey}{question.MappingFromItem.FilePath.ExtensionLowered}{_Configuration.FacesFileNameExtension}"));
|
|
facePartsDirectory = Stateless.MapLogic.GetFacePartsDirectory(_PropertyConfiguration, d2FacePartsContentDirectory, question.FilePath, question.MappingFromItem);
|
|
shortcutFile = Path.Combine(record.PersonDirectory, $"{question.MappingFromLocation.DeterministicHashCodeKey}{question.MappingFromItem.FilePath.ExtensionLowered}.lnk");
|
|
checkFile = Path.Combine(directory, $"{question.MappingFromLocation.DeterministicHashCodeKey}{question.MappingFromItem.FilePath.ExtensionLowered}");
|
|
hiddenFaceFileHolder = IFileHolder.Get(Path.Combine(facesDirectory, $"{question.MappingFromLocation.DeterministicHashCodeKey}{question.MappingFromItem.FilePath.ExtensionLowered}{_Configuration.FacesHiddenFileNameExtension}"));
|
|
facePartsFileHolder = IFileHolder.Get(Path.Combine(facePartsDirectory, $"{question.MappingFromLocation.DeterministicHashCodeKey}{question.MappingFromItem.FilePath.ExtensionLowered}{_Configuration.FacePartsFileNameExtension}"));
|
|
saveContainer = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, question.MappingFromItem.ResizedFileHolder, shortcutFile);
|
|
results.Add(saveContainer);
|
|
if (!_Configuration.SaveIndividually && isBySorting && question.MappingFromPerson is null)
|
|
{
|
|
saveContainer = GetMatchSaveContainer(dFacesContentDirectory, d2FacePartsContentDirectory, directory, question);
|
|
if (saveContainer is not null)
|
|
results.Add(saveContainer);
|
|
}
|
|
if (!_Configuration.SaveIndividually)
|
|
saveContainer = Stateless.MapLogic.GetDebugSaveContainer(sortingContainer, directory, question);
|
|
else
|
|
{
|
|
(saveContainer, SaveContainer? extraSaveContainer) = Stateless.MapLogic.GetContainers(_Configuration.FacesFileNameExtension, _Configuration.FacePartsFileNameExtension, _PropertyConfiguration, dFacesContentDirectory, d2FacePartsContentCollectionDirectory, directory, question);
|
|
if (saveContainer is null || extraSaveContainer is null)
|
|
continue;
|
|
results.Add(extraSaveContainer);
|
|
}
|
|
results.Add(saveContainer);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
public ReadOnlyCollection<SortingContainer> GetFilterSortingContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, string d2FacePartsContentCollectionDirectory, ReadOnlyDictionary<int, ReadOnlyDictionary<int, Mapping>> idToWholePercentagesToMapping, Shared.Models.Methods.IDistanceLimits distanceLimits, ReadOnlyCollection<SortingContainer> sortingContainers)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
if (distanceLimits is not null)
|
|
{
|
|
string counts = distanceLimits.GetCounts();
|
|
_ = Directory.CreateDirectory(Path.Combine(_EDistanceContentTicksDirectory, counts));
|
|
}
|
|
List<SortingContainer> results = [];
|
|
Sorting sorting;
|
|
Mapping? keyMapping;
|
|
List<int>? wholePercentagesCollection;
|
|
MappingFromFilterPre mappingFromFilterPre;
|
|
Dictionary<string, int> keyToCount = [];
|
|
MappingFromFilterPost mappingFromFilterPost;
|
|
ReadOnlyCollection<PersonContainer>? personContainers;
|
|
ReadOnlyDictionary<int, Mapping>? wholePercentagesToMapping;
|
|
Dictionary<int, List<int>> idToWholePercentagesCollection = [];
|
|
int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - _Ticks).TotalSeconds);
|
|
ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers;
|
|
string message = $") {sortingContainers.Count:000} Filter Sorting Container(s) - {totalSeconds} total second(s)";
|
|
ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
|
|
using ProgressBar progressBar = new(sortingContainers.Count, message, options);
|
|
foreach (SortingContainer sortingContainer in sortingContainers)
|
|
{
|
|
progressBar.Tick();
|
|
if (sortingContainer.Source?.MappingFromLocation is null)
|
|
throw new NotSupportedException();
|
|
mappingFromFilterPre = sortingContainer.Source.MappingFromFilterPre;
|
|
mappingFromFilterPost = sortingContainer.Source.MappingFromFilterPost;
|
|
if (sortingContainer.Source.MappingFromFilterPre.InSkipCollection is not null && sortingContainer.Source.MappingFromFilterPre.InSkipCollection.Value)
|
|
throw new NotSupportedException(nameof(GetSortingCollection));
|
|
if (sortingContainer.Source.MappingFromFilterPre.IsFocusModel is not null && !sortingContainer.Source.MappingFromFilterPre.IsFocusModel.Value)
|
|
throw new NotSupportedException(nameof(GetSortingCollection));
|
|
if (sortingContainer.Source.MappingFromFilterPre.IsFocusRelativePath is not null && !sortingContainer.Source.MappingFromFilterPre.IsFocusRelativePath.Value)
|
|
throw new NotSupportedException(nameof(GetSortingCollection));
|
|
if (sortingContainer.Source.MappingFromFilterPost.InSkipCollection is not null && sortingContainer.Source.MappingFromFilterPost.InSkipCollection.Value)
|
|
throw new NotSupportedException(nameof(GetSortingCollection));
|
|
if (sortingContainer.Source.MappingFromFilterPost.InSkipCollection is not null && sortingContainer.Source.MappingFromFilterPost.InSkipCollection.Value)
|
|
throw new NotSupportedException(nameof(GetSortingCollection));
|
|
if (sortingContainer.Source.MappingFromFilterPost.IsFocusPerson is not null && !sortingContainer.Source.MappingFromFilterPost.IsFocusPerson.Value)
|
|
throw new NotSupportedException(nameof(GetSortingCollection));
|
|
sorting = sortingContainer.Sorting;
|
|
if (!idToWholePercentagesToMapping.TryGetValue(sorting.Id, out wholePercentagesToMapping))
|
|
throw new NotSupportedException();
|
|
if (!wholePercentagesToMapping.TryGetValue(sorting.WholePercentages, out keyMapping))
|
|
throw new NotSupportedException();
|
|
if (sortingContainer.Source.MappingFromItem.Id == keyMapping.MappingFromItem.Id)
|
|
throw new NotSupportedException(nameof(GetSortingCollection));
|
|
if (keyMapping.MappingFromFilterPost.CanReMap is not null && !_Configuration.ReMap)
|
|
throw new NotSupportedException(nameof(GetSortingCollection));
|
|
if (keyMapping.MappingFromFilterPost.CanReMap is not null && !keyMapping.MappingFromFilterPost.CanReMap.Value)
|
|
throw new NotSupportedException(nameof(GetSortingCollection));
|
|
if (!PreAndPostContinue(_Configuration, sortingContainer.Source, keyMapping))
|
|
continue;
|
|
if (!idToWholePercentagesCollection.TryGetValue(sorting.Id, out wholePercentagesCollection))
|
|
{
|
|
idToWholePercentagesCollection.Add(sorting.Id, []);
|
|
if (!idToWholePercentagesCollection.TryGetValue(sorting.Id, out wholePercentagesCollection))
|
|
throw new Exception();
|
|
}
|
|
if (sortingContainer.Source.MappingFromPerson is null)
|
|
{
|
|
if (!_Configuration.SaveSortingWithoutPerson)
|
|
continue;
|
|
if (wholePercentagesCollection.Contains(sorting.WholePercentages))
|
|
continue;
|
|
keyMapping.UpdateMappingFromUnknownPerson(_Configuration.SaveIndividually, sortingContainer);
|
|
wholePercentagesCollection.Add(sorting.WholePercentages);
|
|
results.Add(new(keyMapping, sortingContainer.Sorting, sortingContainer.Source));
|
|
}
|
|
else
|
|
{
|
|
if (wholePercentagesCollection.Contains(sorting.WholePercentages))
|
|
continue;
|
|
if (keyMapping.MappingFromFilterPost.CanReMap is not null && (IPerson.IsDefaultName(sortingContainer.Source.MappingFromPerson.DisplayDirectoryName) || _IdThenWholePercentagesToPersonContainers.TryGetValue(sorting.Id, out wholePercentagesToPersonContainers) && wholePercentagesToPersonContainers.TryGetValue(sorting.WholePercentages, out personContainers) && personContainers.Any(l => l.Key == sortingContainer.Source.MappingFromPerson.PersonKey)))
|
|
continue;
|
|
if (sortingContainer.Source.MappingFromPerson is null)
|
|
throw new NotSupportedException();
|
|
wholePercentagesCollection.Add(sorting.WholePercentages);
|
|
results.Add(new(keyMapping, sortingContainer.Sorting, sortingContainer.Source));
|
|
}
|
|
}
|
|
return new(results);
|
|
}
|
|
|
|
private (string, PersonBirthday?) GetPersonBirthday(string[] directoryNames)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
PersonBirthday? personBirthday = null;
|
|
string personKeyFormatted = string.Empty;
|
|
foreach (string directoryName in directoryNames)
|
|
{
|
|
personBirthday = IPersonBirthday.GetPersonBirthday(_Configuration.PersonBirthdayFormat, directoryName);
|
|
if (personBirthday is not null)
|
|
{
|
|
personKeyFormatted = directoryName;
|
|
break;
|
|
}
|
|
}
|
|
return new(personKeyFormatted, personBirthday);
|
|
}
|
|
|
|
private (string, PersonBirthday?) GetPersonBirthday(string windowsShortcutPath)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
string[] directoryNames = IPath.GetDirectoryNames(windowsShortcutPath);
|
|
(string personKeyFormatted, PersonBirthday? personBirthday) = GetPersonBirthday(directoryNames);
|
|
if (personBirthday is null)
|
|
{
|
|
string[] directories = Directory.GetDirectories(windowsShortcutPath, "*", SearchOption.TopDirectoryOnly);
|
|
foreach (string directory in directories)
|
|
{
|
|
directoryNames = IPath.GetDirectoryNames(directory);
|
|
(personKeyFormatted, personBirthday) = GetPersonBirthday(directoryNames);
|
|
if (personBirthday is not null)
|
|
break;
|
|
}
|
|
}
|
|
return new(personKeyFormatted, personBirthday);
|
|
}
|
|
|
|
private List<string> GetPersonKeyFormattedCollection(string[] jLinks, string a2PeopleContentDirectory, ReadOnlyCollection<PersonContainer> personContainers, ReadOnlyDictionary<long, List<int>> personKeyToIds)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
List<string> results = [];
|
|
string[] files;
|
|
List<int>? ids;
|
|
string checkDirectory;
|
|
string[] checkDirectories;
|
|
string personKeyFormatted;
|
|
PersonContainer[] matches;
|
|
PersonBirthday? personBirthday;
|
|
string fileNameWithoutExtension;
|
|
WindowsShortcut windowsShortcut;
|
|
List<(long, string)> collection = [];
|
|
foreach (string directoryName in jLinks)
|
|
{
|
|
checkDirectory = Path.Combine(a2PeopleContentDirectory, directoryName);
|
|
if (!Directory.Exists(checkDirectory))
|
|
continue;
|
|
checkDirectories = Directory.GetDirectories(checkDirectory, "*", SearchOption.TopDirectoryOnly);
|
|
files = Directory.GetFiles(checkDirectory, "*.lnk", SearchOption.TopDirectoryOnly);
|
|
foreach (string file in files)
|
|
{
|
|
collection.Clear();
|
|
windowsShortcut = WindowsShortcut.Load(file);
|
|
fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file);
|
|
if (string.IsNullOrEmpty(windowsShortcut.Path))
|
|
continue;
|
|
if (!Directory.Exists(windowsShortcut.Path))
|
|
{
|
|
if (files.Length != checkDirectories.Length)
|
|
throw new NotSupportedException(fileNameWithoutExtension);
|
|
continue;
|
|
}
|
|
(personKeyFormatted, personBirthday) = GetPersonBirthday(windowsShortcut.Path);
|
|
if (personBirthday is null)
|
|
throw new NotSupportedException(fileNameWithoutExtension);
|
|
if (!personKeyToIds.TryGetValue(personBirthday.Value.Ticks, out ids))
|
|
collection.Add(new(personBirthday.Value.Ticks, Path.Combine(checkDirectory, personKeyFormatted, fileNameWithoutExtension)));
|
|
else
|
|
collection.Add(new(personBirthday.Value.Ticks, Path.Combine(checkDirectory, personKeyFormatted, fileNameWithoutExtension, $"{ids.Count} Face(s)")));
|
|
foreach ((long personKey, string displayDirectoryName) in collection)
|
|
{
|
|
matches = (from l in personContainers where l.Key == personKey select l).ToArray();
|
|
if (matches.Length == 0)
|
|
continue;
|
|
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personKey);
|
|
if (!displayDirectoryName.Contains(personKeyFormatted))
|
|
continue;
|
|
if (!Directory.Exists(displayDirectoryName))
|
|
_ = Directory.CreateDirectory(displayDirectoryName);
|
|
results.Add(personKeyFormatted);
|
|
}
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private FilteredOriginalImage[] GetCollectionForSaveFilteredOriginalImagesFromJLinks(string[] jLinks, string a2PeopleContentDirectory, ReadOnlyCollection<PersonContainer> personContainers, ReadOnlyCollection<Mapping> distinctValidImageMappingCollection, ReadOnlyDictionary<long, List<int>> personKeyToIds)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
FilteredOriginalImage[] results;
|
|
int count = 0;
|
|
int group = 65;
|
|
string checkFile;
|
|
string directory;
|
|
string? directoryName;
|
|
string personDirectory;
|
|
string personKeyFormatted;
|
|
List<int> distinctCollection = [];
|
|
bool usePersonKeyAndDeterministicHashCodeKey = false;
|
|
List<FilteredOriginalImage> filteredOriginalImages = [];
|
|
List<string> personKeyFormattedCollection = GetPersonKeyFormattedCollection(jLinks, a2PeopleContentDirectory, personContainers, personKeyToIds);
|
|
foreach (Mapping mapping in distinctValidImageMappingCollection)
|
|
{
|
|
if (distinctCollection.Contains(mapping.MappingFromItem.Id))
|
|
continue;
|
|
directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
|
|
if (directoryName is null)
|
|
throw new NotSupportedException();
|
|
if (mapping.By is null or Shared.Models.Stateless.IMapLogic.Sorting)
|
|
continue;
|
|
if (mapping.MappingFromPerson is null || mapping.MappingFromLocation is null)
|
|
continue;
|
|
if (string.IsNullOrEmpty(mapping.MappingFromPerson.SegmentB))
|
|
throw new NotSupportedException();
|
|
if (string.IsNullOrEmpty(mapping.MappingFromPerson.DisplayDirectoryName))
|
|
throw new NotSupportedException();
|
|
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, mapping.MappingFromPerson.PersonKey);
|
|
if (personKeyFormatted == "1501-04-10_00")
|
|
continue;
|
|
if (!personKeyFormattedCollection.Contains(personKeyFormatted))
|
|
continue;
|
|
if (!usePersonKeyAndDeterministicHashCodeKey)
|
|
{
|
|
if (count > 499)
|
|
{
|
|
count = 0;
|
|
group += 1;
|
|
}
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, ((char)group).ToString());
|
|
personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName);
|
|
checkFile = Path.Combine(directory, $"{mapping.MappingFromItem.Id}{mapping.MappingFromItem.FilePath.ExtensionLowered}");
|
|
}
|
|
else
|
|
{
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, "Images", personKeyFormatted);
|
|
personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName);
|
|
checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}");
|
|
}
|
|
if (mapping is null)
|
|
continue;
|
|
if (mapping.MappingFromPerson.ApproximateYears is null)
|
|
filteredOriginalImages.Add(new(mapping.MappingFromItem.Id, mapping.MappingFromItem.FilePath, -1, personKeyFormatted, directory, personDirectory, checkFile));
|
|
else
|
|
filteredOriginalImages.Add(new(mapping.MappingFromItem.Id, mapping.MappingFromItem.FilePath, mapping.MappingFromPerson.ApproximateYears.Value, personKeyFormatted, directory, personDirectory, checkFile));
|
|
distinctCollection.Add(mapping.MappingFromItem.Id);
|
|
count += 1;
|
|
}
|
|
results = (from l in filteredOriginalImages orderby l.ApproximateYears descending, l.PersonKeyFormatted descending select l).ToArray();
|
|
return results;
|
|
}
|
|
|
|
public void SaveFilteredOriginalImagesFromJLinks(string[] jLinks, ReadOnlyCollection<PersonContainer> personContainers, string a2PeopleContentDirectory, ReadOnlyDictionary<long, List<int>> personKeyToIds, ReadOnlyCollection<Mapping> distinctValidImageMappingCollection)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
FileHolder fileHolder;
|
|
SaveContainer? saveContainer;
|
|
List<SaveContainer> saveContainers = [];
|
|
FilteredOriginalImage[] filteredOriginalImages = GetCollectionForSaveFilteredOriginalImagesFromJLinks(jLinks, a2PeopleContentDirectory, personContainers, distinctValidImageMappingCollection, personKeyToIds);
|
|
foreach (FilteredOriginalImage filteredOriginalImage in filteredOriginalImages)
|
|
{
|
|
fileHolder = FileHolder.Get(filteredOriginalImage.FilePath);
|
|
saveContainer = new(filteredOriginalImage.PersonDirectory);
|
|
saveContainers.Add(saveContainer);
|
|
saveContainer = new(fileHolder, filteredOriginalImage.CheckFile, filteredOriginalImage.Directory);
|
|
saveContainers.Add(saveContainer);
|
|
}
|
|
SaveContainers(null, saveContainers);
|
|
}
|
|
|
|
public void SaveShortcutsForOutputResolutionsPreMapLogic(string eDistanceContentDirectory, ReadOnlyDictionary<long, List<int>> personKeyToIds, ReadOnlyCollection<Mapping> distinctValidImageMappingCollection)
|
|
{
|
|
string hiddenFile;
|
|
WindowsShortcut windowsShortcut;
|
|
List<SaveShortcutsForOutputResolutions> collection = [];
|
|
collection = GetCollectionForSaveShortcutsForOutputResolutionsPreMapLogic(eDistanceContentDirectory, personKeyToIds, distinctValidImageMappingCollection);
|
|
string[] distinctDirectories = (from l in collection select l.Directory).Distinct().ToArray();
|
|
foreach (string directory in distinctDirectories)
|
|
{
|
|
if (string.IsNullOrEmpty(directory))
|
|
continue;
|
|
if (!Directory.Exists(directory))
|
|
_ = Directory.CreateDirectory(directory);
|
|
}
|
|
foreach (SaveShortcutsForOutputResolutions s in collection)
|
|
{
|
|
hiddenFile = $"{s.FileName}.lvs";
|
|
if (File.Exists(hiddenFile))
|
|
continue;
|
|
if (s.Description is not null)
|
|
{
|
|
File.WriteAllLines(hiddenFile, [s.FullName, s.Description]);
|
|
File.SetAttributes(hiddenFile, FileAttributes.Hidden);
|
|
File.SetLastWriteTime(hiddenFile, s.DateTime);
|
|
}
|
|
if (File.Exists(s.FileName))
|
|
continue;
|
|
try
|
|
{
|
|
windowsShortcut = new() { Path = s.FullName, Description = s.Description };
|
|
windowsShortcut.Save(s.FileName);
|
|
windowsShortcut.Dispose();
|
|
File.SetLastWriteTime(s.FileName, s.DateTime);
|
|
}
|
|
catch (Exception)
|
|
{ }
|
|
}
|
|
}
|
|
|
|
private (List<(string, DateTime[])>, List<SaveShortcutsForOutputResolutions>) GetCollectionForSaveShortcutsForOutputResolutionsDuringMapLogic(ReadOnlyDictionary<long, List<int>> personKeyToIds, string dFacesContentDirectory, ReadOnlyCollection<Item> validImageItems, ReadOnlyCollection<Mapping> distinctValidImageMappingCollection)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
List<int>? ids;
|
|
string fileName;
|
|
string fullName;
|
|
string directory;
|
|
DateTime dateTime;
|
|
string facesDirectory;
|
|
string? directoryName;
|
|
string personDirectory;
|
|
string personKeyFormatted;
|
|
List<string> distinct = [];
|
|
List<SaveShortcutsForOutputResolutions> collection = [];
|
|
List<(string, DateTime[])> directoriesAndDateTimes = [];
|
|
foreach (Item item in validImageItems)
|
|
{
|
|
if (item.ResizedFileHolder is null)
|
|
continue;
|
|
if (item.Faces.Any(l => l.FaceEncoding is not null))
|
|
continue;
|
|
foreach (Face face in item.Faces)
|
|
{
|
|
if (face.Mapping is null)
|
|
continue;
|
|
directoryName = Path.GetDirectoryName(face.Mapping.MappingFromItem.RelativePath);
|
|
if (directoryName is null)
|
|
throw new NotSupportedException();
|
|
if (item.ResizedFileHolder?.DirectoryName is null || !item.ResizedFileHolder.Exists)
|
|
continue;
|
|
directory = Path.Combine(item.ResizedFileHolder.DirectoryName, $"{_PropertyConfiguration.ResultAllInOne}Shortcuts", _PropertyConfiguration.ResultAllInOne);
|
|
personDirectory = Path.Combine(directory, "No Faces");
|
|
fileName = Path.Combine(personDirectory, $"{item.ResizedFileHolder.Name}.lnk");
|
|
collection.Add(new(item.ResizedFileHolder.FullName, personDirectory, new(item.FilePath.LastWriteTicks), fileName, face.Mapping.MappingFromItem.Id.ToString(), MakeAllHidden: false));
|
|
if (face.Mapping.MappingFromItem.ContainerDateTimes.Length > 0 && !distinct.Contains(item.ResizedFileHolder.DirectoryName))
|
|
{
|
|
distinct.Add(item.ResizedFileHolder.DirectoryName);
|
|
directoriesAndDateTimes.Add(new(item.ResizedFileHolder.DirectoryName, face.Mapping.MappingFromItem.ContainerDateTimes));
|
|
}
|
|
}
|
|
}
|
|
foreach (Mapping mapping in distinctValidImageMappingCollection)
|
|
{
|
|
directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
|
|
if (directoryName is null)
|
|
throw new NotSupportedException();
|
|
if (mapping.MappingFromItem.ResizedFileHolder.DirectoryName is null || !mapping.MappingFromItem.ResizedFileHolder.Exists)
|
|
continue;
|
|
dateTime = mapping.MappingFromItem.GetDateTimeOriginalThenMinimumDateTime();
|
|
if (mapping.By is null or Shared.Models.Stateless.IMapLogic.Sorting || mapping.MappingFromPerson?.ApproximateYears is null)
|
|
{
|
|
if (mapping.MappingFromItem.ContainerDateTimes.Length > 0 && !distinct.Contains(mapping.MappingFromItem.ResizedFileHolder.DirectoryName))
|
|
{
|
|
distinct.Add(mapping.MappingFromItem.ResizedFileHolder.DirectoryName);
|
|
directoriesAndDateTimes.Add(new(mapping.MappingFromItem.ResizedFileHolder.DirectoryName, mapping.MappingFromItem.ContainerDateTimes));
|
|
}
|
|
directory = Path.Combine(mapping.MappingFromItem.ResizedFileHolder.DirectoryName, $"{_PropertyConfiguration.ResultAllInOne}Shortcuts", _PropertyConfiguration.ResultAllInOne);
|
|
personDirectory = Path.Combine(directory, "Unknown");
|
|
fileName = Path.Combine(personDirectory, $"{mapping.MappingFromItem.ResizedFileHolder.Name}.lnk");
|
|
collection.Add(new(mapping.MappingFromItem.ResizedFileHolder.FullName, personDirectory, dateTime, fileName, mapping.MappingFromLocation?.DeterministicHashCodeKey, MakeAllHidden: false));
|
|
facesDirectory = Stateless.MapLogic.GetFacesDirectory(_PropertyConfiguration, dFacesContentDirectory, mapping.FilePath, mapping.MappingFromItem);
|
|
if (mapping.MappingFromLocation is null)
|
|
continue;
|
|
fullName = Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.FilePath.ExtensionLowered}{_Configuration.FacesFileNameExtension}");
|
|
fileName = Path.Combine(personDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ResizedFileHolder.ExtensionLowered}{_Configuration.FacesFileNameExtension}.lnk");
|
|
collection.Add(new(fullName, personDirectory, dateTime, fileName, mapping.MappingFromLocation.DeterministicHashCodeKey, MakeAllHidden: true));
|
|
}
|
|
else
|
|
{
|
|
if (string.IsNullOrEmpty(mapping.MappingFromPerson.SegmentB))
|
|
throw new NotSupportedException();
|
|
if (string.IsNullOrEmpty(mapping.MappingFromPerson.DisplayDirectoryName))
|
|
throw new NotSupportedException();
|
|
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, mapping.MappingFromPerson.PersonKey);
|
|
if (mapping.MappingFromItem.ContainerDateTimes.Length > 0 && !distinct.Contains(mapping.MappingFromItem.ResizedFileHolder.DirectoryName))
|
|
{
|
|
distinct.Add(mapping.MappingFromItem.ResizedFileHolder.DirectoryName);
|
|
directoriesAndDateTimes.Add(new(mapping.MappingFromItem.ResizedFileHolder.DirectoryName, mapping.MappingFromItem.ContainerDateTimes));
|
|
}
|
|
directory = Path.Combine(mapping.MappingFromItem.ResizedFileHolder.DirectoryName, $"{_PropertyConfiguration.ResultAllInOne}Shortcuts", personKeyFormatted);
|
|
if (!personKeyToIds.TryGetValue(mapping.MappingFromPerson.PersonKey, out ids))
|
|
personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName);
|
|
else
|
|
personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName, $"{ids.Count} Face(s)");
|
|
fileName = Path.Combine(directory, $"{mapping.MappingFromItem.ResizedFileHolder.Name}.lnk");
|
|
collection.Add(new(mapping.MappingFromItem.ResizedFileHolder.FullName, personDirectory, dateTime, fileName, mapping.MappingFromLocation?.DeterministicHashCodeKey, MakeAllHidden: false));
|
|
}
|
|
}
|
|
return new(directoriesAndDateTimes, collection);
|
|
}
|
|
|
|
public void SaveShortcutsForOutputResolutionsDuringMapLogic(ReadOnlyCollection<Container> containers, ReadOnlyDictionary<long, List<int>> personKeyToIds, string dFacesContentDirectory, ReadOnlyCollection<Mapping> distinctValidImageMappingCollection)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
WindowsShortcut windowsShortcut;
|
|
List<(string, DateTime[])> directoriesAndDateTimes;
|
|
List<SaveShortcutsForOutputResolutions> collection;
|
|
ReadOnlyCollection<Item> validImageItems = IContainer.GetValidImageItems(_PropertyConfiguration, containers, distinctItems: true, filterItems: true);
|
|
(directoriesAndDateTimes, collection) = GetCollectionForSaveShortcutsForOutputResolutionsDuringMapLogic(personKeyToIds, dFacesContentDirectory, validImageItems, distinctValidImageMappingCollection);
|
|
string[] directories = (from l in collection select l.Directory).Distinct().ToArray();
|
|
foreach (string directory in directories)
|
|
{
|
|
if (string.IsNullOrEmpty(directory))
|
|
continue;
|
|
if (!Directory.Exists(directory))
|
|
_ = Directory.CreateDirectory(directory);
|
|
}
|
|
foreach (SaveShortcutsForOutputResolutions s in collection)
|
|
{
|
|
if (File.Exists(s.FileName))
|
|
continue;
|
|
try
|
|
{
|
|
windowsShortcut = new() { Path = s.FullName, Description = s.Description };
|
|
windowsShortcut.Save(s.FileName);
|
|
windowsShortcut.Dispose();
|
|
if (s.MakeAllHidden)
|
|
File.SetAttributes(s.FileName, FileAttributes.Hidden);
|
|
File.SetLastWriteTime(s.FileName, s.DateTime);
|
|
}
|
|
catch (Exception)
|
|
{ }
|
|
}
|
|
foreach ((string directory, DateTime[] dateTimes) in directoriesAndDateTimes)
|
|
{
|
|
if (dateTimes.Length == 0)
|
|
continue;
|
|
Directory.SetCreationTime(directory, dateTimes[0]);
|
|
Directory.SetLastWriteTime(directory, dateTimes[1]);
|
|
}
|
|
}
|
|
|
|
public ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? GetWholePercentagesToPersonContainers(int? id)
|
|
{
|
|
ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? result;
|
|
if (id is null)
|
|
result = null;
|
|
else
|
|
_ = _IdThenWholePercentagesToPersonContainers.TryGetValue(id.Value, out result);
|
|
return result;
|
|
}
|
|
|
|
public bool InSkipCollection(int id, MappingFromLocation mappingFromLocation) =>
|
|
_SkipCollection.TryGetValue(id, out List<int>? wholePercentagesCollection) && wholePercentagesCollection.Contains(mappingFromLocation.WholePercentages);
|
|
|
|
public bool? IsFocusPerson(int? skipPersonWithMoreThen, long[] jLinkResolvedPersonKeys, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers, MappingFromLocation mappingFromLocation)
|
|
{
|
|
bool? result;
|
|
ReadOnlyCollection<PersonContainer>? personContainers;
|
|
if (skipPersonWithMoreThen is null && jLinkResolvedPersonKeys.Length == 0)
|
|
result = null;
|
|
else if (wholePercentagesToPersonContainers is null)
|
|
result = null;
|
|
else if (!wholePercentagesToPersonContainers.TryGetValue(mappingFromLocation.WholePercentages, out personContainers))
|
|
result = null;
|
|
else
|
|
{
|
|
result = false;
|
|
foreach (PersonContainer personContainer in personContainers)
|
|
{
|
|
if (personContainer.Key is null)
|
|
continue;
|
|
if (skipPersonWithMoreThen is not null && _PersonKeyToCount.TryGetValue(personContainer.Key.Value, out int count) && count > 2 && count < skipPersonWithMoreThen.Value)
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
if (jLinkResolvedPersonKeys.Contains(personContainer.Key.Value))
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public void LookForAbandoned(Property.Models.Configuration propertyConfiguration, string bResultsFullGroupDirectory, ReadOnlyCollection<Container> readOnlyContainers, string cResultsFullGroupDirectory, string dResultsFullGroupDirectory, string d2ResultsFullGroupDirectory)
|
|
{
|
|
string[] directories;
|
|
string? directoryName;
|
|
List<int> distinctFilteredIds = IContainer.GetFilteredDistinctIds(propertyConfiguration, readOnlyContainers);
|
|
LookForAbandoned(propertyConfiguration, distinctFilteredIds);
|
|
Stateless.LookForAbandonedLogic.LookForAbandoned(propertyConfiguration, bResultsFullGroupDirectory, distinctFilteredIds);
|
|
directories = Directory.GetDirectories(cResultsFullGroupDirectory, "*", SearchOption.TopDirectoryOnly);
|
|
foreach (string directory in directories)
|
|
{
|
|
directoryName = Path.GetFileName(directory);
|
|
if (string.IsNullOrEmpty(directoryName) || directoryName.Length != 2 && directoryName.Length != 4)
|
|
continue;
|
|
Stateless.LookForAbandonedLogic.LookForAbandoned(propertyConfiguration, distinctFilteredIds, directory, directoryName);
|
|
}
|
|
directories = Directory.GetDirectories(dResultsFullGroupDirectory, "*", SearchOption.TopDirectoryOnly);
|
|
foreach (string directory in directories)
|
|
{
|
|
directoryName = Path.GetFileName(directory);
|
|
if (string.IsNullOrEmpty(directoryName) || directoryName.Length != 2 && directoryName.Length != 4)
|
|
continue;
|
|
Stateless.LookForAbandonedLogic.LookForAbandoned(propertyConfiguration, distinctFilteredIds, directory, directoryName);
|
|
}
|
|
directories = Directory.GetDirectories(d2ResultsFullGroupDirectory, "*", SearchOption.TopDirectoryOnly);
|
|
foreach (string directory in directories)
|
|
{
|
|
directoryName = Path.GetFileName(directory);
|
|
if (string.IsNullOrEmpty(directoryName) || directoryName.Length != 2 && directoryName.Length != 4)
|
|
continue;
|
|
Stateless.LookForAbandonedLogic.LookForAbandoned(propertyConfiguration, distinctFilteredIds, directory, directoryName);
|
|
}
|
|
}
|
|
|
|
} |