CI / Build and test (push) Failing after 3m1s
CI / PostgreSQL 16 integration (push) Skipped
CI / PostgreSQL 17 integration (push) Skipped
CI / Docker image (push) Skipped
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 10s
Release / Build, test and publish (push) Successful in 15m31s
Release / Server image (push) Successful in 1m13s
Convert photos already in the archive to JPEG, TIFF-16 or Linear DNG, from the panel's Library and the desktop's Archive and Library. Each run asks Replace (same frames, originals to the trash, recoverable) or New sequence. A dry run lists what converts, what is skipped and why, size before and after, and free space; the job converts exactly the confirmed photos, resumes, and commits all or nothing per sequence. A conversion never changes what Chronos reads from a photo. Replaced originals are erased only on the archive's own word that their conversion is gone. Desktop TIFFs that WIC showed black or as noise now go to the managed reader; the Edit picker no longer spins a core. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
624 lines
25 KiB
C#
624 lines
25 KiB
C#
using System.Collections.ObjectModel;
|
||
using System.IO;
|
||
using System.Windows.Input;
|
||
using Chronos.App.Archiving;
|
||
using Chronos.App.Infrastructure;
|
||
using Chronos.App.Jobs;
|
||
using Chronos.App.Library;
|
||
using Chronos.App.Settings;
|
||
using Chronos.App.Shell;
|
||
using Chronos.Core.Diagnostics;
|
||
using Chronos.Core.Localization;
|
||
using Chronos.Core.Model;
|
||
using Chronos.Data;
|
||
using Chronos.Data.Jobs;
|
||
using Chronos.Ui.Controls;
|
||
using Chronos.Ui.Mvvm;
|
||
|
||
namespace Chronos.App.Sections;
|
||
|
||
/// <summary>A filter chip of the Jobs toolbar ("Running · 4").</summary>
|
||
public sealed class JobFilterChip(JobFilter filter, Action<JobFilter> select) : ObservableObject
|
||
{
|
||
private int _count;
|
||
private bool _isSelected;
|
||
|
||
public JobFilter Filter { get; } = filter;
|
||
|
||
public string Text => Loc.L("Jobs.Filter." + Filter, Formatting.Count(_count));
|
||
|
||
public string ToolTip => Loc.L("Tooltips.Jobs.Filter." + Filter);
|
||
|
||
public ICommand SelectCommand { get; } = new RelayCommand(() => select(filter));
|
||
|
||
public bool IsSelected
|
||
{
|
||
get => _isSelected;
|
||
set => Set(ref _isSelected, value);
|
||
}
|
||
|
||
public int Count
|
||
{
|
||
get => _count;
|
||
set
|
||
{
|
||
if (Set(ref _count, value)) OnPropertyChanged(nameof(Text));
|
||
}
|
||
}
|
||
|
||
internal void Refresh() => OnAllPropertiesChanged();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Jobs (BRIEF §12.6, Jobs.html), two tabs: Queue, the queue and history with live progress from the engine (batched to
|
||
/// about 10 updates a second), filters, queue order, an expandable log tail per job, and the row actions; Scheduled
|
||
/// (owner review 2, R10), the schedules of this PC (<see cref="SchedulesViewModel"/>). Also feeds the shell's job bar, the
|
||
/// status strip and the rail badge (running jobs, and failures not seen on this screen yet), and raises the toast of a
|
||
/// long operation that ends (<see cref="JobNotices"/>), whichever screen started it.
|
||
/// </summary>
|
||
public sealed class JobsViewModel : SectionViewModel
|
||
{
|
||
private static readonly TimeSpan FlushInterval = TimeSpan.FromMilliseconds(100);
|
||
private const int PageSize = 200;
|
||
|
||
private readonly JobListModel _model = new();
|
||
private readonly JobUpdateBuffer _buffer = new();
|
||
private readonly Dictionary<Guid, JobRowViewModel> _rows = [];
|
||
private readonly HashSet<Guid> _unseenFailures = [];
|
||
private readonly JobEndings _endings = new();
|
||
|
||
/// <summary>Finished renders whose toast was taken (<see cref="ClaimRenderToast"/>).</summary>
|
||
private readonly HashSet<Guid> _renderToasts = [];
|
||
|
||
private readonly JobActions _actions;
|
||
private CoalescingThrottle? _throttle;
|
||
private IJobQueue? _queue;
|
||
private JobFilter _filter = JobFilter.All;
|
||
private string _searchText = string.Empty;
|
||
private string? _cursor;
|
||
private bool _hasMore;
|
||
private bool _loading;
|
||
private bool _hasLoaded;
|
||
private int _tabIndex;
|
||
|
||
public JobsViewModel(ShellViewModel shell)
|
||
: base(SectionKey.Jobs, "Icon.Jobs")
|
||
{
|
||
Shell = shell;
|
||
_actions = new JobActions(this);
|
||
Chips = [.. Enum.GetValues<JobFilter>().Select(f => new JobFilterChip(f, SelectFilter) { IsSelected = f == JobFilter.All })];
|
||
PauseCurrentCommand = new AsyncRelayCommand(PauseCurrentAsync, () => _model.Current is not null);
|
||
PauseAllCommand = new AsyncRelayCommand(PauseAllAsync, () => _model.RunningCount > 0);
|
||
ClearDoneCommand = new RelayCommand(ClearDone, () => _model.CountOf(JobFilter.Done, ClearedAt) + _model.CountOf(JobFilter.Failed, ClearedAt) > 0);
|
||
RenderingSettingsCommand = new RelayCommand(() =>
|
||
{
|
||
Shell.Settings.Page = SettingsPage.Rendering;
|
||
Shell.Navigate(SectionKey.Settings);
|
||
});
|
||
LoadMoreCommand = new RelayCommand(() => _ = LoadMoreAsync());
|
||
ImportCommand = new RelayCommand(() => Shell.Navigate(SectionKey.Import));
|
||
Schedules = new SchedulesViewModel(() => Shell.Services.Scheduler, () => Shell.Services.Database, request => Shell.Services.Dialogs.Confirm(request),
|
||
(title, message, isError) => Shell.Notify(title, message, isError: isError), ShowJobAsync);
|
||
Schedules.HistoryChanged += () => OnPropertyChanged(nameof(HistoryText));
|
||
Schedules.PropertyChanged += (_, e) =>
|
||
{
|
||
if (e.PropertyName is nameof(SchedulesViewModel.IsContentEnabled) or "" or null) OnPropertyChanged(nameof(IsContentEnabled));
|
||
};
|
||
}
|
||
|
||
/// <summary>A row the screen should bring into view and expand (a job shown from Jobs › Scheduled).</summary>
|
||
public event Action<JobRowViewModel>? RowRevealRequested;
|
||
|
||
public ShellViewModel Shell { get; }
|
||
|
||
/// <summary>Jobs › Scheduled.</summary>
|
||
public SchedulesViewModel Schedules { get; }
|
||
|
||
/// <summary>0 = Queue, 1 = Scheduled (the segmented control's index). Scheduled, shown, reads the actions' availability again.</summary>
|
||
public int TabIndex
|
||
{
|
||
get => _tabIndex;
|
||
set
|
||
{
|
||
if (value is < 0 or > 1 || !Set(ref _tabIndex, value)) return;
|
||
OnPropertyChanged(nameof(IsQueue));
|
||
OnPropertyChanged(nameof(IsScheduled));
|
||
if (IsScheduled) _ = Schedules.RefreshActionsAsync();
|
||
}
|
||
}
|
||
|
||
public bool IsQueue => _tabIndex == 0;
|
||
|
||
public bool IsScheduled => _tabIndex == 1;
|
||
|
||
/// <summary>The screen behind the schedule editor takes neither clicks nor keyboard focus.</summary>
|
||
public bool IsContentEnabled => Schedules.IsContentEnabled;
|
||
|
||
/// <summary>Rows in display order for the current filter and search.</summary>
|
||
public ObservableCollection<JobRowViewModel> Rows { get; } = [];
|
||
|
||
public IReadOnlyList<JobFilterChip> Chips { get; }
|
||
|
||
public ICommand PauseCurrentCommand { get; }
|
||
public ICommand PauseAllCommand { get; }
|
||
public ICommand ClearDoneCommand { get; }
|
||
public ICommand RenderingSettingsCommand { get; }
|
||
public ICommand LoadMoreCommand { get; }
|
||
|
||
/// <summary>The empty state's one action: jobs start with an import.</summary>
|
||
public ICommand ImportCommand { get; }
|
||
|
||
public JobFilter Filter
|
||
{
|
||
get => _filter;
|
||
set
|
||
{
|
||
if (!Set(ref _filter, value)) return;
|
||
foreach (var chip in Chips) chip.IsSelected = chip.Filter == value;
|
||
SyncRows();
|
||
}
|
||
}
|
||
|
||
public string SearchText
|
||
{
|
||
get => _searchText;
|
||
set
|
||
{
|
||
if (Set(ref _searchText, value ?? string.Empty)) SyncRows();
|
||
}
|
||
}
|
||
|
||
/// <summary>"8 photos at once": what the running job of this PC processes together (Settings › Rendering › Parallelism).</summary>
|
||
public string ParallelismText => Loc.Plural("Jobs.Parallelism", Shell.Services.Parallelism);
|
||
|
||
/// <summary>The engine of this PC runs jobs (it runs none before it starts).</summary>
|
||
public bool HasEngine => _queue is { IsRunning: true };
|
||
|
||
/// <summary>The priority queue of Settings › Rendering is on: higher jobs pause the running one.</summary>
|
||
public bool IsPriorityQueueOn => HasEngine && Shell.Services.Settings.PriorityQueue;
|
||
|
||
/// <summary>"History keeps 90 days": the age limit of the housekeeping schedule's job-history step; "Full history kept" without one.</summary>
|
||
public string HistoryText => Schedules.HistoryDays is { } days ? Loc.Plural("Jobs.History", days) : Loc.L("Jobs.HistoryKept");
|
||
|
||
public bool IsEmpty => _hasLoaded && Rows.Count == 0;
|
||
|
||
public bool HasRows => Rows.Count > 0;
|
||
|
||
internal IJobQueue? Queue => _queue;
|
||
|
||
internal JobListModel Model => _model;
|
||
|
||
private DateTimeOffset? ClearedAt => Shell.Services.Settings.JobsClearedAt;
|
||
|
||
/// <summary>Subscribes to the engine and loads the first page of jobs; the Scheduled tab follows the schedules once they run.</summary>
|
||
public void Attach()
|
||
{
|
||
// Without an index the Scheduled tab says the schedules do not run.
|
||
_ = Schedules.AttachAsync(Shell.Services.SchedulerReady);
|
||
_queue = Shell.Services.Jobs;
|
||
if (_queue is null)
|
||
{
|
||
_hasLoaded = true;
|
||
RaiseState();
|
||
return;
|
||
}
|
||
_throttle = new CoalescingThrottle(FlushInterval, SynchronizationContext.Current, Flush);
|
||
_queue.JobChanged += OnJobChanged;
|
||
_queue.Progress += OnProgress;
|
||
_ = LoadMoreAsync();
|
||
}
|
||
|
||
public override void Dispose()
|
||
{
|
||
if (_queue is not null)
|
||
{
|
||
_queue.JobChanged -= OnJobChanged;
|
||
_queue.Progress -= OnProgress;
|
||
}
|
||
_throttle?.Dispose();
|
||
Schedules.Dispose();
|
||
base.Dispose();
|
||
}
|
||
|
||
/// <summary>The UI language changed: the rows, the filter chips and the job bar say it again in the new language.</summary>
|
||
protected override void OnLanguageChanged()
|
||
{
|
||
foreach (var row in _rows.Values) row.Refresh();
|
||
foreach (var chip in Chips) chip.Refresh();
|
||
UpdateShell();
|
||
base.OnLanguageChanged();
|
||
}
|
||
|
||
/// <summary>Reads the job list again from the first page (after jobs were written outside the engine).</summary>
|
||
public Task ReloadAsync()
|
||
{
|
||
_cursor = null;
|
||
_hasMore = true;
|
||
_hasLoaded = false;
|
||
return LoadMoreAsync();
|
||
}
|
||
|
||
/// <summary>Next page of the history (newest first); the view calls it when the list scrolls near its end.</summary>
|
||
public async Task LoadMoreAsync()
|
||
{
|
||
if (_queue is null || _loading || (_hasLoaded && !_hasMore)) return;
|
||
_loading = true;
|
||
try
|
||
{
|
||
var stamp = _model.Stamp;
|
||
var page = await _queue.ListAsync(_cursor, PageSize);
|
||
foreach (var job in page.Items) _model.ApplyLoaded(job, stamp);
|
||
_cursor = page.NextCursor;
|
||
_hasMore = page.NextCursor is not null;
|
||
}
|
||
catch (DatabaseException ex)
|
||
{
|
||
Log.Warning("jobs", "Job list unavailable", ex);
|
||
_hasMore = false;
|
||
}
|
||
finally
|
||
{
|
||
_loading = false;
|
||
_hasLoaded = true;
|
||
}
|
||
Flush();
|
||
}
|
||
|
||
/// <summary>Applies everything buffered since the last flush (UI thread).</summary>
|
||
internal void Flush()
|
||
{
|
||
var (jobs, progress) = _buffer.Drain();
|
||
foreach (var job in jobs)
|
||
{
|
||
var before = _model[job.Id]?.State;
|
||
_model.Apply(job);
|
||
Follow(before, job);
|
||
Schedules.OnJob(job);
|
||
}
|
||
foreach (var p in progress) _model.Apply(p);
|
||
foreach (var ending in _endings.Take(_model.IsBusy)) Shell.ShowToast(ToastFor(ending));
|
||
SyncRows();
|
||
UpdateShell();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Failures seen on this screen no longer count on the rail; back on Scheduled (from Settings, say), the actions'
|
||
/// availability is read again.
|
||
/// </summary>
|
||
protected override void OnActivated()
|
||
{
|
||
if (IsScheduled) _ = Schedules.RefreshActionsAsync();
|
||
if (_unseenFailures.Count == 0) return;
|
||
_unseenFailures.Clear();
|
||
UpdateShell();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 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 is announced at the end of the flush (<see cref="JobEndings"/>).
|
||
/// </summary>
|
||
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);
|
||
// A flush can take the end before the editor that follows the render has seen it: the editor says it, with its output.
|
||
if (notice == JobNotice.Done && job.Kind == JobKind.Render
|
||
&& (Shell.Sequence.Editor?.FollowsRender(job.Id) == true || !ClaimRenderToast(job.Id))) return;
|
||
_endings.Add(notice, job);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Takes the toast of a finished render, which is said once (UI thread): true for the first caller only, which then
|
||
/// raises it. The editor of the render's sequence takes it when it sees the render end, and says it with the output
|
||
/// file even when the sequence cannot be read again or the editor closed meanwhile; a render the editor did not
|
||
/// follow is said here.
|
||
/// </summary>
|
||
internal bool ClaimRenderToast(Guid jobId) => _renderToasts.Add(jobId);
|
||
|
||
/// <summary>
|
||
/// 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. Conversions that replaced photos
|
||
/// offer Undo instead (<see cref="ConvertUndo"/>), which never runs from the Windows notification.
|
||
/// </summary>
|
||
private Toast ToastFor(JobEnding ending)
|
||
{
|
||
var job = ending.Jobs[0];
|
||
var failed = ending.Notice == JobNotice.Failed;
|
||
if (!failed && ending.Jobs.All(ConvertUndo.Replaces)) return ConvertUndo.Toast(Shell, ending.Jobs);
|
||
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,
|
||
}
|
||
: 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,
|
||
};
|
||
}
|
||
|
||
/// <summary>A job changed state (any thread; tests feed it too): buffered until the next flush.</summary>
|
||
internal void OnJobChanged(Job job)
|
||
{
|
||
_buffer.Post(job);
|
||
_throttle?.Signal();
|
||
}
|
||
|
||
private void OnProgress(JobProgressInfo progress)
|
||
{
|
||
_buffer.Post(progress);
|
||
_throttle?.Signal();
|
||
}
|
||
|
||
private void SelectFilter(JobFilter filter) => Filter = filter;
|
||
|
||
/// <summary>
|
||
/// Shows a job in the Queue tab (from a schedule's last runs): every filter off, its row read when the list has not
|
||
/// loaded it yet, expanded with its log, and brought into view.
|
||
/// </summary>
|
||
internal async Task ShowJobAsync(Guid jobId)
|
||
{
|
||
TabIndex = 0;
|
||
Filter = JobFilter.All;
|
||
SearchText = string.Empty;
|
||
if (_model[jobId] is null && _queue is not null)
|
||
{
|
||
var stamp = _model.Stamp;
|
||
try
|
||
{
|
||
if (await _queue.GetAsync(jobId) is { } job) _model.ApplyLoaded(job, stamp);
|
||
}
|
||
catch (DatabaseException ex)
|
||
{
|
||
Log.Warning("jobs", $"Job {jobId} could not be read", ex);
|
||
}
|
||
SyncRows();
|
||
}
|
||
if (!_rows.TryGetValue(jobId, out var row) || !Rows.Contains(row))
|
||
{
|
||
// Hidden by Clear done: the history keeps it, the list no longer shows it.
|
||
Shell.Notify(Loc.L("Jobs.Schedule.JobHidden"), Loc.L("Tooltips.Jobs.Schedule.JobHidden"));
|
||
return;
|
||
}
|
||
row.IsExpanded = true;
|
||
RowRevealRequested?.Invoke(row);
|
||
}
|
||
|
||
/// <summary>Brings <see cref="Rows"/> to the model's order with moves (rows keep their expanded log).</summary>
|
||
private void SyncRows()
|
||
{
|
||
_model.PriorityQueue = Shell.Services.PriorityQueue;
|
||
var ordered = _model.Ordered(_filter, _searchText, ClearedAt);
|
||
var wanted = new HashSet<Guid>(ordered.Select(e => e.Id));
|
||
for (var i = Rows.Count - 1; i >= 0; i--)
|
||
{
|
||
if (!wanted.Contains(Rows[i].Id)) Rows.RemoveAt(i);
|
||
}
|
||
for (var i = 0; i < ordered.Count; i++)
|
||
{
|
||
var entry = ordered[i];
|
||
var position = entry.State == JobState.Queued ? _model.QueuePosition(entry.Id) : 0;
|
||
if (!_rows.TryGetValue(entry.Id, out var row))
|
||
{
|
||
row = new JobRowViewModel(entry, position, _actions);
|
||
_rows[entry.Id] = row;
|
||
}
|
||
else
|
||
{
|
||
row.Update(entry, position);
|
||
}
|
||
if (i < Rows.Count && ReferenceEquals(Rows[i], row)) continue;
|
||
var existing = Rows.IndexOf(row);
|
||
if (existing >= 0) Rows.Move(existing, i);
|
||
else Rows.Insert(i, row);
|
||
}
|
||
foreach (var chip in Chips) chip.Count = _model.CountOf(chip.Filter, ClearedAt);
|
||
RaiseState();
|
||
}
|
||
|
||
private void UpdateShell()
|
||
{
|
||
if (_model.Current is { } current)
|
||
Shell.SetJob(JobText.Bar(current), current.Fraction ?? 0, indeterminate: current.Fraction is null, name: JobText.Name(current.Job));
|
||
else
|
||
Shell.SetJob(null, 0);
|
||
// The status strip and the Running chip count the same jobs: running or paused (Jobs.html). The rail badge adds the
|
||
// failures not seen here yet, which also turn the taskbar button red while no job runs.
|
||
var active = _model.CountOf(JobFilter.Running);
|
||
Shell.SetJobCount(active, _model.QueuedCount);
|
||
Shell.SetUnseenFailures(_unseenFailures.Count);
|
||
Badge = active + _unseenFailures.Count;
|
||
OnPropertyChanged(nameof(ParallelismText));
|
||
OnPropertyChanged(nameof(HasEngine));
|
||
OnPropertyChanged(nameof(IsPriorityQueueOn));
|
||
CommandManager.InvalidateRequerySuggested();
|
||
}
|
||
|
||
private void RaiseState()
|
||
{
|
||
OnPropertyChanged(nameof(IsEmpty));
|
||
OnPropertyChanged(nameof(HasRows));
|
||
}
|
||
|
||
private async Task PauseCurrentAsync()
|
||
{
|
||
if (_model.Current is { } current && _queue is not null) await _queue.PauseAsync(current.Id);
|
||
}
|
||
|
||
private async Task PauseAllAsync()
|
||
{
|
||
if (_queue is null) return;
|
||
foreach (var entry in _model.Ordered(JobFilter.Running).Where(e => e.State == JobState.Running).ToList()) await _queue.PauseAsync(entry.Id);
|
||
}
|
||
|
||
private void ClearDone()
|
||
{
|
||
Shell.Services.Settings.JobsClearedAt = DateTimeOffset.UtcNow;
|
||
Shell.Services.SaveSettings();
|
||
SyncRows();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Opens what a job worked on inside Chronos: its sequence in the editor; several sequences (a deep analysis of a
|
||
/// Library selection) in the Library, every one of them selected; else the Archive screen. A job over more sequences
|
||
/// than a Library page holds (a maintenance run over a whole archive) opens the Library as it is: looking each one
|
||
/// up, then reading page after page to select them all, would hold the screen.
|
||
/// </summary>
|
||
internal async Task OpenTargetAsync(Job job)
|
||
{
|
||
var db = Shell.Services.Database;
|
||
if (db is null || job.TargetIds.Count == 0) return;
|
||
var targets = job.TargetIds.Distinct().ToList();
|
||
if (targets.Count > LibraryPager.DefaultPageSize)
|
||
{
|
||
Shell.Navigate(SectionKey.Library);
|
||
return;
|
||
}
|
||
// Each one is looked up: an id no longer in the index would have the Library read every page in search of it.
|
||
var sequences = new List<Guid>(targets.Count);
|
||
foreach (var id in targets)
|
||
{
|
||
if (await db.Sequences.GetAsync(id) is { } sequence) sequences.Add(sequence.Id);
|
||
}
|
||
switch (sequences.Count)
|
||
{
|
||
case 0:
|
||
Shell.Navigate(SectionKey.Archive);
|
||
break;
|
||
case 1:
|
||
Shell.OpenSequence(sequences[0]);
|
||
break;
|
||
default:
|
||
Shell.Navigate(SectionKey.Library);
|
||
await Shell.Library.ShowSelectedAsync(sequences);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/// <summary>Shows the folder of what a job worked on in Explorer.</summary>
|
||
internal async Task RevealTargetAsync(Job job)
|
||
{
|
||
var db = Shell.Services.Database;
|
||
if (db is null || job.TargetIds.Count == 0) return;
|
||
var id = job.TargetIds[0];
|
||
if (await db.Sequences.GetAsync(id) is { } sequence && await db.Archives.GetAsync(sequence.ArchiveId) is { } owner)
|
||
ShellActions.Reveal(Path.Combine(owner.RootPath, sequence.Folder.Replace('/', Path.DirectorySeparatorChar)));
|
||
else if (await db.Archives.GetAsync(id) is { } archive)
|
||
ShellActions.Reveal(archive.RootPath);
|
||
}
|
||
}
|
||
|
||
/// <summary>Row actions per job state (Jobs.html) and their commands.</summary>
|
||
internal sealed class JobActions(JobsViewModel owner)
|
||
{
|
||
public string WorkerId => owner.Queue?.WorkerId ?? Environment.MachineName;
|
||
|
||
public IReadOnlyList<JobAction> For(JobEntry entry)
|
||
{
|
||
var job = entry.Job;
|
||
var row = JobText.Name(job);
|
||
return entry.State switch
|
||
{
|
||
JobState.Running =>
|
||
[
|
||
OnQueue("Jobs.Action.Pause", "Tooltips.Jobs.Pause", row, q => q.PauseAsync(job.Id)),
|
||
OnQueue("Jobs.Action.Cancel", "Tooltips.Jobs.Cancel", row, q => q.CancelAsync(job.Id)),
|
||
],
|
||
JobState.Paused =>
|
||
[
|
||
OnQueue("Jobs.Action.Resume", "Tooltips.Jobs.Resume", row, q => q.ResumeAsync(job.Id)),
|
||
OnQueue("Jobs.Action.Cancel", "Tooltips.Jobs.Cancel", row, q => q.CancelAsync(job.Id)),
|
||
],
|
||
JobState.Queued when job.Priority < JobPriority.User =>
|
||
[
|
||
OnQueue("Jobs.Action.MoveUp", "Tooltips.Jobs.MoveUp", row, q => q.RaisePriorityAsync(job.Id)),
|
||
OnQueue("Jobs.Action.Remove", "Tooltips.Jobs.Remove", row, q => q.CancelAsync(job.Id)),
|
||
],
|
||
JobState.Queued =>
|
||
[
|
||
OnQueue("Jobs.Action.Pause", "Tooltips.Jobs.PauseQueued", row, q => q.PauseAsync(job.Id)),
|
||
OnQueue("Jobs.Action.Remove", "Tooltips.Jobs.Remove", row, q => q.CancelAsync(job.Id)),
|
||
],
|
||
JobState.Failed =>
|
||
[
|
||
OnQueue("Jobs.Action.Retry", "Tooltips.Jobs.Retry", row, q => q.ResumeAsync(job.Id)),
|
||
Action("Jobs.Action.Show", "Tooltips.Jobs.Show", row, () => owner.OpenTargetAsync(job)),
|
||
],
|
||
JobState.Cancelled =>
|
||
[
|
||
OnQueue("Jobs.Action.Retry", "Tooltips.Jobs.Retry", row, q => q.ResumeAsync(job.Id)),
|
||
],
|
||
_ =>
|
||
[
|
||
Action("Jobs.Action.Open", "Tooltips.Jobs.Open", row, () => owner.OpenTargetAsync(job)),
|
||
Action("Jobs.Action.Folder", "Tooltips.Jobs.Folder", row, () => owner.RevealTargetAsync(job)),
|
||
],
|
||
};
|
||
}
|
||
|
||
/// <summary>Reads the stored log tail of a row (persisted with each checkpoint).</summary>
|
||
public async Task LoadLogAsync(JobRowViewModel row)
|
||
{
|
||
if (owner.Queue is not { } queue) return;
|
||
try
|
||
{
|
||
if (await queue.GetAsync(row.Id) is { } job) row.SetLog(job.LogTail);
|
||
}
|
||
catch (DatabaseException ex)
|
||
{
|
||
Log.Warning("jobs", "Job log unavailable", ex);
|
||
}
|
||
}
|
||
|
||
/// <summary>A row button named with its row for screen readers ("Pause: Render · Harbour sunset").</summary>
|
||
private static JobAction Action(string textKey, string toolTipKey, string row, Func<Task> run)
|
||
{
|
||
var text = Loc.L(textKey);
|
||
return new JobAction(text, Loc.L(toolTipKey), Loc.L("Jobs.ActionFor", text, row), new AsyncRelayCommand(run));
|
||
}
|
||
|
||
private JobAction OnQueue(string textKey, string toolTipKey, string row, Func<IJobQueue, Task> run) =>
|
||
Action(textKey, toolTipKey, row, async () =>
|
||
{
|
||
if (owner.Queue is { } queue) await run(queue);
|
||
});
|
||
}
|