feat: add remote pull and push

2026-09-23 00:19:58 +02:00
parent 9aaba69e3c
commit ccf5165417
29 changed files with 3042 additions and 24 deletions
@@ -0,0 +1,196 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:flutter/foundation.dart';
+import 'package:http/http.dart' as http;
+
+import '../database/app_database.dart';
+import '../models/remote_command.dart';
+import '../services/remote_sync_service.dart';
+import '../utils/app_config.dart';
+
+class RemoteSyncViewModel extends ChangeNotifier {
+  final RemoteSyncService syncService;
+
+  RemoteSyncViewModel({required this.syncService}) {
+    _eventSubscription = syncService.events.listen(_onEvent);
+  }
+
+  StreamSubscription<RemoteSyncEvent>? _eventSubscription;
+
+  List<RemoteSyncEvent> _recentEvents = [];
+
+  List<RemoteSyncEvent> get recentEvents => _recentEvents;
+
+  bool _isSyncing = false;
+  bool get isSyncing => _isSyncing;
+
+  bool _isConfigured = false;
+  bool get isConfigured => _isConfigured;
+
+  DateTime? _lastSyncAt;
+  DateTime? get lastSyncAt => _lastSyncAt;
+
+  String? _lastError;
+  String? get lastError => _lastError;
+
+  String? _venueId;
+  String? get venueId => _venueId;
+
+  List<ProcessedRemoteCommandRow> _activity = [];
+  List<ProcessedRemoteCommandRow> get activity => _activity;
+
+  bool _isRegistering = false;
+  bool get isRegistering => _isRegistering;
+
+  String? _registrationError;
+  String? get registrationError => _registrationError;
+
+  Future<void> init() async {
+    _isConfigured = await syncService.isConfigured;
+    _venueId = await syncService.venueId;
+    _lastSyncAt = await syncService.lastSuccessfulSyncAt;
+    await loadActivity();
+    if (_isConfigured) {
+      syncService.startPeriodicSync();
+    }
+    notifyListeners();
+  }
+
+  Future<void> refreshStatus() async {
+    _isConfigured = await syncService.isConfigured;
+    _venueId = await syncService.venueId;
+    notifyListeners();
+  }
+
+  Future<void> syncNow() async {
+    _isSyncing = true;
+    _lastError = null;
+    notifyListeners();
+
+    await syncService.sync();
+
+    _isSyncing = syncService.isSyncing;
+    _lastSyncAt = await syncService.lastSuccessfulSyncAt;
+    await loadActivity();
+    notifyListeners();
+  }
+
+  Future<void> loadActivity() async {
+    try {
+      _activity = await syncService.getRecentActivity();
+    } catch (e) {
+      debugPrint('RemoteSyncViewModel: loadActivity error: $e');
+    }
+  }
+
+  Future<bool> registerDevice({
+    required String venueId,
+    required String deviceName,
+    required String registrationCode,
+  }) async {
+    _isRegistering = true;
+    _registrationError = null;
+    notifyListeners();
+
+    try {
+      final response = await http.post(
+        Uri.parse('$kRemoteServerUrl/devices/register'),
+        headers: {'Content-Type': 'application/json'},
+        body: jsonEncode({
+          'venueId': venueId,
+          'name': deviceName,
+          'registrationCode': registrationCode,
+        }),
+      ).timeout(const Duration(seconds: 15));
+
+      if (response.statusCode == 201) {
+        final data = jsonDecode(response.body) as Map<String, dynamic>;
+        final deviceId = data['deviceId'] as String;
+        final token = data['token'] as String;
+
+        await syncService.setCredentials(
+          deviceId: deviceId,
+          token: token,
+          venueId: venueId,
+          serverUrl: kRemoteServerUrl,
+        );
+
+        _isConfigured = true;
+        _venueId = venueId;
+        _isRegistering = false;
+        notifyListeners();
+
+        syncService.startPeriodicSync();
+        await syncNow();
+
+        return true;
+      } else {
+        final body = response.body;
+        String message;
+        try {
+          final errorData = jsonDecode(body) as Map<String, dynamic>;
+          message = errorData['message'] as String? ?? 'Registration failed';
+        } catch (_) {
+          message = 'Registration failed (HTTP ${response.statusCode})';
+        }
+        _registrationError = message;
+        _isRegistering = false;
+        notifyListeners();
+        return false;
+      }
+    } catch (e) {
+      debugPrint('RemoteSyncViewModel: registration error: $e');
+      _registrationError = e.toString();
+      _isRegistering = false;
+      notifyListeners();
+      return false;
+    }
+  }
+
+  Future<void> unlink() async {
+    syncService.stopPeriodicSync();
+    await syncService.clearCredentials();
+    _isConfigured = false;
+    _venueId = null;
+    _lastSyncAt = null;
+    _lastError = null;
+    _recentEvents = [];
+    _activity = [];
+    notifyListeners();
+  }
+
+  void startSync() {
+    syncService.startPeriodicSync();
+    syncNow();
+  }
+
+  void _onEvent(RemoteSyncEvent event) {
+    _recentEvents = [event, ..._recentEvents.take(49)];
+    _lastSyncAt = DateTime.now();
+
+    if (event.type == RemoteSyncEventType.syncFailed) {
+      _lastError = event.message;
+    } else if (event.type == RemoteSyncEventType.syncCompleted) {
+      _lastError = null;
+    }
+
+    notifyListeners();
+  }
+
+  void pause() {
+    syncService.pause();
+  }
+
+  void resume() {
+    syncService.resume();
+    syncNow();
+  }
+
+  @override
+  void dispose() {
+    _eventSubscription?.cancel();
+    syncService.dispose();
+    super.dispose();
+  }
+}