fix(app): archive picks, early import job ends and language switches

- Archive: picking another archive while the screen was reading kept the old
  archive's tree and figures while Scan, Verify and the set actions targeted the
  new one, and reloads asked for during a read were dropped. A load requested
  during a read now runs once more after it, a read whose archive is no longer
  picked shows nothing, and a new pick clears the tree and the online state
  until the picked archive is read.
- Import: a job that ended before the screen recorded its id (a destination
  gone offline) left the screen copying forever; its state is read back once.
  A replaced import result is disposed, so it no longer stays alive through the
  language event with its whole plan.
- Library: the timeline's month readouts are made again on a language switch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
Claude committed 2026-10-12 10:13:53 +00:00
1 parent 579ffd446d
commit d47e3e9b49
6 files changed
+170 -7

No files matched your search

+47 -6
View File
@@ -52,6 +52,7 @@ public sealed class ArchiveViewModel : SectionViewModel
private int _viewIndex;
private bool _loaded;
private Task _load = Task.CompletedTask;
private bool _reloadPending;
private bool _jobEvents;
private string _lastScanText = string.Empty;
private ArchiveDialogViewModel? _dialog;
@@ -121,9 +122,19 @@ public sealed class ArchiveViewModel : SectionViewModel
set
{
if (value is null || value == _archive) return;
var other = value.Id != _archive?.Id;
_archive = value;
_duplicates = null;
_orphans = null;
if (other)
{
// Until the picked archive is read, nothing of the previous one stays actionable: no tree to take a set
// from, no availability to allow a scan.
_tree = null;
_availability = ArchiveAvailability.Offline;
RebuildRows();
CommandManager.InvalidateRequerySuggested();
}
_ = LoadAsync();
}
}
@@ -370,8 +381,30 @@ public sealed class ArchiveViewModel : SectionViewModel
_ = LoadAsync();
}
/// <summary>Reads archives, figures, tree, health and recent maintenance of the selected archive; joins a read in progress.</summary>
public Task LoadAsync() => _load.IsCompleted ? _load = ReadAsync() : _load;
/// <summary>
/// Reads archives, figures, tree, health and recent maintenance of the selected archive. A call during a read joins
/// it and reads once more when it ends, so a newly picked archive, a language switch or a finished job is never lost
/// behind the read in progress.
/// </summary>
public Task LoadAsync()
{
if (!_load.IsCompleted)
{
_reloadPending = true;
return _load;
}
return _load = ReadUntilCurrentAsync();
}
private async Task ReadUntilCurrentAsync()
{
do
{
_reloadPending = false;
await ReadAsync();
}
while (_reloadPending);
}
private async Task ReadAsync()
{
@@ -384,12 +417,16 @@ public sealed class ArchiveViewModel : SectionViewModel
_archive ??= CurrentArchive.Pick(Archives, Services.Settings.LastArchivePath);
if (_archive is not { } archive) return;
var root = archive.RootPath;
_availability = await Task.Run(() => ArchiveVolume.Probe(new ArchivePaths(root)));
_stats = await db.Sequences.GetStatsAsync(archive.Id);
var availability = await Task.Run(() => ArchiveVolume.Probe(new ArchivePaths(root)));
var stats = await db.Sequences.GetStatsAsync(archive.Id);
var sequences = await ListSequencesAsync(db, archive.Id);
var withoutProxies = await db.Sequences.CountAsync(new SequenceQuery { ArchiveId = archive.Id, WithoutStatus = SequenceStatus.ProxiesBuilt });
ShowFigures(_stats, withoutProxies);
ShowTree(ArchiveTree.Build(archive, _availability, sequences));
// Another archive was picked meanwhile: the read its pick queued shows it, never this one's tree.
if (!IsShowing(archive)) return;
_availability = availability;
_stats = stats;
ShowFigures(stats, withoutProxies);
ShowTree(ArchiveTree.Build(archive, availability, sequences));
await LoadRecentAsync(db, archive);
}
catch (DatabaseException ex)
@@ -572,6 +609,7 @@ public sealed class ArchiveViewModel : SectionViewModel
var jobs = new List<Job>();
foreach (var kind in MaintenanceReports.MaintenanceKinds)
jobs.AddRange((await db.Jobs.ListAsync(null, kind, RecentCount)).Items.Where(j => j.TargetIds.Contains(archive.Id)));
if (!IsShowing(archive)) return;
Recent = MaintenanceReports.Recent(jobs, RecentCount);
var scan = jobs.Where(j => j.Kind == JobKind.Scan && j is { State: JobState.Done, Finished: not null, Started: not null })
.MaxBy(j => j.Finished);
@@ -613,6 +651,9 @@ public sealed class ArchiveViewModel : SectionViewModel
private bool IsOnline() => _archive is not null && _availability == ArchiveAvailability.Online;
/// <summary>The archive a read started with is still the one picked.</summary>
private bool IsShowing(Core.Model.Archive archive) => _archive?.Id == archive.Id;
/// <summary>A command's tooltip, or why it is disabled: these commands write to the archive or read all of it.</summary>
private string WhenOnline(string key) => _archive is null || IsOnline() ? Loc.L(key) : Loc.L("Archive.Blocked.NotOnline");
+10 -1
View File
@@ -547,7 +547,10 @@ public sealed class ImportViewModel : SectionViewModel
get => _result;
private set
{
var replaced = _result;
if (!Set(ref _result, value)) return;
// A replaced result stops listening to language switches, which would otherwise keep it and its plan alive.
replaced?.Dispose();
if (value is null && _phase == ImportPhase.Done) Phase = ImportPhase.Ready;
}
}
@@ -1228,6 +1231,13 @@ public sealed class ImportViewModel : SectionViewModel
_jobCardId = cardId;
// Cancel pressed while the job was being queued.
if (cancelled.IsCancellationRequested && Services.Jobs is { } jobs) await jobs.CancelAsync(job.Id);
// A worker may have run the job to its end before its id was recorded here (a destination gone offline fails at
// once): those events went unseen, so the job's state is read back once.
if (Services.Database is { } db && await db.Jobs.GetAsync(job.Id) is { State: JobState.Done or JobState.Failed or JobState.Cancelled } ended)
{
await OnImportJobChangedAsync(ended);
return;
}
Shell.Notify(Loc.L("Import.Toast.Started", source.Title), plan.CopyCount > 0 ? _totals?.Text : null, Loc.L("Shell.Nav.Jobs"),
Loc.L("Tooltips.Nav.Jobs"), () => Shell.Navigate(SectionKey.Jobs));
}
@@ -1339,7 +1349,6 @@ public sealed class ImportViewModel : SectionViewModel
private void Finish(ImportPlan plan, ImportOutcome outcome)
{
_runCts = null;
_result?.Dispose();
var device = _selected?.Device is { } d && Services.Devices.Devices.Any(x => x.Identity == d.Identity) ? d : null;
var card = _selected?.Card ?? _cards.FirstOrDefault(c => c.Identity == _selected?.Key);
Result = new ImportResultViewModel(Shell, plan, outcome, _choices, _choices.Destination == ImportDestinationKind.Archive ? _archive : null, card, device);
@@ -1191,6 +1191,8 @@ public sealed class LibraryViewModel : SectionViewModel
_year = _year.IsAny ? Years[0] : _year;
_camera = _camera.IsAny ? Cameras[0] : _camera;
_tag = _tag.IsAny ? Tags[0] : _tag;
// The timeline's month readouts are sentences made with the figures: made again in the new language.
ApplyFacets();
foreach (var item in Items)
{
item.Update(item.Sequence);
@@ -170,6 +170,34 @@ public sealed class ArchiveScreenSmokeTests
static DialogFact Fact(RebuildDialogViewModel dialog, string label) => dialog.FactRows.Single(f => f.Label == Loc.L(label));
}
/// <summary>
/// Picking another archive while one is being read shows the picked one: the read in progress is followed by one of
/// the new archive, and meanwhile nothing of the previous archive's tree can be acted on.
/// </summary>
[Test]
public Task PickingAnotherArchiveDuringAReadShowsThePickedOne() => ScreenHost.RunAsync(async () =>
{
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
await app.Sample.FillAsync();
var archive = app.Shell.Archive;
await ArchiveScenes.ShowAsync(app.Shell, "overview");
Assert.Contains(archive.TreeRows, r => r.Node.Kind == TreeNodeKind.Sequence);
var second = await app.Services.Archives!.CreateAsync(Path.Combine(app.Services.Environment.DataDirectory, "second-archive"), "Second");
var reading = archive.LoadAsync();
archive.SelectedArchive = second;
Assert.Empty(archive.TreeRows);
Assert.False(archive.AnalyseSetCommand.CanExecute(null), "nothing of the first archive can be acted on while the picked one is read");
Assert.False(archive.ScanCommand.CanExecute(null), "the picked archive is not known to be online yet");
await reading;
Assert.Equal(second.Id, archive.SelectedArchive!.Id);
Assert.Contains(archive.Archives, a => a.Id == second.Id);
Assert.True(archive.TreeRows[0].IsArchive);
Assert.False(archive.TreeRows.Any(r => r.Node.Kind == TreeNodeKind.Sequence), "the tree is the picked, empty archive's");
Assert.True(archive.ScanCommand.CanExecute(null), "the picked archive was probed: it is online");
});
[Test]
public void TheArrowTowardsTheIndentOpensAYearInEitherDirection()
{
@@ -166,6 +166,62 @@ public sealed class ImportScreenSmokeTests
}
});
/// <summary>
/// An archive import whose job ends before the screen records its id (here cancelled inside the engine's own "queued"
/// event, so the screen sees none of its events) still ends the screen's run instead of leaving it copying forever.
/// </summary>
[Test]
public Task AnImportJobThatEndsBeforeItIsRecordedStillEndsTheRun() => ScreenHost.RunAsync(async () =>
{
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
await app.Sample.FillAsync();
var import = app.Shell.Import;
await ShowAsync(app, "plan");
var engine = Assert.NotNull(app.Services.Engine);
void CancelAtOnce(Core.Model.Job job)
{
if (job is { Kind: Core.Model.JobKind.Import, State: Core.Model.JobState.Queued }) engine.CancelAsync(job.Id).GetAwaiter().GetResult();
}
engine.JobChanged += CancelAtOnce;
try
{
Assert.True(import.StartCommand.CanExecute(null), "the plan can be imported");
import.StartCommand.Execute(null);
for (var i = 0; i < 300 && !import.IsFailed; i++) await Task.Delay(50);
}
finally
{
engine.JobChanged -= CancelAtOnce;
}
Assert.True(import.IsFailed, "the screen left Running though no event of the job reached it");
Assert.Equal(Loc.L("Import.Status.Cancelled"), import.ErrorText);
});
/// <summary>A result replaced by New import stops following the language: nothing keeps it, or its plan, alive.</summary>
[Test]
public Task AReplacedResultStopsFollowingTheLanguage() => ScreenHost.RunAsync(async () =>
{
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
await app.Sample.FillAsync();
var import = app.Shell.Import;
await ShowAsync(app, "done");
var replaced = Assert.NotNull(import.Result);
var refreshed = 0;
replaced.PropertyChanged += (_, _) => refreshed++;
import.NewImportCommand.Execute(null);
Assert.Null(import.Result);
try
{
UiLanguage.Apply("it");
}
finally
{
UiLanguage.Apply("en");
}
Assert.Equal(0, refreshed, "the replaced result was disposed");
await import.WaitForPlanAsync();
});
/// <summary>As <c>--capture</c> does: toasts of the previous state go, those of an insertion state stay.</summary>
private static async Task ShowAsync(ScreenSmokeTests.SampleApp app, string state)
{
@@ -3,6 +3,7 @@ using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using Titano.App.Archiving;
using Titano.App.Infrastructure;
using Titano.App.Library;
using Titano.App.Sections;
using Titano.App.Shell;
@@ -153,6 +154,32 @@ public sealed class LibraryScreenSmokeTests
trash.CloseCommand.Execute(null);
});
/// <summary>A language switch makes the timeline's month readouts again, as it does the filters (BRIEF §16).</summary>
[Test]
public Task TheTimelineReadoutsFollowALanguageSwitch() => ScreenHost.RunAsync(async () =>
{
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
await app.Sample.FillAsync();
await app.Shell.Services.Server.RestoreAsync();
await app.Shell.Services.Sync.RefreshAsync();
var library = app.Shell.Library;
await LibraryScenes.ShowAsync(app.Shell, "timeline");
var english = Readout(library);
try
{
UiLanguage.Apply("it");
var italian = Readout(library);
Assert.NotEqual(english, italian, "the month readouts follow the language");
}
finally
{
UiLanguage.Apply("en");
}
Assert.Equal(english, Readout(library), "and come back with it");
static string Readout(LibraryViewModel library) => library.TimelineBands[0].ToolTips!.First(t => !string.IsNullOrEmpty(t))!;
});
private static void Press(UIElement target, Key key) =>
target.RaiseEvent(new KeyEventArgs(Keyboard.PrimaryDevice, PresentationSource.FromVisual(target)!, 0, key) { RoutedEvent = Keyboard.KeyDownEvent });