diff --git a/i18n/en/Editor.resx b/i18n/en/Editor.resx index f6a59fbb..402b1f0c 100644 --- a/i18n/en/Editor.resx +++ b/i18n/en/Editor.resx @@ -52,6 +52,7 @@ Nothing to restore Undo Pick a sequence in the Library + Photos are being added to this sequence; wait a moment and try again.long The frames of this sequence changed on the server; get its proxies again.long This sequence is no longer in the archive.long Jobs cannot run until the archive index is open.long diff --git a/i18n/it/Editor.it.resx b/i18n/it/Editor.it.resx index 1e8570ad..bfc1a2d8 100644 --- a/i18n/it/Editor.it.resx +++ b/i18n/it/Editor.it.resx @@ -51,6 +51,7 @@ Niente da ripristinare Annulla Scegli una sequenza in Libreria + Si stanno aggiungendo foto a questa sequenza; attendi un momento e riprova. I fotogrammi di questa sequenza sono cambiati sul server; scarica di nuovo i proxy. Questa sequenza non è più nell’archivio. I lavori non possono partire finché l’indice dell’archivio non è aperto. diff --git a/src/Titano.App/Editor/EditorSession.cs b/src/Titano.App/Editor/EditorSession.cs index 9b7f63a6..56b9f2f1 100644 --- a/src/Titano.App/Editor/EditorSession.cs +++ b/src/Titano.App/Editor/EditorSession.cs @@ -13,12 +13,17 @@ namespace Titano.App.Editor; /// and redo, and the actions of every section — edit, Optimise (§10.4), Reset, exclusions and hero, analysis and render /// jobs. Every change is saved shortly after it is made (); a change stored meanwhile by /// someone else (an analysis job, another client) is merged in. On a server sequence, settings both sides changed to -/// different values wait for the user's choice (). Call from one thread (the UI thread). +/// different values wait for the user's choice (). Frames inserted under the editor (a sync +/// download, an import of earlier photos, a scan) are read again before the next save, and the project's frame positions, +/// its undo steps included, move with their frames as the stored ones did. Call from one thread (the UI thread). /// public sealed class EditorSession : IAsyncDisposable { public static readonly TimeSpan DefaultSaveDelay = TimeSpan.FromMilliseconds(400); + /// Times a save reads the frames again when frames keep changing under it. + private const int FollowAttempts = 3; + /// Sections "Optimise all" walks through, in panel order. public static IReadOnlyList OptimisedSections { get; } = [AdvisorSection.Frames, AdvisorSection.Timing, AdvisorSection.Exposure, AdvisorSection.Motion, AdvisorSection.Camera, AdvisorSection.Export]; @@ -27,6 +32,9 @@ public sealed class EditorSession : IAsyncDisposable private readonly ProjectSaver _saver; private ProjectSettings _basis; + /// The sequence being read again () until its content is taken: saves wait for it. + private Task _reading = Task.CompletedTask; + public EditorSession(ISequenceSource source, SequenceContent content, IReadOnlyList codecs, TimeSpan? saveDelay = null) { ArgumentNullException.ThrowIfNull(source); @@ -201,19 +209,31 @@ public sealed class EditorSession : IAsyncDisposable public Task SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken = default) => Source.SubmitAsync(request, cancellationToken); - /// Reads the sequence again (an analysis finished): new reports and advice, the stored project merged into the open one. + /// + /// Reads the sequence again (an analysis finished): new reports and advice, the frames with the project's positions + /// following them (), the stored project merged into the open one. Saves wait until it is taken. + /// public async Task ReloadAsync(CancellationToken cancellationToken = default) { await _saver.FlushAsync(); - var content = await Source.LoadAsync(cancellationToken); - (Content, Context, Advice, Presets) = Analyse(content, _codecs); - // A server's settings that conflict with the editor's waiting change are not merged over it: that change's - // retry meets them and asks (Conflict). - if (Conflict is null && (!IsRemote || ProjectMerge.Conflicts(_basis, Project, content.Project).Count == 0)) + var taken = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + _reading = taken.Task; + try { - var merged = ProjectMerge.Merge(_basis, Project, content.Project); - _basis = content.Project; - History.Replace(merged); + var content = await Source.LoadAsync(cancellationToken); + Follow(content); + // A server's settings that conflict with the editor's waiting change are not merged over it: that change's + // retry meets them and asks (Conflict). + if (Conflict is null && (!IsRemote || ProjectMerge.Conflicts(_basis, Project, content.Project).Count == 0)) + { + var merged = ProjectMerge.Merge(_basis, Project, content.Project); + _basis = content.Project; + History.Replace(merged); + } + } + finally + { + taken.SetResult(); } ContentChanged?.Invoke(); } @@ -233,6 +253,31 @@ public sealed class EditorSession : IAsyncDisposable await Source.DisposeAsync(); } + /// + /// Takes as the sequence. Frames inserted or removed since the last read (a sync download, + /// an import of earlier photos, a scan) moved the stored project's frame positions with their frames: the editor's + /// project, its undo and redo steps and its basis move the same way (), so + /// they keep naming the frames the user chose. Returns that move (none when the frames are the same). + /// + private Func Follow(SequenceContent content) + { + var before = Content.Frames.Select(f => f.Id).ToList(); + (Content, Context, Advice, Presets) = Analyse(content, _codecs); + if (before.SequenceEqual(content.Frames.Select(f => f.Id))) return static project => project; + var after = content.Frames; + Log.Info("editor", $"The frames of {content.Sequence.DisplayTitle} changed while it was open; its frame positions follow them"); + _basis = Move(_basis); + History.Remap(Move); + return Move; + + ProjectSettings Move(ProjectSettings project) => + NamesFrames(project) && ProjectSettings.FollowFrames(project.ToJson(), before, after) is { } moved ? ProjectSettings.FromJson(moved) : project; + } + + /// Exclusions, a hero, keyframes or frames waiting for their photos: positions that follow frames. + private static bool NamesFrames(ProjectSettings project) => + project.ExcludedFrames.Count > 0 || project.HeroFrame is not null || project.Camera.Keyframes.Count > 0 || project.PendingFrames is { Count: > 0 }; + private static (SequenceContent, SequenceContext, AdvisorResult, IReadOnlyList) Analyse(SequenceContent content, IReadOnlyList codecs) { @@ -271,21 +316,39 @@ public sealed class EditorSession : IAsyncDisposable private async Task SaveAsync(ProjectSettings project) { - ProjectSettings stored; - try + if (!_reading.IsCompleted) { - stored = await Source.SaveProjectAsync(project, _basis, CancellationToken.None); + // A read under way decides the frames the project's positions name. Once it is taken, the project as it is + // then contains this change (projects are whole snapshots), with its positions on those frames. + while (!_reading.IsCompleted) await _reading; + project = Project; } - catch (ProjectConflictException ex) + ProjectSettings stored; + for (var attempt = 1; ; attempt++) { - var found = Conflict is null; - Conflict = ex; - if (found) + try { - Log.Info("editor", $"Settings of {Content.Sequence.DisplayTitle} changed on the server too: {string.Join(", ", ex.Differences.Select(d => d.Path))}"); - ConflictFound?.Invoke(ex); + stored = await Source.SaveProjectAsync(project, _basis, CancellationToken.None); + break; + } + catch (FramesChangedException) when (attempt < FollowAttempts) + { + // Frames were inserted under the editor and the stored positions moved with them: the frames are read + // again, this edit's positions follow them too, and it is saved in the new order. + project = Follow(await Source.LoadAsync(CancellationToken.None))(project); + ContentChanged?.Invoke(); + } + catch (ProjectConflictException ex) + { + var found = Conflict is null; + Conflict = ex; + if (found) + { + Log.Info("editor", $"Settings of {Content.Sequence.DisplayTitle} changed on the server too: {string.Join(", ", ex.Differences.Select(d => d.Path))}"); + ConflictFound?.Invoke(ex); + } + throw; } - throw; } Conflict = null; _basis = stored; diff --git a/src/Titano.App/Editor/LocalSequenceSource.cs b/src/Titano.App/Editor/LocalSequenceSource.cs index 2105978f..a7d54027 100644 --- a/src/Titano.App/Editor/LocalSequenceSource.cs +++ b/src/Titano.App/Editor/LocalSequenceSource.cs @@ -23,7 +23,10 @@ namespace Titano.App.Editor; /// project in .titano/project.json mirrored in the index's settings column (with its hero frame, which the /// Library shows), jobs on this PC's engine. Project writes follow the archive engine's protocol: under the sequence's /// lease file (so the server and the job engine wait for it), file first (atomically), then the index with its settings -/// version as an optimistic check. +/// version as an optimistic check. Project settings name frames by position, and frames inserted while the sequence is +/// open (a sync download, an import of earlier photos, a scan) move the stored positions with their frames: a save made +/// against the frames read earlier is refused () until the editor has read them again +/// and moved its own positions the same way (). /// public sealed class LocalSequenceSource : ISequenceSource { @@ -31,6 +34,9 @@ public sealed class LocalSequenceSource : ISequenceSource private const int SaveAttempts = 3; private const int JobsListed = 200; + /// Times the frames are listed again when an insertion lands while they are read. + private const int ReadAttempts = 3; + private readonly TitanoDatabase _db; private readonly Guid _sequenceId; private readonly ImageDecoder _decoder; @@ -41,6 +47,10 @@ public sealed class LocalSequenceSource : ISequenceSource /// The JPEG of each GPR frame that an import keeps in another sequence (), by position. private string?[] _companions = []; private Guid[] _frameIds = []; + + /// The frames version of the frames last read (), whose order the project's positions follow. + private int _framesVersion = -1; + private ArchivePaths? _paths; private SequencePaths? _folder; @@ -74,15 +84,8 @@ public sealed class LocalSequenceSource : ISequenceSource public async Task LoadAsync(CancellationToken cancellationToken) { - var sequence = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); + var (sequence, frames) = await ReadFramesAsync(cancellationToken); var archive = await _db.Archives.GetAsync(sequence.ArchiveId, cancellationToken) ?? throw Missing(); - var frames = new List(); - while (true) - { - var page = await _db.Frames.ListBySequenceAsync(_sequenceId, frames.Count > 0 ? frames[^1].Index : -1, PageSize, cancellationToken); - frames.AddRange(page); - if (page.Count < PageSize) break; - } var renders = await _db.Renders.ListBySequenceAsync(_sequenceId, cancellationToken); var companions = await GprCompanions.FindAsync(_db, archive, frames, cancellationToken); return await Task.Run(() => @@ -95,7 +98,7 @@ public sealed class LocalSequenceSource : ISequenceSource if ((frames[i].Flags & FrameFlags.Missing) == 0) files[i] = paths.FromRelative(frames[i].RelativePath); } _companions = [.. frames.Select(f => companions.GetValueOrDefault(f.Id))]; - (_paths, _folder, _files, _frameIds) = (paths, folder, files, [.. frames.Select(f => f.Id)]); + (_paths, _folder, _files, _frameIds, _framesVersion) = (paths, folder, files, [.. frames.Select(f => f.Id)], sequence.FramesVersion); var context = SequenceContext.FromFrames(frames); return new SequenceContent(sequence, frames, ReadProject(sequence, folder), LightAnalyzer.Analyze(frames), ReadReport(folder, frames.Count), context.SourceWidth, context.SourceHeight, folder.Exports, [.. renders.OrderByDescending(r => r.Created)], SavedCopies.List(folder.MetaDirectory)); @@ -127,7 +130,7 @@ public sealed class LocalSequenceSource : ISequenceSource { ArgumentNullException.ThrowIfNull(project); ArgumentNullException.ThrowIfNull(basis); - var (paths, folder, frameIds) = (_paths, _folder, _frameIds); + var (paths, folder, frameIds, framesVersion) = (_paths, _folder, _frameIds, _framesVersion); if (paths is null || folder is null) throw new InvalidOperationException("LoadAsync first."); return Task.Run(async () => { @@ -137,13 +140,16 @@ public sealed class LocalSequenceSource : ISequenceSource for (var attempt = 1; ; attempt++) { var row = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); + // Frames were inserted or removed since the editor read them, so its positions name the old order. Insertions + // hold this lease, so the frames do not change again before this save ends. + if (row.FramesVersion != framesVersion) throw new FramesChangedException(Loc.L("Editor.Error.FramesArriving")); var stored = ReadProject(row, folder); var merged = ProjectMerge.SameValues(stored, basis) ? project : ProjectMerge.Merge(basis, project, stored); var json = merged.ToJson(); if (json == stored.ToJson()) return merged; AtomicFile.WriteAllText(folder.ProjectPath, json); var edit = new SequenceEdit { SettingsJson = json, HeroFrameId = merged.HeroFrame == stored.HeroFrame ? null : HeroFrameId(merged, frameIds) }; - var result = await _db.Sequences.EditAsync(_sequenceId, edit, row.SettingsVersion, cancellationToken); + var result = await _db.Sequences.EditAsync(_sequenceId, edit, row.SettingsVersion, framesVersion, cancellationToken); switch (result.Outcome) { case SequenceEditOutcome.Updated: @@ -151,7 +157,8 @@ public sealed class LocalSequenceSource : ISequenceSource return merged; case SequenceEditOutcome.NotFound: throw Missing(); - // The settings moved in the index meanwhile (server API): merge again on top of them; the file follows the next write. + // The settings moved in the index meanwhile (server API): merge again on top of them, or find the frames that + // moved; the file follows the next write. case SequenceEditOutcome.Conflict when attempt == SaveAttempts: throw new EditorException(Loc.L("Editor.Error.SaveConflict")); } @@ -181,6 +188,30 @@ public sealed class LocalSequenceSource : ISequenceSource return ValueTask.CompletedTask; } + /// + /// The sequence row with its frames as one state: the frames are listed between two reads of the row that find the + /// same frames version (an insertion renumbers the frames and moves the row's positions in one transaction, and + /// bumps the version), so the project's positions name these frames. + /// + /// The sequence is gone, or an insertion landed during every attempt. + private async Task<(Sequence Row, List Frames)> ReadFramesAsync(CancellationToken cancellationToken) + { + for (var attempt = 0; attempt < ReadAttempts; attempt++) + { + var before = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); + var frames = new List(); + while (true) + { + var page = await _db.Frames.ListBySequenceAsync(_sequenceId, frames.Count > 0 ? frames[^1].Index : -1, PageSize, cancellationToken); + frames.AddRange(page); + if (page.Count < PageSize) break; + } + var after = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); + if (after.FramesVersion == before.FramesVersion) return (after, frames); + } + throw new EditorException(Loc.L("Editor.Error.FramesArriving")); + } + /// The settings in force: the index copy, else project.json, else defaults. /// The settings are not a project or come from a newer Titano. internal static ProjectSettings ReadProject(Sequence sequence, SequencePaths folder) @@ -221,3 +252,9 @@ public sealed class LocalSequenceSource : ISequenceSource private static EditorException Missing() => new(Loc.L("Editor.Error.Missing")); } + +/// +/// The frames of a sequence of this PC changed since the editor read them (frames inserted or removed): nothing was +/// saved. The editor reads them again, moves its positions as the index moved the stored ones, and saves again. +/// +public sealed class FramesChangedException(string message) : EditorException(message); diff --git a/src/Titano.App/Editor/ProjectHistory.cs b/src/Titano.App/Editor/ProjectHistory.cs index 3622b17c..c90b1a95 100644 --- a/src/Titano.App/Editor/ProjectHistory.cs +++ b/src/Titano.App/Editor/ProjectHistory.cs @@ -78,6 +78,25 @@ public sealed class ProjectHistory(ProjectSettings initial, int capacity = 200) Changed?.Invoke(); } + /// + /// Rewrites the project and every undo and redo snapshot with , without an undo step: a change + /// of what the values mean rather than of the values (frame positions following frames inserted under the editor), so + /// undo and redo keep naming the same frames. + /// + public void Remap(Func remap) + { + ArgumentNullException.ThrowIfNull(remap); + foreach (var steps in new[] { _undo, _redo }) + { + for (var node = steps.First; node is not null; node = node.Next) node.Value = remap(node.Value); + } + var current = remap(Current); + if (ProjectMerge.SameValues(current, Current)) return; + _runKey = null; + Current = current; + Changed?.Invoke(); + } + private static void Rebase(LinkedList steps, ProjectMerge.Rebase rebase) { for (var node = steps.First; node is not null; node = node.Next) node.Value = rebase.Apply(node.Value); diff --git a/src/Titano.Core/Project/ProjectSettings.cs b/src/Titano.Core/Project/ProjectSettings.cs index 1494e670..60fc2eae 100644 --- a/src/Titano.Core/Project/ProjectSettings.cs +++ b/src/Titano.Core/Project/ProjectSettings.cs @@ -1,6 +1,7 @@ using System.Text.Json; using System.Text.Json.Nodes; using System.Text.Json.Serialization; +using Titano.Core.Model; namespace Titano.Core.Project; @@ -324,6 +325,39 @@ public sealed record ProjectSettings } } + /// + /// A project written against the frames (frame ids, by index) moved to the frames + /// (in index order) the way the archive index moves its own copy when it takes them + /// (ProjectPositions in Titano.Data): while every frame of is still there, its positions + /// move with their frames (), otherwise they stay; either way pending frames whose + /// photos are now there take their place (). An editor that read the frames + /// before frames were inserted saves its edit in the new order this way. Null when nothing changes. + /// + public static string? FollowFrames(string json, IReadOnlyList before, IReadOnlyList after) + { + ArgumentNullException.ThrowIfNull(before); + ArgumentNullException.ThrowIfNull(after); + var now = new Dictionary(after.Count); + for (var i = 0; i < after.Count; i++) now[after[i].Id] = i; + Dictionary? moves = []; + for (var i = 0; i < before.Count; i++) + { + if (!now.TryGetValue(before[i], out var index)) + { + moves = null; + break; + } + if (index != i) moves[i] = index; + } + var moved = moves is null ? null : MoveFramePositions(json, moves); + var current = moved ?? json; + // Most projects wait for no photo: the frames' photos are gathered only for those that do. + var placed = current.Contains("pendingFrames", StringComparison.OrdinalIgnoreCase) + ? TranslateFramePositions(current, null, new FramePhotos(after.Select((f, i) => (i, new FramePhoto(f.Sha256, f.Size, f.CapturedAt))))) + : null; + return placed ?? moved; + } + private static bool Move(JsonNode? position, Action replace, IReadOnlyDictionary moves) { if (position is not JsonValue value || !value.TryGetValue(out var old) || !moves.TryGetValue(old, out var now) || now == old) return false; diff --git a/tests/Titano.App.Tests/Editor/EditorSessionTests.cs b/tests/Titano.App.Tests/Editor/EditorSessionTests.cs index 7015300d..9b9a5b44 100644 --- a/tests/Titano.App.Tests/Editor/EditorSessionTests.cs +++ b/tests/Titano.App.Tests/Editor/EditorSessionTests.cs @@ -98,6 +98,77 @@ public sealed class EditorSessionTests } } + [Test] + public async Task AnEditMadeBeforeInsertedFramesWereReadIsSavedOnTheFramesItNamed() + { + var (session, source) = OpenShort(); + await using (session) + { + Assert.True(session.SetExcluded([3], true)); + Assert.True(await session.FlushAsync()); + // Two earlier photos are inserted (a download, an import, a scan): the stored exclusion moved with its frame. + var frames = session.Content.Frames; + InsertEarlier(source, 2); + source.Stored = source.Stored with { ExcludedFrames = [5] }; + source.FailNextSave = new FramesChangedException("frames changed"); + + // The editor still shows the frames it read when the user excludes another one. + Assert.True(session.SetExcluded([6], true)); + Assert.True(await session.FlushAsync()); + + Assert.Equal(frames.Count + 2, session.Content.Count, "the frames were read again"); + Assert.SequenceEqual([5, 8], source.Stored.ExcludedFrames); + Assert.SequenceEqual([frames[3].Id, frames[6].Id], session.Project.ExcludedFrames.Select(i => session.Content.Frames[i].Id)); + Assert.True(session.Undo()); + Assert.SequenceEqual([5], session.Project.ExcludedFrames, "undo steps name the same frames"); + Assert.True(session.Undo()); + Assert.Empty(session.Project.ExcludedFrames); + } + } + + [Test] + public async Task AReadAfterFramesWereInsertedMovesTheOpenProjectWithThem() + { + var (session, source) = OpenShort(); + await using (session) + { + Assert.True(session.SetExcluded([3], true)); + Assert.True(session.SetHero(4)); + Assert.True(await session.FlushAsync()); + InsertEarlier(source, 2); + source.Stored = source.Stored with { ExcludedFrames = [5], HeroFrame = 6 }; + + await session.ReloadAsync(); + + Assert.SequenceEqual([5], session.Project.ExcludedFrames); + Assert.Equal(6, session.Project.HeroFrame); + Assert.True(session.Undo()); + Assert.Null(session.Project.HeroFrame); + Assert.SequenceEqual([5], session.Project.ExcludedFrames, "the step before Set hero names the same frame"); + Assert.True(await session.FlushAsync()); + Assert.SequenceEqual([5], source.Stored.ExcludedFrames); + Assert.Null(source.Stored.HeroFrame); + } + } + + /// A short sequence without its analysis, whose frame ids are all different (the synthetic ids repeat every 64 frames). + private static (EditorSession Session, FakeSequenceSource Source) OpenShort() + { + var sequence = EditorFixture.Sequence(12); + var content = EditorFixture.Content(sequence, deep: false); + var source = new FakeSequenceSource(sequence, content); + return (new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)), source); + } + + /// Photos captured before the first frame join the source's sequence, as an insertion renumbers it. + private static void InsertEarlier(FakeSequenceSource source, int count) + { + var first = source.Content.Frames[0]; + var early = Enumerable.Range(0, count).Select(i => first with { Id = Guid.CreateVersion7(), CapturedAt = first.CapturedAt!.Value.AddMinutes(i - count) }); + IReadOnlyList frames = [.. early.Concat(source.Content.Frames).Select((f, i) => f with { Index = i })]; + source.Content = source.Content with { Frames = frames, Light = LightAnalyzer.Analyze(frames) }; + } + [Test] public async Task AFailedSaveStaysPendingUntilItIsStored() { diff --git a/tests/Titano.App.Tests/Editor/ProjectStoreTests.cs b/tests/Titano.App.Tests/Editor/ProjectStoreTests.cs index ab55c4a9..4a8d4de5 100644 --- a/tests/Titano.App.Tests/Editor/ProjectStoreTests.cs +++ b/tests/Titano.App.Tests/Editor/ProjectStoreTests.cs @@ -138,6 +138,63 @@ public sealed class ProjectStoreTests(TestContext context) } } + [Test] + public async Task AnEditorOpenWhileEarlierPhotosArriveSavesOnTheFramesTheUserChose() + { + var (db, sequenceId, root) = await ArchiveAsync(10); + await using (db) + { + var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }; + await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, options); + var content = await source.LoadAsync(context.Cancellation); + var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)); + await using (session) + { + Assert.True(session.SetExcluded([5], true)); + Assert.True(session.SetHero(6)); + Assert.True(await session.FlushAsync()); + + // Three photos taken before the others are found in the folder (a sync download, an import or a scan + // inserts them the same way): the index moves the stored positions with their frames. + var sequence = EditorFixture.Sequence(3); + var first = content.Frames[0].CapturedAt!.Value; + for (var i = 0; i < 3; i++) + { + using var image = sequence.Render(i); + var exif = ExifWriter.BuildJpegApp1(sequence.Metadata[i] with { CapturedAt = first.AddMinutes(i - 3) }); + File.WriteAllBytes(Path.Combine(root, "Synthetic", $"EARLY_{i + 1}.JPG"), + JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 90, App1Segments = [exif[4..]] })); + } + var archive = (await db.Archives.GetAsync(content.Sequence.ArchiveId, context.Cancellation))!; + await new ArchiveService(db, options).Indexer.ScanAsync(archive, ScanMode.Full, null, _ => ValueTask.CompletedTask, context.Cancellation); + var moved = ProjectSettings.FromJson((await db.Sequences.GetAsync(sequenceId))!.SettingsJson!); + Assert.SequenceEqual([8], moved.ExcludedFrames); + Assert.Equal(9, moved.HeroFrame); + + // The editor still shows the ten frames it read; the user excludes the eighth of them. + Assert.Equal(10, session.Content.Count); + Assert.True(session.SetExcluded([7], true)); + Assert.True(await session.FlushAsync()); + + Assert.Equal(13, session.Content.Count, "the frames were read again before the save"); + Assert.SequenceEqual([8, 10], session.Project.ExcludedFrames); + Assert.Equal(9, session.Project.HeroFrame); + var row = (await db.Sequences.GetAsync(sequenceId))!; + var stored = ProjectSettings.FromJson(row.SettingsJson!); + var frames = session.Content.Frames; + Assert.SequenceEqual([content.Frames[5].Id, content.Frames[7].Id], stored.ExcludedFrames.Select(i => frames[i].Id), "the photos the user chose"); + Assert.Equal(content.Frames[6].Id, frames[stored.HeroFrame!.Value].Id); + Assert.Equal(content.Frames[6].Id, row.HeroFrameId); + Assert.Equal(row.SettingsJson, File.ReadAllText(Path.Combine(root, "Synthetic", ".titano", "project.json"))); + + // Undo takes back the user's last step on the new frames too. + Assert.True(session.Undo()); + Assert.True(await session.FlushAsync()); + Assert.SequenceEqual([8], ProjectSettings.FromJson((await db.Sequences.GetAsync(sequenceId))!.SettingsJson!).ExcludedFrames); + } + } + } + [Test] public async Task ASaveThatDoesNotReachTheIndexThrows() { diff --git a/tests/Titano.Core.Tests/Project/ProjectSettingsTests.cs b/tests/Titano.Core.Tests/Project/ProjectSettingsTests.cs index 33e3c525..60978fa2 100644 --- a/tests/Titano.Core.Tests/Project/ProjectSettingsTests.cs +++ b/tests/Titano.Core.Tests/Project/ProjectSettingsTests.cs @@ -167,6 +167,47 @@ public sealed class ProjectSettingsTests Assert.Null(ProjectSettings.MoveFramePositions("""{ "heroFrame": 1, "HeroFrame": 1 }""", new Dictionary { [1] = 2 })); } + [Test] + public void AnEditorsPositionsFollowFramesInsertedUnderItAsTheIndexMovedTheStoredOnes() + { + // An editor read four frames; a download then inserted two earlier photos, one of which an exclusion waited for. + var photos = Enumerable.Range(0, 6).Select(Photo).ToList(); + var ids = Enumerable.Range(0, 6).Select(_ => Guid.CreateVersion7()).ToList(); + IReadOnlyList before = ids[2..]; + var after = ids.Select((id, i) => new Titano.Core.Model.Frame + { + Id = id, + SequenceId = Guid.Empty, + Index = i, + RelativePath = $"s/IMG_{i}.JPG", + FileName = $"IMG_{i}.JPG", + Sha256 = photos[i].Sha256, + Size = photos[i].Size, + CapturedAt = photos[i].CapturedAt, + }).ToList(); + var project = new ProjectSettings + { + ExcludedFrames = [1, 3], + HeroFrame = 0, + Camera = new CameraSettings { Keyframes = [new CameraKey(2, 0.5, 0.5, 1, 0)] }, + Exposure = new ExposureSettings { DeflickerWindow = new Auto().WithManual(41) }, + PendingFrames = [new PendingFrame { Sha256 = photos[1].Sha256, Size = photos[1].Size, Excluded = true }], + }; + + var followed = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.FollowFrames(project.ToJson(), before, after))); + + Assert.SequenceEqual([1, 3, 5], followed.ExcludedFrames); + Assert.Equal(2, followed.HeroFrame); + Assert.SequenceEqual([4], followed.Camera.Keyframes.Select(k => k.Frame)); + Assert.Equal(41, followed.Exposure.DeflickerWindow.Manual); + Assert.Null(followed.PendingFrames); + + // The same frames: nothing moves. A frame the editor read that is gone: positions stay, as the index leaves them. + Assert.Null(ProjectSettings.FollowFrames(new ProjectSettings { ExcludedFrames = [1] }.ToJson(), ids, after)); + var removed = after.Where(f => f.Id != ids[3]).Select((f, i) => f with { Index = i }).ToList(); + Assert.Null(ProjectSettings.FollowFrames(new ProjectSettings { ExcludedFrames = [1, 3] }.ToJson(), before, removed)); + } + [Test] public void PositionsCrossToAnotherCopyByPhotoAndWaitForPhotosItLacks() {