using CommunityToolkit.Mvvm.ComponentModel; using CommunityToolkit.Mvvm.Input; using LehrerApp.Desktop.Services; using LehrerApp.Sync; using LehrerApp.Sync.Models; namespace LehrerApp.Desktop.ViewModels; public partial class SyncStatusViewModel : ObservableObject { private readonly SyncEngine? _engine; private readonly NotificationService? _notifications; private bool _incompatibleNotificationShown; private SyncState _lastNotifiedState = SyncState.Idle; public const string IncompatibleVersionMessage = "Diese App-Version ist veraltet oder nicht mit dem Sync-Server kompatibel. " + "Bitte aktualisiere die LehrerApp. Die Synchronisierung wurde zum Schutz deiner Daten angehalten."; public const string OfflineMessage = "Synchronisierung nicht möglich - Änderungen werden lokal gespeichert und automatisch " + "nachgeholt, sobald die Verbindung zum Server wieder da ist."; [ObservableProperty] private string _statusText = "Kein Server konfiguriert"; [ObservableProperty] private string _lastSyncText = ""; [ObservableProperty] private bool _isSyncing; [ObservableProperty] private bool _isServerConfigured; [ObservableProperty] private bool _isIncompatibleVersion; [ObservableProperty] private bool _canAttemptSync; [ObservableProperty] private int _pendingCount; /// Feuert, wenn ein Sync tatsächlich Daten angewendet hat (siehe SyncEngine. /// DataChanged, TODO 10.1.11) - MainWindowViewModel nutzt das, um die gerade sichtbare Seite /// neu zu laden, da EventApplier absichtlich an jedem ViewModel vorbei direkt auf die LiteDB /// schreibt. public event Action? DataChanged; public SyncStatusViewModel(SyncEngine? engine, NotificationService? notifications = null) { _engine = engine; _notifications = notifications; IsServerConfigured = engine is not null; CanAttemptSync = IsServerConfigured; if (_engine is not null) { _engine.StatusChanged += OnStatus; _engine.DataChanged += () => DataChanged?.Invoke(); // SyncEngine feuert sein erstes StatusChanged bereits im eigenen Konstruktor // (UpdateStatus) - der läuft aber schon, während wir hier noch in GetService() // stecken, also VOR dem obigen Abonnieren. Ohne diesen Nachhol-Aufruf bliebe StatusText // nach jedem Neustart beim Default "Kein Server konfiguriert", bis der nächste // Auto-Sync oder Klick auf "Jetzt synchronisieren" den Text erstmals aktualisiert. OnStatus(_engine.Status); } } private void OnStatus(SyncStatus s) { IsSyncing = s.State == SyncState.Syncing; IsIncompatibleVersion = s.State == SyncState.IncompatibleVersion; CanAttemptSync = IsServerConfigured && !IsIncompatibleVersion; PendingCount = s.PendingEvents; StatusText = s.State switch { SyncState.Idle => PendingCount > 0 ? $"{PendingCount} ausstehend" : "Synchronisiert", SyncState.Syncing => "Synchronisiere…", SyncState.Offline => "Offline", SyncState.Error => $"Fehler: {s.ErrorMessage}", SyncState.IncompatibleVersion => "Update erforderlich", _ => "", }; LastSyncText = s.LastSyncAt.HasValue ? $"Zuletzt: {s.LastSyncAt:HH:mm}" : "Noch nie"; if (IsIncompatibleVersion && !_incompatibleNotificationShown) { _incompatibleNotificationShown = true; _notifications?.ShowError(IncompatibleVersionMessage); } // Offline/Error sonst nur als blasser Text in der Statuszeile sichtbar war - über Stunden // unbemerkt, bis ein Blick auf ein zweites Gerät fehlende Daten offenbarte. Einmalig pro // neuem Ausfall (nicht bei jedem automatischen Retry alle paar Minuten) aktiv als Toast // melden; _lastNotifiedState wird bei Rückkehr zu Idle zurückgesetzt, damit ein späterer, // neuer Ausfall wieder gemeldet wird. if (s.State is SyncState.Offline or SyncState.Error && _lastNotifiedState != s.State) { _lastNotifiedState = s.State; _notifications?.ShowError(s.State == SyncState.Offline ? OfflineMessage : $"Synchronisierung fehlgeschlagen: {s.ErrorMessage}"); } else if (s.State is SyncState.Idle) { // Nicht auch bei SyncState.Syncing zurücksetzen: Jeder Sync-Versuch (auch ein // automatischer Retry im selben Ausfall) durchläuft kurz Syncing, bevor er wieder in // Offline/Error landet - ein Reset hier würde bei jedem Retry erneut einen Toast // auslösen, statt nur einmal pro tatsächlich neuem Ausfall. _lastNotifiedState = SyncState.Idle; } } [RelayCommand(CanExecute = nameof(CanSync))] private async Task SyncNow() { if (_engine is not null) await _engine.SyncNowAsync(); } private bool CanSync() => _engine is not null && !IsSyncing; }