Card scanning (DCIM and flat), session splitting with test-shot merging and user splits/merges, per-body import plans named by templates with archive duplicate detection, hash-verified resumable copy with per-file errors, a plain-folder destination and a verified card erase with dry run. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
182 lines
8.9 KiB
C#
182 lines
8.9 KiB
C#
using System.Globalization;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using Titano.Core.Archiving;
|
|
using Titano.Core.Naming;
|
|
|
|
namespace Titano.Core.Import;
|
|
|
|
/// <summary>An archive frame that may be the same photo.</summary>
|
|
public sealed record ArchiveMatch(Guid FrameId, string? Sha256);
|
|
|
|
/// <summary>What the planner needs to know about the destination (implemented over the archive index).</summary>
|
|
public interface IImportLookup
|
|
{
|
|
/// <summary>The file was imported from this card before (same path, size and time).</summary>
|
|
Task<bool> WasImportedAsync(CardFile file, CancellationToken cancellationToken);
|
|
|
|
/// <summary>Archive frames with this size and capture time; the planner compares hashes only for these.</summary>
|
|
Task<IReadOnlyList<ArchiveMatch>> FindCandidatesAsync(long size, DateTime capturedAt, CancellationToken cancellationToken);
|
|
|
|
/// <summary>Folder of the sequence an earlier import of this session went to, so a re-import continues it.</summary>
|
|
Task<string?> FindSessionFolderAsync(string sessionKey, CancellationToken cancellationToken);
|
|
|
|
/// <summary>The folder is taken by something else (another sequence), so the session needs another name.</summary>
|
|
bool IsFolderTaken(string folder);
|
|
}
|
|
|
|
/// <summary>Turns card photos into an <see cref="ImportPlan"/> (BRIEF §12.4, §13). Nothing is written.</summary>
|
|
public static class ImportPlanner
|
|
{
|
|
public static async Task<ImportPlan> PlanAsync(string sourceRoot, string destinationRoot, IReadOnlyList<CardPhoto> photos,
|
|
IReadOnlyList<ImportProblem> problems, ImportOptions options, IImportLookup lookup, CancellationToken cancellationToken = default)
|
|
{
|
|
var folderTemplate = PathTemplate.Parse(options.FolderTemplate);
|
|
var fileTemplate = PathTemplate.Parse(options.FileTemplate);
|
|
var drafts = new List<(string Key, List<CardPhoto> Photos)>();
|
|
foreach (var body in photos.GroupBy(BodyKey, StringComparer.Ordinal))
|
|
{
|
|
var ordered = body.OrderBy(p => p.CaptureTime).ThenBy(p => p.File.RelativePath, StringComparer.Ordinal).ToList();
|
|
var ranges = SessionSplitter.Split(ordered.ConvertAll(p => p.CaptureTime), options.SessionGap, options.MinimumSessionFrames,
|
|
i => options.SplitBefore.Contains(ordered[i].File.RelativePath) ? true : options.MergeAt.Contains(ordered[i].File.RelativePath) ? false : null);
|
|
foreach (var range in ranges)
|
|
{
|
|
var members = ordered.GetRange(range.Start, range.Count);
|
|
drafts.Add((SessionKey(body.Key, members[0].CaptureTime), members));
|
|
}
|
|
}
|
|
drafts.Sort((a, b) => a.Photos[0].CaptureTime.CompareTo(b.Photos[0].CaptureTime) is var c and not 0 ? c : string.CompareOrdinal(a.Key, b.Key));
|
|
|
|
var claimedFolders = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
var sessions = new List<PlannedSession>(drafts.Count);
|
|
for (var s = 0; s < drafts.Count; s++)
|
|
{
|
|
var (key, members) = drafts[s];
|
|
var first = members[0];
|
|
options.Titles.TryGetValue(key, out var title);
|
|
var context = Context(first, first.CaptureTime, s + 1, 1, title);
|
|
var folder = await lookup.FindSessionFolderAsync(key, cancellationToken).ConfigureAwait(false)
|
|
?? UniqueFolder(folderTemplate.ExpandFolder(context), claimedFolders, lookup);
|
|
claimedFolders.Add(folder);
|
|
|
|
var names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
var items = new List<PlannedItem>(members.Count);
|
|
for (var i = 0; i < members.Count; i++)
|
|
{
|
|
var photo = members[i];
|
|
var name = UniqueName(fileTemplate.ExpandFile(Context(photo, first.CaptureTime, s + 1, i + 1, title)), names);
|
|
items.Add(await PlanItemAsync(sourceRoot, photo, name, options, lookup, cancellationToken).ConfigureAwait(false));
|
|
}
|
|
sessions.Add(new PlannedSession
|
|
{
|
|
Number = s + 1,
|
|
SessionKey = key,
|
|
CameraMake = first.Metadata.Make,
|
|
CameraModel = first.Metadata.Model,
|
|
CameraSerial = first.Metadata.BodySerial,
|
|
Format = first.Metadata.Format,
|
|
Start = first.CaptureTime,
|
|
End = members[^1].CaptureTime,
|
|
Folder = folder,
|
|
Title = title,
|
|
Items = items,
|
|
});
|
|
}
|
|
return new ImportPlan
|
|
{
|
|
Id = Guid.CreateVersion7(),
|
|
SourceRoot = Path.GetFullPath(sourceRoot),
|
|
DestinationRoot = Path.GetFullPath(destinationRoot),
|
|
Created = DateTimeOffset.UtcNow,
|
|
Sessions = sessions,
|
|
Problems = problems,
|
|
AvailableBytes = FreeSpace(destinationRoot),
|
|
};
|
|
}
|
|
|
|
private static async Task<PlannedItem> PlanItemAsync(string sourceRoot, CardPhoto photo, string name, ImportOptions options, IImportLookup lookup,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var item = new PlannedItem
|
|
{
|
|
SourcePath = photo.File.RelativePath,
|
|
Size = photo.File.Size,
|
|
ModifiedUtc = photo.File.ModifiedUtc,
|
|
CapturedAt = photo.CaptureTime,
|
|
FileName = name,
|
|
};
|
|
if (await lookup.WasImportedAsync(photo.File, cancellationToken).ConfigureAwait(false))
|
|
return item with { Action = ImportAction.SkipImported };
|
|
var candidates = await lookup.FindCandidatesAsync(photo.File.Size, photo.CaptureTime, cancellationToken).ConfigureAwait(false);
|
|
if (candidates.Count == 0) return item;
|
|
var sha = await ContentHash.Sha256Async(Path.Combine(sourceRoot, photo.File.RelativePath), null, cancellationToken).ConfigureAwait(false);
|
|
var match = candidates.FirstOrDefault(c => sha.Equals(c.Sha256, StringComparison.OrdinalIgnoreCase));
|
|
if (match is null) return item with { Sha256 = sha };
|
|
return item with
|
|
{
|
|
Sha256 = sha,
|
|
ExistingFrameId = match.FrameId,
|
|
Action = options.Duplicates == DuplicatePolicy.Skip ? ImportAction.SkipInArchive : ImportAction.Copy,
|
|
};
|
|
}
|
|
|
|
private static NamingContext Context(CardPhoto photo, DateTime sessionStart, int session, int number, string? title) => new()
|
|
{
|
|
CapturedAt = photo.CaptureTime,
|
|
SessionStart = sessionStart,
|
|
Session = session,
|
|
Number = number,
|
|
NumberInSession = number,
|
|
CameraMake = photo.Metadata.Make,
|
|
CameraModel = photo.Metadata.Model,
|
|
Lens = photo.Metadata.LensModel,
|
|
Iso = photo.Metadata.Iso,
|
|
ExposureTime = photo.Metadata.ExposureTime,
|
|
FNumber = photo.Metadata.FNumber,
|
|
OriginalName = Path.GetFileNameWithoutExtension(photo.File.RelativePath),
|
|
Extension = Path.GetExtension(photo.File.RelativePath).TrimStart('.'),
|
|
Title = title,
|
|
};
|
|
|
|
/// <summary>Camera body and file format: RAW+JPEG shooting yields two sequences instead of doubled frames.</summary>
|
|
private static string BodyKey(CardPhoto p) => $"{p.Metadata.Make}|{p.Metadata.Model}|{p.Metadata.BodySerial}|{p.Metadata.Format}";
|
|
|
|
private static string SessionKey(string bodyKey, DateTime start) =>
|
|
"card-" + Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(bodyKey)))[..8] + "-"
|
|
+ start.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture);
|
|
|
|
private static string UniqueFolder(string folder, HashSet<string> claimed, IImportLookup lookup)
|
|
{
|
|
if (folder.Length == 0) folder = "Import";
|
|
var candidate = folder;
|
|
for (var n = 2; claimed.Contains(candidate) || lookup.IsFolderTaken(candidate); n++)
|
|
candidate = string.Create(CultureInfo.InvariantCulture, $"{folder} ({n})");
|
|
return candidate;
|
|
}
|
|
|
|
/// <summary>Adds _2, _3… before the extension when the template gives two photos the same name.</summary>
|
|
internal static string UniqueName(string name, HashSet<string> taken)
|
|
{
|
|
var candidate = name;
|
|
var stem = Path.GetFileNameWithoutExtension(name);
|
|
var extension = Path.GetExtension(name);
|
|
for (var n = 2; !taken.Add(candidate); n++) candidate = string.Create(CultureInfo.InvariantCulture, $"{stem}_{n}{extension}");
|
|
return candidate;
|
|
}
|
|
|
|
private static long? FreeSpace(string path)
|
|
{
|
|
try
|
|
{
|
|
var full = Path.GetFullPath(path);
|
|
while (!Directory.Exists(full) && Path.GetDirectoryName(full) is { } parent) full = parent;
|
|
// Windows wants a drive root; Unix accepts any directory and reports the volume it is mounted on.
|
|
return new DriveInfo(OperatingSystem.IsWindows() ? Path.GetPathRoot(full)! : full).AvailableFreeSpace;
|
|
}
|
|
catch (Exception ex) when (ex is ArgumentException or IOException or UnauthorizedAccessException)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
}
|