mirror of
https://github.com/vleeuwenmenno/supplements.git
synced 2025-09-11 18:29:12 +02:00
adds syncing
This commit is contained in:
417
lib/providers/sync_provider.dart
Normal file
417
lib/providers/sync_provider.dart
Normal file
@@ -0,0 +1,417 @@
|
||||
import 'package:flutter/foundation.dart';
|
||||
|
||||
import '../models/sync_data.dart';
|
||||
import '../models/sync_enums.dart';
|
||||
import '../services/webdav_sync_service.dart';
|
||||
import 'supplement_provider.dart';
|
||||
|
||||
/// Provider for managing sync operations with WebDAV servers
|
||||
class SyncProvider with ChangeNotifier {
|
||||
final WebDAVSyncService _syncService = WebDAVSyncService();
|
||||
final SupplementProvider _supplementProvider;
|
||||
|
||||
SyncOperationStatus _status = SyncOperationStatus.idle;
|
||||
SyncResult? _lastSyncResult;
|
||||
DateTime? _lastSyncTime;
|
||||
String? _currentError;
|
||||
bool _isAutoSyncEnabled = false;
|
||||
bool _autoSyncOnDataChanges = true;
|
||||
SyncFrequency _syncFrequency = SyncFrequency.hourly;
|
||||
ConflictResolutionStrategy _conflictStrategy = ConflictResolutionStrategy.manual;
|
||||
List<SyncConflict> _pendingConflicts = [];
|
||||
double _syncProgress = 0.0;
|
||||
|
||||
// WebDAV Configuration
|
||||
String? _serverUrl;
|
||||
String? _username;
|
||||
String? _detectedServerType;
|
||||
String? _finalWebdavUrl;
|
||||
String? _syncFolderName;
|
||||
bool _isConfigured = false;
|
||||
|
||||
SyncProvider(this._supplementProvider);
|
||||
|
||||
// Getters
|
||||
SyncOperationStatus get status => _status;
|
||||
SyncResult? get lastSyncResult => _lastSyncResult;
|
||||
DateTime? get lastSyncTime => _lastSyncTime;
|
||||
String? get currentError => _currentError;
|
||||
bool get isAutoSyncEnabled => _isAutoSyncEnabled;
|
||||
bool get autoSyncOnDataChanges => _autoSyncOnDataChanges;
|
||||
SyncFrequency get syncFrequency => _syncFrequency;
|
||||
ConflictResolutionStrategy get conflictStrategy => _conflictStrategy;
|
||||
List<SyncConflict> get pendingConflicts => List.unmodifiable(_pendingConflicts);
|
||||
double get syncProgress => _syncProgress;
|
||||
String? get serverUrl => _serverUrl;
|
||||
String? get username => _username;
|
||||
String? get detectedServerType => _detectedServerType;
|
||||
String? get finalWebdavUrl => _finalWebdavUrl;
|
||||
String? get syncFolderName => _syncFolderName;
|
||||
bool get isConfigured => _isConfigured;
|
||||
bool get isSyncing => _status == SyncOperationStatus.syncing;
|
||||
bool get hasError => _currentError != null;
|
||||
bool get hasPendingConflicts => _pendingConflicts.isNotEmpty;
|
||||
|
||||
/// Initialize the sync provider
|
||||
Future<void> initialize() async {
|
||||
await _syncService.initialize();
|
||||
_isConfigured = await _syncService.isConfigured();
|
||||
_lastSyncTime = await _syncService.getLastSyncTime();
|
||||
|
||||
if (_isConfigured) {
|
||||
// Load existing configuration
|
||||
_serverUrl = await _syncService.getServerUrl();
|
||||
_username = await _syncService.getUsername();
|
||||
_syncFolderName = await _syncService.getSyncFolderName();
|
||||
_finalWebdavUrl = await _syncService.getLastWorkingUrl();
|
||||
_detectedServerType = _detectServerTypeFromUrl(_finalWebdavUrl ?? _serverUrl ?? '');
|
||||
}
|
||||
|
||||
// Set up data change callback on supplement provider
|
||||
_supplementProvider.setOnDataChangedCallback(() {
|
||||
triggerAutoSyncOnDataChange();
|
||||
});
|
||||
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
/// Configure WebDAV connection
|
||||
Future<bool> configure({
|
||||
required String serverUrl,
|
||||
required String username,
|
||||
String? password,
|
||||
String? deviceName,
|
||||
String? syncFolderName,
|
||||
}) async {
|
||||
try {
|
||||
_setStatus(SyncOperationStatus.syncing);
|
||||
_clearError();
|
||||
|
||||
final success = await _syncService.configure(
|
||||
baseUrl: serverUrl,
|
||||
username: username,
|
||||
password: password,
|
||||
deviceName: deviceName,
|
||||
syncFolderName: syncFolderName ?? 'Supplements',
|
||||
);
|
||||
|
||||
if (success) {
|
||||
_serverUrl = serverUrl;
|
||||
_username = username;
|
||||
_syncFolderName = syncFolderName ?? 'Supplements';
|
||||
_isConfigured = true;
|
||||
|
||||
// Get server detection info
|
||||
_finalWebdavUrl = await _syncService.getLastWorkingUrl();
|
||||
_detectedServerType = _detectServerTypeFromUrl(_finalWebdavUrl ?? serverUrl);
|
||||
|
||||
_setStatus(SyncOperationStatus.success);
|
||||
} else {
|
||||
_setError('Failed to configure WebDAV connection', SyncOperationStatus.authenticationError);
|
||||
}
|
||||
|
||||
return success;
|
||||
} catch (e) {
|
||||
_setError(e.toString(), SyncOperationStatus.authenticationError);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/// Test WebDAV connection
|
||||
Future<bool> testConnection() async {
|
||||
if (!_isConfigured) return false;
|
||||
|
||||
try {
|
||||
_clearError();
|
||||
return await _syncService.testConnection();
|
||||
} catch (e) {
|
||||
_setError(e.toString(), SyncOperationStatus.networkError);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/// Clear WebDAV configuration
|
||||
Future<void> clearConfiguration() async {
|
||||
await _syncService.clearConfiguration();
|
||||
_serverUrl = null;
|
||||
_username = null;
|
||||
_detectedServerType = null;
|
||||
_finalWebdavUrl = null;
|
||||
_syncFolderName = null;
|
||||
_isConfigured = false;
|
||||
_setStatus(SyncOperationStatus.idle);
|
||||
_clearError();
|
||||
}
|
||||
|
||||
/// Perform manual sync
|
||||
Future<bool> performManualSync() async {
|
||||
if (!_isConfigured || _status == SyncOperationStatus.syncing) {
|
||||
return false;
|
||||
}
|
||||
|
||||
try {
|
||||
_setStatus(SyncOperationStatus.syncing);
|
||||
_clearError();
|
||||
_syncProgress = 0.0;
|
||||
|
||||
// Check connectivity first
|
||||
if (!await _syncService.hasConnectivity()) {
|
||||
_setError('No internet connection', SyncOperationStatus.networkError);
|
||||
return false;
|
||||
}
|
||||
|
||||
_syncProgress = 0.2;
|
||||
notifyListeners();
|
||||
|
||||
// Perform the sync
|
||||
final result = await _syncService.performSync();
|
||||
_lastSyncResult = result;
|
||||
_lastSyncTime = result.timestamp;
|
||||
|
||||
_syncProgress = 0.8;
|
||||
notifyListeners();
|
||||
|
||||
if (result.success) {
|
||||
if (result.conflicts.isNotEmpty) {
|
||||
_pendingConflicts = result.conflicts;
|
||||
_setStatus(SyncOperationStatus.conflictsDetected);
|
||||
} else {
|
||||
_setStatus(SyncOperationStatus.success);
|
||||
}
|
||||
|
||||
// Reload local data after successful sync
|
||||
await _supplementProvider.loadSupplements();
|
||||
await _supplementProvider.loadTodayIntakes();
|
||||
} else {
|
||||
_setError(result.error ?? 'Sync failed', result.status);
|
||||
}
|
||||
|
||||
_syncProgress = 1.0;
|
||||
notifyListeners();
|
||||
|
||||
return result.success;
|
||||
} catch (e) {
|
||||
_setError(e.toString(), SyncOperationStatus.serverError);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/// Resolve a conflict
|
||||
Future<void> resolveConflict(String syncId, ConflictResolution resolution) async {
|
||||
_pendingConflicts.removeWhere((conflict) => conflict.syncId == syncId);
|
||||
|
||||
// TODO: Implement actual conflict resolution logic
|
||||
// This would involve updating the local database with the chosen resolution
|
||||
|
||||
if (_pendingConflicts.isEmpty && _status == SyncOperationStatus.conflictsDetected) {
|
||||
_setStatus(SyncOperationStatus.success);
|
||||
}
|
||||
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
/// Resolve all conflicts using the configured strategy
|
||||
Future<void> resolveAllConflicts() async {
|
||||
if (_conflictStrategy == ConflictResolutionStrategy.manual) {
|
||||
return; // Manual conflicts need individual resolution
|
||||
}
|
||||
|
||||
final resolvedConflicts = <SyncConflict>[];
|
||||
|
||||
for (final conflict in _pendingConflicts) {
|
||||
ConflictResolution resolution;
|
||||
|
||||
switch (_conflictStrategy) {
|
||||
case ConflictResolutionStrategy.preferLocal:
|
||||
resolution = ConflictResolution.useLocal;
|
||||
break;
|
||||
case ConflictResolutionStrategy.preferRemote:
|
||||
resolution = ConflictResolution.useRemote;
|
||||
break;
|
||||
case ConflictResolutionStrategy.preferNewer:
|
||||
resolution = conflict.isLocalNewer
|
||||
? ConflictResolution.useLocal
|
||||
: ConflictResolution.useRemote;
|
||||
break;
|
||||
case ConflictResolutionStrategy.manual:
|
||||
continue; // Skip manual conflicts
|
||||
}
|
||||
|
||||
await resolveConflict(conflict.syncId, resolution);
|
||||
resolvedConflicts.add(conflict);
|
||||
}
|
||||
|
||||
if (resolvedConflicts.isNotEmpty) {
|
||||
// Perform another sync to apply resolutions
|
||||
await performManualSync();
|
||||
}
|
||||
}
|
||||
|
||||
/// Enable or disable auto sync
|
||||
Future<void> setAutoSyncEnabled(bool enabled) async {
|
||||
_isAutoSyncEnabled = enabled;
|
||||
notifyListeners();
|
||||
|
||||
if (enabled) {
|
||||
_scheduleNextAutoSync();
|
||||
}
|
||||
// TODO: Cancel existing timers when disabled
|
||||
}
|
||||
|
||||
/// Set sync frequency
|
||||
Future<void> setSyncFrequency(SyncFrequency frequency) async {
|
||||
_syncFrequency = frequency;
|
||||
notifyListeners();
|
||||
|
||||
if (_isAutoSyncEnabled) {
|
||||
_scheduleNextAutoSync();
|
||||
}
|
||||
}
|
||||
|
||||
/// Set conflict resolution strategy
|
||||
Future<void> setConflictResolutionStrategy(ConflictResolutionStrategy strategy) async {
|
||||
_conflictStrategy = strategy;
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
/// Enable or disable auto sync on data changes
|
||||
Future<void> setAutoSyncOnDataChanges(bool enabled) async {
|
||||
_autoSyncOnDataChanges = enabled;
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
/// Trigger sync automatically when data changes (if enabled)
|
||||
Future<void> triggerAutoSyncOnDataChange() async {
|
||||
if (!_autoSyncOnDataChanges || !_isConfigured || _status == SyncOperationStatus.syncing) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Perform sync without blocking the UI
|
||||
performManualSync();
|
||||
}
|
||||
|
||||
/// Get sync statistics from last result
|
||||
SyncStatistics? get lastSyncStatistics => _lastSyncResult?.statistics;
|
||||
|
||||
/// Get formatted last sync time
|
||||
String get formattedLastSyncTime {
|
||||
if (_lastSyncTime == null) return 'Never';
|
||||
|
||||
final now = DateTime.now();
|
||||
final difference = now.difference(_lastSyncTime!);
|
||||
|
||||
if (difference.inMinutes < 1) {
|
||||
return 'Just now';
|
||||
} else if (difference.inMinutes < 60) {
|
||||
return '${difference.inMinutes}m ago';
|
||||
} else if (difference.inHours < 24) {
|
||||
return '${difference.inHours}h ago';
|
||||
} else {
|
||||
return '${difference.inDays}d ago';
|
||||
}
|
||||
}
|
||||
|
||||
/// Get sync status message
|
||||
String get statusMessage {
|
||||
switch (_status) {
|
||||
case SyncOperationStatus.idle:
|
||||
return 'Ready to sync';
|
||||
case SyncOperationStatus.syncing:
|
||||
return 'Syncing... ${(_syncProgress * 100).round()}%';
|
||||
case SyncOperationStatus.success:
|
||||
return 'Sync completed successfully';
|
||||
case SyncOperationStatus.networkError:
|
||||
return 'Network connection failed';
|
||||
case SyncOperationStatus.authenticationError:
|
||||
return 'Authentication failed';
|
||||
case SyncOperationStatus.serverError:
|
||||
return 'Server error occurred';
|
||||
case SyncOperationStatus.conflictsDetected:
|
||||
return '${_pendingConflicts.length} conflict(s) need resolution';
|
||||
case SyncOperationStatus.cancelled:
|
||||
return 'Sync was cancelled';
|
||||
}
|
||||
}
|
||||
|
||||
/// Get device info
|
||||
Future<Map<String, String?>> getDeviceInfo() async {
|
||||
return await _syncService.getDeviceInfo();
|
||||
}
|
||||
|
||||
// Private methods
|
||||
|
||||
void _setStatus(SyncOperationStatus status) {
|
||||
_status = status;
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
void _setError(String error, SyncOperationStatus status) {
|
||||
_currentError = error;
|
||||
_status = status;
|
||||
_syncProgress = 0.0;
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
void _clearError() {
|
||||
_currentError = null;
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
void _scheduleNextAutoSync() {
|
||||
if (!_isAutoSyncEnabled || _syncFrequency == SyncFrequency.manual) {
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO: Implement actual scheduling logic using Timer or WorkManager
|
||||
// This would schedule the next automatic sync based on the frequency
|
||||
if (kDebugMode) {
|
||||
print('Next auto sync scheduled for ${_syncFrequency.displayName}');
|
||||
}
|
||||
}
|
||||
|
||||
/// Detect server type from URL for display purposes
|
||||
String _detectServerTypeFromUrl(String url) {
|
||||
final lowerUrl = url.toLowerCase();
|
||||
|
||||
if (lowerUrl.contains('/remote.php/dav/files/')) {
|
||||
return 'Nextcloud';
|
||||
} else if (lowerUrl.contains('/remote.php/webdav/')) {
|
||||
return 'ownCloud';
|
||||
} else if (lowerUrl.contains('nextcloud')) {
|
||||
return 'Nextcloud';
|
||||
} else if (lowerUrl.contains('owncloud')) {
|
||||
return 'ownCloud';
|
||||
} else if (lowerUrl.contains('/webdav/') || lowerUrl.contains('/dav/')) {
|
||||
return 'Generic WebDAV';
|
||||
} else {
|
||||
return 'WebDAV Server';
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
// TODO: Cancel any pending timers or background tasks
|
||||
super.dispose();
|
||||
}
|
||||
}
|
||||
|
||||
/// Enum for conflict resolution choices
|
||||
enum ConflictResolution {
|
||||
useLocal,
|
||||
useRemote,
|
||||
merge, // For future implementation
|
||||
}
|
||||
|
||||
/// Extension methods for ConflictResolution
|
||||
extension ConflictResolutionExtension on ConflictResolution {
|
||||
String get displayName {
|
||||
switch (this) {
|
||||
case ConflictResolution.useLocal:
|
||||
return 'Use Local Version';
|
||||
case ConflictResolution.useRemote:
|
||||
return 'Use Remote Version';
|
||||
case ConflictResolution.merge:
|
||||
return 'Merge Changes';
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user