diff --git a/app/lib/screens/settings_kuchnia.dart b/app/lib/screens/settings_kuchnia.dart new file mode 100644 index 0000000..3c5b9d1 --- /dev/null +++ b/app/lib/screens/settings_kuchnia.dart @@ -0,0 +1,185 @@ +/// The catering-panel credential section of the settings screen. +/// +/// Its own file because `settings_screen.dart` sits at the repo's 250-line +/// ceiling. +/// +/// Two things about this section are deliberate: +/// +/// * **The fields show on every platform, the fetch button only on Android.** +/// The panel sends no CORS headers, so a browser cannot call it -- but the +/// desktop app is where the user is most likely to be typing a password, and +/// the credential syncs, so hiding the fields there would mean the phone +/// could only ever be set up by typing on the phone. +/// * **The password is stored and synced in plaintext**, and the section says +/// so rather than implying otherwise. The rest of the synced state is not +/// encrypted either. +library; + +import 'package:diet_guard_app/services/kuchnia_client.dart'; +import 'package:diet_guard_app/services/kuchnia_credential_service.dart'; +import 'package:diet_guard_app/services/kuchnia_import.dart'; +import 'package:diet_guard_app/ui/theme.dart'; +import 'package:flutter/material.dart'; + +/// Fetches today's delivery and reports what was banked. +/// +/// Deliberately says "banked", not "logged": a delivered meal is not an eaten +/// meal, so the dishes land in the food bank and the user still taps to log +/// each one. Top-level so the settings screen can pass it without growing. +Future fetchTodaysDelivery() async { + final result = await refreshDelivery(DateTime.now()); + if (!result.ok) return result.reason!; + if (result.dishes.isEmpty) return 'No delivery found for today.'; + final count = result.dishes.length; + return '$count ${count == 1 ? 'dish' : 'dishes'} added to your food bank. ' + 'Log them from the meal screen when you eat them.'; +} + +/// Credential fields plus, on Android, a "fetch today's delivery" action. +class KuchniaSettingsSection extends StatefulWidget { + /// Creates the section. + /// + /// [canFetch] defaults to [kuchniaFetchSupported] -- false on web, where the + /// button is replaced by a one-line explanation rather than silently + /// vanishing. [onFetch] defaults to the real fetch. Both are injectable so a + /// widget test can drive the section without a network or a platform check. + const KuchniaSettingsSection({ + this.canFetch, + this.onFetch, + super.key, + }); + + /// Whether this platform can reach the catering panel; null means ask. + final bool? canFetch; + + /// Fetches today's delivery and returns a status line; null means the real + /// one. + final Future Function()? onFetch; + + @override + State createState() => _KuchniaSettingsSectionState(); +} + +class _KuchniaSettingsSectionState extends State { + late final TextEditingController _username = TextEditingController( + text: KuchniaCredentialService.username, + ); + late final TextEditingController _password = TextEditingController( + text: KuchniaCredentialService.password, + ); + bool _obscured = true; + bool _busy = false; + String? _status; + + @override + void dispose() { + _username.dispose(); + _password.dispose(); + super.dispose(); + } + + Future _save() async { + if (!KuchniaCredentialService.isInitialized) return; + await KuchniaCredentialService.instance.save( + _username.text, + _password.text, + ); + if (!mounted) return; + setState(() => _status = 'Saved. It will sync to your other devices.'); + } + + Future _fetch() async { + setState(() { + _busy = true; + _status = null; + }); + final message = await (widget.onFetch ?? fetchTodaysDelivery)(); + if (!mounted) return; + setState(() { + _busy = false; + _status = message; + }); + } + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + final canFetch = widget.canFetch ?? kuchniaFetchSupported; + // The section owns its own leading divider so the settings screen needs a + // single line for it -- that file sits on the repo's 250-line ceiling. + return Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + const SizedBox(height: 24), + const Divider(), + const SizedBox(height: 8), + Text('Kuchnia Wikinga', style: theme.textTheme.titleMedium), + const SizedBox(height: 4), + Text( + "Your catering panel login, so this device can look up the day's " + 'delivered dishes and their macros. Stored and synced in plain ' + 'text, like the rest of your synced data.', + style: theme.textTheme.bodySmall, + ), + const SizedBox(height: 12), + ConstrainedBox( + constraints: const BoxConstraints(maxWidth: AppWidth.field), + child: TextField( + controller: _username, + keyboardType: TextInputType.emailAddress, + autocorrect: false, + decoration: const InputDecoration(labelText: 'Panel e-mail'), + onSubmitted: (_) => _save(), + ), + ), + const SizedBox(height: 12), + ConstrainedBox( + constraints: const BoxConstraints(maxWidth: AppWidth.field), + child: TextField( + controller: _password, + obscureText: _obscured, + autocorrect: false, + enableSuggestions: false, + decoration: InputDecoration( + labelText: 'Panel password', + suffixIcon: IconButton( + icon: Icon(_obscured ? Icons.visibility : Icons.visibility_off), + tooltip: _obscured ? 'Show password' : 'Hide password', + onPressed: () => setState(() => _obscured = !_obscured), + ), + ), + onSubmitted: (_) => _save(), + ), + ), + const SizedBox(height: 12), + Wrap( + spacing: 8, + runSpacing: 8, + children: [ + FilledButton(onPressed: _save, child: const Text('Save login')), + if (canFetch) + OutlinedButton.icon( + onPressed: _busy ? null : _fetch, + icon: const Icon(Icons.restaurant), + label: Text( + _busy ? 'Fetching…' : "Fetch today's delivery", + ), + ), + ], + ), + if (!canFetch) ...[ + const SizedBox(height: 8), + Text( + 'Android only — the catering panel blocks browser requests. Your ' + 'login still syncs to your phone from here.', + style: theme.textTheme.bodySmall, + ), + ], + if (_status != null) ...[ + const SizedBox(height: 8), + Text(_status!, style: theme.textTheme.bodyMedium), + ], + ], + ); + } +} diff --git a/app/lib/screens/settings_screen.dart b/app/lib/screens/settings_screen.dart index b2058f6..e305d20 100644 --- a/app/lib/screens/settings_screen.dart +++ b/app/lib/screens/settings_screen.dart @@ -14,6 +14,7 @@ import 'package:crdt_sync/crdt_sync.dart'; import 'package:diet_guard_app/models/meal_schedule.dart'; import 'package:diet_guard_app/models/slot.dart'; import 'package:diet_guard_app/screens/github_mirror_screen.dart'; +import 'package:diet_guard_app/screens/settings_kuchnia.dart'; import 'package:diet_guard_app/services/app_settings_service.dart'; import 'package:diet_guard_app/services/due_slot_check.dart'; import 'package:diet_guard_app/services/firebase_backend.dart'; @@ -185,6 +186,7 @@ class _SettingsScreenState extends State const Divider(), const SizedBox(height: 8), ..._mealScheduleSection(context), + const KuchniaSettingsSection(), const SizedBox(height: 24), const Divider(), ListTile( diff --git a/app/pubspec.yaml b/app/pubspec.yaml index 3d2c367..2785973 100644 --- a/app/pubspec.yaml +++ b/app/pubspec.yaml @@ -2,7 +2,7 @@ name: diet_guard_app description: "Companion phone app for diet_guard: log meals on the go." publish_to: 'none' -version: 1.0.62+1 +version: 1.0.63+1 environment: sdk: ^3.12.2 diff --git a/app/test/screens/settings_kuchnia_test.dart b/app/test/screens/settings_kuchnia_test.dart new file mode 100644 index 0000000..d8afe6e --- /dev/null +++ b/app/test/screens/settings_kuchnia_test.dart @@ -0,0 +1,130 @@ +/// The catering credential section of the settings screen. +/// +/// The behaviour that needs pinning is the platform split, because it is the +/// one thing a reader would plausibly "simplify" the wrong way: the credential +/// **fields** show everywhere (the desktop app is where a password is most +/// likely to be typed, and it syncs from there to the phone), while the +/// **fetch button** is Android-only, because the panel sends no CORS headers +/// and a browser cannot call it at all. +library; + +import 'dart:async'; + +import 'package:diet_guard_app/screens/settings_kuchnia.dart'; +import 'package:diet_guard_app/services/document_store.dart'; +import 'package:diet_guard_app/services/kuchnia_credential_service.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; + +/// In-memory store, so these tests need no plugin channel. +class _MemoryStore implements DocumentStore { + final Map documents = {}; + + @override + Future read(String name) async => documents[name]; + + @override + Future write(String name, String contents) async { + documents[name] = contents; + } +} + +Widget _host({required bool canFetch, Future Function()? onFetch}) => + MaterialApp( + home: Scaffold( + body: SingleChildScrollView( + child: KuchniaSettingsSection(canFetch: canFetch, onFetch: onFetch), + ), + ), + ); + +void main() { + setUp(() => KuchniaCredentialService.resetForTesting(store: _MemoryStore())); + tearDown(KuchniaCredentialService.resetForTesting); + + testWidgets('shows both credential fields on every platform', (tester) async { + await tester.pumpWidget(_host(canFetch: false)); + expect(find.text('Panel e-mail'), findsOneWidget); + expect(find.text('Panel password'), findsOneWidget); + }); + + testWidgets('offers the fetch button only where it can work', (tester) async { + await tester.pumpWidget(_host(canFetch: true)); + expect(find.text("Fetch today's delivery"), findsOneWidget); + + await tester.pumpWidget(_host(canFetch: false)); + await tester.pumpAndSettle(); + expect(find.text("Fetch today's delivery"), findsNothing); + }); + + testWidgets('explains the missing button rather than hiding it silently', ( + tester, + ) async { + await tester.pumpWidget(_host(canFetch: false)); + expect( + find.textContaining('Android only'), + findsOneWidget, + reason: 'a browser user needs to know why there is no fetch button, and ' + 'that entering the login here still helps their phone', + ); + }); + + testWidgets('saving persists the credential', (tester) async { + await tester.pumpWidget(_host(canFetch: true)); + await tester.enterText(find.byType(TextField).first, 'me@example.com'); + await tester.enterText(find.byType(TextField).last, 'hunter2'); + await tester.tap(find.text('Save login')); + await tester.pumpAndSettle(); + + expect(KuchniaCredentialService.username, 'me@example.com'); + expect(KuchniaCredentialService.password, 'hunter2'); + expect(find.textContaining('Saved'), findsOneWidget); + }); + + testWidgets('the password is obscured until revealed', (tester) async { + await tester.pumpWidget(_host(canFetch: true)); + TextField passwordField() => + tester.widget(find.byType(TextField).last); + expect(passwordField().obscureText, isTrue); + + await tester.tap(find.byTooltip('Show password')); + await tester.pumpAndSettle(); + expect(passwordField().obscureText, isFalse); + }); + + testWidgets('a fetch shows its result', (tester) async { + await tester.pumpWidget( + _host(canFetch: true, onFetch: () async => '3 dishes added'), + ); + await tester.tap(find.text("Fetch today's delivery")); + await tester.pumpAndSettle(); + expect(find.text('3 dishes added'), findsOneWidget); + }); + + testWidgets('a failed fetch shows the reason, not a crash', (tester) async { + await tester.pumpWidget( + _host(canFetch: true, onFetch: () async => 'catering login rejected'), + ); + await tester.tap(find.text("Fetch today's delivery")); + await tester.pumpAndSettle(); + expect(find.text('catering login rejected'), findsOneWidget); + }); + + testWidgets('the fetch button is disabled while a fetch is in flight', ( + tester, + ) async { + // Otherwise an impatient double-tap pays a second login plus three + // requests against a third party. + final gate = Completer(); + await tester.pumpWidget(_host(canFetch: true, onFetch: () => gate.future)); + + await tester.tap(find.text("Fetch today's delivery")); + await tester.pump(); + expect(find.text('Fetching…'), findsOneWidget); + final button = tester.widget(find.byType(OutlinedButton)); + expect(button.onPressed, isNull); + + gate.complete('done'); + await tester.pumpAndSettle(); + }); +}