mirror of
https://github.com/kuhyx/diet-guard.git
synced 2026-11-22 06:52:20 +01:00
Some checks are pending
dependency freshness / dependencies on newest stable (push) Waiting to run
file-length / file length <= 250 lines (push) Waiting to run
md-naming / markdown naming convention (push) Waiting to run
pre-commit / pre-commit (push) Waiting to run
Tests / test (push) Waiting to run
release-apk / release (APK) (push) Waiting to run
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
116 lines
4.7 KiB
Dart
116 lines
4.7 KiB
Dart
/// Assigns catering dishes to meal slots, in the provider's own order.
|
|
///
|
|
/// The Dart mirror of `diet_guard/_kuchnia_spread.py`.
|
|
///
|
|
/// The panel returns each dish with a `mealPriority` (1..N: Śniadanie, II
|
|
/// śniadanie, Obiad, Podwieczorek, Kolacja) -- the order the catering intends
|
|
/// them to be eaten in. That beats inferring an order from the dish names, and
|
|
/// it beats spreading them arithmetically.
|
|
///
|
|
/// Counts rarely match: a 5-meal plan against the default 4 slots means two
|
|
/// dishes share the first slot. The mapping is `i * S ~/ N`, which is
|
|
/// monotonic non-decreasing, keeps the first dish on the first slot and the
|
|
/// last on the last, and doubles up the earliest slots rather than dropping
|
|
/// anything.
|
|
///
|
|
/// **Integer `~/` only, never `round()`.** Repo convention for slot arithmetic
|
|
/// (`docs/meal-schedule.md`): Python's `round` is banker's and Dart's is
|
|
/// half-away-from-zero, so a float path silently desyncs the two devices --
|
|
/// and a slot one device offers while the other does not is a checkpoint that
|
|
/// can never be satisfied, i.e. a permanent lock. `index`, `span` and `count`
|
|
/// are all `int`, so `~/` matches Python's `//` exactly (`~/` on doubles
|
|
/// truncates toward zero where `//` floors).
|
|
///
|
|
/// KEEP IN SYNC WITH `diet_guard/_kuchnia_spread.py`, gated by
|
|
/// `tests/fixtures/kuchnia_day.json`.
|
|
library;
|
|
|
|
import 'package:diet_guard_app/models/kuchnia_dish.dart';
|
|
|
|
/// A dish paired with the meal-slot hour it was assigned to.
|
|
class SlottedDish {
|
|
/// Pairs [dish] with the [slot] hour it should be logged against.
|
|
const SlottedDish({required this.dish, required this.slot});
|
|
|
|
/// The dish itself.
|
|
final KuchniaDish dish;
|
|
|
|
/// The slot hour, e.g. `12` for the 12:00 checkpoint.
|
|
final int slot;
|
|
}
|
|
|
|
/// Pairs each dish with a slot hour, following the provider's meal order.
|
|
///
|
|
/// Returns an empty list when either input is empty -- a day with no delivery
|
|
/// and a schedule with no slots are both "nothing to assign", not errors.
|
|
List<SlottedDish> assignSlots(List<KuchniaDish> dishes, List<int> slots) {
|
|
if (dishes.isEmpty || slots.isEmpty) return const [];
|
|
|
|
// Ties fall back to name so the result is deterministic; a bank import that
|
|
// reshuffled between runs would look like a change and re-stamp every
|
|
// record.
|
|
//
|
|
// The payload index is the final tiebreak because `List.sort` is *not*
|
|
// stable in Dart while Python's `sorted` is: two dishes sharing both
|
|
// priority and name would otherwise be free to swap here and not on the PC.
|
|
// With the index in the comparator the ordering is total, so both languages
|
|
// agree without relying on either sort's stability.
|
|
final indexed = <(int, KuchniaDish)>[
|
|
for (var i = 0; i < dishes.length; i++) (i, dishes[i]),
|
|
]..sort((a, b) {
|
|
final byPriority = a.$2.priority.compareTo(b.$2.priority);
|
|
if (byPriority != 0) return byPriority;
|
|
final byName = a.$2.name.compareTo(b.$2.name);
|
|
if (byName != 0) return byName;
|
|
return a.$1.compareTo(b.$1);
|
|
});
|
|
|
|
final count = indexed.length;
|
|
final span = slots.length;
|
|
return [
|
|
for (var index = 0; index < count; index++)
|
|
SlottedDish(
|
|
dish: indexed[index].$2,
|
|
slot: slots[index * span ~/ count],
|
|
),
|
|
];
|
|
}
|
|
|
|
/// Returns [dishes] ordered by the provider's own meal priority.
|
|
///
|
|
/// So the dish offered for the slot being filled is the one the catering
|
|
/// actually intends for it, rather than whatever order the payload arrived in.
|
|
List<KuchniaDish> dishesInSlotOrder(
|
|
List<KuchniaDish> dishes,
|
|
List<int> slots,
|
|
) => [for (final item in assignSlots(dishes, slots)) item.dish];
|
|
|
|
/// Returns `(portionGrams, (kcal, protein, carbs, fat))` as form strings.
|
|
///
|
|
/// Phone-only, deliberately: this form logs the fields as typed, so writing
|
|
/// the dish's whole-portion macros into them is correct. The PC gate's form
|
|
/// scales its macros from a "per" basis to the amount eaten, so it goes
|
|
/// through `_kuchnia_log.dish_nutrition` (basis = the dish's own grams)
|
|
/// instead -- filling its fields this way logged 3.5x the calories.
|
|
/// Formatted here rather than in the widget so the numeric formatting is
|
|
/// covered by a test that needs no display.
|
|
///
|
|
/// Python uses `f"{value:g}"`, which drops a trailing `.0`; Dart's
|
|
/// `toStringAsFixed` would keep it and `toString` would render `435.0`. So a
|
|
/// whole number is printed as an integer and anything else keeps its
|
|
/// decimals -- the form should read "435", not "435.0".
|
|
(String, (String, String, String, String)) dishFieldValues(KuchniaDish dish) {
|
|
String format(double value) => value == value.roundToDouble()
|
|
? value.toInt().toString()
|
|
: value.toString();
|
|
return (
|
|
format(dish.grams),
|
|
(
|
|
format(dish.kcal),
|
|
format(dish.proteinG),
|
|
format(dish.carbsG),
|
|
format(dish.fatG),
|
|
),
|
|
);
|
|
}
|