mirror of
https://github.com/vleeuwenmenno/supplements.git
synced 2025-09-11 18:29:12 +02:00
feat adds proper syncing feature
Signed-off-by: Menno van Leeuwen <menno@vleeuwen.me>
This commit is contained in:
@@ -1,928 +0,0 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:connectivity_plus/connectivity_plus.dart';
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
|
||||
import 'package:webdav_client/webdav_client.dart';
|
||||
|
||||
import '../models/supplement.dart';
|
||||
import '../models/supplement_intake.dart';
|
||||
import '../models/sync_data.dart';
|
||||
import '../models/sync_enums.dart';
|
||||
import 'database_helper.dart';
|
||||
|
||||
/// Service for handling WebDAV synchronization operations
|
||||
class WebDAVSyncService {
|
||||
static const String _baseUrlKey = 'webdav_base_url';
|
||||
static const String _usernameKey = 'webdav_username';
|
||||
static const String _passwordKey = 'webdav_password';
|
||||
static const String _deviceNameKey = 'webdav_device_name';
|
||||
static const String _deviceIdKey = 'webdav_device_id';
|
||||
static const String _lastSyncTimeKey = 'webdav_last_sync_time';
|
||||
static const String _lastWorkingUrlKey = 'webdav_last_working_url';
|
||||
static const String _syncFolderNameKey = 'webdav_sync_folder_name';
|
||||
|
||||
final FlutterSecureStorage _secureStorage = const FlutterSecureStorage(
|
||||
aOptions: AndroidOptions(
|
||||
encryptedSharedPreferences: true,
|
||||
),
|
||||
iOptions: IOSOptions(
|
||||
accessibility: KeychainAccessibility.first_unlock_this_device,
|
||||
),
|
||||
);
|
||||
|
||||
final DatabaseHelper _databaseHelper = DatabaseHelper.instance;
|
||||
final Connectivity _connectivity = Connectivity();
|
||||
|
||||
Client? _webdavClient;
|
||||
String? _currentDeviceId;
|
||||
String? _currentDeviceName;
|
||||
String? _syncFolderName;
|
||||
|
||||
/// Initialize the service and generate device ID if needed
|
||||
Future<void> initialize() async {
|
||||
await _ensureDeviceInfo();
|
||||
_syncFolderName = await getSyncFolderName();
|
||||
}
|
||||
|
||||
/// Check if WebDAV is configured
|
||||
Future<bool> isConfigured() async {
|
||||
final baseUrl = await _secureStorage.read(key: _baseUrlKey);
|
||||
final username = await _secureStorage.read(key: _usernameKey);
|
||||
final password = await _secureStorage.read(key: _passwordKey);
|
||||
|
||||
return baseUrl != null &&
|
||||
baseUrl.isNotEmpty &&
|
||||
username != null &&
|
||||
username.isNotEmpty &&
|
||||
password != null &&
|
||||
password.isNotEmpty;
|
||||
}
|
||||
|
||||
/// Configure WebDAV connection
|
||||
Future<bool> configure({
|
||||
required String baseUrl,
|
||||
required String username,
|
||||
String? password,
|
||||
String? deviceName,
|
||||
String? syncFolderName,
|
||||
}) async {
|
||||
try {
|
||||
// For updates without password, get existing password
|
||||
String actualPassword = password ?? '';
|
||||
if (password == null) {
|
||||
actualPassword = await _secureStorage.read(key: _passwordKey) ?? '';
|
||||
if (actualPassword.isEmpty) {
|
||||
throw Exception('No existing password found and no new password provided');
|
||||
}
|
||||
}
|
||||
|
||||
// Validate and normalize base URL
|
||||
final normalizedUrl = _normalizeUrl(baseUrl);
|
||||
|
||||
// Build the full WebDAV URL with username for Nextcloud/ownCloud
|
||||
final fullWebdavUrl = _buildFullWebDAVUrl(normalizedUrl, username);
|
||||
|
||||
// Test connection with smart fallback
|
||||
final testResult = await _testConnectionWithFallback(
|
||||
fullWebdavUrl,
|
||||
username,
|
||||
actualPassword,
|
||||
baseUrl, // Original URL for fallback attempts
|
||||
);
|
||||
|
||||
if (!testResult.success) {
|
||||
throw Exception(testResult.errorMessage);
|
||||
}
|
||||
|
||||
final finalUrl = testResult.workingUrl!;
|
||||
|
||||
// Save configuration with the working URL
|
||||
await _secureStorage.write(key: _baseUrlKey, value: finalUrl);
|
||||
await _secureStorage.write(key: _lastWorkingUrlKey, value: finalUrl);
|
||||
await _secureStorage.write(key: _usernameKey, value: username);
|
||||
await _secureStorage.write(key: _passwordKey, value: actualPassword);
|
||||
|
||||
if (deviceName != null && deviceName.isNotEmpty) {
|
||||
await _secureStorage.write(key: _deviceNameKey, value: deviceName);
|
||||
_currentDeviceName = deviceName;
|
||||
}
|
||||
|
||||
// Store sync folder name
|
||||
final folderName = syncFolderName ?? 'Supplements';
|
||||
await _secureStorage.write(key: _syncFolderNameKey, value: folderName);
|
||||
_syncFolderName = folderName;
|
||||
|
||||
// Initialize client with the working URL
|
||||
_webdavClient = newClient(
|
||||
finalUrl,
|
||||
user: username,
|
||||
password: actualPassword,
|
||||
debug: kDebugMode,
|
||||
);
|
||||
|
||||
// Ensure sync directory exists
|
||||
await _ensureSyncDirectoryExists();
|
||||
|
||||
if (kDebugMode) {
|
||||
print('WebDAV configured successfully: $finalUrl');
|
||||
print('Original URL: $baseUrl -> Detected: $finalUrl');
|
||||
}
|
||||
|
||||
return true;
|
||||
} catch (e) {
|
||||
if (kDebugMode) {
|
||||
print('WebDAV configuration failed: $e');
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/// Remove WebDAV configuration
|
||||
Future<void> clearConfiguration() async {
|
||||
await _secureStorage.delete(key: _baseUrlKey);
|
||||
await _secureStorage.delete(key: _usernameKey);
|
||||
await _secureStorage.delete(key: _passwordKey);
|
||||
await _secureStorage.delete(key: _deviceNameKey);
|
||||
await _secureStorage.delete(key: _lastSyncTimeKey);
|
||||
await _secureStorage.delete(key: _lastWorkingUrlKey);
|
||||
await _secureStorage.delete(key: _syncFolderNameKey);
|
||||
_webdavClient = null;
|
||||
_syncFolderName = null;
|
||||
}
|
||||
|
||||
/// Test WebDAV connection
|
||||
Future<bool> testConnection() async {
|
||||
try {
|
||||
await _ensureClient();
|
||||
if (_webdavClient == null) return false;
|
||||
|
||||
await _webdavClient!.ping();
|
||||
return true;
|
||||
} catch (e) {
|
||||
if (kDebugMode) {
|
||||
print('WebDAV connection test failed: $e');
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/// Check if device has internet connectivity
|
||||
Future<bool> hasConnectivity() async {
|
||||
final connectivityResult = await _connectivity.checkConnectivity();
|
||||
return connectivityResult.any((result) =>
|
||||
result == ConnectivityResult.mobile ||
|
||||
result == ConnectivityResult.wifi ||
|
||||
result == ConnectivityResult.ethernet);
|
||||
}
|
||||
|
||||
/// Perform full sync operation
|
||||
Future<SyncResult> performSync() async {
|
||||
final syncStartTime = DateTime.now();
|
||||
|
||||
try {
|
||||
// Check connectivity
|
||||
if (!await hasConnectivity()) {
|
||||
return SyncResult.failure(
|
||||
error: 'No internet connection',
|
||||
status: SyncOperationStatus.networkError,
|
||||
);
|
||||
}
|
||||
|
||||
// Ensure client is initialized
|
||||
await _ensureClient();
|
||||
if (_webdavClient == null) {
|
||||
return SyncResult.failure(
|
||||
error: 'WebDAV client not configured',
|
||||
status: SyncOperationStatus.authenticationError,
|
||||
);
|
||||
}
|
||||
|
||||
// Download remote data
|
||||
final remoteSyncData = await _downloadSyncData();
|
||||
|
||||
// Get local data that needs syncing
|
||||
final localSyncData = await _getLocalSyncData();
|
||||
|
||||
// Merge data and detect conflicts
|
||||
final mergeResult = await _mergeData(localSyncData, remoteSyncData);
|
||||
|
||||
// Upload merged data back to server
|
||||
if (mergeResult.hasChanges) {
|
||||
await _uploadSyncData(mergeResult.mergedData);
|
||||
}
|
||||
|
||||
// Update local sync status
|
||||
await _updateLocalSyncStatus(mergeResult.mergedData);
|
||||
|
||||
// Update last sync time
|
||||
await _updateLastSyncTime();
|
||||
|
||||
final syncDuration = DateTime.now().difference(syncStartTime);
|
||||
|
||||
return SyncResult.success(
|
||||
conflicts: mergeResult.conflicts,
|
||||
statistics: SyncStatistics(
|
||||
supplementsUploaded: mergeResult.statistics.supplementsUploaded,
|
||||
supplementsDownloaded: mergeResult.statistics.supplementsDownloaded,
|
||||
intakesUploaded: mergeResult.statistics.intakesUploaded,
|
||||
intakesDownloaded: mergeResult.statistics.intakesDownloaded,
|
||||
conflictsResolved: mergeResult.statistics.conflictsResolved,
|
||||
syncDuration: syncDuration,
|
||||
),
|
||||
);
|
||||
|
||||
} catch (e) {
|
||||
if (kDebugMode) {
|
||||
print('Sync operation failed: $e');
|
||||
}
|
||||
|
||||
SyncOperationStatus status = SyncOperationStatus.serverError;
|
||||
if (e is SocketException || e.toString().contains('network')) {
|
||||
status = SyncOperationStatus.networkError;
|
||||
} else if (e.toString().contains('401') || e.toString().contains('403')) {
|
||||
status = SyncOperationStatus.authenticationError;
|
||||
}
|
||||
|
||||
return SyncResult.failure(
|
||||
error: e.toString(),
|
||||
status: status,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Get last sync time
|
||||
Future<DateTime?> getLastSyncTime() async {
|
||||
final lastSyncStr = await _secureStorage.read(key: _lastSyncTimeKey);
|
||||
if (lastSyncStr != null) {
|
||||
return DateTime.tryParse(lastSyncStr);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Get current device info
|
||||
Future<Map<String, String?>> getDeviceInfo() async {
|
||||
await _ensureDeviceInfo();
|
||||
return {
|
||||
'deviceId': _currentDeviceId,
|
||||
'deviceName': _currentDeviceName,
|
||||
};
|
||||
}
|
||||
|
||||
/// Get the last working WebDAV URL
|
||||
Future<String?> getLastWorkingUrl() async {
|
||||
return await _secureStorage.read(key: _lastWorkingUrlKey);
|
||||
}
|
||||
|
||||
/// Get stored server URL
|
||||
Future<String?> getServerUrl() async {
|
||||
return await _secureStorage.read(key: _baseUrlKey);
|
||||
}
|
||||
|
||||
/// Get stored username
|
||||
Future<String?> getUsername() async {
|
||||
return await _secureStorage.read(key: _usernameKey);
|
||||
}
|
||||
|
||||
/// Get stored sync folder name
|
||||
Future<String?> getSyncFolderName() async {
|
||||
final folderName = await _secureStorage.read(key: _syncFolderNameKey);
|
||||
return folderName ?? 'Supplements';
|
||||
}
|
||||
|
||||
// Private methods
|
||||
|
||||
Future<void> _ensureDeviceInfo() async {
|
||||
_currentDeviceId = await _secureStorage.read(key: _deviceIdKey);
|
||||
if (_currentDeviceId == null) {
|
||||
_currentDeviceId = _generateDeviceId();
|
||||
await _secureStorage.write(key: _deviceIdKey, value: _currentDeviceId!);
|
||||
}
|
||||
|
||||
_currentDeviceName = await _secureStorage.read(key: _deviceNameKey);
|
||||
if (_currentDeviceName == null) {
|
||||
_currentDeviceName = _getDefaultDeviceName();
|
||||
await _secureStorage.write(key: _deviceNameKey, value: _currentDeviceName!);
|
||||
}
|
||||
}
|
||||
|
||||
String _generateDeviceId() {
|
||||
final timestamp = DateTime.now().millisecondsSinceEpoch;
|
||||
final random = DateTime.now().microsecond;
|
||||
return 'device_${timestamp}_$random';
|
||||
}
|
||||
|
||||
String _getDefaultDeviceName() {
|
||||
if (Platform.isAndroid) return 'Android Device';
|
||||
if (Platform.isIOS) return 'iOS Device';
|
||||
if (Platform.isWindows) return 'Windows PC';
|
||||
if (Platform.isMacOS) return 'Mac';
|
||||
if (Platform.isLinux) return 'Linux PC';
|
||||
return 'Unknown Device';
|
||||
}
|
||||
|
||||
String _normalizeUrl(String url) {
|
||||
// Clean and trim the URL
|
||||
url = url.trim();
|
||||
if (url.endsWith('/')) {
|
||||
url = url.substring(0, url.length - 1);
|
||||
}
|
||||
|
||||
// Add protocol if missing - try HTTPS first, fallback to HTTP if needed
|
||||
if (!url.startsWith('http://') && !url.startsWith('https://')) {
|
||||
url = 'https://$url';
|
||||
}
|
||||
|
||||
return _detectAndBuildWebDAVUrl(url);
|
||||
}
|
||||
|
||||
/// Advanced server detection and WebDAV URL building
|
||||
String _detectAndBuildWebDAVUrl(String baseUrl) {
|
||||
final uri = Uri.tryParse(baseUrl);
|
||||
if (uri == null) return baseUrl;
|
||||
|
||||
final host = uri.host.toLowerCase();
|
||||
final path = uri.path.toLowerCase();
|
||||
|
||||
// If already contains WebDAV path, return as-is
|
||||
if (path.contains('/remote.php/dav') || path.contains('/remote.php/webdav')) {
|
||||
return baseUrl;
|
||||
}
|
||||
|
||||
// Nextcloud detection patterns
|
||||
if (_isNextcloudServer(host, path)) {
|
||||
return _buildNextcloudUrl(baseUrl, uri);
|
||||
}
|
||||
|
||||
// ownCloud detection patterns
|
||||
if (_isOwnCloudServer(host, path)) {
|
||||
return _buildOwnCloudUrl(baseUrl, uri);
|
||||
}
|
||||
|
||||
// Generic WebDAV detection
|
||||
if (_isGenericWebDAVServer(host, path)) {
|
||||
return _buildGenericWebDAVUrl(baseUrl, uri);
|
||||
}
|
||||
|
||||
// Default: assume it's a base URL and try Nextcloud first (most common)
|
||||
return _buildNextcloudUrl(baseUrl, uri);
|
||||
}
|
||||
|
||||
/// Detect if server is likely Nextcloud
|
||||
bool _isNextcloudServer(String host, String path) {
|
||||
// Common Nextcloud hosting patterns
|
||||
final nextcloudPatterns = [
|
||||
'nextcloud',
|
||||
'cloud',
|
||||
'nc.',
|
||||
'.cloud.',
|
||||
'files.',
|
||||
'drive.',
|
||||
];
|
||||
|
||||
// Check hostname patterns
|
||||
for (final pattern in nextcloudPatterns) {
|
||||
if (host.contains(pattern)) return true;
|
||||
}
|
||||
|
||||
// Check path patterns
|
||||
if (path.contains('nextcloud') || path.contains('index.php/apps/files')) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/// Detect if server is likely ownCloud
|
||||
bool _isOwnCloudServer(String host, String path) {
|
||||
final owncloudPatterns = [
|
||||
'owncloud',
|
||||
'oc.',
|
||||
'.owncloud.',
|
||||
];
|
||||
|
||||
// Check hostname patterns
|
||||
for (final pattern in owncloudPatterns) {
|
||||
if (host.contains(pattern)) return true;
|
||||
}
|
||||
|
||||
// Check path patterns
|
||||
if (path.contains('owncloud') || path.contains('index.php/apps/files')) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/// Detect if server might be generic WebDAV
|
||||
bool _isGenericWebDAVServer(String host, String path) {
|
||||
final webdavPatterns = [
|
||||
'webdav',
|
||||
'dav',
|
||||
'caldav',
|
||||
'carddav',
|
||||
];
|
||||
|
||||
// Check hostname and path for WebDAV indicators
|
||||
for (final pattern in webdavPatterns) {
|
||||
if (host.contains(pattern) || path.contains(pattern)) return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/// Build Nextcloud WebDAV URL with username detection
|
||||
String _buildNextcloudUrl(String baseUrl, Uri uri) {
|
||||
String webdavUrl = '${uri.scheme}://${uri.host}';
|
||||
|
||||
if (uri.hasPort && uri.port != 80 && uri.port != 443) {
|
||||
webdavUrl += ':${uri.port}';
|
||||
}
|
||||
|
||||
// Handle subdirectory installations
|
||||
String basePath = uri.path;
|
||||
if (basePath.isNotEmpty && basePath != '/') {
|
||||
// Remove common Nextcloud paths that shouldn't be in base
|
||||
basePath = basePath.replaceAll(RegExp(r'/index\.php.*$'), '');
|
||||
basePath = basePath.replaceAll(RegExp(r'/apps/files.*$'), '');
|
||||
webdavUrl += basePath;
|
||||
}
|
||||
|
||||
// Add Nextcloud WebDAV path - we'll need username later
|
||||
webdavUrl += '/remote.php/dav/files/';
|
||||
|
||||
return webdavUrl;
|
||||
}
|
||||
|
||||
/// Build ownCloud WebDAV URL
|
||||
String _buildOwnCloudUrl(String baseUrl, Uri uri) {
|
||||
String webdavUrl = '${uri.scheme}://${uri.host}';
|
||||
|
||||
if (uri.hasPort && uri.port != 80 && uri.port != 443) {
|
||||
webdavUrl += ':${uri.port}';
|
||||
}
|
||||
|
||||
// Handle subdirectory installations
|
||||
String basePath = uri.path;
|
||||
if (basePath.isNotEmpty && basePath != '/') {
|
||||
basePath = basePath.replaceAll(RegExp(r'/index\.php.*$'), '');
|
||||
basePath = basePath.replaceAll(RegExp(r'/apps/files.*$'), '');
|
||||
webdavUrl += basePath;
|
||||
}
|
||||
|
||||
webdavUrl += '/remote.php/webdav/';
|
||||
|
||||
return webdavUrl;
|
||||
}
|
||||
|
||||
/// Build generic WebDAV URL
|
||||
String _buildGenericWebDAVUrl(String baseUrl, Uri uri) {
|
||||
// For generic WebDAV, we assume the URL provided is correct
|
||||
// but we might need to add common WebDAV paths if missing
|
||||
if (!uri.path.endsWith('/')) {
|
||||
return '$baseUrl/';
|
||||
}
|
||||
return baseUrl;
|
||||
}
|
||||
|
||||
Future<void> _ensureClient() async {
|
||||
if (_webdavClient == null) {
|
||||
final baseUrl = await _secureStorage.read(key: _baseUrlKey);
|
||||
final username = await _secureStorage.read(key: _usernameKey);
|
||||
final password = await _secureStorage.read(key: _passwordKey);
|
||||
|
||||
if (baseUrl != null && username != null && password != null) {
|
||||
_webdavClient = newClient(
|
||||
baseUrl,
|
||||
user: username,
|
||||
password: password,
|
||||
debug: kDebugMode,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _ensureSyncDirectoryExists() async {
|
||||
if (_webdavClient == null) return;
|
||||
|
||||
// Get the configured folder name, default to 'Supplements'
|
||||
final folderName = _syncFolderName ?? await getSyncFolderName() ?? 'Supplements';
|
||||
|
||||
try {
|
||||
await _webdavClient!.mkdir(folderName);
|
||||
} catch (e) {
|
||||
// Directory might already exist, ignore error
|
||||
if (kDebugMode && !e.toString().contains('409')) {
|
||||
print('Failed to create sync directory ($folderName): $e');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Future<SyncData?> _downloadSyncData() async {
|
||||
if (_webdavClient == null) return null;
|
||||
|
||||
try {
|
||||
final folderName = _syncFolderName ?? await getSyncFolderName() ?? 'Supplements';
|
||||
final syncFilePath = '$folderName/${SyncConstants.syncFileName}';
|
||||
final fileData = await _webdavClient!.read(syncFilePath);
|
||||
final jsonString = utf8.decode(fileData);
|
||||
return SyncData.fromJsonString(jsonString);
|
||||
} catch (e) {
|
||||
if (kDebugMode) {
|
||||
print('Failed to download sync data: $e');
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
Future<SyncData> _getLocalSyncData() async {
|
||||
await _ensureDeviceInfo();
|
||||
|
||||
final supplements = await _databaseHelper.getAllSupplements();
|
||||
final archivedSupplements = await _databaseHelper.getArchivedSupplements();
|
||||
final allSupplements = [...supplements, ...archivedSupplements];
|
||||
|
||||
// Get all intakes (we'll need to implement a method to get all intakes)
|
||||
final intakes = await _getAllIntakes();
|
||||
|
||||
return SyncData(
|
||||
version: SyncConstants.currentSyncVersion,
|
||||
deviceId: _currentDeviceId!,
|
||||
deviceName: _currentDeviceName!,
|
||||
syncTimestamp: DateTime.now(),
|
||||
supplements: allSupplements,
|
||||
intakes: intakes,
|
||||
metadata: {
|
||||
'totalSupplements': allSupplements.length,
|
||||
'totalIntakes': intakes.length,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
Future<List<SupplementIntake>> _getAllIntakes() async {
|
||||
// This is a simplified version - in practice, you might want to limit
|
||||
// to a certain date range or implement pagination for large datasets
|
||||
final now = DateTime.now();
|
||||
final oneYearAgo = now.subtract(const Duration(days: 365));
|
||||
|
||||
List<SupplementIntake> allIntakes = [];
|
||||
DateTime current = oneYearAgo;
|
||||
|
||||
while (current.isBefore(now)) {
|
||||
final monthIntakes = await _databaseHelper.getIntakesForMonth(
|
||||
current.year,
|
||||
current.month,
|
||||
);
|
||||
allIntakes.addAll(monthIntakes);
|
||||
current = DateTime(current.year, current.month + 1);
|
||||
}
|
||||
|
||||
return allIntakes;
|
||||
}
|
||||
|
||||
Future<_MergeResult> _mergeData(SyncData local, SyncData? remote) async {
|
||||
if (remote == null) {
|
||||
// No remote data, just mark local data as pending sync
|
||||
return _MergeResult(
|
||||
mergedData: local,
|
||||
conflicts: [],
|
||||
hasChanges: true,
|
||||
statistics: SyncStatistics(
|
||||
supplementsUploaded: local.supplements.length,
|
||||
intakesUploaded: local.intakes.length,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
final conflicts = <SyncConflict>[];
|
||||
final mergedSupplements = <String, Supplement>{};
|
||||
final mergedIntakes = <String, SupplementIntake>{};
|
||||
|
||||
// Merge supplements
|
||||
for (final localSupplement in local.supplements) {
|
||||
mergedSupplements[localSupplement.syncId] = localSupplement;
|
||||
}
|
||||
|
||||
int supplementsDownloaded = 0;
|
||||
int supplementsUploaded = local.supplements.length;
|
||||
|
||||
for (final remoteSupplement in remote.supplements) {
|
||||
final localSupplement = mergedSupplements[remoteSupplement.syncId];
|
||||
|
||||
if (localSupplement == null) {
|
||||
// New remote supplement
|
||||
mergedSupplements[remoteSupplement.syncId] = remoteSupplement;
|
||||
supplementsDownloaded++;
|
||||
} else {
|
||||
// Check for conflicts
|
||||
if (localSupplement.lastModified.isAfter(remoteSupplement.lastModified)) {
|
||||
// Local is newer, keep local
|
||||
continue;
|
||||
} else if (remoteSupplement.lastModified.isAfter(localSupplement.lastModified)) {
|
||||
// Remote is newer, use remote
|
||||
mergedSupplements[remoteSupplement.syncId] = remoteSupplement;
|
||||
supplementsDownloaded++;
|
||||
} else {
|
||||
// Same timestamp - potential conflict if data differs
|
||||
if (!_supplementsEqual(localSupplement, remoteSupplement)) {
|
||||
conflicts.add(SyncConflict(
|
||||
syncId: localSupplement.syncId,
|
||||
type: ConflictType.modification,
|
||||
localTimestamp: localSupplement.lastModified,
|
||||
remoteTimestamp: remoteSupplement.lastModified,
|
||||
localData: localSupplement.toMap(),
|
||||
remoteData: remoteSupplement.toMap(),
|
||||
suggestedResolution: ConflictResolutionStrategy.preferNewer,
|
||||
));
|
||||
|
||||
// For now, keep local version
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Merge intakes (intakes are usually append-only, so fewer conflicts)
|
||||
for (final localIntake in local.intakes) {
|
||||
mergedIntakes[localIntake.syncId] = localIntake;
|
||||
}
|
||||
|
||||
int intakesDownloaded = 0;
|
||||
int intakesUploaded = local.intakes.length;
|
||||
|
||||
for (final remoteIntake in remote.intakes) {
|
||||
if (!mergedIntakes.containsKey(remoteIntake.syncId)) {
|
||||
mergedIntakes[remoteIntake.syncId] = remoteIntake;
|
||||
intakesDownloaded++;
|
||||
}
|
||||
}
|
||||
|
||||
final mergedData = SyncData(
|
||||
version: SyncConstants.currentSyncVersion,
|
||||
deviceId: local.deviceId,
|
||||
deviceName: local.deviceName,
|
||||
syncTimestamp: DateTime.now(),
|
||||
supplements: mergedSupplements.values.toList(),
|
||||
intakes: mergedIntakes.values.toList(),
|
||||
metadata: {
|
||||
'mergedAt': DateTime.now().toIso8601String(),
|
||||
'sourceDevices': [local.deviceId, remote.deviceId],
|
||||
'conflicts': conflicts.length,
|
||||
},
|
||||
);
|
||||
|
||||
return _MergeResult(
|
||||
mergedData: mergedData,
|
||||
conflicts: conflicts,
|
||||
hasChanges: supplementsDownloaded > 0 || intakesDownloaded > 0 || conflicts.isNotEmpty,
|
||||
statistics: SyncStatistics(
|
||||
supplementsUploaded: supplementsUploaded,
|
||||
supplementsDownloaded: supplementsDownloaded,
|
||||
intakesUploaded: intakesUploaded,
|
||||
intakesDownloaded: intakesDownloaded,
|
||||
conflictsResolved: 0, // Conflicts are not auto-resolved yet
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
bool _supplementsEqual(Supplement a, Supplement b) {
|
||||
return a.name == b.name &&
|
||||
a.brand == b.brand &&
|
||||
a.numberOfUnits == b.numberOfUnits &&
|
||||
a.unitType == b.unitType &&
|
||||
a.frequencyPerDay == b.frequencyPerDay &&
|
||||
a.reminderTimes.join(',') == b.reminderTimes.join(',') &&
|
||||
a.notes == b.notes &&
|
||||
a.isActive == b.isActive &&
|
||||
a.isDeleted == b.isDeleted &&
|
||||
_ingredientsEqual(a.ingredients, b.ingredients);
|
||||
}
|
||||
|
||||
bool _ingredientsEqual(List ingredients1, List ingredients2) {
|
||||
if (ingredients1.length != ingredients2.length) return false;
|
||||
|
||||
for (int i = 0; i < ingredients1.length; i++) {
|
||||
final ing1 = ingredients1[i];
|
||||
final ing2 = ingredients2[i];
|
||||
if (ing1.name != ing2.name ||
|
||||
ing1.amount != ing2.amount ||
|
||||
ing1.unit != ing2.unit) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
Future<void> _uploadSyncData(SyncData syncData) async {
|
||||
if (_webdavClient == null) return;
|
||||
|
||||
final folderName = _syncFolderName ?? await getSyncFolderName() ?? 'Supplements';
|
||||
final syncFilePath = '$folderName/${SyncConstants.syncFileName}';
|
||||
final jsonString = syncData.toJsonString();
|
||||
final jsonBytes = utf8.encode(jsonString);
|
||||
|
||||
// Create backup of existing file first
|
||||
try {
|
||||
final backupPath = '$folderName/${SyncConstants.syncFileBackupName}';
|
||||
final existingData = await _webdavClient!.read(syncFilePath);
|
||||
await _webdavClient!.write(backupPath, Uint8List.fromList(existingData));
|
||||
} catch (e) {
|
||||
// Backup failed, continue anyway
|
||||
if (kDebugMode) {
|
||||
print('Failed to create backup: $e');
|
||||
}
|
||||
}
|
||||
|
||||
// Upload new sync data
|
||||
await _webdavClient!.write(syncFilePath, jsonBytes);
|
||||
|
||||
if (kDebugMode) {
|
||||
print('Sync data uploaded successfully to $folderName');
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _updateLocalSyncStatus(SyncData mergedData) async {
|
||||
// Mark all synced items as synced in local database
|
||||
for (final supplement in mergedData.supplements) {
|
||||
if (supplement.syncStatus != SyncStatus.synced) {
|
||||
await _databaseHelper.markSupplementAsSynced(supplement.syncId);
|
||||
}
|
||||
}
|
||||
|
||||
for (final intake in mergedData.intakes) {
|
||||
if (intake.syncStatus != SyncStatus.synced) {
|
||||
await _databaseHelper.markIntakeAsSynced(intake.syncId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _updateLastSyncTime() async {
|
||||
await _secureStorage.write(
|
||||
key: _lastSyncTimeKey,
|
||||
value: DateTime.now().toIso8601String(),
|
||||
);
|
||||
}
|
||||
|
||||
/// Build full WebDAV URL including username for Nextcloud/ownCloud
|
||||
String _buildFullWebDAVUrl(String baseUrl, String username) {
|
||||
// If URL ends with /files/ (Nextcloud), add username
|
||||
if (baseUrl.endsWith('/remote.php/dav/files/')) {
|
||||
return '$baseUrl$username/';
|
||||
}
|
||||
|
||||
// If URL ends with /webdav/ (ownCloud), it's ready to use
|
||||
if (baseUrl.endsWith('/remote.php/webdav/')) {
|
||||
return baseUrl;
|
||||
}
|
||||
|
||||
// For other cases, return as-is
|
||||
return baseUrl;
|
||||
}
|
||||
|
||||
/// Test connection with smart fallback logic
|
||||
Future<_ConnectionTestResult> _testConnectionWithFallback(
|
||||
String primaryUrl,
|
||||
String username,
|
||||
String password,
|
||||
String originalUrl,
|
||||
) async {
|
||||
// Try the primary detected URL first
|
||||
try {
|
||||
final client = newClient(primaryUrl, user: username, password: password, debug: kDebugMode);
|
||||
await client.ping();
|
||||
return _ConnectionTestResult.success(primaryUrl);
|
||||
} catch (e) {
|
||||
if (kDebugMode) {
|
||||
print('Primary URL failed: $primaryUrl - $e');
|
||||
}
|
||||
}
|
||||
|
||||
// Generate fallback URLs to try
|
||||
final fallbackUrls = _generateFallbackUrls(originalUrl, username);
|
||||
|
||||
for (final fallbackUrl in fallbackUrls) {
|
||||
try {
|
||||
final client = newClient(fallbackUrl, user: username, password: password, debug: kDebugMode);
|
||||
await client.ping();
|
||||
|
||||
if (kDebugMode) {
|
||||
print('Fallback URL succeeded: $fallbackUrl');
|
||||
}
|
||||
|
||||
return _ConnectionTestResult.success(fallbackUrl);
|
||||
} catch (e) {
|
||||
if (kDebugMode) {
|
||||
print('Fallback URL failed: $fallbackUrl - $e');
|
||||
}
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
return _ConnectionTestResult.failure('Could not connect to WebDAV server. Please check your server URL, username, and password.');
|
||||
}
|
||||
|
||||
/// Generate fallback URLs to try if primary detection fails
|
||||
List<String> _generateFallbackUrls(String originalUrl, String username) {
|
||||
final fallbackUrls = <String>[];
|
||||
|
||||
final uri = Uri.tryParse(originalUrl.startsWith('http') ? originalUrl : 'https://$originalUrl');
|
||||
if (uri == null) return fallbackUrls;
|
||||
|
||||
String baseUrl = '${uri.scheme}://${uri.host}';
|
||||
if (uri.hasPort && uri.port != 80 && uri.port != 443) {
|
||||
baseUrl += ':${uri.port}';
|
||||
}
|
||||
|
||||
// Add path if exists (for subdirectory installations)
|
||||
String installPath = uri.path;
|
||||
if (installPath.isNotEmpty && installPath != '/') {
|
||||
// Clean common paths
|
||||
installPath = installPath.replaceAll(RegExp(r'/index\.php.*$'), '');
|
||||
installPath = installPath.replaceAll(RegExp(r'/apps/files.*$'), '');
|
||||
installPath = installPath.replaceAll(RegExp(r'/remote\.php.*$'), '');
|
||||
baseUrl += installPath;
|
||||
}
|
||||
|
||||
// Try different combinations
|
||||
fallbackUrls.addAll([
|
||||
// Nextcloud variants
|
||||
'$baseUrl/remote.php/dav/files/$username/',
|
||||
'$baseUrl/nextcloud/remote.php/dav/files/$username/',
|
||||
'$baseUrl/cloud/remote.php/dav/files/$username/',
|
||||
|
||||
// ownCloud variants
|
||||
'$baseUrl/remote.php/webdav/',
|
||||
'$baseUrl/owncloud/remote.php/webdav/',
|
||||
|
||||
// Generic WebDAV variants
|
||||
'$baseUrl/webdav/',
|
||||
'$baseUrl/dav/',
|
||||
|
||||
// Try with different protocols if HTTPS failed
|
||||
..._generateProtocolVariants(baseUrl, username),
|
||||
]);
|
||||
|
||||
// Remove duplicates and return
|
||||
return fallbackUrls.toSet().toList();
|
||||
}
|
||||
|
||||
/// Generate protocol variants (HTTP/HTTPS)
|
||||
List<String> _generateProtocolVariants(String baseUrl, String username) {
|
||||
if (baseUrl.startsWith('https://')) {
|
||||
// Try HTTP variants
|
||||
final httpBase = baseUrl.replaceFirst('https://', 'http://');
|
||||
return [
|
||||
'$httpBase/remote.php/dav/files/$username/',
|
||||
'$httpBase/remote.php/webdav/',
|
||||
'$httpBase/webdav/',
|
||||
];
|
||||
} else if (baseUrl.startsWith('http://')) {
|
||||
// Try HTTPS variants
|
||||
final httpsBase = baseUrl.replaceFirst('http://', 'https://');
|
||||
return [
|
||||
'$httpsBase/remote.php/dav/files/$username/',
|
||||
'$httpsBase/remote.php/webdav/',
|
||||
'$httpsBase/webdav/',
|
||||
];
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/// Internal class for merge operation results
|
||||
class _MergeResult {
|
||||
final SyncData mergedData;
|
||||
final List<SyncConflict> conflicts;
|
||||
final bool hasChanges;
|
||||
final SyncStatistics statistics;
|
||||
|
||||
const _MergeResult({
|
||||
required this.mergedData,
|
||||
required this.conflicts,
|
||||
required this.hasChanges,
|
||||
required this.statistics,
|
||||
});
|
||||
}
|
||||
|
||||
/// Internal class for connection test results
|
||||
class _ConnectionTestResult {
|
||||
final bool success;
|
||||
final String? workingUrl;
|
||||
final String? errorMessage;
|
||||
|
||||
const _ConnectionTestResult._({
|
||||
required this.success,
|
||||
this.workingUrl,
|
||||
this.errorMessage,
|
||||
});
|
||||
|
||||
factory _ConnectionTestResult.success(String url) {
|
||||
return _ConnectionTestResult._(success: true, workingUrl: url);
|
||||
}
|
||||
|
||||
factory _ConnectionTestResult.failure(String error) {
|
||||
return _ConnectionTestResult._(success: false, errorMessage: error);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user