diff --git a/src/Titano.App/Archive/ArchiveDialogViewModels.cs b/src/Titano.App/Archive/ArchiveDialogViewModels.cs index 98f9c303..9b938445 100644 --- a/src/Titano.App/Archive/ArchiveDialogViewModels.cs +++ b/src/Titano.App/Archive/ArchiveDialogViewModels.cs @@ -16,13 +16,15 @@ namespace Titano.App.Archiving; /// /// An in-window dialog of the Archive screen: one primary action, one way out. While its action runs, the way out /// stops it when it can be stopped, and is disabled otherwise; the close callback receives the dialog, so a late close -/// never closes another one. +/// never closes another one. A failure stays on screen as one sentence until the next attempt. /// public abstract class ArchiveDialogViewModel : LocalizedViewModel { private readonly Action _close; private bool _isBusy; private string? _busyText; + private string? _errorText; + private string? _errorToolTip; protected ArchiveDialogViewModel(Action close) { @@ -61,11 +63,32 @@ public abstract class ArchiveDialogViewModel : LocalizedViewModel public string? BusyText { get => _busyText; protected set => Set(ref _busyText, value); } + /// Why the last dry run or apply stopped (); null when nothing failed. + public string? ErrorText { get => _errorText; private set => Set(ref _errorText, value); } + + /// The failure as the engine reported it, for the tooltip. + public string? ErrorToolTip { get => _errorToolTip; private set => Set(ref _errorToolTip, value); } + protected void Close() => _close(this); + + protected void ShowError(Exception ex) + { + ErrorText = ArchiveFailures.Cause(ex); + ErrorToolTip = ex.Message; + } + + protected void ClearError() + { + ErrorText = null; + ErrorToolTip = null; + } } -/// A fact of the rebuild dialog ("Sidecars · 412"). -public sealed record DialogFact(string Label, string Value); +/// A fact of the rebuild dialog ("Sidecars · 412"); a path stays left to right, a missing value says why in its tooltip. +public sealed record DialogFact(string Label, string Value, bool IsPath = false, string? Reason = null) +{ + public string ToolTip => Reason ?? Value; +} /// /// "Rebuild index" (BRIEF §12.5): what the rebuild reads — the sidecars on disk, then a full metadata scan of folders @@ -84,7 +107,7 @@ public sealed class RebuildDialogViewModel : ArchiveDialogViewModel Archive = archive; Availability = availability; Indexed = indexed; - _facts = Facts(null); + _facts = Facts(null, availability == ArchiveAvailability.Offline ? Loc.L("Archive.Error.Offline", Formatting.LeftToRight(archive.RootPath)) : null); RebuildCommand = new AsyncRelayCommand(RebuildAsync, () => !IsBusy && availability == ArchiveAvailability.Online); } @@ -98,7 +121,10 @@ public sealed class RebuildDialogViewModel : ArchiveDialogViewModel public string RebuildToolTip => Availability == ArchiveAvailability.Online ? Loc.L("Tooltips.Archive.RebuildStart") : Loc.L("Archive.Blocked.NotOnline"); - /// Counts sequence folders with and without a sidecar (a walk of the archive tree, off the UI thread). + /// + /// Counts sequence folders with and without a sidecar (a walk of the archive tree, off the UI thread). The counts + /// read "Counting…" only while the walk runs; an offline archive or a failed walk leaves "—" with the reason. + /// public async Task CountAsync() { if (Availability == ArchiveAvailability.Offline) return; @@ -107,11 +133,12 @@ public sealed class RebuildDialogViewModel : ArchiveDialogViewModel { var root = Archive.RootPath; var folders = await Task.Run(() => ArchiveScanner.FindSequenceFolders(new ArchivePaths(root))); - FactRows = Facts(folders); + FactRows = Facts(folders, null); } catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) { Log.Warning("archive", "Counting sidecars failed", ex); + FactRows = Facts(null, ArchiveFailures.Cause(ex)); } finally { @@ -120,19 +147,24 @@ public sealed class RebuildDialogViewModel : ArchiveDialogViewModel } /// Shows counts computed elsewhere (capture). - public void ShowFolders(IReadOnlyList folders) => FactRows = Facts(folders); + public void ShowFolders(IReadOnlyList folders) => FactRows = Facts(folders, null); - private IReadOnlyList Facts(IReadOnlyList? folders) + /// The counted folders; null while counting or when they cannot be counted. + /// Why the folders cannot be counted; null while counting. + private IReadOnlyList Facts(IReadOnlyList? folders, string? uncounted) { - var waiting = Loc.L("Archive.Rebuild.Counting"); + DialogFact Count(string label, Func counted) => + folders is not null ? new(label, Formatting.Count(folders.Count(counted))) + : uncounted is not null ? new(label, "—", Reason: uncounted) + : new(label, Loc.L("Archive.Rebuild.Counting")); return [ new(Loc.L("Archive.Rebuild.Archive"), Archive.Name), - new(Loc.L("Archive.Rebuild.Root"), Archive.RootPath), + new(Loc.L("Archive.Rebuild.Root"), Archive.RootPath, IsPath: true), new(Loc.L("Archive.Rebuild.State"), Loc.L("Archive.Availability." + Availability)), new(Loc.L("Archive.Rebuild.Indexed"), Loc.Plural("Shell.Status.Sequences", Indexed)), - new(Loc.L("Archive.Rebuild.Sidecars"), folders is null ? waiting : Formatting.Count(folders.Count(f => f.Sidecar is not null))), - new(Loc.L("Archive.Rebuild.Metadata"), folders is null ? waiting : Formatting.Count(folders.Count(f => f.Sidecar is null))), + Count(Loc.L("Archive.Rebuild.Sidecars"), f => f.Sidecar is not null), + Count(Loc.L("Archive.Rebuild.Metadata"), f => f.Sidecar is null), ]; } @@ -163,6 +195,7 @@ public sealed class RenameDialogViewModel : ArchiveDialogViewModel private readonly Func _applied; private readonly DispatcherTimer _delay = new() { Interval = TimeSpan.FromMilliseconds(400) }; private RenamePlan? _plan; + private string? _planError; private IReadOnlyList _rows = []; private CancellationTokenSource? _planning; @@ -196,7 +229,7 @@ public sealed class RenameDialogViewModel : ArchiveDialogViewModel private string? ApplyBlocker => IsBusy ? Loc.L("Archive.Blocked.Applying") : Template.Error is { } error ? error - : _plan is null ? Loc.L("Archive.Blocked.Planning") + : _plan is null ? _planError ?? Loc.L("Archive.Blocked.Planning") : _plan.Steps.Count == 0 ? Loc.L("Archive.Blocked.NoChanges") : null; @@ -221,14 +254,20 @@ public sealed class RenameDialogViewModel : ArchiveDialogViewModel base.Dispose(); } - /// The dry run of the current template (the engine's plan; nothing changes on disk). - public async Task PlanAsync() + /// The dry run of the current template (the engine's plan; nothing changes on disk); it clears the last failure. + public Task PlanAsync() + { + ClearError(); + return DryRunAsync(); + } + + private async Task DryRunAsync() { _planning?.Cancel(); _plan = null; + _planError = null; Rows = []; - OnPropertyChanged(nameof(SummaryText)); - OnPropertyChanged(nameof(ApplyToolTip)); + OnPlanChanged(); if (Template.HasErrors) return; var cts = _planning = new CancellationTokenSource(); var template = Template.Text; @@ -240,41 +279,57 @@ public sealed class RenameDialogViewModel : ArchiveDialogViewModel if (cts.IsCancellationRequested) return; _plan = plan; Rows = MassRename.Rows(plan, Mode); - OnPropertyChanged(nameof(SummaryText)); - OnPropertyChanged(nameof(ApplyToolTip)); - CommandManager.InvalidateRequerySuggested(); } catch (OperationCanceledException) when (cts.IsCancellationRequested) { + return; } catch (Exception ex) when (ex is ArgumentException or DatabaseException or FormatException) { Log.Warning("archive", "Rename plan failed", ex); - BusyText = ex.Message; + _planError = ArchiveFailures.Cause(ex); + ShowError(ex); } + OnPlanChanged(); + } + + private void OnPlanChanged() + { + OnPropertyChanged(nameof(SummaryText)); + OnPropertyChanged(nameof(ApplyToolTip)); + CommandManager.InvalidateRequerySuggested(); } private async Task ApplyAsync() { if (_plan is not { } plan) return; + ClearError(); IsBusy = true; - var progress = new Progress(n => BusyText = Loc.L("Archive.Rename.Applying", Formatting.Count(n), Formatting.Count(plan.Steps.Count))); + // A tick posted before the apply ended must not bring its progress back. + var progress = new Progress(n => + { + if (IsBusy) BusyText = Loc.L("Archive.Rename.Applying", Formatting.Count(n), Formatting.Count(plan.Steps.Count)); + }); try { await Task.Run(() => _archives.ApplyRenameAsync(plan, progress)); Log.Info("archive", $"{Mode} applied to {plan.Steps.Count} sequence(s)"); await _applied(plan.Steps.Count); Close(); + return; } - catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or StaleRenamePlanException or ArchiveOfflineException) + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or StaleRenamePlanException or DatabaseException) { Log.Warning("archive", "Rename failed", ex); - BusyText = ex.Message; + ShowError(ex); } finally { IsBusy = false; + BusyText = null; } + // Part of the plan may have been applied, or the archive changed under it: the dry run shows what is left. + await DryRunAsync(); } } @@ -338,6 +393,7 @@ public sealed class RetagDialogViewModel : ArchiveDialogViewModel var changes = Changes(); var run = _run = new CancellationTokenSource(); var done = 0; + ClearError(); IsBusy = true; try { @@ -351,16 +407,17 @@ public sealed class RetagDialogViewModel : ArchiveDialogViewModel await _applied(done); Close(); } - catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException or DatabaseException or ArchiveOfflineException) + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException or DatabaseException) { Log.Warning("archive", "Retag failed", ex); - BusyText = ex.Message; + ShowError(ex); } finally { _run = null; run.Dispose(); IsBusy = false; + BusyText = null; } } } diff --git a/src/Titano.App/Archive/ArchiveFailures.cs b/src/Titano.App/Archive/ArchiveFailures.cs new file mode 100644 index 00000000..3a4f88cc --- /dev/null +++ b/src/Titano.App/Archive/ArchiveFailures.cs @@ -0,0 +1,26 @@ +using Titano.App.Infrastructure; +using Titano.Core.Archiving; +using Titano.Core.Localization; +using Titano.Data; +using Titano.Data.Archiving; + +namespace Titano.App.Archiving; + +/// +/// Why an Archive screen action stopped, as one localized sentence chosen by cause (BRIEF §0.2 rule 6). The +/// exception's own text, which may be technical or unlocalized, goes to the tooltip and the log only. +/// +public static class ArchiveFailures +{ + public static string Cause(Exception ex) => ex switch + { + ArchiveOfflineException offline => Loc.L(offline.Availability == ArchiveAvailability.ReadOnly ? "Archive.Error.ReadOnly" : "Archive.Error.Offline", + Formatting.LeftToRight(offline.Root)), + // Already one localized sentence each. + LeaseUnavailableException or StaleRenamePlanException => ex.Message, + UnauthorizedAccessException => Loc.L("Archive.Failed.Access"), + DatabaseException => Loc.L("Archive.Failed.Index"), + ArgumentException => Loc.L("Archive.Failed.Gone"), + _ => Loc.L("Archive.Failed.Files"), + }; +} diff --git a/src/Titano.App/Archive/ArchiveFigures.cs b/src/Titano.App/Archive/ArchiveFigures.cs index b66e2872..b254e772 100644 --- a/src/Titano.App/Archive/ArchiveFigures.cs +++ b/src/Titano.App/Archive/ArchiveFigures.cs @@ -23,6 +23,7 @@ public enum HealthAction Proxies, Analyse, Duplicates, + MarkDuplicates, Orphans, } @@ -44,7 +45,7 @@ public static class ArchiveFigures var years = stats.ByYear.Select(y => y.Year).ToList(); var range = years.Count == 0 ? "—" : years.Min() == years.Max() ? Year(years.Min()) - : Loc.L("Archive.Tile.YearRange", Year(years.Min()), Year(years.Max())); + : Formatting.LeftToRight(Loc.L("Archive.Tile.YearRange", Year(years.Min()), Year(years.Max()))); var cameras = stats.ByCamera.Count(c => !string.IsNullOrWhiteSpace(c.Model) || !string.IsNullOrWhiteSpace(c.Make)); return [ @@ -56,9 +57,22 @@ public static class ArchiveFigures ]; } - /// Culture month initials for the heatmap columns ("J F M …", "G F M …"). - public static IReadOnlyList MonthLabels() => - [.. Loc.Culture.DateTimeFormat.AbbreviatedMonthNames.Take(12).Select(m => m.Length == 0 ? string.Empty : char.ToUpper(m[0], Loc.Culture).ToString())]; + /// + /// The heatmap columns: month initials where the culture's month names start with a letter of a cased alphabet + /// ("J F M …", "G F M …"); month numbers in every other language, whose abbreviations are numbered ("1月", + /// "Tháng 1"), start alike or do not abbreviate to one letter (Thai, Arabic, Hebrew, Persian). + /// + public static IReadOnlyList MonthLabels() + { + var culture = Loc.Culture; + var names = culture.DateTimeFormat.AbbreviatedMonthNames.Take(12).ToList(); + return names.All(HasInitial) + ? [.. names.Select(m => char.ToUpper(m[0], culture).ToString())] + : [.. Enumerable.Range(1, 12).Select(month => month.ToString("N0", culture))]; + } + + private static bool HasInitial(string month) => + month.Length > 0 && char.IsLetter(month[0]) && char.ToUpperInvariant(month[0]) != char.ToLowerInvariant(month[0]) && !month.Any(char.IsDigit); /// One row per year from the first to the last with photos, oldest first; months after are NaN. public static IReadOnlyList PhotosPerMonth(ArchiveStats stats, DateTime today) @@ -125,8 +139,11 @@ public static class ArchiveFigures _ => format.ToString().ToUpperInvariant(), }; - /// Index health (Archive.html): what needs attention, each with its fix. - public static IReadOnlyList Health(ArchiveStats stats, int withoutProxies) + /// + /// Index health (Archive.html): what needs attention, each with its fix. Duplicates follow the last duplicates + /// search (, groups found by hash); before one, the copies already flagged. + /// + public static IReadOnlyList Health(ArchiveStats stats, int withoutProxies, int? duplicateGroups = null) { var h = stats.Health; var damaged = h.MissingFrames + h.CorruptFrames; @@ -144,12 +161,18 @@ public static class ArchiveFigures h.NotAnalyzed == 0 ? new HealthLine(true, Loc.L("Archive.Health.AnalysedOk"), HealthAction.None) : new HealthLine(false, Loc.Plural("Archive.Health.NotAnalysed", h.NotAnalyzed), HealthAction.Analyse), - h.DuplicateFrames == 0 - ? new HealthLine(true, Loc.L("Archive.Health.NoDuplicates"), HealthAction.None) - : new HealthLine(false, Loc.Plural("Archive.Health.Duplicates", h.DuplicateFrames), HealthAction.Duplicates), + Duplicates(h.DuplicateFrames, duplicateGroups), ]; } + private static HealthLine Duplicates(long flagged, int? groups) => groups switch + { + 0 => new HealthLine(true, Loc.L("Archive.Health.NoDuplicates"), HealthAction.None), + { } found => new HealthLine(false, Loc.Plural("Archive.Health.DuplicateGroups", found), HealthAction.MarkDuplicates), + null when flagged == 0 => new HealthLine(true, Loc.L("Archive.Health.NoneFlagged"), HealthAction.None), + null => new HealthLine(false, Loc.Plural("Archive.Health.Duplicates", flagged), HealthAction.Duplicates), + }; + private static IReadOnlyList Shares(List<(string Name, long Photos)> ranked, int top, Func restLabel, long total) { var bars = new List(top + 1); diff --git a/src/Titano.App/Archive/ArchiveRowViewModels.cs b/src/Titano.App/Archive/ArchiveRowViewModels.cs index 08b9b5cb..639e7e51 100644 --- a/src/Titano.App/Archive/ArchiveRowViewModels.cs +++ b/src/Titano.App/Archive/ArchiveRowViewModels.cs @@ -24,8 +24,18 @@ public sealed class ArchiveTreeRowViewModel(ArchiveTreeNode node, ArchiveAvailab public string ToggleToolTip => Loc.L(Node.IsExpanded ? "Tooltips.Archive.Collapse" : "Tooltips.Archive.Expand"); - /// The row's figures; a year also says how the keyboard opens and closes it. - public string RowToolTip => IsYear ? Loc.L("Tooltips.Archive.YearRow", Detail) : Detail; + /// + /// The full title (the tree trims it) and its figures; a year also says how the keyboard opens and closes it, with + /// the arrow keys swapped in a right-to-left layout. + /// + public string RowToolTip + { + get + { + var text = Title + " · " + Detail; + return IsYear ? Loc.L(Loc.IsRightToLeft ? "Tooltips.Archive.YearRowRtl" : "Tooltips.Archive.YearRow", text) : text; + } + } public ICommand ToggleCommand { get; } = new RelayCommand(() => toggle(node)); @@ -42,12 +52,12 @@ public sealed class ArchiveTreeRowViewModel(ArchiveTreeNode node, ArchiveAvailab public string AvailabilityToolTip => Loc.L("Tooltips.Archive.Availability." + availability); } -/// A line of "Index health" with its fix. +/// A line of "Index health" with its fix: ● ok or ▲ needs attention. public sealed class HealthLineViewModel(HealthLine line, ICommand? fix) : ObservableObject { public HealthLine Line { get; } = line; public string Text => Line.Text; - public StatusKind Kind => Line.IsOk ? StatusKind.Done : StatusKind.Warning; + public bool IsOk => Line.IsOk; public string KindToolTip => Loc.L(Line.IsOk ? "Tooltips.Archive.HealthOk" : "Tooltips.Archive.HealthWarning"); public bool HasFix => FixCommand is not null && Line.Action != HealthAction.None; public ICommand? FixCommand { get; } = fix; @@ -64,11 +74,10 @@ public sealed class DuplicateRowViewModel(DuplicateRow row, ICommand open, IComm public ICommand RevealCommand { get; } = reveal; } -/// An orphan line with its fix (index, reconcile, remove the row, scan). +/// An orphan line with its fix (index, reconcile, remove the row, scan); every kind is a ▲ warning the fix resolves. public sealed class OrphanRowViewModel(OrphanRow row, ICommand fix) : ObservableObject { public OrphanRow Row { get; } = row; - public StatusKind Kind => Row.Kind is OrphanKind.MissingFiles or OrphanKind.MissingSequence ? StatusKind.Warning : StatusKind.Queued; public string KindText => Loc.L("Archive.Orphans.Kind." + Row.Kind); public ICommand FixCommand { get; } = fix; public string FixText => Loc.L("Archive.Orphans.Fix." + Row.Kind); diff --git a/src/Titano.App/Archive/MaintenanceReports.cs b/src/Titano.App/Archive/MaintenanceReports.cs index 6a551755..efa8a977 100644 --- a/src/Titano.App/Archive/MaintenanceReports.cs +++ b/src/Titano.App/Archive/MaintenanceReports.cs @@ -4,6 +4,7 @@ using Titano.Core.Localization; using Titano.Core.Model; using Titano.Data.Archiving; using Titano.Data.Repositories; +using Titano.Ui.Controls; namespace Titano.App.Archiving; @@ -30,11 +31,26 @@ public enum OrphanKind public sealed record OrphanRow(OrphanKind Kind, string Title, string Detail, Guid? SequenceId); /// A line of "Recent maintenance": date, operation and outcome. -public sealed record MaintenanceRow(Guid JobId, string DateText, string Text, string StateText, JobState State); +public sealed record MaintenanceRow(Guid JobId, string DateText, string Text, string StateText, JobState State) +{ + /// The outcome's glyph and colour, as on the Jobs screen (paired with the word, never colour alone). + public StatusKind StateKind => State switch + { + JobState.Running => StatusKind.Running, + JobState.Queued => StatusKind.Queued, + JobState.Paused => StatusKind.Paused, + JobState.Done => StatusKind.Done, + JobState.Failed => StatusKind.Failed, + _ => StatusKind.Offline, + }; + + public string StateToolTip => Loc.L("Tooltips.Jobs.State." + State); +} /// /// The Maintenance view's reports (BRIEF §12.5): duplicates across sequences, orphans with their safe fixes, and the -/// recent archive jobs. Nothing here deletes a file; the only removal is of index rows whose sidecar is gone. +/// recent archive jobs. Nothing here deletes a file; the only removal is of index rows whose sidecar is gone. Folders +/// and paths are kept left to right inside right-to-left text (BRIEF §16). /// public static class MaintenanceReports { @@ -50,7 +66,8 @@ public static class MaintenanceReports { var first = g.Frames[0]; var name = first.RelativePath[(first.RelativePath.LastIndexOf('/') + 1)..]; - var places = g.Frames.Select(f => Loc.L("Archive.Duplicates.Place", titles.GetValueOrDefault(f.SequenceId, f.RelativePath), f.RelativePath)).ToList(); + var places = g.Frames.Select(f => Loc.L("Archive.Duplicates.Place", titles.GetValueOrDefault(f.SequenceId, f.RelativePath), + Formatting.LeftToRight(f.RelativePath))).ToList(); return new DuplicateRow(name, Loc.Plural("Archive.Duplicates.Copies", g.Frames.Count), places, first.SequenceId); }), ]; @@ -63,16 +80,19 @@ public static class MaintenanceReports foreach (var s in report.Sequences) { byFolder.TryGetValue(s.Folder, out var location); - var title = location?.Title ?? s.Folder; + var title = location?.Title ?? Formatting.LeftToRight(s.Folder); if (s.UnindexedFiles.Count > 0) rows.Add(new OrphanRow(OrphanKind.UnlistedFiles, title, Loc.Plural("Archive.Orphans.Unlisted", s.UnindexedFiles.Count), location?.Id)); if (s.MissingFiles.Count > 0) rows.Add(new OrphanRow(OrphanKind.MissingFiles, title, Loc.Plural("Archive.Orphans.Missing", s.MissingFiles.Count), location?.Id)); } foreach (var missing in report.MissingSequences) - rows.Add(new OrphanRow(OrphanKind.MissingSequence, missing.Title ?? missing.Folder, Loc.L("Archive.Orphans.NoSidecar", missing.Folder), missing.Id)); + { + var folder = Formatting.LeftToRight(missing.Folder); + rows.Add(new OrphanRow(OrphanKind.MissingSequence, missing.Title ?? folder, Loc.L("Archive.Orphans.NoSidecar", folder), missing.Id)); + } foreach (var folder in report.UnindexedFolders) - rows.Add(new OrphanRow(OrphanKind.NewFolder, folder.Length == 0 ? "/" : folder, Loc.L("Archive.Orphans.NewFolder"), null)); + rows.Add(new OrphanRow(OrphanKind.NewFolder, Formatting.LeftToRight(folder.Length == 0 ? "/" : folder), Loc.L("Archive.Orphans.NewFolder"), null)); return rows; } diff --git a/src/Titano.App/Sections/ArchiveViewModel.cs b/src/Titano.App/Sections/ArchiveViewModel.cs index 75884631..037d318a 100644 --- a/src/Titano.App/Sections/ArchiveViewModel.cs +++ b/src/Titano.App/Sections/ArchiveViewModel.cs @@ -46,6 +46,7 @@ public sealed class ArchiveViewModel : SectionViewModel private Core.Model.Archive? _archive; private ArchiveAvailability _availability = ArchiveAvailability.Offline; private ArchiveStats? _stats; + private int _withoutProxies; private ArchiveTree? _tree; private int _viewIndex; private bool _loaded; @@ -126,7 +127,7 @@ public sealed class ArchiveViewModel : SectionViewModel public bool HasArchive => _archive is not null; - public string ArchiveToolTip => _archive is null ? Loc.L("Tooltips.Archive.Pick") : Loc.L("Tooltips.Archive.PickRoot", _archive.RootPath); + public string ArchiveToolTip => _archive is null ? Loc.L("Tooltips.Archive.Pick") : Loc.L("Tooltips.Archive.PickRoot", Formatting.LeftToRight(_archive.RootPath)); /// 0 = overview (tree and figures), 1 = maintenance. public int ViewIndex @@ -188,6 +189,20 @@ public sealed class ArchiveViewModel : SectionViewModel public IReadOnlyList CameraBars { get => _cameras; private set => Set(ref _cameras, value); } public IReadOnlyList FormatBars { get => _formats; private set => Set(ref _formats, value); } + /// The heatmap's scale in the card header (Archive.html: "0 ▭ 21,000"); hidden without photos. + public bool HasMonthScale => MonthScaleMax > 0; + + public string MonthScaleLow => Formatting.Count(0); + public string MonthScaleHigh => Formatting.Count((long)MonthScaleMax); + + private double MonthScaleMax => _months.SelectMany(r => r.Values).Where(double.IsFinite).DefaultIfEmpty(0).Max(); + + /// What each chart shows, value by value, for screen readers (the charts themselves are images). + public string MonthsDescription => Describe(_months.SelectMany(r => r.Values.Select((photos, month) => photos > 0 ? r.ToolTips?[month] : null))); + public string StorageDescription => Describe(_storage.Select(b => b.ToolTip)); + public string CamerasDescription => Describe(_cameras.Select(b => b.ToolTip)); + public string FormatsDescription => Describe(_formats.Select(b => b.ToolTip)); + /// Photos per month in the culture's digits. public Func CountFormatter { get; } = v => Formatting.Count((long)v); @@ -205,6 +220,9 @@ public sealed class ArchiveViewModel : SectionViewModel } } + /// The set button's accessible name: what it is and the set it shows. + public string SetFilterName => Loc.L("Archive.Set.Filter") + " · " + SetText; + /// Camera, status and tag on top of the tree selection. public ArchiveSetFilter Filter { @@ -276,7 +294,9 @@ public sealed class ArchiveViewModel : SectionViewModel get => _duplicates; private set { - if (Set(ref _duplicates, value)) OnPropertyChanged(nameof(DuplicatesText)); + if (!Set(ref _duplicates, value)) return; + OnPropertyChanged(nameof(DuplicatesText)); + ShowHealth(); } } @@ -289,8 +309,11 @@ public sealed class ArchiveViewModel : SectionViewModel } } - /// A duplicates or orphans search runs; it can be cancelled. - public bool IsSearching => _search is not null; + /// The duplicates search runs: its card offers Cancel; the other card's Find waits for it. + public bool IsFindingDuplicates => _findingDuplicates; + + /// The orphans search runs: its card offers Cancel; the other card's Find waits for it. + public bool IsFindingOrphans => _findingOrphans; /// "3 groups", "None found", or empty before the first search. public string DuplicatesText => _findingDuplicates ? Loc.L("Archive.Find.Searching") @@ -418,19 +441,28 @@ public sealed class ArchiveViewModel : SectionViewModel private void ShowFigures(ArchiveStats stats, int withoutProxies) { + _withoutProxies = withoutProxies; Tiles = ArchiveFigures.Tiles(stats); MonthRows = [.. ArchiveFigures.PhotosPerMonth(stats, DateTime.Today).Select(r => new ChartRow(r.Label, r.Values, r.ToolTips))]; StorageBars = Bars(ArchiveFigures.StorageByYear(stats)); CameraBars = Bars(ArchiveFigures.ByCamera(stats)); FormatBars = Bars(ArchiveFigures.ByFormat(stats)); + ShowHealth(); + } + + /// The health lines of the last figures; the duplicates line follows the last duplicates search. + private void ShowHealth() + { + if (_stats is not { } stats) return; Health = [ - .. ArchiveFigures.Health(stats, withoutProxies).Select(line => new HealthLineViewModel(line, line.Action switch + .. ArchiveFigures.Health(stats, _withoutProxies, _duplicates?.Count).Select(line => new HealthLineViewModel(line, line.Action switch { HealthAction.Verify => new AsyncRelayCommand(() => QueueStatusAsync(SequenceStatus.Verified, ids => ArchiveJobs.Verify(_archive!, ids))), HealthAction.Proxies => new AsyncRelayCommand(() => QueueStatusAsync(SequenceStatus.ProxiesBuilt, ids => ArchiveJobs.Proxies(ids, CountLabel(ids)))), HealthAction.Analyse => new AsyncRelayCommand(() => QueueStatusAsync(SequenceStatus.AnalyzedLight, ids => ProcessingJobs.LightAnalysis(ids, CountLabel(ids)))), HealthAction.Duplicates => FindDuplicatesCommand, + HealthAction.MarkDuplicates => MarkDuplicatesCommand, HealthAction.Orphans => FindOrphansCommand, _ => null, })), @@ -440,6 +472,8 @@ public sealed class ArchiveViewModel : SectionViewModel private static IReadOnlyList Bars(IReadOnlyList values) => [.. values.Select(v => new ChartItem(v.Label, v.Value, v.ValueText, v.ToolTip))]; + private static string Describe(IEnumerable values) => string.Join(Environment.NewLine, values.Where(v => !string.IsNullOrEmpty(v))); + /// A reloaded tree keeps the open years and the selection (nodes that still exist). private void ShowTree(ArchiveTree tree) { @@ -488,6 +522,7 @@ public sealed class ArchiveViewModel : SectionViewModel private void OnSetChanged() { OnPropertyChanged(nameof(SetText)); + OnPropertyChanged(nameof(SetFilterName)); OnPropertyChanged(nameof(CameraChoices)); OnPropertyChanged(nameof(StatusChoices)); OnPropertyChanged(nameof(TagChoices)); @@ -679,22 +714,26 @@ public sealed class ArchiveViewModel : SectionViewModel try { var path = await db.BackupAsync(Services.Environment.BackupDirectory); - Shell.Notify(Loc.L("Settings.Advanced.BackupDone"), Path.GetFileName(path), Loc.L("Library.Export.Show"), Loc.L("Tooltips.Library.ShowExport"), - () => ShellActions.Reveal(path)); + Shell.Notify(Loc.L("Settings.Advanced.BackupDone"), Formatting.LeftToRight(Path.GetFileName(path)), Loc.L("Library.Export.Show"), + Loc.L("Tooltips.Library.ShowExport"), () => ShellActions.Reveal(path)); } catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or DatabaseException or NotSupportedException) { Log.Warning("archive", "Database backup failed", ex); - Shell.Notify(Loc.L("Archive.Backup.Failed"), ex.Message); + NotifyFailure("Archive.Backup.Failed", ex, BackupCommand); } } /// A moved archive keeps its id: opening it at the new root relinks every sequence (BRIEF §12.5 Move archive). private async Task RelinkAsync() { - if (Services.Archives is not { } archives) return; var folder = Services.Dialogs.PickFolder(Loc.L("Archive.Relink.Title")); - if (folder is null) return; + if (folder is not null) await RelinkAsync(folder); + } + + private async Task RelinkAsync(string folder) + { + if (Services.Archives is not { } archives) return; try { var archive = await Task.Run(() => archives.OpenAsync(folder)); @@ -702,13 +741,13 @@ public sealed class ArchiveViewModel : SectionViewModel Services.SaveSettings(); _archive = archive; await Services.QueueScanAsync(archive, full: false); - Shell.Notify(Loc.L("Archive.Relink.Done", archive.Name), archive.RootPath); + Shell.Notify(Loc.L("Archive.Relink.Done", archive.Name), Formatting.LeftToRight(archive.RootPath)); await LoadAsync(); } catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or DatabaseException) { Log.Warning("archive", $"Relinking {folder} failed", ex); - Shell.Notify(Loc.L("Archive.Relink.Failed"), ex.Message); + NotifyFailure("Archive.Relink.Failed", ex, new AsyncRelayCommand(() => RelinkAsync(folder))); } } @@ -742,7 +781,8 @@ public sealed class ArchiveViewModel : SectionViewModel } catch (DatabaseException ex) { - Shell.ReportError(ex); + Log.Warning("archive", "Duplicates search failed", ex); + NotifyFailure("Archive.Duplicates.Failed", ex, FindDuplicatesCommand); } finally { @@ -768,10 +808,10 @@ public sealed class ArchiveViewModel : SectionViewModel catch (OperationCanceledException) when (search.IsCancellationRequested) { } - catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or ArchiveOfflineException or DatabaseException) + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or DatabaseException) { Log.Warning("archive", "Orphan search failed", ex); - Shell.Notify(Loc.L("Archive.Orphans.Failed"), ex.Message); + NotifyFailure("Archive.Orphans.Failed", ex, FindOrphansCommand); } finally { @@ -796,7 +836,8 @@ public sealed class ArchiveViewModel : SectionViewModel private void OnSearchChanged() { - OnPropertyChanged(nameof(IsSearching)); + OnPropertyChanged(nameof(IsFindingDuplicates)); + OnPropertyChanged(nameof(IsFindingOrphans)); OnPropertyChanged(nameof(DuplicatesText)); OnPropertyChanged(nameof(OrphansText)); OnPropertyChanged(nameof(DuplicatesToolTip)); @@ -853,11 +894,14 @@ public sealed class ArchiveViewModel : SectionViewModel Orphans = Orphans?.Where(o => o.Row != row).ToList(); await LoadAsync(); } - catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or ArchiveOfflineException or DatabaseException - or ArgumentException) + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or DatabaseException or ArgumentException) { Log.Warning("archive", $"Fixing {row.Title} failed", ex); - Shell.Notify(Loc.L("Archive.Orphans.FixFailed"), ex.Message); + NotifyFailure("Archive.Orphans.FixFailed", ex, new AsyncRelayCommand(() => FixAsync(row))); } } + + /// An action stopped: what stopped, why in one sentence, and Retry to run it again (BRIEF §0.2 rule 6). + private void NotifyFailure(string titleKey, Exception ex, ICommand retry) => + Shell.Notify(Loc.L(titleKey), ArchiveFailures.Cause(ex), Loc.L("Archive.Failed.Retry"), Loc.L("Tooltips.Archive.Retry"), () => retry.Execute(null)); }