diff --git a/i18n/en/Library.resx b/i18n/en/Library.resx
index 8d365087..b4bac4f4 100644
--- a/i18n/en/Library.resx
+++ b/i18n/en/Library.resx
@@ -61,8 +61,11 @@
TitleAnalysedAnalysing
+ Conflict
+ Newer hereProxiesRemote
+ Newer on serverSyncedViewGrid
diff --git a/i18n/en/Server.resx b/i18n/en/Server.resx
index 512ef763..9e2ada8b 100644
--- a/i18n/en/Server.resx
+++ b/i18n/en/Server.resx
@@ -5,12 +5,19 @@
System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089nas.local:8443invariant
+ Sync projects automaticallyCertificateForgetKeepTitano trusts this certificate for this server. Forgetting it disconnects, and the next connection asks again.longServer certificateTLS {0} trusted {1}
+ Cancel
+ {0}: {1} here, {2} on the serverlong; {0} setting path, {1} value on this PC, {2} value on the server
+ The server copy of {0} will be replaced by this PC's settings.long; {0} sequence title
+ Keep this PC's settings?
+ This PC's settings of {0} will be replaced by the server copy.long; {0} sequence title
+ Take the server's settings?ConnectDisconnectNot connected to a server
@@ -71,6 +78,7 @@
The current password is wrong.longThis upload belongs to a render job.longServers found
+ Keep proxies offlineAccountServerStatus
@@ -93,6 +101,53 @@
Connecting…DisconnectedNot connected
+ Download originals
+ Keep mine
+ Open with proxies
+ Pause
+ Resume
+ Save both
+ Sync settings
+ Take server
+ Upload
+ Server archive {1} · {0} sequencelong; {0} sequence count, {1} archive size
+ Server archive {1} · {0} sequenceslong; {0} sequence count, {1} archive size
+ The server copy changed again; compare and choose again.long
+ This PC
+ Sequence
+ Server
+ State
+ Nothing to compare yet
+ {0} export{0} count
+ {0} exports{0} count
+ All · {0}{0} count
+ Conflicts · {0}{0} count
+ Local only · {0}{0} count
+ Remote · {0}{0} count
+ Last sync {0} · manifest diff {1} slong; {0} time of day, {1} seconds
+ No sequence matches
+ —invariant
+ Open admin panel
+ originals
+ proxies
+ {0} upload queued{0} count
+ {0} uploads queued{0} count
+ {0} received{0} percent
+ Not compared · retrying
+ Search
+ settings differ
+ downloading
+ in sync
+ newer here
+ local only
+ paused
+ proxies only
+ remote
+ newer on server
+ uploading
+ waiting
+ Sequences
+ Upload all localTrustCancel{0} uses a certificate Titano does not know yet. Compare the fingerprint with the one in the server's admin panel before you trust it.long
diff --git a/i18n/en/Tooltips.resx b/i18n/en/Tooltips.resx
index 7ca6cbe4..8995adcf 100644
--- a/i18n/en/Tooltips.resx
+++ b/i18n/en/Tooltips.resx
@@ -74,13 +74,16 @@
Filter by analysis, proxies, verification or warningsAnalysed: exposure, flicker and motion are measuredAn analysis job is running on this sequence
+ Settings changed here and on the server; choose on the Server screenSome frames are missing or unreadable; open the sequence for details
+ This PC has originals or settings the server does not have yetNo proxies yet; editing reads the originalsNot analysed yetJPEG proxies built for fast editingLives on the server; this PC has proxies at mostRendered onceRendered {0:N0} times
+ The server has originals or settings this PC does not have yetThe same on this PC and on the server{0:N0} warning; open the sequence for details{0:N0} warnings; open the sequence for details
@@ -97,14 +100,18 @@
Connection, sync and render node · Ctrl+6Preferences of this PC · Ctrl+,Address of the Titano Server; https is assumed · Enter connects
+ Send and take project settings as they change; settings changed on both sides wait for your choice in the table belowShow the full fingerprint, or forget the trustFingerprint trusted on first use; a change blocks the connection and asks you again
+ Close without changing either copy
+ The settings that differ: this PC's value, then the server'sIdentify the server, confirm a new certificate, then sign in · EnterClose the session and work with the local archive only; you stay signed inDo not connect; nothing is sent to this serverSHA-256 fingerprint of the server certificateForget this certificate; the next connection asks againServers found on this network and used before
+ Keep JPEG proxies of every server sequence on this PC to edit without the originals; uses space in the cache folderKeep trusting this certificateClose without signing in · EscSent only to this server; Titano keeps a session token, never the password
@@ -118,6 +125,36 @@
Sign in; the token is stored encrypted for this Windows user · EnterSign out; the token is removed from this PCConnection to the server
+ Size and sequences of the server archive
+ Fetch the originals to this PC, verified by hash ({0}){0} size
+ All sequences on this PC and on the server
+ Settings differ between this PC and the server
+ Only on this PC
+ Only on the server
+ Overwrite the server copy with this PC's settings
+ When this PC last compared every sequence with the server, and how long it took
+ Open the web admin in your browser (admins only)
+ Open the editor on the proxies; the render runs on the server
+ Pause this transfer; it resumes where it stopped
+ Resume this transfer where it stopped
+ The last comparison failed: {0}. It is retried automatically.{0} reason
+ Take the server copy and keep this PC's settings as a dated copy of the project
+ Filter the table by sequence title
+ Settings changed both here and on the server; choose which to keep
+ Originals or proxies are arriving from the server
+ Same originals and settings on this PC and on the server
+ This PC has originals or settings the server does not have yet
+ Only on this PC; upload it to keep it on the server too
+ The transfer is paused; resume it to continue
+ On the server; this PC keeps its proxies for editing
+ Only on the server
+ The server has originals or settings this PC does not have yet
+ Originals are being sent to the server
+ The transfer waits for its turn in the job queue
+ Send or take the settings changed on one side
+ Replace this PC's settings with the server copy
+ Copy originals and settings to the server ({0}){0} size
+ Send every local-only sequence to the server ({0} sequences, {1}){0} count, {1} sizeTrust this certificate for this server and continue to sign inUse this addressGraphics adapter and Media Foundation encoders found
diff --git a/i18n/it/Library.it.resx b/i18n/it/Library.it.resx
index cbf7ca1a..29240386 100644
--- a/i18n/it/Library.it.resx
+++ b/i18n/it/Library.it.resx
@@ -61,8 +61,11 @@
TitoloAnalizzataIn analisi
+ Conflitto
+ Più recente quiProxyRemota
+ Più recente sul serverSincronizzataVistaGriglia
diff --git a/i18n/it/Server.it.resx b/i18n/it/Server.it.resx
index fb5bdb68..b5bd92ab 100644
--- a/i18n/it/Server.it.resx
+++ b/i18n/it/Server.it.resx
@@ -4,12 +4,19 @@
2.0System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+ Sincronia automatica progettiCertificatoDimenticaMantieniTitano considera attendibile questo certificato per questo server. Se lo dimentichi la connessione si chiude e la prossima volta te lo chiederà di nuovo.Certificato del serverTLS {0} attendibile dal {1}
+ Annulla
+ {0}: {1} qui, {2} sul server
+ La copia sul server di {0} sarà sostituita dalle impostazioni di questo PC.
+ Tenere le impostazioni di questo PC?
+ Le impostazioni di {0} su questo PC saranno sostituite dalla copia del server.
+ Usare le impostazioni del server?ConnettiDisconnettiNon connesso a un server
@@ -70,6 +77,7 @@
La password attuale è errata.Questo caricamento appartiene a un job di rendering.Server trovati
+ Proxy disponibili offlineAccountServerStato
@@ -92,6 +100,52 @@
Connessione…DisconnessoNon connesso
+ Scarica originali
+ Tieni le mie
+ Apri con i proxy
+ Pausa
+ Riprendi
+ Salva entrambe
+ Sincronizza
+ Usa il server
+ Carica
+ Archivio del server {1} · {0} sequenza
+ Archivio del server {1} · {0} sequenze
+ La copia sul server è cambiata di nuovo; confronta e scegli di nuovo.
+ Questo PC
+ Sequenza
+ Server
+ Stato
+ Ancora nulla da confrontare
+ {0} esportazione
+ {0} esportazioni
+ Tutte · {0}
+ Conflitti · {0}
+ Solo locali · {0}
+ Sul server · {0}
+ Ultima sincronia {0} · confronto {1} s
+ Nessuna sequenza corrisponde
+ Apri pannello admin
+ originali
+ proxy
+ {0} caricamento in coda
+ {0} caricamenti in coda
+ {0} ricevuto
+ Confronto non riuscito · riprovo
+ Cerca
+ impostazioni diverse
+ in scaricamento
+ sincronizzata
+ più recente qui
+ solo locale
+ in pausa
+ solo proxy
+ sul server
+ più recente sul server
+ in caricamento
+ in attesa
+ Sequenze
+ Carica tutte le localiConsidera attendibileAnnulla{0} usa un certificato che Titano non conosce ancora. Confronta l'impronta con quella del pannello di amministrazione del server prima di considerarlo attendibile.
diff --git a/i18n/it/Tooltips.it.resx b/i18n/it/Tooltips.it.resx
index c81ad08f..cd171b20 100644
--- a/i18n/it/Tooltips.it.resx
+++ b/i18n/it/Tooltips.it.resx
@@ -74,13 +74,16 @@
Filtra per analisi, proxy, verifica o avvisiAnalizzata: esposizione, flicker e movimento sono misuratiUn'attività di analisi è in corso su questa sequenza
+ Impostazioni cambiate qui e sul server; scegli nella schermata ServerAlcuni fotogrammi mancano o sono illeggibili; apri la sequenza per i dettagli
+ Questo PC ha originali o impostazioni che il server non ha ancoraAncora nessun proxy; la modifica legge gli originaliNon ancora analizzataProxy JPEG pronti per una modifica veloceSi trova sul server; questo PC ne ha al massimo i proxyEsportata una voltaEsportata {0:N0} volte
+ Il server ha originali o impostazioni che questo PC non ha ancoraUguale su questo PC e sul server{0:N0} avviso; apri la sequenza per i dettagli{0:N0} avvisi; apri la sequenza per i dettagli
@@ -97,14 +100,18 @@
Connessione, sincronizzazione e nodo di rendering · Ctrl+6Preferenze di questo PC · Ctrl+,Indirizzo del Titano Server; si presume https · Invio per connettersi
+ Invia e ricevi le impostazioni dei progetti quando cambiano; quelle cambiate da entrambe le parti attendono la tua scelta nella tabella sottoMostra l'impronta completa o revoca la fiduciaImpronta accettata al primo utilizzo; se cambia, la connessione si blocca e te lo chiede di nuovo
+ Chiudi senza modificare nessuna delle due copie
+ Le impostazioni diverse: il valore di questo PC, poi quello del serverIdentifica il server, conferma un certificato nuovo e poi accedi · InvioChiude la sessione e lavora solo con l'archivio locale; l'accesso resta salvatoNon connetterti; a questo server non viene inviato nullaImpronta SHA-256 del certificato del serverDimentica questo certificato; alla prossima connessione verrà chiesto di nuovoServer trovati in questa rete e usati in precedenza
+ Tieni su questo PC i proxy JPEG di ogni sequenza del server per lavorare senza gli originali; usa spazio nella cartella cacheContinua a considerare attendibile questo certificatoChiude senza accedere · EscInviata solo a questo server; Titano conserva un token di sessione, mai la password
@@ -118,6 +125,36 @@
Accedi; il token viene salvato cifrato per questo utente di Windows · InvioEsci; il token viene rimosso da questo PCConnessione al server
+ Dimensione e sequenze dell'archivio del server
+ Scarica gli originali su questo PC, verificati con l'hash ({0})
+ Tutte le sequenze di questo PC e del server
+ Le impostazioni differiscono tra questo PC e il server
+ Solo su questo PC
+ Solo sul server
+ Sovrascrivi la copia del server con le impostazioni di questo PC
+ Quando questo PC ha confrontato per l'ultima volta tutte le sequenze con il server, e quanto ha impiegato
+ Apri l'amministrazione web nel browser (solo amministratori)
+ Apri l'editor sui proxy; il rendering avviene sul server
+ Metti in pausa questo trasferimento; riprende da dove si è fermato
+ Riprendi questo trasferimento da dove si è fermato
+ L'ultimo confronto non è riuscito: {0}. Viene ripetuto automaticamente.
+ Usa la copia del server e conserva le impostazioni di questo PC come copia datata del progetto
+ Filtra la tabella per titolo della sequenza
+ Le impostazioni sono cambiate sia qui sia sul server; scegli quali tenere
+ Originali o proxy in arrivo dal server
+ Stessi originali e impostazioni su questo PC e sul server
+ Questo PC ha originali o impostazioni che il server non ha ancora
+ Solo su questo PC; caricala per averla anche sul server
+ Il trasferimento è in pausa; riprendilo per continuare
+ Sul server; questo PC ne conserva i proxy per modificarla
+ Solo sul server
+ Il server ha originali o impostazioni che questo PC non ha ancora
+ Originali in invio al server
+ Il trasferimento attende il suo turno nella coda delle attività
+ Invia o ricevi le impostazioni cambiate da una sola parte
+ Sostituisci le impostazioni di questo PC con la copia del server
+ Copia originali e impostazioni sul server ({0})
+ Invia al server ogni sequenza solo locale ({0} sequenze, {1})Considera attendibile questo certificato per questo server e prosegui con l'accessoUsa questo indirizzoScheda grafica ed encoder Media Foundation trovati
diff --git a/src/Titano.App/Infrastructure/AppServices.cs b/src/Titano.App/Infrastructure/AppServices.cs
index 5ed5098f..9184d2b4 100644
--- a/src/Titano.App/Infrastructure/AppServices.cs
+++ b/src/Titano.App/Infrastructure/AppServices.cs
@@ -29,7 +29,7 @@ namespace Titano.App.Infrastructure;
/// archive engine (WIC first, then managed decoders), the analysis and render engine (the same decoders; Media
/// Foundation, then managed encoders), the one of this PC with the handlers of
/// , thumbnails, the server session, the render node, the encoder inventory and the
-/// update check. Started after the window shows, stopped when the app exits. The last archive is reopened at start and
+/// update check, and the sync with the signed-in server (). Started after the window shows, stopped when the app exits. The last archive is reopened at start and
/// rescanned every (BRIEF §7: polling, no file-system watchers). The render node runs while
/// the user offers this PC () and a server session is open.
///
@@ -52,6 +52,7 @@ public sealed class AppServices : IAsyncDisposable
SaveSettingsAction = saveSettings;
Dialogs = dialogs;
ArchiveSetup = new EngineArchiveSetup(this);
+ Sync = new SyncHost(this);
Server = new ServerSession(settings, saveSettings, new TitanoServerApiFactory(), new DpapiTokenProtector());
Encoders = new MediaFoundationInventory();
CheckForUpdateAsync = ct => UpdateCheck.FetchAsync(Http.Value, ProductLinks.LatestReleaseApi, VersionText, ct);
@@ -81,9 +82,13 @@ public sealed class AppServices : IAsyncDisposable
_server = value;
_server.PropertyChanged += OnServerChanged;
UpdateRenderNode();
+ Sync.Update();
}
}
+ /// Sync with the signed-in server: engine, job connection, background comparison.
+ public SyncHost Sync { get; }
+
public IEncoderInventory Encoders { get; set; }
/// Latest public release (GitHub Releases API of the releases repository, BRIEF §18).
@@ -111,7 +116,10 @@ public sealed class AppServices : IAsyncDisposable
/// The job handlers of this PC's engine — the single registration list; a kind without a handler stays
/// queued (it is never claimed here).
public static IReadOnlyList CreateJobHandlers(AppServices services) =>
- [.. services.Archives?.CreateJobHandlers() ?? [], .. services.Processing?.CreateJobHandlers() ?? []];
+ [
+ .. services.Archives?.CreateJobHandlers() ?? [], .. services.Processing?.CreateJobHandlers() ?? [],
+ .. services.Sync.Service?.CreateJobHandlers(services.Sync) ?? [],
+ ];
/// Queues a scan of unless one is already waiting or running.
public async Task QueueScanAsync(Archive archive, bool full, CancellationToken ct = default)
@@ -174,6 +182,7 @@ public sealed class AppServices : IAsyncDisposable
_server.PropertyChanged -= OnServerChanged;
await _nodeSwitch;
await StopRenderNodeAsync();
+ await Sync.DisposeAsync();
(Jobs as IDisposable)?.Dispose();
if (Engine is not null) await Engine.DisposeAsync();
Thumbnails?.Dispose();
@@ -209,6 +218,7 @@ public sealed class AppServices : IAsyncDisposable
var archive = new ArchiveServiceOptions { Decoder = DecoderFactory.CreateClient(new WicDecoderProvider()) };
Archives = new ArchiveService(database, archive);
Processing = new ProcessingService(database, ProcessingOptions(archive));
+ Sync.Open(database, Archives, archive);
var handlers = CreateJobHandlers(this);
var kinds = handlers.Select(h => h.Kind).Distinct().ToArray();
Engine = new JobEngine(database, handlers, new JobEngineOptions { WorkerId = WorkerId, Kinds = kinds });
@@ -218,6 +228,7 @@ public sealed class AppServices : IAsyncDisposable
Jobs = new EngineJobQueue(database, Engine, started);
Log.Info("jobs", started ? $"Job engine started with {Engine.Options.Workers} worker(s) for {string.Join(", ", kinds)}" : "No job handlers registered; jobs stay queued");
UpdateRenderNode();
+ Sync.Update();
}
/// Media Foundation (hardware first, software H.264) then managed encoders; frames spill into the cache folder
@@ -235,7 +246,11 @@ public sealed class AppServices : IAsyncDisposable
},
};
- private void OnServerChanged(object? sender, PropertyChangedEventArgs e) => UpdateRenderNode();
+ private void OnServerChanged(object? sender, PropertyChangedEventArgs e)
+ {
+ UpdateRenderNode();
+ Sync.Update();
+ }
/// Waits for the previous switch, then runs the node for the current session, or stops it.
private async Task SwitchRenderNodeAsync(Task previous)
diff --git a/src/Titano.App/Infrastructure/AppSettings.cs b/src/Titano.App/Infrastructure/AppSettings.cs
index 59385ce1..dcf5bb47 100644
--- a/src/Titano.App/Infrastructure/AppSettings.cs
+++ b/src/Titano.App/Infrastructure/AppSettings.cs
@@ -111,6 +111,12 @@ public sealed class AppSettings
/// Let the server send render jobs to this PC (BRIEF §14.7).
public bool RenderNodeOptIn { get; set; }
+ /// Keep the proxies of every server sequence without local originals in the cache (BRIEF §12.7).
+ public bool KeepProxiesOffline { get; set; }
+
+ /// Send and take project settings changed on one side without asking (Server.html).
+ public bool SyncSettingsAutomatically { get; set; } = true;
+
// ---- Jobs ----
/// "Clear done": finished jobs older than this are hidden from the Jobs list (they stay in the history).
public DateTimeOffset? JobsClearedAt { get; set; }
diff --git a/src/Titano.App/Library/SequenceItem.cs b/src/Titano.App/Library/SequenceItem.cs
index f1ed8d64..ef467181 100644
--- a/src/Titano.App/Library/SequenceItem.cs
+++ b/src/Titano.App/Library/SequenceItem.cs
@@ -147,6 +147,16 @@ public sealed class SequenceItem : ObservableObject
OnPropertyChanged(nameof(PrimaryStatus));
}
+ /// Where a local copy stands against the server (the sync engine writes the state); null while it is only here.
+ public static CardStatus? SyncStatus(SyncState state) => state switch
+ {
+ SyncState.InSync => new CardStatus(StatusKind.Synced, Loc.L("Library.Status.Synced"), Loc.L("Tooltips.Library.Status.Synced")),
+ SyncState.LocalAhead => new CardStatus(StatusKind.Synced, Loc.L("Library.Status.LocalAhead"), Loc.L("Tooltips.Library.Status.LocalAhead")),
+ SyncState.ServerAhead => new CardStatus(StatusKind.Remote, Loc.L("Library.Status.ServerAhead"), Loc.L("Tooltips.Library.Status.ServerAhead")),
+ SyncState.Conflict => new CardStatus(StatusKind.Warning, Loc.L("Library.Status.Conflict"), Loc.L("Tooltips.Library.Status.Conflict")),
+ _ => null,
+ };
+
/// Card status row: analysed, proxies, renders, sync, warnings (Main.html).
public static IReadOnlyList BuildStatuses(Sequence s, bool analysing)
{
@@ -168,8 +178,7 @@ public sealed class SequenceItem : ObservableObject
if (s.RenderedCount > 0)
list.Add(new CardStatus(StatusKind.Rendered, Formatting.Count(s.RenderedCount), Loc.Plural("Tooltips.Library.Status.Rendered", s.RenderedCount)));
- if (s.SyncState == SyncState.InSync)
- list.Add(new CardStatus(StatusKind.Synced, Loc.L("Library.Status.Synced"), Loc.L("Tooltips.Library.Status.Synced")));
+ if (SyncStatus(s.SyncState) is { } sync) list.Add(sync);
if ((s.Status & SequenceStatus.HasErrors) != 0)
list.Add(new CardStatus(StatusKind.Error, Formatting.Count(Math.Max(1, s.WarningCount)), Loc.L("Tooltips.Library.Status.Errors")));
else if (s.WarningCount > 0 || (s.Status & SequenceStatus.HasWarnings) != 0)
diff --git a/src/Titano.App/Sections/LibraryViewModel.cs b/src/Titano.App/Sections/LibraryViewModel.cs
index f1072311..a70ed8d7 100644
--- a/src/Titano.App/Sections/LibraryViewModel.cs
+++ b/src/Titano.App/Sections/LibraryViewModel.cs
@@ -497,7 +497,7 @@ public sealed class LibraryViewModel : SectionViewModel
{
if (await _db.Sequences.GetAsync(item.Id) is { } fresh) item.Update(fresh);
}
- if (job.Kind is JobKind.Scan or JobKind.Rebuild or JobKind.Import or JobKind.Adopt or JobKind.Move or JobKind.UploadCommit) await RefreshAsync();
+ if (job.Kind is JobKind.Scan or JobKind.Rebuild or JobKind.Import or JobKind.Adopt or JobKind.Move or JobKind.UploadCommit or JobKind.Download) await RefreshAsync();
}
catch (DatabaseException ex)
{
diff --git a/src/Titano.App/Sections/ServerView.xaml b/src/Titano.App/Sections/ServerView.xaml
index 4ad2e471..c4d1d067 100644
--- a/src/Titano.App/Sections/ServerView.xaml
+++ b/src/Titano.App/Sections/ServerView.xaml
@@ -15,9 +15,12 @@
+
+
+
-
+
@@ -112,9 +115,112 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Titano.App/Sections/ServerViewModel.cs b/src/Titano.App/Sections/ServerViewModel.cs
index b50d7a70..d6daacc2 100644
--- a/src/Titano.App/Sections/ServerViewModel.cs
+++ b/src/Titano.App/Sections/ServerViewModel.cs
@@ -10,9 +10,9 @@ using Titano.Ui.Mvvm;
namespace Titano.App.Sections;
///
-/// Server, connection part (BRIEF §12.7, Server.html): address with LAN-discovered servers, connect with
-/// trust-on-first-use and login, status (name, version, latency, certificate), account and quota, sign out, and
-/// the render-node opt-in. The sync table and render-node panel join this screen later.
+/// Server (BRIEF §12.7, Server.html): address with LAN-discovered servers, connect with trust-on-first-use and login,
+/// status (name, version, latency, certificate), account and quota, sign out, the options of this PC (render node,
+/// proxies kept offline, automatic project sync) and the sync table ().
///
public sealed class ServerViewModel : SectionViewModel
{
@@ -34,8 +34,12 @@ public sealed class ServerViewModel : SectionViewModel
else if (p is string text) Address = text;
});
CertificateCommand = new RelayCommand(ShowCertificate, () => Fingerprint is not null);
+ Sync = new SyncTableViewModel(shell);
}
+ /// Sequences of this PC and of the server, where they stand and what can be done.
+ public SyncTableViewModel Sync { get; }
+
public ShellViewModel Shell { get; }
private ServerSession Session => _session ?? Shell.Services.Server;
@@ -134,6 +138,20 @@ public sealed class ServerViewModel : SectionViewModel
}
}
+ /// Keep the proxies of every server sequence without local originals on this PC.
+ public bool KeepProxiesOffline
+ {
+ get => Shell.Services.Settings.KeepProxiesOffline;
+ set => SetSyncOption(value, Shell.Services.Settings.KeepProxiesOffline, v => Shell.Services.Settings.KeepProxiesOffline = v);
+ }
+
+ /// Send and take project settings changed on one side without asking.
+ public bool SyncSettingsAutomatically
+ {
+ get => Shell.Services.Settings.SyncSettingsAutomatically;
+ set => SetSyncOption(value, Shell.Services.Settings.SyncSettingsAutomatically, v => Shell.Services.Settings.SyncSettingsAutomatically = v);
+ }
+
/// Re-reads values another screen changed (Settings › Server).
public void Refresh() => OnPropertyChanged(nameof(RenderNodeOptIn));
@@ -149,6 +167,7 @@ public sealed class ServerViewModel : SectionViewModel
if (Address.Length == 0 && Session.Discovered.Count > 0) Address = Session.Discovered[0].Address;
};
if (!Shell.Services.Environment.IsCapture) _session.StartDiscovery();
+ Sync.Attach();
await _session.RestoreAsync();
if (_session.Flow.Error is not ConnectError.None and var error && !_session.IsConnected) ErrorText = ServerSession.ErrorText(error);
}
@@ -156,9 +175,19 @@ public sealed class ServerViewModel : SectionViewModel
public override void Dispose()
{
if (_session is not null) _session.PropertyChanged -= OnSessionChanged;
+ Sync.Dispose();
base.Dispose();
}
+ private void SetSyncOption(bool value, bool current, Action store, [System.Runtime.CompilerServices.CallerMemberName] string? name = null)
+ {
+ if (value == current) return;
+ store(value);
+ Shell.Services.SaveSettings();
+ Shell.Services.Sync.RequestRefresh();
+ OnPropertyChanged(name);
+ }
+
private async Task ConnectAsync()
{
ErrorText = null;
diff --git a/src/Titano.App/Server/SyncHost.cs b/src/Titano.App/Server/SyncHost.cs
new file mode 100644
index 00000000..29051bc0
--- /dev/null
+++ b/src/Titano.App/Server/SyncHost.cs
@@ -0,0 +1,137 @@
+using System.IO;
+using Titano.App.Infrastructure;
+using Titano.Core.Diagnostics;
+using Titano.Core.Model;
+using Titano.Data;
+using Titano.Data.Sync;
+using Titano.Protocol.Client;
+
+namespace Titano.App.Server;
+
+/// Makes the sync connection of a signed-in session.
+public delegate ISyncRemote SyncRemoteFactory(Uri address, string token, IReadOnlyCollection trustedFingerprints);
+
+///
+/// This PC's sync with the signed-in server (BRIEF §4.4, §14.5): the of the index, the
+/// connection of upload and download jobs () and a that keeps the
+/// table current while a session is open, started and stopped in order as the session changes. Options come from
+/// and .
+///
+public sealed class SyncHost(AppServices services) : ISyncConnector, IAsyncDisposable
+{
+ /// How long a job resumed at start waits for the saved session to be restored.
+ private static readonly TimeSpan RestoreWait = TimeSpan.FromSeconds(30);
+
+ private Task _switch = Task.CompletedTask;
+ private Credentials? _credentials;
+ private (SyncAgent Agent, ISyncRemote Remote, Credentials Credentials)? _running;
+
+ /// Connections over ; screenshots substitute a fake server.
+ public SyncRemoteFactory RemoteFactory { get; set; } = (address, token, trusted) =>
+ new TitanoSyncRemote(new TitanoClient(address, new CertificatePinning(trusted), $"Titano ({Environment.MachineName})") { Token = token }, ownsClient: true);
+
+ /// The engine; null until the index is open.
+ public SyncService? Service { get; private set; }
+
+ /// The background comparison of the signed-in server; null while signed out.
+ public SyncAgent? Agent => _running?.Agent;
+
+ /// The agent's connection, for the table's own calls (conflict resolution); null while signed out.
+ public ISyncRemote? Remote => _running?.Remote;
+
+ /// Key of the signed-in server (); null while signed out.
+ public string? Server => Volatile.Read(ref _credentials) is { } c ? SyncService.ServerKey(c.Address) : null;
+
+ public SyncPolicy Policy => new(services.Settings.SyncSettingsAutomatically, services.Settings.KeepProxiesOffline);
+
+ /// The agent started, stopped or compared, or the table of the signed-in server changed (any thread).
+ public event Action? Changed;
+
+ /// Creates the engine over the open index; the proxy cache lives in the client's cache folder.
+ public SyncService Open(TitanoDatabase database, Titano.Data.Archiving.ArchiveService archives, Titano.Data.Archiving.ArchiveServiceOptions options)
+ {
+ var cache = CacheStore.Folder(services.Environment, services.Settings);
+ Service = new SyncService(database, archives, new SyncOptions { Archive = options, ProxyCacheDirectory = Path.Combine(cache, "proxies") });
+ Service.Changed += server =>
+ {
+ if (server == Server) Changed?.Invoke();
+ };
+ return Service;
+ }
+
+ /// Follows the server session (UI thread): starts the agent for a new sign-in, stops it on sign-out.
+ public void Update()
+ {
+ var session = services.Server;
+ Credentials? wanted = session.IsConnected && session.Flow is { Address: { } address, Token: { } token }
+ ? new Credentials(address, token, session.Fingerprints)
+ : null;
+ Volatile.Write(ref _credentials, wanted);
+ _switch = SwitchAsync(_switch, wanted);
+ }
+
+ /// Compares again soon (an option changed, an edit on this PC).
+ public void RequestRefresh() => Agent?.RequestRefresh();
+
+ /// The archive downloaded originals go to when a sequence has no local copy: the one this PC works with.
+ public async Task CurrentArchiveAsync(CancellationToken ct = default)
+ {
+ if (services.Database is not { } db) return null;
+ var archives = await db.Archives.ListAsync(ct);
+ if (services.Settings.LastArchivePath is { Length: > 0 } root)
+ {
+ var full = Path.GetFullPath(root).TrimEnd(Path.DirectorySeparatorChar);
+ if (archives.FirstOrDefault(a => string.Equals(Path.GetFullPath(a.RootPath).TrimEnd(Path.DirectorySeparatorChar), full, StringComparison.OrdinalIgnoreCase))
+ is { } current) return current;
+ }
+ return archives.Count == 1 ? archives[0] : null;
+ }
+
+ public async ValueTask ConnectAsync(string server, CancellationToken cancellationToken)
+ {
+ // A job resumed at start runs before the saved session is restored: give the restore a moment.
+ var until = DateTime.UtcNow + RestoreWait;
+ while (Volatile.Read(ref _credentials) is null && services.Settings.ProtectedToken is not null && DateTime.UtcNow < until)
+ await Task.Delay(500, cancellationToken);
+ if (Volatile.Read(ref _credentials) is not { } c || SyncService.ServerKey(c.Address) != server) return null;
+ CacheStore.Prepare(CacheStore.Folder(services.Environment, services.Settings));
+ return RemoteFactory(c.Address, c.Token, c.Fingerprints);
+ }
+
+ public async ValueTask DisposeAsync()
+ {
+ Volatile.Write(ref _credentials, null);
+ await _switch;
+ await StopAsync();
+ }
+
+ private async Task SwitchAsync(Task previous, Credentials? wanted)
+ {
+ await previous;
+ if (_running is { } running && wanted is { } same && running.Credentials.Address == same.Address && running.Credentials.Token == same.Token) return;
+ await StopAsync();
+ if (wanted is not { } start || Service is not { } service)
+ {
+ Changed?.Invoke();
+ return;
+ }
+ var remote = RemoteFactory(start.Address, start.Token, start.Fingerprints);
+ var agent = new SyncAgent(service, remote, () => Policy, services.Engine);
+ agent.Changed += () => Changed?.Invoke();
+ agent.Start();
+ _running = (agent, remote, start);
+ Log.Info("sync", $"Comparing with {remote.Server}");
+ Changed?.Invoke();
+ }
+
+ private async Task StopAsync()
+ {
+ if (_running is not { } running) return;
+ _running = null;
+ await running.Agent.DisposeAsync();
+ running.Remote.Dispose();
+ Changed?.Invoke();
+ }
+
+ private sealed record Credentials(Uri Address, string Token, IReadOnlyCollection Fingerprints);
+}
diff --git a/src/Titano.App/Server/SyncRow.cs b/src/Titano.App/Server/SyncRow.cs
new file mode 100644
index 00000000..91c86041
--- /dev/null
+++ b/src/Titano.App/Server/SyncRow.cs
@@ -0,0 +1,58 @@
+using System.Windows.Input;
+using Titano.App.Infrastructure;
+using Titano.Core.Localization;
+using Titano.Data.Sync;
+using Titano.Ui.Controls;
+using Titano.Ui.Mvvm;
+
+namespace Titano.App.Server;
+
+/// A row button: "Upload", "Keep mine", …
+public sealed record SyncRowAction(SyncAction Action, string Text, string ToolTip, ICommand Command);
+
+/// One row of the sync table (Server.html): sequence, this PC, server, state and the actions that apply.
+public sealed class SyncRow : ObservableObject
+{
+ private readonly Func _act;
+ private SyncEntry _entry;
+ private SyncRights _rights;
+
+ public SyncRow(SyncEntry entry, SyncRights rights, Func act)
+ {
+ _entry = entry;
+ _rights = rights;
+ _act = act;
+ Actions = BuildActions();
+ }
+
+ public SyncEntry Entry => _entry;
+ public Guid Id => _entry.Id;
+ public string Title => _entry.Title;
+ public string LocalText => SyncText.Local(_entry);
+ public string ServerText => SyncText.Server(_entry);
+ public StatusKind StateKind => SyncText.State(_entry).Kind;
+ public string StateText => SyncText.State(_entry).Text;
+ public string StateToolTip => SyncText.State(_entry).ToolTip;
+ public IReadOnlyList Actions { get; private set; }
+
+ /// Takes a fresher comparison of the same sequence.
+ public void Update(SyncEntry entry, SyncRights rights)
+ {
+ _entry = entry;
+ _rights = rights;
+ Actions = BuildActions();
+ OnAllPropertiesChanged();
+ }
+
+ private List BuildActions() =>
+ [
+ .. SyncText.Actions(_entry, _rights).Select(action => new SyncRowAction(action, Loc.L("Server.Sync.Action." + action), ToolTip(action),
+ new AsyncRelayCommand(() => _act(this, action)))),
+ ];
+
+ private string ToolTip(SyncAction action) => action switch
+ {
+ SyncAction.Upload or SyncAction.DownloadOriginals => Loc.L("Tooltips.Server.Sync." + action, Formatting.Bytes(SyncText.Size(_entry, action))),
+ _ => Loc.L("Tooltips.Server.Sync." + action),
+ };
+}
diff --git a/src/Titano.App/Server/SyncTableViewModel.cs b/src/Titano.App/Server/SyncTableViewModel.cs
new file mode 100644
index 00000000..179f1167
--- /dev/null
+++ b/src/Titano.App/Server/SyncTableViewModel.cs
@@ -0,0 +1,366 @@
+using System.Collections.Concurrent;
+using System.Collections.ObjectModel;
+using System.Net;
+using System.Windows.Input;
+using System.Windows.Threading;
+using Titano.App.Infrastructure;
+using Titano.App.Shell;
+using Titano.Core.Diagnostics;
+using Titano.Core.Localization;
+using Titano.Core.Model;
+using Titano.Data.Jobs;
+using Titano.Data.Sync;
+using Titano.Protocol.Client;
+using Titano.Ui.Mvvm;
+
+namespace Titano.App.Server;
+
+/// A filter chip of the sync table: "Conflicts · 1".
+public sealed class SyncFilterChip(SyncFilter filter, Action select) : ObservableObject
+{
+ private int _count;
+ private bool _isSelected;
+
+ public SyncFilter Filter { get; } = filter;
+ public string Text => Loc.L("Server.Sync.Filter." + Filter, Formatting.Count(_count));
+ public string ToolTip => Loc.L("Tooltips.Server.Sync.Filter." + Filter);
+ public ICommand SelectCommand { get; } = new RelayCommand(() => select(filter));
+
+ /// Conflicts waiting for a choice: the chip is drawn in the warning colour.
+ public bool NeedsAttention => Filter == SyncFilter.Conflicts && _count > 0;
+
+ public bool IsSelected
+ {
+ get => _isSelected;
+ set => Set(ref _isSelected, value);
+ }
+
+ public int Count
+ {
+ get => _count;
+ set
+ {
+ if (!Set(ref _count, value)) return;
+ OnPropertyChanged(nameof(Text));
+ OnPropertyChanged(nameof(NeedsAttention));
+ }
+ }
+}
+
+///
+/// The sync table of the Server screen (BRIEF §12.7, Server.html): every sequence of this PC and of the signed-in
+/// server with what each side holds, where it stands and what can be done (upload, download originals, open with
+/// proxies, settle a settings conflict, pause or resume a transfer), filter chips, search, "Upload all local" and the
+/// footer (last comparison, server archive, admin panel). Reloads when the sync engine reports a change; transfer
+/// progress is applied at most a few times a second. Runs on the UI thread.
+///
+public sealed class SyncTableViewModel : ObservableObject, IDisposable
+{
+ private readonly ShellViewModel _shell;
+ private readonly IReadOnlyList _chips;
+ private readonly HashSet _openWhenCached = [];
+ private readonly ConcurrentDictionary _progress = new();
+ private readonly SemaphoreSlim _reloading = new(1, 1);
+ private IReadOnlyList _entries = [];
+ private SyncFilter _filter = SyncFilter.All;
+ private string _search = string.Empty;
+ private int _progressQueued;
+ private int _reloadQueued;
+ private bool _attached;
+
+ public SyncTableViewModel(ShellViewModel shell)
+ {
+ _shell = shell;
+ _chips = [.. Enum.GetValues().Select(f => new SyncFilterChip(f, Select) { IsSelected = f == SyncFilter.All })];
+ UploadAllCommand = new AsyncRelayCommand(UploadAllAsync, () => Rights.CanUpload && LocalOnly.Any());
+ OpenAdminCommand = new RelayCommand(() =>
+ {
+ if (Host.Server is { } server) ShellActions.OpenUrl(server + "/admin");
+ });
+ }
+
+ public ObservableCollection Rows { get; } = [];
+ public IReadOnlyList Chips => _chips;
+ public ICommand UploadAllCommand { get; }
+ public ICommand OpenAdminCommand { get; }
+
+ public string SearchText
+ {
+ get => _search;
+ set
+ {
+ if (Set(ref _search, value ?? string.Empty)) ApplyFilter();
+ }
+ }
+
+ /// Signed in: the table compares this PC with that server.
+ public bool IsActive => Host.Server is not null;
+
+ public bool HasRows => Rows.Count > 0;
+
+ /// "Not connected to a server", "Nothing to compare yet" or "No sequence matches"; null when rows show.
+ public string? EmptyText => HasRows ? null
+ : !IsActive ? Loc.L("Server.Empty")
+ : _entries.Count == 0 ? Loc.L("Server.Sync.Empty")
+ : Loc.L("Server.Sync.NoMatch");
+
+ public string UploadAllToolTip => Loc.L("Tooltips.Server.Sync.UploadAll", Formatting.Count(LocalOnly.Count()), Formatting.Bytes(LocalOnly.Sum(e => e.Local!.TotalBytes)));
+
+ /// "Last sync 10:15 · manifest diff 0.4 s"; null before the first comparison.
+ public string? LastSyncText => Host.Agent?.Snapshot is { } s
+ ? Loc.L("Server.Sync.Last", Formatting.TimeOfDay(s.RefreshedAt), s.Duration.TotalSeconds.ToString("0.0", Loc.Culture))
+ : null;
+
+ /// "Server archive 9.4 TB · 412 sequences".
+ public string? ArchiveText => Host.Agent?.Snapshot is { } s ? Loc.Plural("Server.Sync.Archive", s.ServerSequences, Formatting.Bytes(s.ServerBytes)) : null;
+
+ /// The last comparison failed (it is retried with growing pauses); null when it worked.
+ public string? ErrorText => Host.Agent?.LastError is not null ? Loc.L("Server.Sync.Retrying") : null;
+
+ public string? ErrorToolTip => Host.Agent?.LastError is { } error ? Loc.L("Tooltips.Server.Sync.Retrying", error.Message) : null;
+
+ /// The server's web admin (it admits administrators only).
+ public bool CanOpenAdmin => IsActive;
+
+ private SyncHost Host => _shell.Services.Sync;
+
+ private SyncRights Rights => _shell.Services.Server.User is { } user ? SyncRights.Of(user.Permissions) : default;
+
+ private IEnumerable LocalOnly => _entries.Where(e => e.Status == SyncStatus.LocalOnly);
+
+ /// Starts following the sync engine and the transfer jobs.
+ public void Attach()
+ {
+ if (_attached) return;
+ _attached = true;
+ Host.Changed += OnChanged;
+ if (_shell.Services.Jobs is { } jobs)
+ {
+ jobs.JobChanged += OnJobChanged;
+ jobs.Progress += OnProgress;
+ }
+ _ = ReloadAsync();
+ }
+
+ /// Reads the table again; concurrent requests collapse into one more pass.
+ public async Task ReloadAsync()
+ {
+ Interlocked.Exchange(ref _reloadQueued, 1);
+ if (!await _reloading.WaitAsync(0)) return;
+ try
+ {
+ while (Interlocked.Exchange(ref _reloadQueued, 0) == 1)
+ {
+ _entries = Host is { Service: { } service, Server: { } server } ? await service.ListAsync(server, CancellationToken.None) : [];
+ Refresh();
+ }
+ }
+ catch (Exception ex) when (ex is Data.DatabaseException or InvalidOperationException)
+ {
+ Log.Warning("sync", "The sync table could not be read", ex);
+ }
+ finally
+ {
+ _reloading.Release();
+ }
+ }
+
+ public void Dispose()
+ {
+ if (!_attached) return;
+ Host.Changed -= OnChanged;
+ if (_shell.Services.Jobs is { } jobs)
+ {
+ jobs.JobChanged -= OnJobChanged;
+ jobs.Progress -= OnProgress;
+ }
+ }
+
+ private void Select(SyncFilter filter)
+ {
+ _filter = filter;
+ foreach (var chip in _chips) chip.IsSelected = chip.Filter == filter;
+ ApplyFilter();
+ }
+
+ /// Counts, rows, footer and the Library's sync glyphs after a reload.
+ private void Refresh()
+ {
+ foreach (var chip in _chips) chip.Count = _entries.Count(e => SyncText.Matches(e, chip.Filter, string.Empty));
+ ApplyFilter();
+ UpdateLibrary();
+ OpenCachedProxies();
+ OnPropertyChanged(nameof(IsActive));
+ OnPropertyChanged(nameof(UploadAllToolTip));
+ OnPropertyChanged(nameof(LastSyncText));
+ OnPropertyChanged(nameof(ArchiveText));
+ OnPropertyChanged(nameof(ErrorText));
+ OnPropertyChanged(nameof(ErrorToolTip));
+ OnPropertyChanged(nameof(CanOpenAdmin));
+ CommandManager.InvalidateRequerySuggested();
+ }
+
+ /// Updates the rows in place (scroll position and recycled containers survive), adding and removing as needed.
+ private void ApplyFilter()
+ {
+ var rights = Rights;
+ var wanted = _entries.Where(e => SyncText.Matches(e, _filter, _search.Trim())).ToList();
+ var byId = Rows.ToDictionary(r => r.Id);
+ for (var i = 0; i < wanted.Count; i++)
+ {
+ var entry = wanted[i];
+ if (byId.Remove(entry.Id, out var row))
+ {
+ row.Update(entry, rights);
+ var at = Rows.IndexOf(row);
+ if (at != i) Rows.Move(at, i);
+ }
+ else
+ {
+ Rows.Insert(i, new SyncRow(entry, rights, ActAsync));
+ }
+ }
+ while (Rows.Count > wanted.Count) Rows.RemoveAt(Rows.Count - 1);
+ OnPropertyChanged(nameof(HasRows));
+ OnPropertyChanged(nameof(EmptyText));
+ }
+
+ /// The Library shows each local copy's sync state: rows it has loaded take the fresh state.
+ private void UpdateLibrary()
+ {
+ var locals = _entries.Where(e => e.Local is not null).ToDictionary(e => e.Local!.Id, e => e.Local!);
+ foreach (var item in _shell.Library.Items)
+ {
+ if (locals.TryGetValue(item.Id, out var fresh) && fresh.SyncState != item.Sequence.SyncState) item.Update(fresh);
+ }
+ }
+
+ /// "Open with proxies" waits for the proxy download; the editor opens once it is in the cache.
+ private void OpenCachedProxies()
+ {
+ foreach (var entry in _entries)
+ {
+ if (entry.Status == SyncStatus.ProxiesOnly && _openWhenCached.Remove(entry.Id)) _shell.OpenSequence(entry.Id);
+ }
+ }
+
+ private async Task ActAsync(SyncRow row, SyncAction action)
+ {
+ if (Host is not { Service: { } service, Server: { } server } || _shell.Services.Engine is not { } engine) return;
+ var entry = row.Entry;
+ switch (action)
+ {
+ case SyncAction.Upload:
+ await service.EnqueueUploadAsync(engine, server, entry.Local!);
+ break;
+ case SyncAction.DownloadOriginals:
+ if ((entry.Local?.ArchiveId ?? (await Host.CurrentArchiveAsync())?.Id) is not { } archive)
+ {
+ _shell.Notify(Loc.L("Errors.Sync.NoArchive"));
+ return;
+ }
+ await service.EnqueueDownloadAsync(engine, server, entry.Id, entry.Title, SyncDownloadMode.Originals, archive);
+ break;
+ case SyncAction.OpenWithProxies when entry.Status == SyncStatus.ProxiesOnly && service.OpenRemote(server, entry.Id) is not null:
+ _shell.OpenSequence(entry.Id);
+ return;
+ case SyncAction.OpenWithProxies:
+ _openWhenCached.Add(entry.Id);
+ await service.EnqueueDownloadAsync(engine, server, entry.Id, entry.Title, SyncDownloadMode.Proxies, null);
+ break;
+ case SyncAction.Pause:
+ await _shell.Services.Jobs!.PauseAsync(entry.Transfer!.Id);
+ break;
+ case SyncAction.Resume:
+ await _shell.Services.Jobs!.ResumeAsync(entry.Transfer!.Id);
+ break;
+ case SyncAction.SyncSettings when Host.Remote is { } remote:
+ await service.SyncSettingsAsync(remote, entry.Id, CancellationToken.None);
+ break;
+ case SyncAction.KeepMine or SyncAction.TakeServer or SyncAction.SaveBoth when Host.Remote is { } remote:
+ await ResolveAsync(service, remote, entry, action);
+ break;
+ }
+ await ReloadAsync();
+ }
+
+ /// Settles a conflict; overwriting one side is confirmed first with the settings that differ (the dry run).
+ private async Task ResolveAsync(SyncService service, ISyncRemote remote, SyncEntry entry, SyncAction action)
+ {
+ var resolution = action switch
+ {
+ SyncAction.KeepMine => SyncResolution.KeepMine,
+ SyncAction.TakeServer => SyncResolution.TakeServer,
+ _ => SyncResolution.SaveBoth,
+ };
+ if (resolution != SyncResolution.SaveBoth && !_shell.Services.Dialogs.Confirm(new ConfirmRequest
+ {
+ Heading = Loc.L("Server.Conflict." + action + ".Title"),
+ Message = Loc.L("Server.Conflict." + action + ".Message", entry.Title),
+ Detail = SyncText.Conflict(entry),
+ DetailToolTip = Loc.L("Tooltips.Server.Conflict.Detail"),
+ SafeText = Loc.L("Server.Conflict.Cancel"),
+ SafeToolTip = Loc.L("Tooltips.Server.Conflict.Cancel"),
+ ActionText = Loc.L("Server.Sync.Action." + action),
+ ActionToolTip = Loc.L("Tooltips.Server.Sync." + action),
+ IsDestructive = true,
+ })) return;
+ try
+ {
+ await service.ResolveAsync(remote, entry.Id, resolution, CancellationToken.None);
+ }
+ catch (TitanoApiException ex) when (ex.Status == HttpStatusCode.Conflict)
+ {
+ // The server copy changed again meanwhile: compare again and let the user choose on fresh content.
+ _shell.Notify(Loc.L("Server.Sync.ChangedAgain"));
+ await service.RefreshSequencesAsync(remote, [entry.Id], Host.Policy, CancellationToken.None);
+ }
+ }
+
+ private async Task UploadAllAsync()
+ {
+ if (Host is not { Service: { } service, Server: { } server } || _shell.Services.Engine is not { } engine) return;
+ var queued = 0;
+ foreach (var entry in LocalOnly.ToList())
+ {
+ await service.EnqueueUploadAsync(engine, server, entry.Local!);
+ queued++;
+ }
+ _shell.Notify(Loc.Plural("Server.Sync.Queued", queued));
+ await ReloadAsync();
+ }
+
+ private void OnChanged() => Dispatch(() => _ = ReloadAsync());
+
+ private void OnJobChanged(Job job)
+ {
+ if (job.Kind is not (JobKind.UploadCommit or JobKind.Download)) return;
+ _progress.TryRemove(job.Id, out _);
+ OnChanged();
+ }
+
+ /// Transfer progress ("46 % received") without reading the table again, at most a few times a second.
+ private void OnProgress(JobProgressInfo info)
+ {
+ if (info.Kind is not (JobKind.UploadCommit or JobKind.Download)) return;
+ _progress[info.JobId] = info;
+ if (Interlocked.Exchange(ref _progressQueued, 1) == 1) return;
+ System.Windows.Application.Current?.Dispatcher.BeginInvoke(DispatcherPriority.Background, async () =>
+ {
+ await Task.Delay(250);
+ Interlocked.Exchange(ref _progressQueued, 0);
+ var rights = Rights;
+ foreach (var row in Rows)
+ {
+ if (row.Entry.Transfer is { } job && _progress.TryGetValue(job.Id, out var p))
+ row.Update(row.Entry with { Transfer = job with { ProgressDone = p.Done, ProgressTotal = p.Total } }, rights);
+ }
+ });
+ }
+
+ private static void Dispatch(Action action)
+ {
+ if (System.Windows.Application.Current?.Dispatcher is not { } dispatcher || dispatcher.CheckAccess()) action();
+ else dispatcher.BeginInvoke(action);
+ }
+}
diff --git a/src/Titano.App/Server/SyncText.cs b/src/Titano.App/Server/SyncText.cs
new file mode 100644
index 00000000..07ded298
--- /dev/null
+++ b/src/Titano.App/Server/SyncText.cs
@@ -0,0 +1,147 @@
+using Titano.App.Infrastructure;
+using Titano.Core.Localization;
+using Titano.Core.Model;
+using Titano.Data.Sync;
+using Titano.Ui.Controls;
+
+namespace Titano.App.Server;
+
+/// Filter chips of the sync table (Server.html).
+public enum SyncFilter
+{
+ All,
+ LocalOnly,
+ Remote,
+ Conflicts,
+}
+
+/// What a row of the sync table offers.
+public enum SyncAction
+{
+ Upload,
+ OpenWithProxies,
+ DownloadOriginals,
+ SyncSettings,
+ KeepMine,
+ TakeServer,
+ SaveBoth,
+ Pause,
+ Resume,
+}
+
+/// What the signed-in account may do (server permission bits).
+/// Send originals and settings.
+/// Download originals (editors and render nodes).
+public readonly record struct SyncRights(bool CanUpload, bool CanFetchOriginals)
+{
+ public static SyncRights Of(long permissions) => new(
+ (permissions & (long)Permissions.Upload) != 0 && (permissions & (long)Permissions.Edit) != 0,
+ (permissions & (long)(Permissions.Edit | Permissions.RenderNode)) != 0);
+}
+
+/// The words, glyphs and actions of the sync table (BRIEF §12.7): plain functions of a .
+public static class SyncText
+{
+ /// "originals · proxies", "proxies" (cached server proxies) or "—".
+ public static string Local(SyncEntry entry)
+ {
+ if (entry.HasLocalOriginals)
+ return (entry.Local!.Status & SequenceStatus.ProxiesBuilt) != 0 ? Join(Loc.L("Server.Sync.Originals"), Loc.L("Server.Sync.Proxies")) : Loc.L("Server.Sync.Originals");
+ return entry.Link is { ProxiesCached: > 0 } ? Loc.L("Server.Sync.Proxies") : Loc.L("Server.Sync.None");
+ }
+
+ /// "originals · proxies · 3 exports", "46 % received" while uploading, or "—".
+ public static string Server(SyncEntry entry)
+ {
+ if (entry.Transfer is { Kind: JobKind.UploadCommit, State: JobState.Running, ProgressTotal: > 0 } upload)
+ return Loc.L("Server.Sync.Received", Formatting.Percent((double)upload.ProgressDone / upload.ProgressTotal));
+ if (entry.Link is not { } link) return Loc.L("Server.Sync.None");
+ var parts = new List(3) { Loc.L("Server.Sync.Originals") };
+ if (link.ServerHasProxies) parts.Add(Loc.L("Server.Sync.Proxies"));
+ if (link.RenderCount > 0) parts.Add(Loc.Plural("Server.Sync.Exports", link.RenderCount));
+ return Join([.. parts]);
+ }
+
+ /// The State column: glyph kind, word and tooltip (never colour alone).
+ public static (StatusKind Kind, string Text, string ToolTip) State(SyncEntry entry)
+ {
+ if (entry.Transfer is { } job)
+ {
+ var upload = job.Kind == JobKind.UploadCommit;
+ return job.State switch
+ {
+ JobState.Paused => (StatusKind.Paused, Loc.L("Server.Sync.State.Paused"), Loc.L("Tooltips.Server.Sync.State.Paused")),
+ JobState.Queued => (StatusKind.Queued, Loc.L("Server.Sync.State.Waiting"), Loc.L("Tooltips.Server.Sync.State.Waiting")),
+ _ => (StatusKind.Running, Loc.L(upload ? "Server.Sync.State.Uploading" : "Server.Sync.State.Downloading"),
+ Loc.L(upload ? "Tooltips.Server.Sync.State.Uploading" : "Tooltips.Server.Sync.State.Downloading")),
+ };
+ }
+ return entry.Status switch
+ {
+ SyncStatus.InSync => (StatusKind.Done, Loc.L("Server.Sync.State.InSync"), Loc.L("Tooltips.Server.Sync.State.InSync")),
+ SyncStatus.LocalOnly => (StatusKind.Offline, Loc.L("Server.Sync.State.LocalOnly"), Loc.L("Tooltips.Server.Sync.State.LocalOnly")),
+ SyncStatus.RemoteOnly => (StatusKind.Remote, Loc.L("Server.Sync.State.RemoteOnly"), Loc.L("Tooltips.Server.Sync.State.RemoteOnly")),
+ SyncStatus.ProxiesOnly => (StatusKind.Remote, Loc.L("Server.Sync.State.ProxiesOnly"), Loc.L("Tooltips.Server.Sync.State.ProxiesOnly")),
+ SyncStatus.LocalAhead => (StatusKind.Synced, Loc.L("Server.Sync.State.LocalAhead"), Loc.L("Tooltips.Server.Sync.State.LocalAhead")),
+ SyncStatus.ServerAhead => (StatusKind.Remote, Loc.L("Server.Sync.State.ServerAhead"), Loc.L("Tooltips.Server.Sync.State.ServerAhead")),
+ _ => (StatusKind.Warning, Loc.L("Server.Sync.State.Conflict"), Conflict(entry)),
+ };
+ }
+
+ /// "exposure.deflickerWindow.manual: 41 here, 33 on the server" for each setting that differs (at most three).
+ public static string Conflict(SyncEntry entry)
+ {
+ var differences = entry.Link?.ConflictSettingsJson is { } theirs ? SyncRules.Differences(entry.Local?.SettingsJson, theirs) : [];
+ if (differences.Count == 0) return Loc.L("Tooltips.Server.Sync.State.Conflict");
+ return string.Join("\n", differences.Select(d => Loc.L("Server.Conflict.Difference", d.Path, d.Mine ?? Loc.L("Server.Sync.None"), d.Theirs ?? Loc.L("Server.Sync.None"))));
+ }
+
+ /// The row's buttons, in the order the mockup shows them.
+ public static IReadOnlyList Actions(SyncEntry entry, SyncRights rights)
+ {
+ if (entry.Transfer is { } job) return job.State == JobState.Paused ? [SyncAction.Resume] : [SyncAction.Pause];
+ var actions = new List(3);
+ switch (entry.Status)
+ {
+ case SyncStatus.LocalOnly when rights.CanUpload:
+ actions.Add(SyncAction.Upload);
+ break;
+ case SyncStatus.RemoteOnly or SyncStatus.ProxiesOnly:
+ actions.Add(SyncAction.OpenWithProxies);
+ if (rights.CanFetchOriginals) actions.Add(SyncAction.DownloadOriginals);
+ break;
+ case SyncStatus.LocalAhead when entry.Link is { MissingRemote: > 0 }:
+ if (rights.CanUpload) actions.Add(SyncAction.Upload);
+ break;
+ case SyncStatus.ServerAhead when entry.Link is { MissingLocal: > 0 }:
+ if (rights.CanFetchOriginals) actions.Add(SyncAction.DownloadOriginals);
+ break;
+ case SyncStatus.LocalAhead or SyncStatus.ServerAhead:
+ actions.Add(SyncAction.SyncSettings);
+ break;
+ case SyncStatus.Conflict:
+ actions.AddRange([SyncAction.KeepMine, SyncAction.TakeServer, SyncAction.SaveBoth]);
+ break;
+ }
+ return actions;
+ }
+
+ /// The bytes an upload or download of the row moves (for the tooltips).
+ public static long Size(SyncEntry entry, SyncAction action) => action switch
+ {
+ SyncAction.Upload => entry.Local?.TotalBytes ?? 0,
+ SyncAction.DownloadOriginals => entry.Link?.TotalBytes ?? 0,
+ _ => 0,
+ };
+
+ public static bool Matches(SyncEntry entry, SyncFilter filter, string search) =>
+ (filter switch
+ {
+ SyncFilter.LocalOnly => entry.Status == SyncStatus.LocalOnly,
+ SyncFilter.Remote => entry.Status is SyncStatus.RemoteOnly or SyncStatus.ProxiesOnly,
+ SyncFilter.Conflicts => entry.Status == SyncStatus.Conflict,
+ _ => true,
+ }) && (search.Length == 0 || entry.Title.Contains(search, StringComparison.CurrentCultureIgnoreCase));
+
+ private static string Join(params string[] parts) => string.Join(" · ", parts);
+}