diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 9936c0bf..9df8466c 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -46,7 +46,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S | `Model` | Domain entities and enums (§5) shared by Data, Server and clients | | `Packaging` | TPK1 installer payload writer/reader, staged install transaction | | `Diagnostics` | `Log`, file sink, synthetic sequences, `SecretScrubber`, `DiagnosticsArchive` (scrubbed diagnostics zip) | -| `Localization`, `IO`, `Hashing`, `Branding` | `Loc`/plural rules, `AtomicFile`, CRC-32/SHA helpers, brand mark geometry | +| `Localization`, `IO`, `Hashing`, `Branding` | `Loc`/plural rules, `AtomicFile`, `StartupCommand` (sign-in entries of the programs, removed by the uninstaller), CRC-32/SHA helpers, brand mark geometry | ### 2.2 Titano.Data @@ -71,8 +71,8 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S | `Import` | `CardPool` (inserted cards, remembered cards, folders), camera profiles, plans and choices, destinations (archive, folder, server through `ServerImportSink`), card actions (verified delete, format, eject) | | `Archive` | `CurrentArchive`, `ArchiveTree`, figures for the charts, maintenance reports, mass rename and move, delete and trash dialogs (`SequenceDeletion`, `DeletePlans`), `ArchiveFailures` | | `Server` | `ServerSession`, `ConnectFlow` (trust on first use), `SyncHost` (sync engine, agent, metered hold, editor connections, Export Sync), sync table, `RemoteSequenceApi` | -| `Jobs`, `Settings`, `About` | Job list and buffering, `JobNotices` (which job endings raise a toast); settings rows, encoder inventory, language catalog, naming preview; update check and download | -| `Infrastructure` | `AppServices` (composition root), `AppSettings`, `AppEnvironment` (installed or portable), `UiLanguage`, `LiveRegion`, `RenderNodeHost`, `DiagnosticsBundle`, `ShellActions` (BRIEF §8.6), device monitor | +| `Jobs`, `Settings`, `About` | Job list and buffering, `JobNotices` (which job endings raise a toast; `JobEndings` lets a batch speak once); settings rows, encoder inventory, language catalog, naming preview; update check and download | +| `Infrastructure` | `AppServices` (composition root), `AppSettings`, `AppEnvironment` (installed or portable), `StartWithWindows` (this copy's sign-in entry), `UiLanguage`, `LiveRegion`, `RenderNodeHost`, `DiagnosticsBundle`, `ShellActions` (BRIEF §8.6), device monitor | | `DesignTime` | `SampleData`: the archive, jobs and server the screenshots and smoke tests run on | ### 2.4 Titano.Ui and Titano.Server diff --git a/i18n/en/Shell.resx b/i18n/en/Shell.resx index 40ec77a9..478c846a 100644 --- a/i18n/en/Shell.resx +++ b/i18n/en/Shell.resx @@ -6,7 +6,11 @@ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Titanoinvariant Job finished + {0} job finished + {0} jobs finished Job failed + {0} job failed + {0} jobs failed Ready Pause job Ready · {0} jobs queued diff --git a/i18n/it/Shell.it.resx b/i18n/it/Shell.it.resx index 676f7569..417f41f4 100644 --- a/i18n/it/Shell.it.resx +++ b/i18n/it/Shell.it.resx @@ -5,7 +5,11 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Attività completata + {0} attività completata + {0} attività completate Attività non riuscita + {0} attività non riuscita + {0} attività non riuscite Pronto Pausa attività Pronto · {0} attività in coda diff --git a/src/Titano.App/Jobs/JobListModel.cs b/src/Titano.App/Jobs/JobListModel.cs index 4621ace1..364396fd 100644 --- a/src/Titano.App/Jobs/JobListModel.cs +++ b/src/Titano.App/Jobs/JobListModel.cs @@ -137,6 +137,13 @@ public sealed class JobListModel public int QueuedCount => _entries.Values.Count(e => e.State == JobState.Queued); + /// + /// A job of that the user waits for (not background work) is queued or running. Paused jobs + /// do not count: they wait for the user, or for an unmetered network, not for the queue. + /// + public bool IsBusy(JobKind kind) => + _entries.Values.Any(e => e.Job.Kind == kind && e.Job.Priority != JobPriority.Background && e.State is JobState.Queued or JobState.Running); + /// Same order as JobRepository.ClaimNextAsync: priority descending, then creation time and id. public static bool ClaimsBefore(Job a, Job b) => a.Priority != b.Priority ? a.Priority > b.Priority : a.Created != b.Created ? a.Created < b.Created : a.Id.CompareTo(b.Id) < 0; diff --git a/src/Titano.App/Jobs/JobNotices.cs b/src/Titano.App/Jobs/JobNotices.cs index 8d516776..71a7f036 100644 --- a/src/Titano.App/Jobs/JobNotices.cs +++ b/src/Titano.App/Jobs/JobNotices.cs @@ -14,7 +14,8 @@ public enum JobNotice /// Which job endings raise a toast (BRIEF §12.1 "toasts for job completion"): the long operations the user asked for /// end with one toast, whichever screen started them. Background work (thumbnails, proxies, light analysis, the /// analysis queued after an import) and scans (the archive is rescanned every 10 minutes) end silently; an import -/// has its own toast when it ends well, and the Import screen holds its retry. Cancelled jobs were stopped on purpose. +/// has its own toast when it ends well, and a download shows on its Library card and Server row. Every other failure +/// is said. Cancelled jobs were stopped on purpose. /// public static class JobNotices { @@ -29,11 +30,69 @@ public static class JobNotices return job.State switch { JobState.Done when Announces(job.Kind) => JobNotice.Done, - JobState.Failed when Announces(job.Kind) || job.Kind == JobKind.Import => JobNotice.Failed, + JobState.Failed when !IsUpkeep(job.Kind) => JobNotice.Failed, _ => JobNotice.None, }; } private static bool Announces(JobKind kind) => - kind is JobKind.Render or JobKind.DeepAnalyse or JobKind.Verify or JobKind.Rebuild or JobKind.Maintenance or JobKind.UploadCommit; + kind is JobKind.Render or JobKind.DeepAnalyse or JobKind.Verify or JobKind.Rebuild or JobKind.Maintenance or JobKind.UploadCommit + or JobKind.Move or JobKind.Adopt; + + /// Work that keeps the index and its previews current: the next run repeats it, the Archive screen shows what is missing. + private static bool IsUpkeep(JobKind kind) => + kind is JobKind.Scan or JobKind.Thumbs or JobKind.Proxies or JobKind.LightAnalyse; +} + +/// Endings said in one toast: one job, or several of a batch. +public sealed record JobEnding(JobNotice Notice, IReadOnlyList Jobs); + +/// +/// Job endings waiting for their toast, so that a batch speaks once (Server › Upload all queues one upload per +/// sequence): finished jobs of one kind wait until no job of that kind the user waits for is queued or running, then +/// one toast says how many finished; failures are said at the end of the update that brought them, together when +/// several failed at once. WPF-free; feed it on the UI thread. +/// +public sealed class JobEndings +{ + private readonly SortedDictionary> _done = []; + private readonly List _failed = []; + + /// Finished jobs still waiting for the rest of their kind (tests). + public int Waiting => _done.Values.Sum(l => l.Count); + + public void Add(JobNotice notice, Job job) + { + ArgumentNullException.ThrowIfNull(job); + if (notice == JobNotice.Failed) + { + _failed.Add(job); + } + else if (notice == JobNotice.Done) + { + if (!_done.TryGetValue(job.Kind, out var jobs)) _done[job.Kind] = jobs = []; + jobs.Add(job); + } + } + + /// + /// The toasts due now: the failures added since the last call, then each finished kind that + /// no longer reports as queued or running. What is returned is forgotten. + /// + public IReadOnlyList Take(Func busy) + { + ArgumentNullException.ThrowIfNull(busy); + var due = new List(); + if (_failed.Count > 0) + { + due.Add(new JobEnding(JobNotice.Failed, [.. _failed])); + _failed.Clear(); + } + foreach (var kind in _done.Keys.Where(k => !busy(k)).ToList()) + { + due.Add(new JobEnding(JobNotice.Done, _done[kind])); + _done.Remove(kind); + } + return due; + } } diff --git a/src/Titano.App/Sections/ArchiveViewModel.cs b/src/Titano.App/Sections/ArchiveViewModel.cs index a2d11016..6bc7ee4c 100644 --- a/src/Titano.App/Sections/ArchiveViewModel.cs +++ b/src/Titano.App/Sections/ArchiveViewModel.cs @@ -484,6 +484,8 @@ public sealed class ArchiveViewModel : SectionViewModel _ => null, })), ]; + // The rail badge counts the health lines that need attention (BRIEF §12.1 "badge counts (warnings, …)"). + Badge = Health.Count(h => !h.IsOk); } private static IReadOnlyList Bars(IReadOnlyList values) => diff --git a/src/Titano.App/Sections/ImportViewModel.cs b/src/Titano.App/Sections/ImportViewModel.cs index 763091c5..f934a46e 100644 --- a/src/Titano.App/Sections/ImportViewModel.cs +++ b/src/Titano.App/Sections/ImportViewModel.cs @@ -1399,7 +1399,7 @@ public sealed class ImportViewModel : SectionViewModel if (_phase == ImportPhase.Failed && _jobId is not null && _jobSourceKey == device.Identity) { Shell.Notify(Loc.L("Import.Toast.Inserted", source.Title), Loc.L("Import.Toast.ResumeMessage"), Loc.L("Import.Toast.Resume"), - Loc.L("Tooltips.Import.Resume"), () => RetryCommand.Execute(null)); + Loc.L("Tooltips.Import.Resume"), () => RetryCommand.Execute(null), runsFromNotification: true); return; } if (_phase == ImportPhase.Running) return; @@ -1425,6 +1425,8 @@ public sealed class ImportViewModel : SectionViewModel SelectSource(device.Identity); Shell.Navigate(SectionKey.Import); }), + // BRIEF §12.4: the Windows notification "Card X detected — Import" opens the card on Import. + RunsFromNotification = true, }); } diff --git a/src/Titano.App/Sections/JobsViewModel.cs b/src/Titano.App/Sections/JobsViewModel.cs index e82b8f4c..fff2a7fb 100644 --- a/src/Titano.App/Sections/JobsViewModel.cs +++ b/src/Titano.App/Sections/JobsViewModel.cs @@ -62,6 +62,7 @@ public sealed class JobsViewModel : SectionViewModel private readonly JobUpdateBuffer _buffer = new(); private readonly Dictionary _rows = []; private readonly HashSet _unseenFailures = []; + private readonly JobEndings _endings = new(); private readonly JobActions _actions; private CoalescingThrottle? _throttle; private IJobQueue? _queue; @@ -227,6 +228,7 @@ public sealed class JobsViewModel : SectionViewModel Follow(before, job); } foreach (var p in progress) _model.Apply(p); + foreach (var ending in _endings.Take(_model.IsBusy)) Shell.ShowToast(ToastFor(ending)); SyncRows(); UpdateShell(); } @@ -241,43 +243,72 @@ public sealed class JobsViewModel : SectionViewModel /// /// A change the engine reported (these are live, never pages read again): a failure counts on the rail until this - /// screen is opened, and a long operation that ends says so in a toast with one action (BRIEF §12.1, §0.2 rule 6). + /// screen is opened, and a long operation that ends is announced at the end of the flush (). /// private void Follow(JobState? before, Job job) { if (job.State != JobState.Failed) _unseenFailures.Remove(job.Id); else if (before != JobState.Failed && !IsSelected) _unseenFailures.Add(job.Id); var notice = JobNotices.For(before, job); - if (notice == JobNotice.None || (notice == JobNotice.Done && EditorAnnounces(job))) return; - Shell.ShowToast(notice == JobNotice.Done - ? new Toast + if (notice == JobNotice.Done && EditorAnnounces(job)) return; + _endings.Add(notice, job); + } + + /// + /// The toast of a job that ended, with one action (BRIEF §12.1, §0.2 rule 6). Several endings at once (a batch + /// finished, or failed together) say how many and lead to this screen. Clicking the Windows notification of a + /// toast opens what it names; a retry waits until the user has seen why the job failed. + /// + private Toast ToastFor(JobEnding ending) + { + var job = ending.Jobs[0]; + var failed = ending.Notice == JobNotice.Failed; + if (ending.Jobs.Count > 1) + { + return new Toast + { + Title = Loc.Plural(failed ? "Shell.Job.FailedPlural" : "Shell.Job.DonePlural", ending.Jobs.Count), + Message = ending.Jobs.All(j => j.Kind == job.Kind) ? JobText.Kind(job.Kind) : null, + ActionText = Loc.L("Shell.Nav.Jobs"), + ActionToolTip = Loc.L("Tooltips.Nav.Jobs"), + ActionCommand = new RelayCommand(() => Shell.Navigate(SectionKey.Jobs)), + IsError = failed, + RunsFromNotification = true, + }; + } + if (!failed) + { + return new Toast { Title = Loc.L("Shell.Job.Done"), Message = JobText.Name(job), ActionText = Loc.L("Jobs.Action.Open"), ActionToolTip = Loc.L("Tooltips.Jobs.Open"), ActionCommand = new AsyncRelayCommand(() => OpenTargetAsync(job)), + RunsFromNotification = true, + }; + } + return job.Kind == JobKind.Import + // The Import screen resumes an import with its plan and card; it holds the retry. + ? new Toast + { + Title = Loc.L("Shell.Job.Failed"), + Message = JobText.Name(job), + ActionText = Loc.L("Shell.Nav.Import"), + ActionToolTip = Loc.L("Tooltips.Nav.Import"), + ActionCommand = new RelayCommand(() => Shell.Navigate(SectionKey.Import)), + IsError = true, + RunsFromNotification = true, } - : job.Kind == JobKind.Import - // The Import screen resumes an import with its plan and card; it holds the retry. - ? new Toast - { - Title = Loc.L("Shell.Job.Failed"), - Message = JobText.Name(job), - ActionText = Loc.L("Shell.Nav.Import"), - ActionToolTip = Loc.L("Tooltips.Nav.Import"), - ActionCommand = new RelayCommand(() => Shell.Navigate(SectionKey.Import)), - IsError = true, - } - : new Toast - { - Title = Loc.L("Shell.Job.Failed"), - Message = JobText.Name(job), - ActionText = Loc.L("Jobs.Action.Retry"), - ActionToolTip = Loc.L("Tooltips.Jobs.Retry"), - ActionCommand = new AsyncRelayCommand(() => _queue?.ResumeAsync(job.Id) ?? Task.CompletedTask), - IsError = true, - }); + : new Toast + { + Title = Loc.L("Shell.Job.Failed"), + Message = JobText.Name(job), + ActionText = Loc.L("Jobs.Action.Retry"), + ActionToolTip = Loc.L("Tooltips.Jobs.Retry"), + ActionCommand = new AsyncRelayCommand(() => _queue?.ResumeAsync(job.Id) ?? Task.CompletedTask), + IsError = true, + }; } /// A finished render of the sequence open in the editor: the editor says it, with its output file. diff --git a/src/Titano.App/Sections/LibraryViewModel.cs b/src/Titano.App/Sections/LibraryViewModel.cs index 9b680bdc..5af04da3 100644 --- a/src/Titano.App/Sections/LibraryViewModel.cs +++ b/src/Titano.App/Sections/LibraryViewModel.cs @@ -700,6 +700,7 @@ public sealed class LibraryViewModel : SectionViewModel _hasArchive = (await _db.Archives.ListAsync()).Count > 0; Shell.SetLibraryTotals(stats.Sequences, stats.Photos, stats.Bytes); _localStats = stats; + await CountWarningsAsync(); _suppressReload = true; var tag = _tag.Value; @@ -1025,6 +1026,8 @@ public sealed class LibraryViewModel : SectionViewModel if (job.Kind is JobKind.Scan or JobKind.Rebuild or JobKind.Import or JobKind.Adopt or JobKind.Move or JobKind.UploadCommit || SyncService.TransferKind(job) is SyncTransferKind.DownloadOriginals or SyncTransferKind.GetExports) await RefreshAsync(); + else if (job.Kind is JobKind.LightAnalyse or JobKind.DeepAnalyse) + await CountWarningsAsync(); } catch (DatabaseException ex) { @@ -1032,6 +1035,15 @@ public sealed class LibraryViewModel : SectionViewModel } } + /// + /// The rail badge counts the sequences of this PC with warnings (BRIEF §12.1 "badge counts (warnings, …)"), the + /// ones the Warnings filter shows; analyses change it. + /// + private async Task CountWarningsAsync() + { + if (_db is not null) Badge = await _db.Sequences.CountAsync(new SequenceQuery { WithStatus = SequenceStatus.HasWarnings }); + } + /// Open: the editor for a sequence here; for a remote card, with proxies (fetched first when this PC has none). private async Task OpenAsync(SequenceItem item) { diff --git a/src/Titano.App/Shell/MainWindow.xaml.cs b/src/Titano.App/Shell/MainWindow.xaml.cs index 4dd67dac..d8d19c07 100644 --- a/src/Titano.App/Shell/MainWindow.xaml.cs +++ b/src/Titano.App/Shell/MainWindow.xaml.cs @@ -43,6 +43,17 @@ public partial class MainWindow : TitanoWindow internal static bool StartsMinimized(IReadOnlyList arguments) => arguments.Any(a => a.Equals(RunKeyStartWithWindows.MinimizedOption, StringComparison.OrdinalIgnoreCase)); + /// Minimised until the user opens it; that first restore brings back the saved state (maximised or not). + internal void WaitMinimized(bool maximized) + { + WindowState = WindowState.Minimized; + _restoreTo = maximized ? WindowState.Maximized : WindowState.Normal; + } + + /// The maximised flag to save: a window started minimised and never opened keeps the state it would come back to. + internal static bool SavesMaximized(WindowState state, WindowState? restoreTo) => + state == WindowState.Maximized || (state == WindowState.Minimized && restoreTo == WindowState.Maximized); + /// The first restore of a window started minimised brings back the saved maximised state. protected override void OnStateChanged(EventArgs e) { @@ -101,11 +112,7 @@ public partial class MainWindow : TitanoWindow if (_shell.Services.Environment.IsCapture) return; var p = _shell.Services.Settings.Window; var maximized = p?.Maximized == true; - if (StartsMinimized(Environment.GetCommandLineArgs())) - { - WindowState = WindowState.Minimized; - _restoreTo = maximized ? WindowState.Maximized : WindowState.Normal; - } + if (StartsMinimized(Environment.GetCommandLineArgs())) WaitMinimized(maximized); if (p is null || p.Width < MinWidth || p.Height < MinHeight) return; var virtualScreen = new Rect(SystemParameters.VirtualScreenLeft, SystemParameters.VirtualScreenTop, SystemParameters.VirtualScreenWidth, SystemParameters.VirtualScreenHeight); var rect = new Rect(p.Left, p.Top, p.Width, p.Height); @@ -128,8 +135,7 @@ public partial class MainWindow : TitanoWindow Top = b.Top, Width = b.Width, Height = b.Height, - // Started minimised and never opened: the saved state stays the one it would have been restored to. - Maximized = WindowState == WindowState.Maximized || (WindowState == WindowState.Minimized && _restoreTo == WindowState.Maximized), + Maximized = SavesMaximized(WindowState, _restoreTo), }; } } diff --git a/src/Titano.App/Shell/OsNotifications.cs b/src/Titano.App/Shell/OsNotifications.cs index 38c81783..906db231 100644 --- a/src/Titano.App/Shell/OsNotifications.cs +++ b/src/Titano.App/Shell/OsNotifications.cs @@ -9,8 +9,10 @@ namespace Titano.App.Shell; /// Windows notifications for the toasts nobody would see (BRIEF §12.1 "optional OS toast when minimised", §12.4 "Card /// X detected — Import"): while the main window is minimised, hidden or behind another program, every toast also goes /// to a tray balloon, which Windows 10/11 shows as a notification, when Settings › General allows it. Clicking it -/// brings the window back and runs the toast's action. The tray icon exists only while such a notification can be -/// clicked: it goes once a window of Titano is active again. Create, use and dispose it on the UI thread. +/// brings the window back; it also runs the toast's action when the toast allows it +/// () and it is the only notification shown, since Windows does not say which +/// of several was clicked. The tray icon exists only while such a notification can be clicked: it goes once a window +/// of Titano is active again. Create, use and dispose it on the UI thread. /// public sealed class OsNotifications : IDisposable { @@ -21,6 +23,7 @@ public sealed class OsNotifications : IDisposable private readonly Action _dismiss; private TrayIcon? _tray; private Toast? _latest; + private int _shown; private bool _disposed; /// The main window, restored by a click. @@ -44,6 +47,7 @@ public sealed class OsNotifications : IDisposable if (_disposed || !_enabled() || !IsUnseen(_window.WindowState, _window.IsVisible, AnyWindowActive())) return false; _tray ??= new TrayIcon(Loc.L("Shell.AppName"), Menu, OnMenu, Restore, OnBalloonClicked); _latest = toast; + _shown++; _tray.ShowBalloon(toast.Title, BalloonText(toast), toast.IsError); return true; } @@ -60,16 +64,31 @@ public sealed class OsNotifications : IDisposable state == WindowState.Minimized || !isVisible || !anyWindowActive; /// - /// The notification's text: the toast's message, then its action ("Import"), which a click on it runs; the title - /// alone when there is neither (Windows needs a text to show a notification at all). + /// The notification's text: the toast's message, then the action a click on it runs ("Import"); the title alone + /// when there is neither (Windows needs a text to show a notification at all). An action a click does not run + /// waits in the window and is not offered here. /// public static string BalloonText(Toast toast) { ArgumentNullException.ThrowIfNull(toast); - var lines = new[] { toast.Message, toast.ActionText }.Where(l => !string.IsNullOrWhiteSpace(l)); + var lines = new[] { toast.Message, toast.RunsFromNotification ? toast.ActionText : null }.Where(l => !string.IsNullOrWhiteSpace(l)); return string.Join(Environment.NewLine, lines) is { Length: > 0 } text ? text : toast.Title; } + /// + /// A notification was clicked: the window comes back, and the toast's action runs when the toast allows it and + /// no other notification was shown since the icon appeared (Windows does not say which one was clicked). + /// + internal void OnBalloonClicked() + { + var toast = _shown == 1 ? _latest : null; + _latest = null; + Restore(); + if (toast is not { RunsFromNotification: true, ActionCommand: { } command } || !command.CanExecute(null)) return; + command.Execute(null); + _dismiss(toast); + } + private static bool AnyWindowActive() => Application.Current?.Windows.OfType().Any(w => w.IsActive) ?? false; private IReadOnlyList Menu() => [new(MenuShow, Loc.L("Shell.Tray.Show"))]; @@ -87,16 +106,6 @@ public sealed class OsNotifications : IDisposable _window.Activate(); } - private void OnBalloonClicked() - { - var toast = _latest; - _latest = null; - Restore(); - if (toast?.ActionCommand is not { } command || !command.CanExecute(null)) return; - command.Execute(null); - _dismiss(toast); - } - /// /// Back in front: the notifications have done their job. The icon goes after the current message, since activation /// may come from a click the icon's own window is still handling, unless the window went to the background again. @@ -113,6 +122,7 @@ public sealed class OsNotifications : IDisposable private void RemoveIcon() { _latest = null; + _shown = 0; _tray?.Dispose(); _tray = null; } diff --git a/src/Titano.App/Shell/ShellViewModel.cs b/src/Titano.App/Shell/ShellViewModel.cs index e762d7f7..0cd51a77 100644 --- a/src/Titano.App/Shell/ShellViewModel.cs +++ b/src/Titano.App/Shell/ShellViewModel.cs @@ -291,8 +291,10 @@ public sealed class ShellViewModel : LocalizedViewModel /// /// A one-line notice with one action (job done, update available). marks something that /// did not happen or failed: screen readers then say it at once instead of after what they are reading. + /// : a click on its Windows notification also runs the action (). /// - public void Notify(string title, string? message = null, string? actionText = null, string? actionToolTip = null, Action? action = null, bool isError = false) => + public void Notify(string title, string? message = null, string? actionText = null, string? actionToolTip = null, Action? action = null, bool isError = false, + bool runsFromNotification = false) => ShowToast(new Toast { Title = title, @@ -301,6 +303,7 @@ public sealed class ShellViewModel : LocalizedViewModel ActionToolTip = actionToolTip, ActionCommand = action is null ? null : new RelayCommand(action), IsError = isError, + RunsFromNotification = runsFromNotification, }); /// Errors are one sentence saying what happened plus one action (BRIEF §0.2 rule 6); the details go to the log. diff --git a/src/Titano.Ui/Controls/Toasts.cs b/src/Titano.Ui/Controls/Toasts.cs index 16f8c33c..f4538890 100644 --- a/src/Titano.Ui/Controls/Toasts.cs +++ b/src/Titano.Ui/Controls/Toasts.cs @@ -22,6 +22,13 @@ public sealed class Toast : ObservableObject /// Something failed: screen readers say it at once, ahead of other notices (assertive, not polite). public bool IsError { get; init; } + + /// + /// A click on the toast's Windows notification also runs its action (it opens what the toast names). Off by + /// default: people click a notification to bring the window back, so a Cancel, Undo or Retry there would act + /// before they have read why. + /// + public bool RunsFromNotification { get; init; } } /// diff --git a/tests/Titano.App.Tests/Jobs/JobNoticesTests.cs b/tests/Titano.App.Tests/Jobs/JobNoticesTests.cs index 69136c59..797ebb88 100644 --- a/tests/Titano.App.Tests/Jobs/JobNoticesTests.cs +++ b/tests/Titano.App.Tests/Jobs/JobNoticesTests.cs @@ -4,7 +4,7 @@ using Titano.Testing; namespace Titano.App.Tests.Jobs; -/// UI-08: which job endings raise the shell's toast, whichever screen started the job. +/// UI-08: which job endings raise the shell's toast, whichever screen started the job, and how a batch speaks once. public sealed class JobNoticesTests { [Theory] @@ -14,6 +14,8 @@ public sealed class JobNoticesTests [Case(JobKind.Rebuild)] [Case(JobKind.Maintenance)] [Case(JobKind.UploadCommit)] + [Case(JobKind.Move)] + [Case(JobKind.Adopt)] public void ALongOperationThatEndsSaysSo(JobKind kind) { Assert.Equal(JobNotice.Done, JobNotices.For(JobState.Running, Job(kind, JobState.Done))); @@ -28,26 +30,30 @@ public sealed class JobNoticesTests [Case(JobKind.LightAnalyse)] [Case(JobKind.Thumbs)] [Case(JobKind.Proxies)] - [Case(JobKind.Download)] - public void BackgroundWorkAndScansEndSilently(JobKind kind) + public void UpkeepAndScansEndSilently(JobKind kind) { Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Done))); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Failed))); } - [Test] - public void AnImportSaysOnlyThatItFailed() + [Theory] + [Case(JobKind.Import)] + [Case(JobKind.Download)] + [Case(JobKind.Duplicates)] + [Case(JobKind.Orphans)] + public void EveryOtherFailureIsSaid(JobKind kind) { - // The Import screen announces a finished import with its result. - Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(JobKind.Import, JobState.Done))); - Assert.Equal(JobNotice.Failed, JobNotices.For(JobState.Running, Job(JobKind.Import, JobState.Failed))); + // An import announces its result on the Import screen, a download on its Library card and Server row. + Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Done))); + Assert.Equal(JobNotice.Failed, JobNotices.For(JobState.Running, Job(kind, JobState.Failed))); } [Test] public void BackgroundPriorityCancelledAndRepeatedEndingsSayNothing() { - // The deep analysis queued after an import runs in the background. + // The deep analysis queued after an import, and the proxies sync fetches, run in the background. Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(JobKind.DeepAnalyse, JobState.Done, JobPriority.Background))); + Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(JobKind.Download, JobState.Failed, JobPriority.Background))); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(JobKind.Render, JobState.Cancelled))); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Done, Job(JobKind.Render, JobState.Done))); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Failed, Job(JobKind.Render, JobState.Failed))); @@ -56,6 +62,84 @@ public sealed class JobNoticesTests Assert.Equal(JobNotice.Done, JobNotices.For(JobState.Running, Job(JobKind.Render, JobState.Done, JobPriority.Normal))); } + [Test] + public void ABatchOfOneKindSpeaksOnceWhenItsLastJobEnds() + { + // Server › Upload all: 100 uploads queued; each one that ends waits for the rest. + var endings = new JobEndings(); + var model = new JobListModel(); + var uploads = Enumerable.Range(0, 100).Select(_ => Job(JobKind.UploadCommit, JobState.Queued)).ToList(); + foreach (var upload in uploads) model.Apply(upload); + for (var i = 0; i < 99; i++) + { + var done = uploads[i] with { State = JobState.Done }; + model.Apply(done); + endings.Add(JobNotices.For(JobState.Running, done), done); + Assert.Empty(endings.Take(model.IsBusy)); + } + Assert.Equal(99, endings.Waiting); + + // A render of the same flush is its own kind: it is said at once. + var render = Job(JobKind.Render, JobState.Done); + model.Apply(render); + endings.Add(JobNotice.Done, render); + var due = endings.Take(model.IsBusy); + Assert.Count(1, due); + Assert.Equal(JobNotice.Done, due[0].Notice); + Assert.SequenceEqual([render.Id], due[0].Jobs.Select(j => j.Id)); + + var last = uploads[99] with { State = JobState.Done }; + model.Apply(last); + endings.Add(JobNotice.Done, last); + due = endings.Take(model.IsBusy); + Assert.Count(1, due); + Assert.SequenceEqual(uploads.Select(u => u.Id), due[0].Jobs.Select(j => j.Id)); + Assert.Equal(0, endings.Waiting); + Assert.Empty(endings.Take(model.IsBusy)); + } + + [Test] + public void PausedAndBackgroundJobsDoNotHoldABatch() + { + var endings = new JobEndings(); + var model = new JobListModel(); + // An upload paused on a metered network, and the proxies sync fetches in the background, wait for something else. + model.Apply(Job(JobKind.UploadCommit, JobState.Paused)); + model.Apply(Job(JobKind.Download, JobState.Running, JobPriority.Background)); + var upload = Job(JobKind.UploadCommit, JobState.Done); + model.Apply(upload); + endings.Add(JobNotice.Done, upload); + Assert.Count(1, endings.Take(model.IsBusy)); + Assert.False(model.IsBusy(JobKind.UploadCommit)); + Assert.False(model.IsBusy(JobKind.Download)); + } + + [Test] + public void FailuresAreSaidAtTheEndOfTheirFlushTogether() + { + var endings = new JobEndings(); + var model = new JobListModel(); + // More uploads still run: failures do not wait for them. + model.Apply(Job(JobKind.UploadCommit, JobState.Running)); + var first = Job(JobKind.UploadCommit, JobState.Failed); + var second = Job(JobKind.Verify, JobState.Failed); + endings.Add(JobNotice.Failed, first); + endings.Add(JobNotice.Failed, second); + endings.Add(JobNotice.None, Job(JobKind.Scan, JobState.Done)); + var due = endings.Take(model.IsBusy); + Assert.Count(1, due); + Assert.Equal(JobNotice.Failed, due[0].Notice); + Assert.SequenceEqual([first.Id, second.Id], due[0].Jobs.Select(j => j.Id)); + + // The next flush starts again. + var third = Job(JobKind.UploadCommit, JobState.Failed); + endings.Add(JobNotice.Failed, third); + due = endings.Take(model.IsBusy); + Assert.Count(1, due); + Assert.SequenceEqual([third.Id], due[0].Jobs.Select(j => j.Id)); + Assert.Empty(endings.Take(model.IsBusy)); + } + private static Job Job(JobKind kind, JobState state, JobPriority priority = JobPriority.User) => new() { Id = Guid.CreateVersion7(), diff --git a/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs b/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs index 03771f37..11b19f09 100644 --- a/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs +++ b/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs @@ -8,6 +8,7 @@ using Titano.App.Settings; using Titano.App.Shell; using Titano.Core.Localization; using Titano.Core.Model; +using Titano.Data.Repositories; using Titano.Testing; using Titano.Ui.Controls; using Titano.Ui.Mvvm; @@ -110,6 +111,7 @@ public sealed class ShellNotificationTests var done = raised.Single(t => t.Title == Loc.L("Shell.Job.Done")); Assert.Equal(Loc.L("Jobs.Action.Open"), done.ActionText); Assert.False(done.IsError); + Assert.True(done.RunsFromNotification, "a click on the Windows notification opens what the job worked on"); // The same ending reported again says nothing more. jobs.OnJobChanged(analysis with { State = JobState.Done }); jobs.Flush(); @@ -124,6 +126,7 @@ public sealed class ShellNotificationTests var failed = raised.Single(t => t.Title == Loc.L("Shell.Job.Failed")); Assert.True(failed.IsError); Assert.Equal(Loc.L("Jobs.Action.Retry"), failed.ActionText); + Assert.False(failed.RunsFromNotification, "a click on the Windows notification does not retry before the user sees why"); Assert.Equal(badge + 1, jobs.Badge); Assert.Equal(TaskbarItemProgressState.Error, shell.TaskbarState); shell.Navigate(SectionKey.Jobs); @@ -150,6 +153,37 @@ public sealed class ShellNotificationTests jobs.Flush(); Assert.Equal(1, raised.Count(t => t.Title == Loc.L("Shell.Job.Done"))); await shell.Sequence.CloseAsync(); + + // Server › Upload all: the batch speaks once, when its last upload ends. + raised.Clear(); + var uploads = Enumerable.Range(0, 3).Select(_ => Job(JobKind.UploadCommit, JobState.Queued, Guid.CreateVersion7())).ToList(); + foreach (var upload in uploads) jobs.OnJobChanged(upload); + jobs.Flush(); + foreach (var upload in uploads) + { + Assert.Empty(raised); + jobs.OnJobChanged(upload with { State = JobState.Done }); + jobs.Flush(); + } + var batch = raised.Single(); + Assert.Equal(Loc.Plural("Shell.Job.DonePlural", 3), batch.Title); + Assert.Equal(Loc.L("Jobs.Kind.UploadCommit"), batch.Message); + Assert.Equal(Loc.L("Shell.Nav.Jobs"), batch.ActionText); + shell.Navigate(SectionKey.Library); + batch.ActionCommand!.Execute(null); + Assert.Equal(SectionKey.Jobs, shell.Current.Key); + + // Two failures of one update: one error toast that leads to the Jobs screen. + raised.Clear(); + var broken = new[] { Job(JobKind.Move, JobState.Running, Guid.CreateVersion7()), Job(JobKind.Adopt, JobState.Running, Guid.CreateVersion7()) }; + foreach (var job in broken) jobs.OnJobChanged(job); + jobs.Flush(); + foreach (var job in broken) jobs.OnJobChanged(job with { State = JobState.Failed }); + jobs.Flush(); + var failures = raised.Single(); + Assert.True(failures.IsError); + Assert.Equal(Loc.Plural("Shell.Job.FailedPlural", 2), failures.Title); + Assert.Null(failures.Message); }); [Test] @@ -161,9 +195,12 @@ public sealed class ShellNotificationTests Assert.False(OsNotifications.IsUnseen(WindowState.Maximized, isVisible: true, anyWindowActive: true)); // The card prompt of BRIEF §12.4 reads "Card X detected", then its action, which a click runs. - var card = new Toast { Title = "EOS R5 card A inserted", Message = "SD 128 GB", ActionText = "Import" }; + var card = new Toast { Title = "EOS R5 card A inserted", Message = "SD 128 GB", ActionText = "Import", RunsFromNotification = true }; Assert.Equal("SD 128 GB" + Environment.NewLine + "Import", OsNotifications.BalloonText(card)); Assert.Equal("Job finished", OsNotifications.BalloonText(new Toast { Title = "Job finished" })); + // An action a click does not run (the auto-import's Cancel) waits in the window. + var auto = new Toast { Title = "EOS R5 card A inserted", Message = "Importing into the archive", ActionText = "Cancel" }; + Assert.Equal("Importing into the archive", OsNotifications.BalloonText(auto)); Assert.True(MainWindow.StartsMinimized(["Titano.exe", "--minimized"])); Assert.False(MainWindow.StartsMinimized(["Titano.exe"])); @@ -184,6 +221,80 @@ public sealed class ShellNotificationTests app.Window.WindowState = WindowState.Normal; }); + [Test] + public Task AClickOnANotificationBringsTheWindowBackAndRunsOnlyWhatItNames() => ScreenHost.RunAsync(async () => + { + await using var app = await ScreenSmokeTests.SampleApp.StartAsync(); + app.Shell.CompleteWelcome(); + var window = app.Window; + var imported = 0; + var cancelled = 0; + var dismissed = new List(); + Toast Import() => new() { Title = "EOS R5 card A inserted", ActionText = "Import", ActionCommand = new RelayCommand(() => imported++), RunsFromNotification = true }; + + // "Card X detected — Import": the click restores the window, opens the card and closes the in-window toast. + using (var notifications = new OsNotifications(window, () => true, dismissed.Add)) + { + window.WindowState = WindowState.Minimized; + var card = Import(); + Assert.True(notifications.Show(card)); + notifications.OnBalloonClicked(); + await StateAsync(window, WindowState.Normal); + Assert.Equal(1, imported); + Assert.SequenceEqual([card], dismissed); + } + + // The auto-import's toast offers Cancel: the click only brings the window back. + using (var notifications = new OsNotifications(window, () => true, dismissed.Add)) + { + window.WindowState = WindowState.Minimized; + Assert.True(notifications.Show(new Toast { Title = "EOS R5 card A inserted", ActionText = "Cancel", ActionCommand = new RelayCommand(() => cancelled++) })); + notifications.OnBalloonClicked(); + await StateAsync(window, WindowState.Normal); + Assert.Equal(0, cancelled); + Assert.Count(1, dismissed); + } + + // Two notifications: Windows does not say which one was clicked, so neither action runs. + using (var notifications = new OsNotifications(window, () => true, dismissed.Add)) + { + window.WindowState = WindowState.Minimized; + Assert.True(notifications.Show(Import())); + Assert.True(notifications.Show(Import())); + notifications.OnBalloonClicked(); + await StateAsync(window, WindowState.Normal); + Assert.Equal(1, imported); + Assert.Count(1, dismissed); + } + }); + + [Test] + public Task AWindowStartedMinimisedComesBackAsItWasSaved() => ScreenHost.RunAsync(async () => + { + // Closed while still minimised from the start: the saved state stays the one it would have come back to. + Assert.True(MainWindow.SavesMaximized(WindowState.Maximized, restoreTo: null)); + Assert.True(MainWindow.SavesMaximized(WindowState.Minimized, WindowState.Maximized)); + Assert.False(MainWindow.SavesMaximized(WindowState.Minimized, WindowState.Normal)); + Assert.False(MainWindow.SavesMaximized(WindowState.Normal, restoreTo: null)); + + await using var app = await ScreenSmokeTests.SampleApp.StartAsync(); + app.Shell.CompleteWelcome(); + var window = app.Window; + // Started at sign-in with the window saved maximised: it waits on the taskbar. + window.WaitMinimized(maximized: true); + Assert.Equal(WindowState.Minimized, window.WindowState); + // The user opens it from the taskbar: it comes back maximised. + window.WindowState = WindowState.Normal; + await StateAsync(window, WindowState.Maximized); + // Only that first restore: later ones are the user's. + window.WindowState = WindowState.Normal; + window.WindowState = WindowState.Minimized; + window.WindowState = WindowState.Normal; + await StateAsync(window, WindowState.Normal); + await Task.Delay(100); + Assert.Equal(WindowState.Normal, window.WindowState); + }); + [Test] public Task GeneralSettingsHoldStartupAndNotificationsButNoConsent() => ScreenHost.RunAsync(async () => { @@ -244,6 +355,31 @@ public sealed class ShellNotificationTests Assert.Equal(1, shell.Server.Badge); }); + [Test] + public Task TheLibraryAndArchiveBadgesCountWarnings() => ScreenHost.RunAsync(async () => + { + await using var app = await ScreenSmokeTests.SampleApp.StartAsync(); + var shell = app.Shell; + shell.CompleteWelcome(); + await app.Sample.FillAsync(); + var db = Assert.NotNull(shell.Services.Database); + + // Library: the sequences the Warnings filter shows; an analysis that finds warnings adds one. + await shell.Library.RefreshAsync(); + var warned = await db.Sequences.CountAsync(new SequenceQuery { WithStatus = SequenceStatus.HasWarnings }); + Assert.Equal(warned, shell.Library.Badge); + var clean = (await db.Sequences.ListAsync(new SequenceQuery { WithoutStatus = SequenceStatus.HasWarnings, Limit = 1 })).Items[0]; + await db.Sequences.RecordAnalysisAsync(clean.Id, SequenceStatus.AnalyzedLight | SequenceStatus.HasWarnings, SequenceStatus.None, 2, null); + await shell.Library.RefreshAsync(); + Assert.Equal(warned + 1, shell.Library.Badge); + + // Archive: the index health lines that need attention (the sample has unverified sequences). + shell.Navigate(SectionKey.Archive); + await shell.Archive.LoadAsync(); + Assert.Greater(shell.Archive.Badge, 0); + Assert.Equal(shell.Archive.Health.Count(h => !h.IsOk), shell.Archive.Badge); + }); + /// The Jobs screen read its first page (it would set the job bar and the badge again). private static async Task JobsLoadedAsync(ShellViewModel shell) { @@ -251,6 +387,13 @@ public sealed class ShellNotificationTests Assert.True(shell.Jobs.IsEmpty || shell.Jobs.HasRows, "the job list loaded"); } + /// The window reached (a restore from a notification is a posted system command). + private static async Task StateAsync(Window window, WindowState state) + { + for (var i = 0; i < 250 && window.WindowState != state; i++) await Task.Delay(20); + Assert.Equal(state, window.WindowState); + } + private static Job Job(JobKind kind, JobState state, Guid target) => new() { Id = Guid.CreateVersion7(),