/// Cross-device log sync orchestration for the diet_guard companion app. /// /// Pulls every other device's pushed log from GitHub-backed dumb storage /// ([GitHubClient]), merges with the local log ([mergeLogs]), rebuilds the /// food bank, and pushes this device's own merged log back up. A **new** /// implementation, not a port of `~/todo`'s CRDT-based sync (this app has no /// CRDT layer) -- a Dart twin of the same pull-merge-rebuild-push sequence /// as `diet_guard/_sync.py`, plus one phone-specific step: a pulled copy of /// an entry never carries `imagePath` (stripped before push, meaningless on /// another device), so it must not null out a local photo attachment for /// the same `id` (plan decision 10). library; import 'dart:convert'; import 'package:diet_guard_app/models/food_entry.dart'; import 'package:diet_guard_app/services/foodbank_service.dart'; import 'package:diet_guard_app/services/github_client.dart'; import 'package:diet_guard_app/services/log_storage_service.dart'; import 'package:diet_guard_app/services/sync_merge.dart'; const _devicesDir = 'devices'; /// This device's id in the `devices//food_log.json` layout. The PC /// pushes under `pc` (`SYNC_DEVICE_ID` in `diet_guard/_constants.py`); the /// phone is the only other device in this design. const phoneDeviceId = 'phone'; String _deviceLogPath(String deviceId) => '$_devicesDir/$deviceId/food_log.json'; /// Runs one full sync tick: pull, merge, preserve photos, persist, push. /// /// Returns the merged log as it now sits on disk locally. Propagates any /// [GitHubApiException] from the client for the caller (auto-sync / the /// manual "Sync now" action) to decide how to report. Future runSync(GitHubClient client) async { final logService = LogStorageService.instance; final local = await logService.readLog(); final localImagePaths = _imagePathsById(local); var merged = local; for (final deviceId in await client.listEntryNames(_devicesDir)) { if (deviceId == phoneDeviceId) continue; final text = await client.getFileText(_deviceLogPath(deviceId)); if (text == null) continue; final remoteLog = _decodeRemoteLog(text); if (remoteLog == null) continue; merged = mergeLogs(merged, remoteLog); } merged = _preserveLocalImagePaths(merged, localImagePaths); await logService.writeLog(merged); await FoodBankService.instance.rebuildAndPersist(merged); await client.putFileText( _deviceLogPath(phoneDeviceId), _encodeForPush(merged), sha: await _ownFileSha(client), message: 'diet_guard_app sync', ); return merged; } /// Returns this device's current `food_log.json` sha if it has pushed /// before, so [GitHubClient.putFileText] updates rather than creates. Future _ownFileSha(GitHubClient client) async { final files = await client.listDirectory('$_devicesDir/$phoneDeviceId'); for (final file in files) { if (file.name == 'food_log.json') return file.sha; } return null; } Map _imagePathsById(DayLog log) { final result = {}; for (final entries in log.values) { for (final entry in entries) { final id = entry.id; final imagePath = entry.imagePath; if (id != null && imagePath != null) result[id] = imagePath; } } return result; } DayLog _preserveLocalImagePaths( DayLog log, Map imagePathsById, ) { if (imagePathsById.isEmpty) return log; return { for (final mapEntry in log.entries) mapEntry.key: [ for (final entry in mapEntry.value) _withPreservedImagePath(entry, imagePathsById), ], }; } FoodEntry _withPreservedImagePath( FoodEntry entry, Map imagePathsById, ) { if (entry.imagePath != null) return entry; final preserved = imagePathsById[entry.id]; if (preserved == null) return entry; return entry.copyWithImagePath(preserved); } /// Parses a device's pushed log, mirroring `_sync._pull_remote_logs`'s /// tolerance for a corrupt/truncated push: an unparsable file is skipped /// (returns null) rather than aborting the whole sync tick. DayLog? _decodeRemoteLog(String text) { Object? decoded; try { decoded = jsonDecode(text); } on FormatException { return null; } if (decoded is! Map) return null; final result = >{}; for (final mapEntry in decoded.entries) { final key = mapEntry.key; final value = mapEntry.value; if (key is! String || value is! List) continue; result[key] = value .whereType>() .map((m) => FoodEntry.fromJson(m.cast())) .toList(); } return result; } /// Serializes the full merged log for push via [FoodEntry.toSyncJson], /// which excludes [FoodEntry.imagePath] (phone-local only) and `hmac` (the /// PC re-signs every persisted entry on its own next sync tick regardless). String _encodeForPush(DayLog log) { final encoded = { for (final mapEntry in log.entries) mapEntry.key: mapEntry.value.map((e) => e.toSyncJson()).toList(), }; return jsonEncode(encoded); }