- Conflicts are settled against the versions the user was shown; a later change on
either side refuses the choice and compares again. Title, tags, rating and notes
changed differently on both sides are a conflict too (no silent tag union).
- Links are written under the engine's gate and forgotten only after a 404; linked
local copies are read by id; unlinked copies with the same originals are linked
by content.
- A failure on one sequence is recorded on its link; the others are still compared.
- Downloads hash unverified local copies first and restore originals missing here.
- Background proxy downloads give way to the user's requests; "Keep proxies offline"
refreshes the caches of sequences opened with proxies, checks free space and backs
off after a failure.
- Renders travel on request: Send exports (chunked, hash-verified upload keeping the
render id; new POST /sequences/{id}/renders endpoints) and Get exports.
- Server screen: stable row buttons, mockup column grid, Tab through rows, conflict
rows first on the card colour, localised conflict detail, Save both confirmation,
Pause metered uploads, culture switch, Library one-word sync glyphs.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
253 lines
10 KiB
C#
253 lines
10 KiB
C#
using System.ComponentModel;
|
||
using System.Windows.Input;
|
||
using Titano.App.Infrastructure;
|
||
using Titano.App.Server;
|
||
using Titano.App.Shell;
|
||
using Titano.Core.Localization;
|
||
using Titano.Ui.Controls;
|
||
using Titano.Ui.Mvvm;
|
||
|
||
namespace Titano.App.Sections;
|
||
|
||
/// <summary>
|
||
/// 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, uploads paused on metered networks) and the sync table (<see cref="Sync"/>).
|
||
/// </summary>
|
||
public sealed class ServerViewModel : SectionViewModel
|
||
{
|
||
private string _address;
|
||
private string? _errorText;
|
||
private ServerSession? _session;
|
||
|
||
public ServerViewModel(ShellViewModel shell)
|
||
: base(SectionKey.Server, "Icon.Server")
|
||
{
|
||
Shell = shell;
|
||
_address = ServerAddress.Display(shell.Services.Settings.ServerUrl);
|
||
ConnectCommand = new AsyncRelayCommand(ConnectAsync, () => !IsBusy && !IsConnected && Address.Trim().Length > 0);
|
||
DisconnectCommand = new RelayCommand(() => Session.Disconnect(), () => IsConnected);
|
||
SignOutCommand = new AsyncRelayCommand(SignOutAsync, () => IsConnected);
|
||
UseServerCommand = new RelayCommand(p =>
|
||
{
|
||
if (p is DiscoveredServer s) Address = s.Address;
|
||
else if (p is string text) Address = text;
|
||
});
|
||
CertificateCommand = new RelayCommand(ShowCertificate, () => Fingerprint is not null);
|
||
Sync = new SyncTableViewModel(shell);
|
||
}
|
||
|
||
/// <summary>Sequences of this PC and of the server, where they stand and what can be done.</summary>
|
||
public SyncTableViewModel Sync { get; }
|
||
|
||
public ShellViewModel Shell { get; }
|
||
|
||
private ServerSession Session => _session ?? Shell.Services.Server;
|
||
|
||
public ICommand ConnectCommand { get; }
|
||
public ICommand DisconnectCommand { get; }
|
||
public ICommand SignOutCommand { get; }
|
||
public ICommand UseServerCommand { get; }
|
||
public ICommand CertificateCommand { get; }
|
||
|
||
/// <summary>Servers found on the LAN plus recently used ones, for the ▾ list.</summary>
|
||
public IEnumerable<DiscoveredServer> KnownServers =>
|
||
Session.Discovered.Concat(Shell.Services.Settings.RecentServers
|
||
.Where(r => !Session.Discovered.Any(d => d.Address.Equals(r, StringComparison.OrdinalIgnoreCase)))
|
||
.Select(r => new DiscoveredServer(r, r)));
|
||
|
||
public bool HasKnownServers => KnownServers.Any();
|
||
|
||
public string Address
|
||
{
|
||
get => _address;
|
||
set
|
||
{
|
||
if (Set(ref _address, value ?? string.Empty)) CommandManager.InvalidateRequerySuggested();
|
||
}
|
||
}
|
||
|
||
public bool IsBusy => Session.IsBusy;
|
||
public bool IsConnected => Session.IsConnected;
|
||
public bool IsDisconnected => !Session.IsConnected;
|
||
|
||
/// <summary>One sentence about the last failure; null when none.</summary>
|
||
public string? ErrorText
|
||
{
|
||
get => _errorText;
|
||
private set => Set(ref _errorText, value);
|
||
}
|
||
|
||
// ---- Status row ----
|
||
public StatusKind StatusKind => IsConnected ? StatusKind.Online : IsBusy ? StatusKind.Running : ErrorText is null ? StatusKind.Offline : StatusKind.Error;
|
||
|
||
public string StatusText => IsConnected ? Loc.L("Server.Status.Connected")
|
||
: IsBusy ? Loc.L("Server.Status.Connecting")
|
||
: Session.HasSavedSession ? Loc.L("Server.Status.Disconnected")
|
||
: Loc.L("Server.Status.NotConnected");
|
||
|
||
/// <summary>"Studio NAS · v1.3.0 · 14 ms".</summary>
|
||
public string? ServerText
|
||
{
|
||
get
|
||
{
|
||
if (!IsConnected || Session.Flow.Info is not { } info) return null;
|
||
var parts = new List<string> { info.Name, Loc.L("Server.Version", info.Version) };
|
||
if (Session.Flow.Latency is { } latency) parts.Add(Loc.L("Server.Latency", Math.Max(1, (int)Math.Round(latency.TotalMilliseconds))));
|
||
return string.Join(" · ", parts);
|
||
}
|
||
}
|
||
|
||
/// <summary>Fingerprint of the trusted self-signed certificate; null for a publicly valid certificate.</summary>
|
||
public string? Fingerprint => IsConnected ? Session.TrustOf(Session.Flow.Info?.TlsFingerprint)?.Fingerprint : null;
|
||
|
||
/// <summary>"TLS 9A:3C:71:E0:… trusted 2026-09-01".</summary>
|
||
public string? CertificateText => Fingerprint is { } fp && Session.TrustOf(fp) is { } trust
|
||
? Loc.L("Server.Certificate.Trusted", ServerSession.ShortFingerprint(fp), Formatting.Date(trust.TrustedAt))
|
||
: null;
|
||
|
||
public string CertificateToolTip => Loc.L("Tooltips.Server.CertificateTrusted");
|
||
|
||
// ---- Account row ----
|
||
public string? Username => Session.User?.Username;
|
||
public string Initial => Username is { Length: > 0 } u ? char.ToUpper(u[0], Loc.Culture).ToString() : string.Empty;
|
||
|
||
public string? RoleText => Session.User?.Role is { } role ? KnownRole(role) is { } known ? Loc.L("Server.Role." + known) : role : null;
|
||
|
||
public string? RoleToolTip => Session.User?.Role is { } role && KnownRole(role) is { } known ? Loc.L("Tooltips.Server.Role." + known) : null;
|
||
|
||
public bool HasQuota => Session.User is { QuotaBytes: > 0 };
|
||
|
||
public double QuotaFraction => Session.User is { QuotaBytes: > 0 } u ? Math.Clamp((double)u.UsedBytes / u.QuotaBytes, 0, 1) : 0;
|
||
|
||
/// <summary>"2.1 TB of 5 TB", or the used bytes when unlimited.</summary>
|
||
public string? QuotaText => Session.User is not { } u ? null
|
||
: u.QuotaBytes > 0 ? Loc.L("Server.Quota", Formatting.Bytes(u.UsedBytes), Formatting.Bytes(u.QuotaBytes))
|
||
: Loc.L("Server.QuotaUnlimited", Formatting.Bytes(u.UsedBytes));
|
||
|
||
// ---- Options ----
|
||
public bool RenderNodeOptIn
|
||
{
|
||
get => Shell.Services.Settings.RenderNodeOptIn;
|
||
set
|
||
{
|
||
if (Shell.Services.Settings.RenderNodeOptIn == value) return;
|
||
Shell.Services.Settings.RenderNodeOptIn = value;
|
||
Shell.Services.SaveSettings();
|
||
OnPropertyChanged();
|
||
}
|
||
}
|
||
|
||
/// <summary>Keep the proxy caches of server sequences opened with proxies up to date on this PC.</summary>
|
||
public bool KeepProxiesOffline
|
||
{
|
||
get => Shell.Services.Settings.KeepProxiesOffline;
|
||
set => SetSyncOption(value, Shell.Services.Settings.KeepProxiesOffline, v => Shell.Services.Settings.KeepProxiesOffline = v);
|
||
}
|
||
|
||
/// <summary>Send and take project settings changed on one side without asking.</summary>
|
||
public bool SyncSettingsAutomatically
|
||
{
|
||
get => Shell.Services.Settings.SyncSettingsAutomatically;
|
||
set => SetSyncOption(value, Shell.Services.Settings.SyncSettingsAutomatically, v => Shell.Services.Settings.SyncSettingsAutomatically = v);
|
||
}
|
||
|
||
/// <summary>Pause uploads while the connection is metered.</summary>
|
||
public bool PauseUploadsOnMetered
|
||
{
|
||
get => Shell.Services.Settings.PauseUploadsOnMetered;
|
||
set
|
||
{
|
||
if (Shell.Services.Settings.PauseUploadsOnMetered == value) return;
|
||
Shell.Services.Settings.PauseUploadsOnMetered = value;
|
||
Shell.Services.SaveSettings();
|
||
Shell.Services.Sync.Uploads.Request();
|
||
OnPropertyChanged();
|
||
}
|
||
}
|
||
|
||
/// <summary>Re-reads values another screen changed (Settings › Server).</summary>
|
||
public void Refresh() => OnPropertyChanged(nameof(RenderNodeOptIn));
|
||
|
||
/// <summary>Restores the saved session and starts listening for LAN servers.</summary>
|
||
public async Task AttachAsync()
|
||
{
|
||
_session = Shell.Services.Server;
|
||
_session.PropertyChanged += OnSessionChanged;
|
||
_session.Discovered.CollectionChanged += (_, _) =>
|
||
{
|
||
OnPropertyChanged(nameof(KnownServers));
|
||
OnPropertyChanged(nameof(HasKnownServers));
|
||
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);
|
||
}
|
||
|
||
public override void Dispose()
|
||
{
|
||
if (_session is not null) _session.PropertyChanged -= OnSessionChanged;
|
||
Sync.Dispose();
|
||
base.Dispose();
|
||
}
|
||
|
||
private void SetSyncOption(bool value, bool current, Action<bool> 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;
|
||
var connected = await Session.ConnectAsync(Address, Shell.Services.Dialogs);
|
||
if (connected)
|
||
{
|
||
Address = ServerAddress.Display(Session.SavedAddress);
|
||
return;
|
||
}
|
||
if (Session.Flow.Error is not ConnectError.None and var error) ErrorText = ServerSession.ErrorText(error);
|
||
}
|
||
|
||
private async Task SignOutAsync()
|
||
{
|
||
await Session.SignOutAsync();
|
||
ErrorText = null;
|
||
}
|
||
|
||
private void ShowCertificate()
|
||
{
|
||
if (Fingerprint is not { } fingerprint) return;
|
||
var forget = Shell.Services.Dialogs.Confirm(new ConfirmRequest
|
||
{
|
||
Heading = Loc.L("Server.Certificate.Title"),
|
||
Message = Loc.L("Server.Certificate.Message"),
|
||
Detail = ServerSession.FormatFingerprint(fingerprint),
|
||
DetailToolTip = Loc.L("Tooltips.Server.Fingerprint"),
|
||
SafeText = Loc.L("Server.Certificate.Keep"),
|
||
SafeToolTip = Loc.L("Tooltips.Server.KeepTrust"),
|
||
ActionText = Loc.L("Server.Certificate.Forget"),
|
||
ActionToolTip = Loc.L("Tooltips.Server.ForgetTrust"),
|
||
IsDestructive = true,
|
||
});
|
||
if (!forget) return;
|
||
Session.Disconnect();
|
||
Session.Forget(fingerprint);
|
||
}
|
||
|
||
private void OnSessionChanged(object? sender, PropertyChangedEventArgs e)
|
||
{
|
||
OnAllPropertiesChanged();
|
||
CommandManager.InvalidateRequerySuggested();
|
||
}
|
||
|
||
/// <summary>The <see cref="Core.Model.UserRole"/> name of a server role, or null for a role this build does not know.</summary>
|
||
private static string? KnownRole(string role) =>
|
||
Enum.TryParse<Core.Model.UserRole>(role, ignoreCase: true, out var parsed) ? parsed.ToString() : null;
|
||
}
|