mirror of
https://github.com/kuhyx/diet-guard.git
synced 2026-11-21 13:22:17 +01:00
Four asks, plus the fixes two review passes turned up. Removals (all unused): - "Repeat last meal" button, and the reward/temptation-bundling prompt it was the sole trigger for. Replaced with a post-log progress card showing kcal against budget, macros, and the adherence streak. - The multi-item meal builder, on both the gate and the phone. The stored `components` field stays: nothing writes it now, but historical composite entries and the food bank still read it and it is part of the wire format. - Meal photos entirely: 13 files, `imagePath`, the photo filter, the wrapper's /blobs/ route, image_picker, and the CAMERA permission. Reminder false alarms had three real causes, all fixed: - Logging never reconciled notifications, so a reminder sat on screen up to 15 minutes after the meal was logged -- on the phone itself. - The background check never pulled, so a PC-logged meal nagged forever until the app was opened. Now mirrors _cli_gate._should_lock: cheap local check, network only when a slot looks due, then re-check. - Meals before 08:00 / after 22:00 were attributed to no slot at all. New slot_for_log/slotForLog clamps them to the first/last slot, byte-identical across Python and Dart. Deliberately separate from elapsed_slots, which would otherwise make every slot fall due at 23:00. Budget history, so lowering the budget stops rewriting the past: - Forward-only (effective_from, kcal) entries; each day is judged against the budget in force then. Verified live: setting 2000 left a 36-day adherence streak and the whole calendar pixel-identical. - Rides as hist:<date> fields on the existing budget record. crdt_sync merges per-field over the union of field names and both devices push the merged log, so a device that predates the feature relays them untouched -- no coordinated rollout, no second document. - The seed guard tests emptiness, not file presence: _sync can write an empty history after merging with a pre-feature peer, and a presence check would then never seed again, silently reclassifying every past day. One shared source of truth for every piece of data: - Body weight now travels as its own `weight` CRDT field. Inside `value` it was collateral damage of whole-map LWW -- any phone budget edit deleted it, and the protein target with it. - Both halves of the food bank sync. The curated half (foods added without eating them) was the last device-local state. The derived half merges with count as the clock, so LWW means max-count-wins; the log stays authoritative for membership, because a CRDT union never shrinks and a peer's stale copy would otherwise resurrect a deleted food permanently. - Bank adapters honour tombstones, and Dart parses bank records defensively: a cast failure there is an Error, not an Exception, so one malformed remote record would have broken phone sync permanently. _test_guard.py blocks any pathlib write to real user state while pytest is in the process, whatever conftest is loaded. A throwaway test run outside the package conftest destroyed a real GitHub token during this work; this makes that class of accident impossible rather than merely discouraged. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
75 lines
3.5 KiB
Dart
75 lines
3.5 KiB
Dart
/// The periodic due/missing-slot check, shared by every platform's scheduler.
|
|
///
|
|
/// Re-runs the same due/missing-slot logic diet_guard's `_gate.py` uses to
|
|
/// decide whether to lock the PC, and syncs notifications to match. Kept in
|
|
/// its own library, free of any scheduler plugin, because the two platforms
|
|
/// drive it very differently: Android hands it to WorkManager as a real
|
|
/// background isolate, while the browser-hosted desktop app can only run it
|
|
/// from an in-page timer while its window is open (see
|
|
/// `background_tasks_web.dart`).
|
|
library;
|
|
|
|
import 'package:diet_guard_app/models/slot.dart';
|
|
import 'package:diet_guard_app/services/background_sync_service.dart';
|
|
import 'package:diet_guard_app/services/log_storage_service.dart';
|
|
import 'package:diet_guard_app/services/notification_service.dart';
|
|
import 'package:http/http.dart' as http;
|
|
|
|
/// Reads the local log, computes today's due-but-unlogged slots as of
|
|
/// [now] (defaults to the real clock), and syncs notifications to match.
|
|
///
|
|
/// Pulls from GitHub *only* when a slot looks due, then re-checks -- the
|
|
/// local log alone cannot see a meal logged on the PC, so without this the
|
|
/// phone re-fires "you haven't logged your 12:00 meal" every background tick
|
|
/// until the app is next opened. Deliberately mirrors `_cli_gate._should_lock`
|
|
/// on the Python side: cheap local check first, network only when it would
|
|
/// change the answer, then decide on the merged result.
|
|
///
|
|
/// Set [pullWhenDue] false when the caller has just written to the local log
|
|
/// itself (the log screen). There the local copy is by definition the freshest
|
|
/// thing in existence, so a pull would only duplicate the screen's own
|
|
/// auto-sync and delay dismissing the notification.
|
|
///
|
|
/// [now] is injectable so a test does not depend on the wall-clock hour it
|
|
/// happens to run at, the same reason `slot.dart`'s functions are clock-free.
|
|
/// [httpClient] is injectable for the same reason [backgroundSyncPush] takes
|
|
/// one: the real plugin path only exists in a background isolate on-device.
|
|
Future<void> checkAndNotify({
|
|
DateTime? now,
|
|
http.Client? httpClient,
|
|
bool pullWhenDue = true,
|
|
}) async {
|
|
await LogStorageService.init();
|
|
final at = now ?? DateTime.now();
|
|
var due = missingSlots(
|
|
at,
|
|
await LogStorageService.instance.loggedSlotsToday(),
|
|
);
|
|
if (pullWhenDue && due.isNotEmpty) {
|
|
// Reuses backgroundSyncPush's settings/isConfigured/try-catch guard rather
|
|
// than reimplementing it: that path is already proven to work from a
|
|
// WorkManager isolate, including the token read and singleton init.
|
|
await backgroundSyncPush(httpClient: httpClient);
|
|
due = missingSlots(at, await LogStorageService.instance.loggedSlotsToday());
|
|
}
|
|
await _reconcileNotifications(due);
|
|
}
|
|
|
|
/// Posts/cancels notifications for [due], swallowing platform failures.
|
|
///
|
|
/// Best-effort by design, and for both callers: from the log screen the meal
|
|
/// is already written by this point and must not be lost to a notification
|
|
/// hiccup, and from the WorkManager tick a throw would put the task into a
|
|
/// retry-with-backoff loop over something purely cosmetic. `on Object`
|
|
/// rather than `on Exception` because `flutter_local_notifications` reports
|
|
/// an absent platform channel as a `LateInitializationError`, which is an
|
|
/// `Error`.
|
|
Future<void> _reconcileNotifications(List<int> due) async {
|
|
try {
|
|
await NotificationService.init();
|
|
await NotificationService.instance.syncToSlots(due);
|
|
} on Object {
|
|
// Notifications are a nicety; nothing above depends on them.
|
|
}
|
|
}
|