Doormile/doormile_milderapp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

device infos

Browse Source
This commit is contained in:
Thiru-tenext
2026-08-28 15:07:30 +05:30
parent 5723d373b2
commit 69f4f3e909
84 changed files with 4337 additions and 2339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1976
lib/background/backgroundservice.dart
View File

File diff suppressed because it is too large Load Diff

49
lib/background/foreground_service.dart
View File

@@ -10,11 +10,10 @@ import 'package:miler/views/helpers/constants/apiconstants.dart';
import 'package:miler/providers/Riderlog/riderlog_provider.dart';
import 'package:miler/background/backgroundservice.dart';
import 'package:geolocator/geolocator.dart';
import 'package:miler/data/device_telemetry.dart';
import 'package:miler/utils/kalman_filter.dart';
import 'package:miler/utils/mqtt_service.dart';
import 'package:miler/views/helpers/constants/mqtt_constants.dart';
import 'package:battery_plus/battery_plus.dart';
import 'package:connectivity_plus/connectivity_plus.dart';
class _BackgroundRiderLog {
static MilerKalmanFilter? _kf;
@@ -165,6 +164,24 @@ class _BackgroundRiderLog {
final int? logid = prefs.getInt('logId') ?? prefs.getInt('logid');
final String orderId = prefs.getString('current_riding_order_id') ?? '';
// ── The handset's own state goes IN the heartbeat ──
//
// It used to be gathered further down, after this post had already gone,
// and published to MQTT alone — so the console reading `/miler/logs` had
// a position and nothing else, and drew an em dash against Battery,
// Connection, GPS Accuracy and Location Service on a rider whose phone
// was reporting all four.
//
// Read here, once, and spread into the payload below. The MQTT publish
// further down reuses the same values rather than asking again, so the
// two lanes cannot disagree about the same second. See [DeviceTelemetry].
final telemetry = await DeviceTelemetry.read(
// The fix lookup already resolved this to get a position at all;
// asking a second time can disagree with itself if the rider toggles
// the setting in between.
locationService: loc['status'],
);
final payload = {
"logid": logid ?? 0,
"userid": userid,
@@ -189,6 +206,15 @@ class _BackgroundRiderLog {
"userfcmtoken": userfcmtoken ?? '',
"username": (username ?? '').trim(),
"orderid": orderId,
// What the dispatcher needs when a rider goes quiet: the battery, the
// signal, whether location is even on, and how good the last fix was.
...telemetry.toPayload(),
// Only a measured one — a `0` reads on the console as a perfect fix.
if ((loc['accuracy'] ?? '0') != '0') "accuracy": loc['accuracy'],
// This heartbeat is the *background* one — it is what keeps reporting
// while the app is not on screen, which is exactly the state the
// console's App State column exists to show.
"is_background": true,
};
final firstName = prefs.getString('firstname') ?? '';
@@ -223,18 +249,13 @@ class _BackgroundRiderLog {
}
if (mqttService.isConnected) {
// Gather Telemetry
final battery = Battery();
final int batteryLevel = await battery.batteryLevel;
final BatteryState batteryState = await battery.batteryState;
final isCharging =
batteryState == BatteryState.charging ||
batteryState == BatteryState.full;
final connectivity = await Connectivity().checkConnectivity();
final String connType = connectivity.isNotEmpty
? connectivity.first.toString().split('.').last
: 'none';
// The same reading the heartbeat above carried — not a second one.
// Two reads a second apart can report two batteries, and the console
// then shows one number on the live tile and a different one in the
// trail it is drawn from.
final int batteryLevel = telemetry.battery ?? 0;
final bool isCharging = telemetry.isCharging ?? false;
final String connType = telemetry.connection ?? 'none';
// 1. Direct Telemetry (Feeding the /full API)
mqttService.publish('battery', '$batteryLevel%');

24
lib/controllers/pickups_controller.dart
View File

@@ -9,6 +9,7 @@ import 'package:latlong2/latlong.dart' show LatLng;
import 'package:miler/helpers/miler_router.dart';
import 'package:get/get.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:miler/data/accepted_store.dart';
import 'package:geolocator/geolocator.dart';
import 'package:miler/views/helpers/constants/apiconstants.dart';
@@ -574,6 +575,29 @@ class PickupsController extends GetxController
}
}
// ── Written down, not only sent ──
//
// This figure is the only measurement of the leg that exists: the backend
// does not reliably send a distance back on `GET /miler/bookings`, and
// until now the app posted this and kept nothing, so Activity's `km
// ridden` had no row to total and printed an em dash on a day of real
// riding. Recorded against the stop so the record that gets filed carries
// it — see [kStopKmKey] and `addCompletedBookings`.
//
// Best-effort: a preferences write must never cost the rider a pickup
// that has otherwise succeeded.
if (calculatedKms > 0) {
try {
final prefs = await SharedPreferences.getInstance();
await prefs.setString(
kStopKmKey(pickupId),
calculatedKms.toStringAsFixed(2),
);
} catch (e) {
debugPrint('[PICKED] could not record the distance: $e');
}
}
final payload = <String, dynamic>{
'pickupid': pickupId,
// Not sent to the backend — the legacy shape carries it and the mapper

45
lib/controllers/riderlog.dart
View File

@@ -15,6 +15,7 @@ import 'package:miler/controllers/logcontroller.dart';
import 'package:miler/background/foreground_service.dart' as fg;
import 'package:miler/utils/kalman_filter.dart';
import 'package:miler/utils/mqtt_service.dart';
import 'package:miler/data/device_telemetry.dart';
import 'package:miler/views/helpers/constants/mqtt_constants.dart';
import 'package:battery_plus/battery_plus.dart';
import 'package:miler/controllers/connectivity_mixin.dart';
@@ -260,6 +261,14 @@ class RiderLogController extends GetxController
}
} catch (_) {}
// The handset's own state — see [DeviceTelemetry] for why this is read
// here and not published to MQTT alone. The console's Battery,
// Connection, GPS Accuracy and Location Service columns are read off the
// rider log, and until now nothing put them in it.
final telemetry = await DeviceTelemetry.read(
locationService: loc['status'],
);
final Map<String, dynamic> payload = {
// Base from server template
...baseTemplate,
@@ -288,6 +297,14 @@ class RiderLogController extends GetxController
'applocationid': applocationid ?? 0,
'userfcmtoken': userfcmtoken ?? '',
'orderid': orderId,
...telemetry.toPayload(),
// Only a measured one. A `0` here would draw on the console as a
// perfect fix rather than as no fix at all.
if ((loc['accuracy'] ?? '').isNotEmpty) 'accuracy': loc['accuracy'],
// This is the *foreground* controller — the rider has the app open.
// The background heartbeat sends true, and the difference between the
// two is what the console's App State column reports.
'is_background': false,
};
// --- MQTT LOGIC ( Lane Split ) ---
@@ -325,6 +342,10 @@ class RiderLogController extends GetxController
'heading': loc['heading'] ?? '0',
'status': riderStatus,
'orderid': orderId,
// The same reading the log above carries, so the live lane and the
// trail cannot report two different batteries a second apart.
...telemetry.toPayload(),
if ((loc['accuracy'] ?? '').isNotEmpty) 'accuracy': loc['accuracy'],
});
// Ensure rider identity fields are clean:
@@ -779,6 +800,19 @@ class RiderLogController extends GetxController
'heading': '0',
'velocity_lat': '0',
'velocity_lng': '0',
// ── Two fields the background lookup has always returned and this one
// did not ──
//
// `accuracy` is how good the fix is and `status` is whether location is
// switched on at all — the two the console draws under GPS Accuracy and
// Location Service. Absent here, the foreground heartbeat had nothing to
// send and would have had to invent a `0`, which reads as a *perfect*
// fix rather than as no fix.
//
// Empty, not zero: an unknown accuracy is dropped from the payload by
// the caller and drawn as an em dash, which is the truth.
'accuracy': '',
'status': 'unknown',
};
try {
final needsFetch =
@@ -786,7 +820,10 @@ class RiderLogController extends GetxController
if (!needsFetch) return result;
final serviceEnabled = await Geolocator.isLocationServiceEnabled();
if (!serviceEnabled) return result;
if (!serviceEnabled) {
result['status'] = 'disabled';
return result;
}
LocationPermission permission = await Geolocator.checkPermission();
if (permission == LocationPermission.denied) {
@@ -794,8 +831,12 @@ class RiderLogController extends GetxController
}
if (permission == LocationPermission.denied ||
permission == LocationPermission.deniedForever) {
result['status'] = permission == LocationPermission.deniedForever
? 'denied_forever'
: 'denied';
return result;
}
result['status'] = 'enabled';
final Position pos = await Geolocator.getCurrentPosition(
locationSettings: const LocationSettings(
@@ -836,6 +877,8 @@ class RiderLogController extends GetxController
'heading': heading.toStringAsFixed(2),
'velocity_lat': velocityLat.toStringAsFixed(4),
'velocity_lng': velocityLng.toStringAsFixed(4),
'accuracy': pos.accuracy.toStringAsFixed(1),
'status': 'enabled',
};
} catch (_) {
return result;

99
lib/data/accepted_store.dart
View File

@@ -71,7 +71,7 @@ Future<void> migrateLegacyStores() async {
_kConsignmentIdsKeyBase,
_kOutForDeliveryKeyBase,
_kNotLoadedKeyBase,
_kBagLabelsKeyBase,
_kOrderLabelsKeyBase,
]) {
await _drainLegacy(base, scope);
}
@@ -117,7 +117,7 @@ Future<void> clearScopedStores() async {
_kConsignmentIdsKeyBase,
_kOutForDeliveryKeyBase,
_kNotLoadedKeyBase,
_kBagLabelsKeyBase,
_kOrderLabelsKeyBase,
]) {
await prefs.remove(scope.scoped(base));
await prefs.remove(base);
@@ -296,6 +296,26 @@ String kStopStartedKey(Object pickupId) => 'stop_started_$pickupId';
/// Written by the stop map screen when it starts the pickup.
String kStopArrivedKey(Object pickupId) => 'pickup_start_$pickupId';
/// Prefs key holding the kilometres the app measured for a stop as it closed.
///
/// ── The app measured this, posted it, and kept no copy ──
///
/// `PickupsController.updateToPicked` works out how far the rider came —
/// `Geolocator.distanceBetween`, rider fix to pickup point — and sends it as
/// `actualkms`. Then it dropped it. The number existed for the length of one
/// HTTP request.
///
/// Which is why Activity's `km ridden` read an em dash on a day the rider had
/// plainly ridden: [StopCompliance] looks for `actualkms` on the row, the row
/// never carried one, and `GET /miler/bookings` does not reliably send the
/// distance back. The app was the only thing that knew, and it forgot.
///
/// So it is written here as it is posted, and [addCompletedBookings] merges it
/// onto the record it files — the same rescue it already performs for the two
/// clocks beside it, for the same reason: the moment the fact is true is the
/// moment to write it down.
String kStopKmKey(Object pickupId) => 'stop_km_$pickupId';
/// Record a finished stop. [cancelled] separates "could not complete" from a
/// clean pickup/delivery — Activity shows both, worded differently.
///
@@ -362,10 +382,18 @@ Future<void> addCompletedBookings(
final arrived = prefs.getString(kStopArrivedKey(pickupId));
if (started != null && started.isNotEmpty) copy['startedat'] = started;
if (arrived != null && arrived.isNotEmpty) copy['arrivedat'] = arrived;
// The distance the app measured as it closed this stop — see
// [kStopKmKey]. A figure already on the row wins: that one came from the
// hub, and this is the app's own measurement standing in for it.
final km = prefs.getString(kStopKmKey(pickupId));
if (km != null && km.isNotEmpty && (copy['actualkms'] ?? '') == '') {
copy['actualkms'] = km;
}
// Cleared, or a stop worked twice in a day (a resumed skip) reports the
// first attempt's clock against the second attempt's completion.
await prefs.remove(kStopStartedKey(pickupId));
await prefs.remove(kStopArrivedKey(pickupId));
await prefs.remove(kStopKmKey(pickupId));
}
// Stamped with the session that produced it, so a row read back later
@@ -795,26 +823,36 @@ Future<void> addNotLoadedOrderIds(List<String> ids) async {
}
// ─────────────────────────────────────────────────────────────────────────
// BAG IDENTITY — which bag an order travels in, for as long as it travels
// THE COUNTER'S OWN LABEL — carried for as long as the order travels
//
// ── Why this is stored rather than recomputed ──
//
// A bag number is the order's position in the load it came off — Joe is Bag 1
// of the five that left Vidhya Kitchen. Recomputing that later from whatever
// list happens to be on screen is how identity breaks: deliver Joe, and a
// position-derived Arun silently becomes Bag 1. The rider is then looking for a
// bag labelled 1 that is in a customer's hallway.
// A kitchen that prints labels prints them once, at the counter, and the label
// is what the rider matches against the object in his hands for the rest of the
// day. Recomputing anything from whatever list happens to be on screen is how
// identity breaks — deliver one order and a position-derived label silently
// moves to another, sending the rider looking for something that is already in
// a customer's hallway.
//
// So the pairing is fixed once, at the counter, at the moment the manifest is
// confirmed — and read back unchanged through delivery, skip, completion and a
// day of intermittent signal. See [BagManifest], which derives it; this only
// remembers what it derived.
// So the pairing is fixed once, at the moment the manifest is confirmed, and
// read back unchanged through delivery, skip, completion and a day of
// intermittent signal. See [OrderManifest.labelFor], which reads it off the
// payload; this only remembers what was read.
//
// ── It is empty on most routes now, and that is correct ──
//
// This used to hold `Bag 1 … Bag n`, manufactured from each order's position
// when the payload printed nothing — so every route stored a set of references
// no counter had ever issued. Only a label the kitchen actually printed is
// stored now, which on a route that prints none means nothing is stored at all
// and every screen simply shows no tag.
// ─────────────────────────────────────────────────────────────────────────
const String _kBagLabelsKeyBase = 'order_bag_labels';
const String _kOrderLabelsKeyBase = 'order_bag_labels';
/// Remembers which bag each order travels in. Merges, never replaces: a rider
/// works two kitchens and the second load must not erase the first.
Future<void> saveBagLabels(Map<String, String> byOrderId) async {
/// Remembers the label a counter printed on each order. Merges, never
/// replaces: a rider works two kitchens and the second load must not erase the
/// first. Orders with no printed label contribute nothing.
Future<void> saveOrderLabels(Map<String, String> byOrderId) async {
final clean = {
for (final e in byOrderId.entries)
if (e.key.trim().isNotEmpty && e.value.trim().isNotEmpty)
@@ -823,19 +861,20 @@ Future<void> saveBagLabels(Map<String, String> byOrderId) async {
if (clean.isEmpty) return;
final prefs = await SharedPreferences.getInstance();
final merged = {...await getBagLabels(), ...clean};
final merged = {...await getOrderLabels(), ...clean};
// Stored as `id\u0000label` rows: SharedPreferences has no map type, and a
// NUL separator cannot collide with an order id or a bag label.
await prefs.setStringList(await _scopedKey(_kBagLabelsKeyBase), [
// NUL separator cannot collide with an order id or a printed label.
await prefs.setStringList(await _scopedKey(_kOrderLabelsKeyBase), [
for (final e in merged.entries) '${e.key}\u0000${e.value}',
]);
}
/// The bag each order is in, as recorded at pickup. Empty before any load.
Future<Map<String, String>> getBagLabels() async {
/// The label each order carries, as recorded at pickup. Empty before any load,
/// and empty all day on a route whose counters print nothing.
Future<Map<String, String>> getOrderLabels() async {
final prefs = await SharedPreferences.getInstance();
final rows =
prefs.getStringList(await _scopedKey(_kBagLabelsKeyBase)) ??
prefs.getStringList(await _scopedKey(_kOrderLabelsKeyBase)) ??
const <String>[];
return {
for (final row in rows)
@@ -854,7 +893,7 @@ Future<void> clearServiceRunState() async {
await prefs.remove(await _scopedKey(_kCollectedOrderIdsKeyBase));
await prefs.remove(await _scopedKey(_kOutForDeliveryKeyBase));
await prefs.remove(await _scopedKey(_kNotLoadedKeyBase));
await prefs.remove(await _scopedKey(_kBagLabelsKeyBase));
await prefs.remove(await _scopedKey(_kOrderLabelsKeyBase));
}
// ─────────────────────────────────────────────────────────────────────────
@@ -933,16 +972,16 @@ Future<int> purgeDemoRecords() async {
// Harmless on its own, but this store exists to be the one place that knows
// which bag an order is in, and a stale entry is exactly the kind of thing
// that is trusted later precisely because it is stored.
final bags =
prefs.getStringList(await _scopedKey(_kBagLabelsKeyBase)) ??
final labels =
prefs.getStringList(await _scopedKey(_kOrderLabelsKeyBase)) ??
const <String>[];
if (bags.isNotEmpty) {
final kept = bags
if (labels.isNotEmpty) {
final kept = labels
.where((row) => !_looksLikeDemoId(row.split('\u0000').first))
.toList();
if (kept.length != bags.length) {
dropped += bags.length - kept.length;
await prefs.setStringList(await _scopedKey(_kBagLabelsKeyBase), kept);
if (kept.length != labels.length) {
dropped += labels.length - kept.length;
await prefs.setStringList(await _scopedKey(_kOrderLabelsKeyBase), kept);
}
}

83
lib/data/api_config.dart
View File

@@ -524,9 +524,92 @@ class ApiConfig {
'parcels': booking['parcels'] ?? const [],
'starttime': s(booking['createdat']),
'eta': s(booking['eta']),
// ── The row's own clocks, carried verbatim ──
//
// This adapter builds a **fixed map**, so a field it does not name is a
// field the app can never see — the same trap `step` and `stoptype` were
// in. Every timestamp on the booking was in that trap, and the cost was
// not cosmetic: [ServiceDay] dates a row by exactly these key names, so
// an adapted row carried nothing to date it by and *every* screen that
// asks "does this belong to today" had to answer "cannot tell".
//
// That is how yesterday's assignments stayed on Home. The filter was
// never missing so much as starved: it was asking a question of fields
// this method had already thrown away.
//
// Copied under the names the wire uses, with no reshaping and no
// parsing. [ServiceDay] and [parseStamp] own the reading of them —
// Doormile sends IST wall-clock in naive columns, sometimes with a
// trailing `Z` it never had, and the one place that knows that should
// stay the one place that knows it.
for (final k in timestampFieldNames)
if (booking[k] != null && booking[k].toString().trim().isNotEmpty)
k: booking[k],
// ── And the row's distances, for the same reason ──
//
// `cumulativekms` was named above and the rest were not, so the whole
// distance vocabulary was dropped here: `kms` (what the hub planned),
// `riderkms` (what the rider actually covered) and the `compliance` block
// the contract carries them in.
//
// [StopCompliance] reads exactly those names, so it answered `null` for
// every adapted row — and Activity's `km ridden` totalled zero all day
// and printed an em dash. Same failure as the timestamps, on a different
// set of fields: a fixed map cannot pass on what it does not name.
for (final k in distanceFieldNames)
if (booking[k] != null && booking[k].toString().trim().isNotEmpty)
k: booking[k],
};
}
/// Every distance key a booking row is known to carry, copied through
/// [pickupFromBooking] untouched.
///
/// Kept in step with [StopCompliance], which is what reads them. `compliance`
/// is a nested object rather than a number and is passed on whole — this
/// adapter's job is to stop losing fields, not to reshape them.
static const List<String> distanceFieldNames = [
// What the hub planned for this stop.
'kms',
'km',
// What the rider actually covered. `riderkms` is the backend's name;
// `actualkms` is the name this app posts on its own pickup write.
'riderkms',
'actualkms',
// The contract's block, carrying both plus the on-time verdict.
'compliance',
];
/// Every timestamp key a booking row is known to carry, copied through
/// [pickupFromBooking] untouched.
///
/// Deliberately a superset of what any one endpoint sends: a name that is
/// absent costs one map lookup, and a name that is missing costs a screen
/// its ability to tell today from yesterday. Kept in step with
/// `ServiceDay.timeKeys`, which is what reads them.
static const List<String> timestampFieldNames = [
'createdat',
'createdon',
'updatedat',
'updatedon',
'modifiedon',
'pickedtime',
'picked_time',
'deliverytime',
'deliveredat',
'completedat',
'expected_pickup_time',
'expectedpickuptime',
'slotstarttime',
'slotendtime',
'slotfrom',
'slotto',
'assignedat',
'assignedon',
];
static List<Map<String, dynamic>> pickupsFromBookings(dynamic data) {
if (data is List) {
return data.whereType<Map>().map((b) => pickupFromBooking(b)).toList();

124
lib/data/bag_manifest.dart
View File

@@ -1,124 +0,0 @@
import 'package:miler/data/milk_run.dart';
import 'package:miler/views/Dashboard/pickups/stop_type.dart';
/// ─────────────────────────────────────────────────────────────────────────
/// ONE PICKUP ORDER = ONE BAG
///
/// The rule the whole rider workflow rests on, in one file so it cannot be
/// stated two different ways on two screens.
///
/// If a kitchen has five pickup orders, the rider is handed **five bags** — one
/// per order — and ends up with **five deliveries**, each carrying the bag it
/// arrived in:
///
/// ```
/// Order 1 → Bag 1 → Joe
/// Order 2 → Bag 2 → Arun
/// Order 3 → Bag 3 → Priya
/// ```
///
/// ── Why this is a file and not a `+ 1` at each call site ──
///
/// Every screen in the pickup half of the app has to answer "how many bags?"
/// and "which bag is this?", and every screen that answered it independently
/// answered it differently: one showed a backend `Quantity` (an order's item
/// count, not a bag count), one showed a bare `baglabel` when the payload
/// happened to carry one and nothing at all when it did not, and the kitchen
/// heading counted "meals". A rider standing at a counter comparing "5 meals"
/// on his phone with four bags on the shelf has no way to tell which of the two
/// numbers is wrong.
///
/// So the count is **derived from the orders**, always, and there is no second
/// quantity anywhere that can disagree with it.
///
/// ── What is derived, and what is never invented ──
///
/// • **The count** is `orders.length`. It cannot drift, because it is not
/// stored — a bag is what an order arrives in.
/// • **The identity** prefers the label the backend printed on the physical
/// bag ([stopBagLabel]) and falls back to the order's **position in its own
/// pickup group** — `Bag 1`, `Bag 2` — which is what a rider counting a
/// shelf actually uses.
///
/// Nothing here fabricates a crate, a tote or a quantity the backend has not
/// sent. If a future contract ever puts more than one bag on an order, this is
/// the one file that changes.
/// ─────────────────────────────────────────────────────────────────────────
class BagManifest {
BagManifest._();
/// One line of a pickup manifest: the order, the customer it is for, and the
/// bag it travels in.
///
/// Deliberately carries the stop itself: every caller that renders a manifest
/// also needs to act on the orders behind it, and pairing them here is what
/// stops a screen from rendering five lines and posting four ids.
static List<BagLine> forGroup(List<Map<String, dynamic>> stops) => [
for (var i = 0; i < stops.length; i++)
BagLine(
stop: stops[i],
orderId: MilkRun.idOf(stops[i]),
customer: customerOf(stops[i]),
bag: _bagFor(stops[i], i),
),
];
/// The bag one order travels in, given the group it was collected with.
///
/// [stops] must be the whole pickup group in route order — the position in it
/// *is* the bag number when the backend has not printed one.
static String bagFor(
Map<String, dynamic> stop,
List<Map<String, dynamic>> group,
) {
final id = MilkRun.idOf(stop);
final index = group.indexWhere((s) => MilkRun.idOf(s) == id);
return _bagFor(stop, index < 0 ? 0 : index);
}
static String _bagFor(Map<String, dynamic> stop, int index) {
final printed = stopBagLabel(stop);
return printed.isNotEmpty ? printed : 'Bag ${index + 1}';
}
/// `5 bags` — the load, in the unit the rider actually carries.
///
/// It used to print `5 orders · 5 bags`: the two halves of the one-bag-per-
/// order rule side by side, as a check the rider could eyeball. On a device
/// that check cost the header the fact it exists for — a real kitchen name
/// plus `13 orders · 13 bags` pushed `11 to accept` off the row, and the
/// clause that truncated was the one that changes what he does next.
///
/// One number survives, and it is the physical one: the rows underneath are
/// named `Bag 1 … Bag n` and a settled group says `n bags collected`, so
/// "bags" is the word this column already speaks. No information is lost —
/// the rule makes the counts identical — and the verifiable statement lives
/// where the verifying happens: the manifest list itself, one line per bag.
static String countLabel(int orders) {
return orders == 1 ? '1 bag' : '$orders bags';
}
/// The name the bag is going to, for a manifest line.
static String customerOf(Map<String, dynamic> stop) =>
(stop['pickupcustomer'] ??
stop['customername'] ??
stop['tenantname'] ??
'')
.toString()
.trim();
}
/// One row of a pickup manifest. See [BagManifest.forGroup].
class BagLine {
final Map<String, dynamic> stop;
final String orderId;
final String customer;
final String bag;
const BagLine({
required this.stop,
required this.orderId,
required this.customer,
required this.bag,
});
}

92
lib/data/consignment_state.dart
View File

@@ -176,8 +176,100 @@ extension ConsignmentStateX on ConsignmentState {
/// widened it on 21 Aug 2026 so a failed attempt is reportable the moment
/// the parcel is collected, not only once the round has started.
bool get canSkip => needsRelease || isDeliverable;
/// Why **Start ride** could not set off, in words a rider can act on — or
/// null when this state is not a reason to refuse one.
///
/// ── The screen was reading the state machine out loud ──
///
/// When `start-delivery` refuses, the backend answers with an assertion
/// about its own model: *"consignment is Inwarded_At_Hub, not
/// Collected_By_Miler"*. That sentence was passed through to the rider
/// verbatim, on the reasoning that the server's own words beat a guess — and
/// that reasoning is right about *whose* answer it is and wrong about *what
/// kind of sentence* it is. `Inwarded_At_Hub` is a database enum. It is not
/// something a man holding a phone at a kitchen counter can do anything
/// with, and he had no way to tell it from a bug.
///
/// So the state is translated here, in the file that owns the vocabulary,
/// exactly once. Every sentence answers the only two questions he has: is
/// this mine, and is sliding again going to help.
///
/// Null for [outForDelivery], [collectedByMiler] and [unknown] — the first
/// two are not refusals at all and the third is not an answer, so the caller
/// falls back rather than inventing a cause.
String? get startRefusalSentence => switch (this) {
// Converted and not yet routed. The one refusal here that a second slide
// in a minute genuinely can clear.
ConsignmentState.created =>
'Your office is still setting this one up. Give it a moment and slide '
'again.',
// The logistics network has it. Said without naming a building the rider
// has never been to — what matters is that it is not his round.
ConsignmentState.inwardedAtHub ||
ConsignmentState.tripsheetLoaded ||
ConsignmentState.inTransit =>
"This one has already been handed on — it's not yours to deliver.",
ConsignmentState.delivered =>
'This one has already been delivered. Nothing left to start.',
ConsignmentState.rtoInitiated || ConsignmentState.returnedToSender =>
'This one is going back to the sender, so there is no delivery to '
'start.',
ConsignmentState.missing || ConsignmentState.damaged =>
'Your office has flagged a problem with this parcel. They have to clear '
'it before it can go out.',
ConsignmentState.cancelled =>
'This one has been cancelled. There is nothing to deliver.',
ConsignmentState.outForDelivery ||
ConsignmentState.collectedByMiler ||
ConsignmentState.unknown => null,
};
}
/// The consignment state a **start-delivery** refusal names, or
/// [ConsignmentState.unknown] when it names none this build knows.
///
/// ── Reading a state out of a sentence, safely ──
///
/// Parsing prose is normally a bad idea, and this is the case where it is not,
/// because it does not depend on the prose. `POST
/// /miler/consignments/:id/start-delivery` accepts **exactly one** state —
/// `Collected_By_Miler`. So of the state names a refusal from that endpoint
/// mentions, the only one that cannot be describing where the consignment
/// actually *is* is the one that would have been accepted. Drop that, and
/// whatever is left is the answer — whichever order the words come in, and
/// however the sentence is later reworded.
///
/// This exists because the state read can fail twice: the row need not carry
/// `consignmentstatus`, and `GET /miler/consignments/:id` can 404 on an older
/// deployment. In that case the refusal itself is the only thing that knows
/// what happened, and throwing it away costs the rider a real answer.
///
/// Matches only the wire's own shape — capitalised words joined by
/// underscores — so an ordinary sentence yields nothing.
ConsignmentState consignmentStateNamedInRefusal(String message) {
if (message.isEmpty) return ConsignmentState.unknown;
for (final m in RegExp(
r'[A-Za-z]+(?:_[A-Za-z]+)+',
).allMatches(message)) {
final state = consignmentStateFromRaw(m.group(0));
if (state == ConsignmentState.unknown) continue;
// The state the endpoint requires, not the state it found.
if (state == ConsignmentState.collectedByMiler) continue;
return state;
}
return ConsignmentState.unknown;
}
/// True when [message] is the backend talking to itself.
///
/// A refusal carrying a wire enum — `Inwarded_At_Hub`, `Out_for_Delivery` — is
/// a state-machine assertion, not a sentence for a rider, and it must never
/// reach a screen. Anything else the server says is prose written for a person
/// and is worth more than a generic apology, so it is still passed through.
bool namesWireState(String message) =>
RegExp(r'[A-Za-z]+(?:_[A-Za-z]+)+').hasMatch(message);
/// What the app is allowed to do with a consignment, decided from the
/// authoritative server state rather than from a booking row or a local flag.
enum DeliverGate {

133
lib/data/device_telemetry.dart Normal file
View File

@@ -0,0 +1,133 @@
import 'package:battery_plus/battery_plus.dart';
import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:flutter/foundation.dart';
import 'package:geolocator/geolocator.dart';
/// ─────────────────────────────────────────────────────────────────────────
/// WHAT THE CONSOLE NEEDS TO SEE ABOUT THE HANDSET
///
/// The dispatcher watching a rider is not only asking *where is he*. When a
/// rider stops reporting, the question is **why** — and the answers are all
/// facts about the phone: the battery died, the signal dropped, he turned
/// location off, the app went to the background and the OS stopped waking it.
/// `POST /miler/logs` has fields for every one of them:
///
/// ```
/// battery is_charging connection location_service accuracy is_background
/// ```
///
/// ── Why the console was showing an em dash for all of it ──
///
/// Not because nothing was measured. Every one of these was already being read
/// on the heartbeat — and published to **MQTT only**, in a block that ran
/// *after* the log had been posted. So the telemetry existed, reached a
/// different transport, and the rider-log row the console actually reads
/// carried nothing but a position.
///
/// It was two lanes for one fact, and the lane the console reads was the empty
/// one. This is the reader both now share: one place that knows how to ask the
/// handset, so the MQTT publish and the log post cannot report different
/// batteries a second apart.
///
/// ── Never throws, never blocks ──
///
/// Telemetry is the least important thing the app does. A permissions prompt, a
/// platform channel that hangs, a plugin missing on a desktop test host — none
/// of them may cost the rider his heartbeat, so every read is guarded
/// individually and an unavailable one simply does not appear in the map.
/// A field that is absent renders as the em dash it already rendered as; a
/// field that is *wrong* would be read as fact by somebody making a decision.
/// ─────────────────────────────────────────────────────────────────────────
class DeviceTelemetry {
/// Battery percentage, or null when the platform will not say.
final int? battery;
/// True while on the charger — a rider at 12% and charging is not the same
/// problem as a rider at 12% and riding.
final bool? isCharging;
/// `wifi`, `mobile`, `none` … as the platform names it.
final String? connection;
/// `enabled`, `disabled`, `denied`, `denied_forever`, `unknown`.
///
/// The one field here that is about a *choice the rider made*, which is why
/// it is worth a column of its own on the console: a disabled location
/// service explains a silent rider completely, and no amount of staring at
/// his last position does.
final String? locationService;
const DeviceTelemetry({
this.battery,
this.isCharging,
this.connection,
this.locationService,
});
/// Reads what the handset will say about itself, right now.
///
/// [locationService] can be supplied by a caller that has just resolved a
/// fix and already knows — the position lookup has to ask the same question
/// to get a fix at all, and asking twice can disagree with itself when the
/// rider toggles the setting between the two calls.
static Future<DeviceTelemetry> read({String? locationService}) async {
int? level;
bool? charging;
try {
final battery = Battery();
level = await battery.batteryLevel;
final state = await battery.batteryState;
charging =
state == BatteryState.charging || state == BatteryState.full;
} catch (e) {
debugPrint('[TELEMETRY] battery unavailable: $e');
}
String? connection;
try {
final result = await Connectivity().checkConnectivity();
connection = result.isNotEmpty
? result.first.toString().split('.').last
: 'none';
} catch (e) {
debugPrint('[TELEMETRY] connectivity unavailable: $e');
}
var service = locationService;
if (service == null || service.isEmpty || service == 'unknown') {
try {
service = await Geolocator.isLocationServiceEnabled()
? 'enabled'
: 'disabled';
} catch (e) {
debugPrint('[TELEMETRY] location service unavailable: $e');
service = null;
}
}
return DeviceTelemetry(
battery: level,
isCharging: charging,
connection: connection,
locationService: service,
);
}
/// The heartbeat payload's own field names, ready to spread into it.
///
/// Only what was actually read: an absent key is a field the console draws as
/// unknown, which is the truth. A `0` battery or a `none` connection standing
/// in for "could not ask" is a fact somebody would act on.
Map<String, dynamic> toPayload() => <String, dynamic>{
if (battery != null) 'battery': '$battery',
if (isCharging != null) 'is_charging': isCharging,
if (connection != null && connection!.isNotEmpty) 'connection': connection,
if (locationService != null && locationService!.isNotEmpty)
'location_service': locationService,
};
@override
String toString() =>
'battery=$battery charging=$isCharging '
'connection=$connection location=$locationService';
}

24
lib/data/meal_run_mock.dart
View File

@@ -149,7 +149,7 @@ class MealRunMock {
lat: 11.0271,
lng: 76.9962,
kitchen: _vidhya,
bag: 'DG-1001',
label: 'DG-1001',
meals: 1,
),
_drop(
@@ -161,7 +161,7 @@ class MealRunMock {
lat: 11.0248,
lng: 76.9941,
kitchen: _vidhya,
bag: 'DG-1002',
label: 'DG-1002',
meals: 1,
),
_drop(
@@ -173,7 +173,7 @@ class MealRunMock {
lat: 11.0043,
lng: 76.9518,
kitchen: _vidhya,
bag: 'DG-1003',
label: 'DG-1003',
meals: 1,
),
_drop(
@@ -185,7 +185,7 @@ class MealRunMock {
lat: 11.0168,
lng: 76.9558,
kitchen: _vidhya,
bag: 'DG-1004',
label: 'DG-1004',
meals: 1,
),
_drop(
@@ -197,7 +197,7 @@ class MealRunMock {
lat: 10.9925,
lng: 77.0289,
kitchen: _vidhya,
bag: 'DG-1005',
label: 'DG-1005',
meals: 1,
),
@@ -211,7 +211,7 @@ class MealRunMock {
lat: 11.0181,
lng: 76.9603,
kitchen: _annapoorna,
bag: 'AM-2001',
label: 'AM-2001',
meals: 1,
),
_drop(
@@ -223,7 +223,7 @@ class MealRunMock {
lat: 10.9871,
lng: 76.9931,
kitchen: _annapoorna,
bag: 'AM-2002',
label: 'AM-2002',
meals: 1,
),
_drop(
@@ -235,7 +235,7 @@ class MealRunMock {
lat: 10.9903,
lng: 76.9977,
kitchen: _annapoorna,
bag: 'AM-2003',
label: 'AM-2003',
meals: 1,
),
_drop(
@@ -247,7 +247,7 @@ class MealRunMock {
lat: 11.0221,
lng: 76.9391,
kitchen: _annapoorna,
bag: 'AM-2004',
label: 'AM-2004',
meals: 1,
),
];
@@ -303,7 +303,7 @@ class MealRunMock {
int locationId,
})
kitchen,
required String bag,
required String label,
required int meals,
}) => <String, dynamic>{
// `MOCK-` so `purgeDemoRecords()` recognises anything that leaks into a
@@ -334,11 +334,11 @@ class MealRunMock {
// bag identity all key off these.
'kitchenid': kitchen.id,
'kitchenname': kitchen.name,
'baglabel': bag,
'baglabel': label,
// A drop, and how many boxes are in it. One order is one bag — the count
// here is the *meal* count inside that bag, and nothing reads it as a bag
// count. See [BagManifest].
// count. See [OrderManifest].
'type': 'delivery',
'deliveryqty': meals,
'quantity': meals,

83
lib/data/milk_run.dart
View File

@@ -102,7 +102,60 @@ class MilkRun {
// fabricated kitchen.
/// The stable key a stop groups under for pickup.
static String sourceKeyOf(Map<String, dynamic> stop) {
///
/// ── The address is the last witness, and it was not being asked ──
///
/// Id, then name, then `'none'` — and `'none'` is its own bucket per the note
/// above, on the sound principle that the app must not fabricate a kitchen.
///
/// What that missed is that a stop with no source id and no source name is
/// not a stop with no *place*. It still says where it is collected from: the
/// pickup address, which is on every row, and which two orders off the same
/// counter share exactly because it is the same counter.
///
/// The cost of not asking was visible on a real morning. Eight orders came
/// from one kitchen, seven carrying its id and one not, and the eighth could
/// not be grouped with its siblings — so it fell out of the dropdown into a
/// flat header of its own, titled with the customer's name, reading as a
/// second place the rider had to ride to. Seven bags in a list and one
/// stranded above it, off the same shelf.
///
/// Grouping by address is not a fabricated kitchen: it is the weakest true
/// statement available — *these are collected from the same address* — and it
/// is only reached when the two stronger ones are absent. A row with no
/// address at all still gets `'none'`, and still stands alone.
/// [within] is the rest of the day, when the caller has it. A stop that
/// names no counter **adopts the one its neighbours name at the same
/// address** — which is the half of this that the reported case actually
/// needed: seven of the eight carried the kitchen's id and the eighth carried
/// nothing, so keying the odd one out by its address alone still left it in a
/// bucket of its own, correctly grouped with nobody.
///
/// Only ever *adopts*, never overrides: a stop with its own identity is
/// keyed by it and does not consult the day at all. So two counters that
/// share a street cannot merge, and a row cannot be pulled away from the id
/// the hub gave it.
static String sourceKeyOf(
Map<String, dynamic> stop, {
List<Map<String, dynamic>> within = const [],
}) {
final own = _identityKeyOf(stop);
if (own.isNotEmpty) return own;
final place = _addressKey(stop);
if (place.isEmpty) return 'none';
for (final other in within) {
if (_addressKey(other) != place) continue;
final identified = _identityKeyOf(other);
if (identified.isNotEmpty) return identified;
}
return 'at:$place';
}
/// The counter this stop names for itself — `id:…`, `name:…`, or `''` when
/// the payload names none.
static String _identityKeyOf(Map<String, dynamic> stop) {
final id =
(stop['sourceid'] ??
stop['kitchenid'] ??
@@ -113,7 +166,25 @@ class MilkRun {
if (id.isNotEmpty && id != '0') return 'id:$id';
final name = sourceNameOf(stop).toLowerCase();
if (name.isNotEmpty) return 'name:$name';
return 'none';
return '';
}
/// A pickup address reduced to something two rows can be compared on.
///
/// Case, spacing and punctuation all vary between rows the same hub wrote —
/// `12, SNS Colony` and `12 SNS COLONY ` are one place — so everything but
/// the letters and digits is dropped before comparing. Deliberately not
/// `compactAddress`: that is written to be *read*, and a key should not
/// change because a display rule was tuned.
static String _addressKey(Map<String, dynamic> stop) {
final raw =
(stop['pickupaddress'] ??
stop['PickupAddress'] ??
stop['pickup_address'] ??
'')
.toString()
.toLowerCase();
return raw.replaceAll(RegExp(r'[^a-z0-9]'), '');
}
/// The kitchen's name as the rider reads it, or '' when the payload has none.
@@ -177,10 +248,14 @@ class MilkRun {
Map<String, dynamic> stop,
List<Map<String, dynamic>> stops,
) {
final key = sourceKeyOf(stop);
// The day is passed on both sides so a row that names no counter is
// gathered with the ones that do — see [sourceKeyOf]. Without it the bulk
// collect would leave behind exactly the order the route card had just
// learned to group in, which is the two-readers failure in a new place.
final key = sourceKeyOf(stop, within: stops);
return [
for (final s in stops)
if (sourceKeyOf(s) == key) s,
if (sourceKeyOf(s, within: stops) == key) s,
];
}

68
lib/data/order_events.dart
View File

@@ -131,10 +131,49 @@ Future<void> stampOrderEvent(
/// Stamps one event against several orders at once — a kitchen handover, an
/// accept-all, a released round.
Future<void> stampOrderEvents(Iterable<Object> orderIds, String event) async {
final at = DateTime.now();
for (final id in orderIds) {
await stampOrderEvent(id, event, at: at);
Future<void> stampOrderEvents(Iterable<Object> orderIds, String event) async =>
stampOrderEventsAndRead(orderIds, event);
/// [stampOrderEvents], and hands back the whole ledger it just wrote.
///
/// ── Why the batch is one read and one write ──
///
/// [stampOrderEvent] is a read-modify-write of the entire ledger, and the loop
/// that called it did that **once per order**. A rider holding sixty bookings
/// therefore paid sixty decodes and sixty encodes of a JSON blob that grows
/// with his day, on every poll — which is why the call site had to fire it into
/// the dark with `unawaited` and could never use the result.
///
/// It is used now: [WorkRepository] merges the assignment stamp back onto the
/// rows it just fetched, so "when did this reach me" is a fact on the stop
/// rather than a second store every screen has to join for itself. That needs
/// the ledger *after* the write, which is the other half of why this exists.
///
/// Still written once — an order that already carries [event] keeps the clock
/// it has.
Future<Map<String, Map<String, String>>> stampOrderEventsAndRead(
Iterable<Object> orderIds,
String event,
) async {
try {
final prefs = await SharedPreferences.getInstance();
final all = await _read(prefs);
final at = DateTime.now().toIso8601String();
var added = 0;
for (final raw in orderIds) {
final id = raw.toString().trim();
if (id.isEmpty) continue;
final mine = all.putIfAbsent(id, () => <String, String>{});
if (mine.containsKey(event)) continue;
mine[event] = at;
added++;
}
if (added > 0) await prefs.setString(_kKey, jsonEncode(all));
return all;
} catch (e) {
debugPrint('[EVENTS] could not stamp $event on a batch: $e');
return const {};
}
}
@@ -170,9 +209,24 @@ Future<void> clearOrderEvents(Object orderId) async {
///
/// The ledger is per-order and nothing prunes it on read, so without this it
/// grows for the life of the install — the same trap `removeCollectedOrderIds`
/// exists to avoid. Two days rather than one, because a shift that crosses
/// midnight must not lose its own morning.
Future<void> pruneOrderEvents({int keepDays = 2}) async {
/// exists to avoid.
///
/// ── Why two days was not enough once Home read this ──
///
/// It was two, on the reasoning that a shift crossing midnight must not lose
/// its own morning. That is the right floor for a *timeline*, which is all this
/// fed. It is the wrong floor for a **day filter**.
///
/// [OrderEvent.assigned] is now what dates a booking the backend dates with
/// nothing, and an order still sitting in the queue undecided carries that one
/// stamp and no other. At two days it was pruned on the third morning, the next
/// fetch stamped it afresh with *that* day's clock, and a booking from Monday
/// reappeared on Thursday's Home as Thursday's work — the precise failure the
/// filter was added to stop, arriving three days late.
///
/// A fortnight is well past any open booking's life, and the cost is a few
/// hundred bytes: the entry is an id and up to five short strings.
Future<void> pruneOrderEvents({int keepDays = 14}) async {
try {
final prefs = await SharedPreferences.getInstance();
final all = await _read(prefs);

114
lib/data/order_manifest.dart Normal file
View File

@@ -0,0 +1,114 @@
import 'package:miler/data/milk_run.dart';
import 'package:miler/views/Dashboard/pickups/stop_type.dart';
/// ─────────────────────────────────────────────────────────────────────────
/// WHAT THE RIDER COLLECTS AT A COUNTER, AS A LIST HE CAN COUNT
///
/// One pickup order is one handover. If a kitchen has five pickup orders the
/// rider is handed five things and ends up with five deliveries, each carrying
/// what it arrived in. That rule lives here so it cannot be stated two
/// different ways on two screens.
///
/// ── Why this is a file and not a `+ 1` at each call site ──
///
/// Every screen in the pickup half of the app has to answer "how many?" and
/// "which one is this?", and every screen that answered independently answered
/// differently: one showed a backend `Quantity` (an order's item count, not a
/// count of handovers), one showed a bare printed label when the payload
/// happened to carry one and nothing at all when it did not, and the kitchen
/// heading counted "meals". A rider standing at a counter comparing "5 meals"
/// on his phone with four items on the shelf has no way to tell which of the
/// two numbers is wrong.
///
/// So the count is **derived from the orders**, always, and there is no second
/// quantity anywhere that can disagree with it.
///
/// ── The invented numbering is gone ──
///
/// This used to name every line `Bag 1 … Bag n`, falling back to the order's
/// position in its group whenever the payload printed no label of its own. Two
/// things were wrong with that, and only the second is about the word.
///
/// The number was **the app's own invention presented as a physical fact**. It
/// counted positions in a list the app had built, and it was drawn as a tag in
/// the corner of every row where it read like something stencilled on a
/// container. A rider matching a shelf against it was matching against the
/// app's arithmetic, not against anything the kitchen had written; and the rail
/// beside it already numbers the same rows, so the tag mostly restated the node
/// two columns to its left in louder type.
///
/// A label the counter **actually printed** is a different thing entirely — it
/// is a fact about an object in front of him — so it survives, verbatim, under
/// whatever name the kitchen gave it. What is never done again is manufacturing
/// one where none exists.
///
/// Nothing here fabricates a crate, a tote or a quantity the backend has not
/// sent. If a future contract ever puts more than one handover on an order,
/// this is the one file that changes.
/// ─────────────────────────────────────────────────────────────────────────
class OrderManifest {
OrderManifest._();
/// One line per order: the stop, who it is for, and the label the counter
/// printed on it — empty when it printed none.
///
/// Deliberately carries the stop itself: every caller that renders a manifest
/// also needs to act on the orders behind it, and pairing them here is what
/// stops a screen from rendering five lines and posting four ids.
static List<ManifestLine> forGroup(List<Map<String, dynamic>> stops) => [
for (var i = 0; i < stops.length; i++)
ManifestLine(
stop: stops[i],
orderId: MilkRun.idOf(stops[i]),
customer: customerOf(stops[i]),
label: labelFor(stops[i]),
),
];
/// The label physically printed on one order's handover, or `''`.
///
/// Read straight off the payload and never derived. A counter that prints
/// nothing leaves this empty, and the row simply carries no tag — which is
/// honest, where a manufactured `Bag 4` was a shelf reference the shelf had
/// never heard of.
static String labelFor(Map<String, dynamic> stop) => stopPrintedLabel(stop);
/// `5 orders` — the load, in the unit everything else on the screen counts.
///
/// It printed `5 orders · 5 bags` once: the two halves of one rule side by
/// side, as a check the rider could eyeball. That cost the header the fact it
/// exists for — a real kitchen name plus `13 orders · 13 bags` pushed
/// `11 to accept` off the row — so it was cut to the physical half, `13 bags`.
///
/// Now that the app no longer names anything a bag, the surviving half is the
/// one the rest of the screen already speaks: the rows underneath are orders,
/// the chip counts orders, the hub assigns orders. One word, everywhere.
static String countLabel(int orders) =>
orders == 1 ? '1 order' : '$orders orders';
/// The name the order is going to, for a manifest line.
static String customerOf(Map<String, dynamic> stop) =>
(stop['pickupcustomer'] ??
stop['customername'] ??
stop['tenantname'] ??
'')
.toString()
.trim();
}
/// One row of a pickup manifest. See [OrderManifest.forGroup].
class ManifestLine {
final Map<String, dynamic> stop;
final String orderId;
final String customer;
/// What the counter printed on this order, or `''` when it printed nothing.
final String label;
const ManifestLine({
required this.stop,
required this.orderId,
required this.customer,
this.label = '',
});
}

92
lib/data/service_day.dart
View File

@@ -89,7 +89,22 @@ abstract final class ServiceDay {
'modifiedon',
'updatedat',
'expected_pickup_time',
'expectedpickuptime',
'createdat',
'createdon',
// ── Last, because it is the app's own guess and not the hub's record ──
//
// When the booking first appeared in this rider's queue, written by
// [WorkRepository] and merged onto the row there. It is the weakest answer
// on this list — a booking the rider's phone met for the first time this
// morning may have been raised last night — so every clock the backend
// actually sends outranks it.
//
// It is on the list because the alternative is worse. A row the backend
// dates with nothing is a row no screen can place, and the observable
// result was yesterday's assignments sitting on Home under a heading that
// says today. An approximate day beats no day.
'assignedat',
];
/// The service day [row] belongs to, or `''` when it carries nothing usable.
@@ -154,6 +169,83 @@ abstract final class ServiceDay {
return day == (now ?? today);
}
/// The rows of [stops] that belong to [now], for a screen that shows the
/// rider's **live** work — Home's run, Deliveries' queue.
///
/// ── Why the work screens needed this and Activity did not ──
///
/// `GET /miler/bookings` returns the rider's whole **open** set, not his day.
/// A booking assigned on Tuesday and never closed comes back on Wednesday and
/// on Thursday, so every screen built from that call was showing a week and
/// calling it today: yesterday's stops inside the kitchen dropdown, inside
/// the trip counts, inside the progress ring and inside the delivery queue.
///
/// Activity already filtered, with [belongsToToday], and that is why the two
/// halves of the app disagreed about the same order. This is the same
/// predicate, applied at the same kind of boundary — the fetch — so that
/// every figure a screen prints is computed from one set rather than each
/// widget filtering for itself. A filter inside a card would have left the
/// counts above it still totalling Tuesday.
///
/// ── The burden of proof is on the row ──
///
/// Undated rows go too, exactly as they do on Activity. They are rare now:
/// `ApiConfig.pickupFromBooking` carries every clock the backend sends
/// instead of dropping them at the adapter, and `WorkRepository` stamps
/// `assignedat` on everything still in front of the rider. A stop with no
/// date at all is one the app has never seen as open work, which is not this
/// morning's assignment.
///
/// ── One safety net, and it is deliberately narrow ──
///
/// If the day came back with rows and **not one of them** can be dated, that
/// is not a stale queue — it is the app having lost the ability to date
/// anything at all, and the answer to that is not to show a rider an empty
/// screen while his hub believes he has twenty stops. That case keeps
/// everything and says so in the log. One undated row among dated ones is a
/// data defect and is dropped; *every* row undated is a broken build, and
/// blanking the screen would hide it behind something that reads like good
/// news.
///
/// [where] names the caller in the log line, so two screens filtering the
/// same day are told apart. Nothing is deleted anywhere: this is a view
/// filter, and both local stores and the backend keep every record they had.
static List<Map<String, dynamic>> onlyToday(
List<Map<String, dynamic>> stops, {
String? now,
String where = 'DAY',
}) {
if (stops.isEmpty) return stops;
final day = now ?? today;
final kept = <Map<String, dynamic>>[];
var undated = 0;
for (final s in stops) {
if (of(s).isEmpty) {
undated++;
logUndated(s);
continue;
}
if (belongsToToday(s, now: day)) kept.add(s);
}
if (undated == stops.length) {
debugPrint(
'[$where] $day — not one of ${stops.length} stops carries a date. '
'Showing the lot rather than an empty day; check the adapter.',
);
return stops;
}
if (kept.length != stops.length) {
debugPrint(
'[$where] $day — kept ${kept.length} of ${stops.length} stops'
'${undated > 0 ? ' ($undated undated)' : ''}',
);
}
return kept;
}
/// The standard [belongsToToday] undated reporter: names the row, says which
/// fields were looked for, and stays out of release logs.
///

10
lib/data/service_profile.dart
View File

@@ -572,10 +572,12 @@ Future<ServiceProfile> resolveServiceProfile() async {
// patterns collide. Tenant 13 carrying a display name that normalises to
// `doormile` — which is, after all, the company that owns the tenant record —
// resolved that rider to Logistics and never consulted the id at all. On the
// Logistics line `_unreleased` is empty by design, so the **Start round** bar
// does not render, and once `MILER_COLLECTED_STATE_ENABLED` is on his
// collected parcels strand at `Collected_By_Miler` with no control to release
// them. A global flag gets one safe shot, and this was the loose end in it.
// Logistics line a rider has no customer round at all — he carries what he
// collects to the hub — so nothing in the app will ever call
// `start-delivery` for him. Once `MILER_COLLECTED_STATE_ENABLED` is on, a
// meal rider resolved onto Logistics has his collected orders strand at
// `Collected_By_Miler` with no control anywhere that releases them. A global
// flag gets one safe shot, and this was the loose end in it.
//
// A deliberate statement about a known tenant outranks a match on a word
// nobody on either side of the API controls the spelling of.

30
lib/data/stop_area.dart
View File

@@ -157,6 +157,36 @@ String areaOf(Map<String, dynamic> stop, {bool preferDrop = true}) {
return '';
}
/// Where a stop is **collected from**, as the payload writes it, or `''`.
///
/// ── Why this is not [areaOf] with `preferDrop: false` ──
///
/// [areaOf] answers "which neighbourhood", and deliberately throws away
/// everything that is not a locality name — which is the right answer for a
/// list of twenty stops and the wrong one for the counter the rider is riding
/// to. He needs the street to find the door.
///
/// Three screens were each reading the same four key names for this and one of
/// them, the route card, was reading none of them at all. One reader, so a
/// payload that spells it `pickup_address` cannot answer on the preview sheet
/// and stay blank on the card behind it.
///
/// Returns `''` rather than a placeholder: a card prints nothing where there is
/// no address, which is honest, where "Address not available" is a line of
/// furniture saying the app has failed.
String pickupAddressOf(Map<String, dynamic> stop) {
for (final key in const [
'pickupaddress',
'PickupAddress',
'pickup_address',
'address',
]) {
final raw = (stop[key] ?? '').toString().trim();
if (raw.isNotEmpty && raw.toLowerCase() != 'null') return raw;
}
return '';
}
/// A full address, minus the boilerplate a geocoder appends.
///
/// The record page prints the address in full — it is the one screen whose

83
lib/data/work_repository.dart
View File

@@ -228,23 +228,19 @@ class WorkRepository {
// it is the timeline contradicting itself in the rider's face. Anything the
// backend already reports as past his hands is skipped, and stays skipped
// forever because [stampOrderEvent] never overwrites.
unawaited(
stampOrderEvents(
mapped
.where((s) {
final st = stopStatusOf(s);
return !st.isWorkComplete &&
!st.isCancelled &&
!st.isRejected &&
!st.isSkipped &&
!st.isPicked &&
!st.isDeliveryLeg;
})
.map((s) => (s['orderid'] ?? '').toString())
.where((id) => id.isNotEmpty),
OrderEvent.assigned,
),
);
//
// ── And it is read back onto the row ──
//
// It used to be fired into the dark with `unawaited`: written for one
// screen's timeline, and joined by that screen alone. That left every other
// screen with no clock at all on a row the backend dates with nothing, and
// "does this belong to today" is a question three of them ask.
//
// So the stamp comes back as `assignedat` — a field on the stop, like any
// other. Awaited rather than fired off, because a row that reaches Home
// before its own clock does is a row Home cannot place, and the batch is
// one read and one write of a small blob. See [stampOrderEventsAndRead].
await _stampAssignment(mapped);
_loadedAt = DateTime.now();
return _publish(
@@ -286,6 +282,59 @@ class WorkRepository {
}
}
/// Writes each stop's assignment clock onto it, in place, as `assignedat`.
///
/// ── Which rows are stamped, and which only read ──
///
/// Only work still in front of the rider is *stamped* — see the note at the
/// call site: the ledger did not exist when a stop that is already delivered
/// arrived, so its first sighting is whenever the app happened to be opened,
/// and an `Assigned 3:34 PM` above a `Delivered 11:57 AM` is the timeline
/// contradicting itself.
///
/// Every row is **read**, though, finished ones included. A stop the rider
/// collected this morning was stamped this morning while it was still ahead
/// of him, and that clock is exactly what keeps it inside today's trip — drop
/// it and the progress ring loses its own denominator the moment the work is
/// done.
///
/// A backend clock always wins: this only fills a gap, never overwrites.
static Future<void> _stampAssignment(List<Map<String, dynamic>> day) async {
if (day.isEmpty) return;
try {
final ledger = await stampOrderEventsAndRead(
day
.where((s) {
final st = stopStatusOf(s);
return !st.isWorkComplete &&
!st.isCancelled &&
!st.isRejected &&
!st.isSkipped &&
!st.isPicked &&
!st.isDeliveryLeg;
})
.map((s) => (s['orderid'] ?? '').toString())
.where((id) => id.isNotEmpty),
OrderEvent.assigned,
);
if (ledger.isEmpty) return;
for (final stop in day) {
final id = (stop['orderid'] ?? '').toString().trim();
if (id.isEmpty) continue;
final at = ledger[id]?[OrderEvent.assigned];
if (at == null || at.isEmpty) continue;
final existing = (stop['assignedat'] ?? '').toString().trim();
if (existing.isNotEmpty) continue;
stop['assignedat'] = at;
}
} catch (e) {
// A day with no assignment clocks is a day the screens date by whatever
// the backend sent. Never worth failing the fetch over.
debugPrint('[WORK] could not read the assignment ledger: $e');
}
}
/// Turns a refused call into the thing the rider does about it.
static LoadFailureKind _classify(ApiResult res) => switch (res.status) {
0 => LoadFailureKind.offline,

36
lib/helpers/http_overrides.dart
View File

@@ -1,10 +1,36 @@
import 'dart:io';
/// ─────────────────────────────────────────────────────────────────────────
/// THE APP VALIDATES CERTIFICATES AGAIN
///
/// This class used to override `badCertificateCallback` to return `true` for
/// every certificate, on every host, and it was installed globally in three
/// places — `main`, the background isolate and the notification handler. That
/// is not a lenient setting; it is **TLS switched off**. Any network the rider's
/// phone joins could present a self-signed certificate for `api.doormile.com`
/// and the app would hand over his session token, his live position and the
/// day's cash figures without a word.
///
/// It is the kind of thing that gets added once to get past a staging server
/// and then ships. Both live hosts were checked before removing it and both
/// present valid, publicly-trusted certificates — `api.doormile.com` and
/// `queue.workolik.com` verify strictly under TLS 1.3 against Let's Encrypt.
/// Nothing needed the bypass.
///
/// ── What is left, and why the class is still here ──
///
/// Dart's default `HttpClient` already validates properly, so the honest
/// version of this override is one that changes nothing about trust. It stays
/// as a named place to put a real connection policy — a timeout, a proxy, a
/// pinned certificate — so that the next person who needs one has somewhere
/// obvious to put it that is not "turn the checks off".
///
/// **Never restore the callback.** If a host genuinely cannot present a valid
/// certificate, pin *that host's* certificate here; do not trust every host on
/// the internet to work around one.
/// ─────────────────────────────────────────────────────────────────────────
class MyHttpOverrides extends HttpOverrides {
@override
HttpClient createHttpClient(SecurityContext? context) {
return super.createHttpClient(context)
..badCertificateCallback =
(X509Certificate cert, String host, int port) => true;
}
HttpClient createHttpClient(SecurityContext? context) =>
super.createHttpClient(context);
}

11
lib/providers/Riderlog/riderlog_provider.dart
View File

@@ -125,6 +125,17 @@ Future<Map<String, dynamic>?> _heartbeat(Map data) async {
connection: _s(data['connection']).isEmpty
? null
: _s(data['connection']),
// ── This was being dropped on the floor ──
//
// Every other device field on the heartbeat was forwarded and this one
// was not, so `location_service` could never reach `/miler/logs` however
// faithfully the caller supplied it — and the console's Location Service
// column had no field to read. It is the single most useful thing on
// that panel: a rider who has turned location off explains his own
// silence, and nothing else on the row can.
locationService: _s(data['location_service']).isEmpty
? null
: _s(data['location_service']),
isBackground: data['is_background'] == true,
),
);

84
lib/test/tmp_m/m.dart
View File

@@ -1,84 +0,0 @@
import 'dart:ui' as ui;
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:miler/views/helpers/constants/Colorconstants.dart';
import 'package:miler/views/helpers/constants/Font_constant.dart';
/// Mirrors `_calloutBitmap` in map.dart so the drawing maths can be checked
/// headless — the real one is private to a State inside a `part` file.
Future<({int w, int h})> callout(String text, double dpr) async {
const double padH = 12, padV = 9, radius = 12, tail = 9, tailW = 14;
const double maxTextWidth = 190;
final painter = TextPainter(
text: TextSpan(
text: text,
style: TextStyle(
fontSize: 12 * dpr,
height: 1.25,
fontWeight: FontWeight.w600,
color: ColorConstants.slateText,
fontFamily: FontConstants.fontFamily,
),
),
maxLines: 2,
ellipsis: '…',
textDirection: TextDirection.ltr,
)..layout(maxWidth: maxTextWidth * dpr);
final w = painter.width + padH * 2 * dpr;
final h = painter.height + padV * 2 * dpr;
final totalH = h + tail * dpr;
final rec = ui.PictureRecorder();
final canvas = Canvas(rec);
final body = RRect.fromRectAndRadius(
Rect.fromLTWH(0, 0, w, h),
Radius.circular(radius * dpr),
);
canvas.drawRRect(
body.shift(Offset(0, 1.5 * dpr)),
Paint()
..color = Colors.black.withValues(alpha: 0.18)
..maskFilter = MaskFilter.blur(BlurStyle.normal, 3 * dpr),
);
canvas.drawRRect(body, Paint()..color = Colors.white);
final tip = Path()
..moveTo(w / 2 - tailW / 2 * dpr, h - 1)
..lineTo(w / 2, totalH)
..lineTo(w / 2 + tailW / 2 * dpr, h - 1)
..close();
canvas.drawPath(tip, Paint()..color = Colors.white);
canvas.drawRRect(
RRect.fromRectAndCorners(
Rect.fromLTWH(0, 0, 4 * dpr, h),
topLeft: Radius.circular(radius * dpr),
bottomLeft: Radius.circular(radius * dpr),
),
Paint()..color = ColorConstants.primary,
);
painter.paint(canvas, Offset(padH * dpr + 2 * dpr, padV * dpr));
final img = await rec.endRecording().toImage(w.ceil(), totalH.ceil());
final bytes = await img.toByteData(format: ui.ImageByteFormat.png);
if (bytes == null) throw StateError('no png');
return (w: img.width, h: img.height);
}
void main() {
testWidgets('callout rasterises at every dpr', (tester) async {
for (final dpr in [1.0, 2.0, 3.0]) {
final r = await callout('18, Chinnavedampatti Road, Coimbatore', dpr);
print('dpr=$dpr ${r.w}x${r.h}px');
expect(r.w, greaterThan(0));
expect(r.h, greaterThan(0));
}
// A very long address must clamp, not grow without bound.
final long = await callout(
'Plot 42B, Second Cross Street, Behind Sri Ramakrishna Mills, '
'Ganapathy Post, Coimbatore, Tamil Nadu 641006',
3.0,
);
print('long address at dpr=3: ${long.w}x${long.h}px');
expect(long.w, lessThanOrEqualTo((190 + 24) * 3 + 2));
});
}

187
lib/views/Dashboard/home/homepage.dart
View File

@@ -64,12 +64,13 @@ import 'package:miler/views/Dashboard/pickups/collect_payment.dart';
import 'package:miler/views/Dashboard/pickups/stop_type.dart';
import 'package:miler/widget/Bottom_page.dart';
import 'package:miler/data/meal_run_mock.dart';
import 'package:miler/data/bag_manifest.dart';
import 'package:miler/data/order_manifest.dart';
import 'package:miler/data/milk_run.dart';
import 'package:miler/data/order_events.dart';
import 'package:miler/data/work_domain.dart';
import 'package:miler/data/work_repository.dart';
import 'package:miler/data/pickup_locations.dart';
import 'package:miler/data/service_day.dart';
import 'package:miler/data/service_profile.dart';
import 'package:miler/views/helpers/constants/miler_type.dart';
import 'package:miler/views/Dashboard/home/pickup_preview_sheet.dart';
@@ -241,9 +242,22 @@ class _HomepageState extends State<Homepage>
Set<String> _closedIds = <String>{};
Set<String> _rejectedIds = <String>{};
/// Notices when the day underneath the screen has moved on.
///
/// [_fetchQueues] filters against `ServiceDay.today` *as read at fetch time*,
/// so the route on screen is only ever as fresh as the last fetch. See
/// [_rolloverCheck].
final ServiceDayRollover _day = ServiceDayRollover();
/// Fires at the next local midnight. See [_armRollover].
Timer? _rollover;
/// Which trip tab is open.
int _selectedTripIndex = 0;
/// True once the rider has picked a tab himself. See [_settleTripTab].
bool _tripTabChosen = false;
/// Stops the rider has ticked, for "accept just these".
Set<String> _selectedStopIds = <String>{};
@@ -258,6 +272,7 @@ class _HomepageState extends State<Homepage>
}
_pollerSubscription?.cancel();
_locationTimer?.cancel();
_rollover?.cancel();
_httpClient.close();
super.dispose();
}
@@ -271,6 +286,7 @@ class _HomepageState extends State<Homepage>
_ensureLocationPermission();
_ensureCameraPermission();
_startPolling();
_armRollover();
// What the counters are actually called, joined on the location id the
// booking already carries. One request, cached, and every failure resolves
// to "use the row's own name" — see [PickupLocations].
@@ -971,6 +987,11 @@ class _HomepageState extends State<Homepage>
@override
void didChangeAppLifecycleState(AppLifecycleState state) {
super.didChangeAppLifecycleState(state);
// Before the early return below: a resume inside the same foreground state
// still has to notice a midnight that passed while the phone was in the
// rider's pocket, and that is the case the timer cannot cover — both
// platforms suspend timers in the background.
if (state == AppLifecycleState.resumed) _rolloverCheck();
final bool foreground = state == AppLifecycleState.resumed;
if (foreground == _pollForeground) return;
_pollForeground = foreground;
@@ -1175,7 +1196,15 @@ class _HomepageState extends State<Homepage>
// are still on the rider's route — their parcels are still to be
// collected and their kilometres still to be ridden. The route brief
// must count them or it understates the day.
final acceptedStops = await getAcceptedBookings();
// Through the day filter as well. The accepted store is deliberately
// *not* pruned to today — it is "what have I taken on", and an id set
// that forgets a stop would flip that stop back to pending under the
// rider's thumb — but the route brief above the run is a statement about
// **this** day's kilometres and parcels. Yesterday's accepted-and-unclosed
// booking belongs in the set and not in that total.
//
// Only the rows are filtered; `acceptedIds` above is left whole.
final acceptedStops = _todayOnly(await getAcceptedBookings());
if (mounted && acceptedStops.length != _acceptedStops.length) {
setState(() => _acceptedStops = acceptedStops);
} else {
@@ -1192,7 +1221,9 @@ class _HomepageState extends State<Homepage>
//
// Accepted stops still also appear on Bookings — that is where he WORKS
// them. Home is where he watches the trip fill up.
final allStops = items.whereType<Map<String, dynamic>>().toList();
final allStops = _todayOnly(
items.whereType<Map<String, dynamic>>().toList(),
);
// ── The skip store is the truth about what is parked ──
//
@@ -1311,6 +1342,8 @@ class _HomepageState extends State<Homepage>
}
}
});
// After the state is applied, because the slots are derived from it.
_settleTripTab();
} catch (e) {
debugPrint('[FETCH_QUEUES] Error: $e');
if (mounted) setState(() => _fetchFailed = true);
@@ -1322,6 +1355,108 @@ class _HomepageState extends State<Homepage>
}
}
/// Opens Home on a tab that has work on it.
///
/// ── Why this became necessary ──
///
/// The tab index is a **day part**, not a position: slot 0 is the morning
/// whether or not the rider has morning work. That is the right model, and
/// while nothing could place a trip by day part it cost nothing — every trip
/// fell into the undated bucket and landed on Trip 1, so Trip 1 was where the
/// work was.
///
/// Now that [Trip.dayPartTimeOf] can place them, a rider whose whole day is
/// an afternoon run has his work under Trip 2 — correctly — and Home opened
/// on Trip 1 and told him his hub had assigned him nothing. The fix for one
/// screen must not hand him a worse version of the same lie.
///
/// So the landing tab is the first slot that actually holds stops. Three
/// things keep it from fighting the rider:
///
/// • It gives up the moment he taps a tab himself — [_tripTabChosen]. An
/// empty Trip 3 he chose deliberately is an answer he asked for.
/// • It gives up the moment the tab it is on has work, so it lands once and
/// then stops moving under him.
/// • It never *hides* a slot. The tabs still show all three, empty ones
/// included, because "the day has room left in it" is a fact he plans
/// around.
void _settleTripTab() {
if (_tripTabChosen || !mounted) return;
final trips = _trips;
final here = trips.tripAt(_selectedTripIndex);
if (here != null && here.stops.isNotEmpty) return;
final slots = trips.slots;
for (var i = 0; i < slots.length; i++) {
final t = slots[i];
if (t == null || t.stops.isEmpty) continue;
if (i != _selectedTripIndex) {
setState(() {
_selectedTripIndex = i;
_selectedStopIds.clear();
});
}
return;
}
}
/// ── Home is today's work, and only today's ──
///
/// The rule, and the reasoning behind every part of it, is
/// [ServiceDay.onlyToday] — shared with the Deliveries queue, because the two
/// screens showing the rider's live work must not disagree about which day it
/// is. What is local here is only *which* day: the one the screen is
/// currently showing, adopted so the midnight check below compares against
/// the pixels rather than reading the wall clock twice.
List<Map<String, dynamic>> _todayOnly(List<Map<String, dynamic>> stops) {
_day.rollIfNeeded();
return ServiceDay.onlyToday(stops, now: _day.day, where: 'HOME');
}
/// ── The day ending under a screen that is already open ──
///
/// [ServiceDay] answers "which day is this row" at read time, which is right
/// for the data and not sufficient for the screen: [_fetchQueues] filters
/// against the day *as read when it ran*. A rider who leaves Home open
/// through 23:59, or backgrounds the app on it and picks the phone up at six,
/// is looking at a route filtered against a day that has ended.
///
/// Two triggers, because a phone gives no single reliable one — a timer to
/// the next local midnight for the app left in the foreground, and resume for
/// every other case. Both land in [_rolloverCheck], which is idempotent.
/// The same arrangement `ActivityPage` uses, for the same reason.
void _armRollover() {
_rollover?.cancel();
_rollover = Timer(_day.untilNextDay, _rolloverCheck);
}
/// Turns Home over when the service day has moved on.
///
/// Yesterday's stops are cleared **before** the refetch, not after it. A new
/// day starts empty even with no signal, because the alternative is a rider
/// in a dead spot at six in the morning reading yesterday's route as today's
/// assignment — the exact failure this exists to stop. Anything that really
/// is the new day's comes straight back from the fetch.
void _rolloverCheck() {
if (!mounted) return;
_armRollover();
if (!_day.rollIfNeeded()) return;
setState(() {
_allTripStops = <Map<String, dynamic>>[];
_ordersMap = <String, Map<String, dynamic>>{};
_orderIds = <String>[];
_selectedOrders = <String, bool>{};
_selectedStopIds = <String>{};
_acceptedStops = <Map<String, dynamic>>[];
isAllSelected = false;
// The fetch short-circuits on an unchanged payload, and the payload has
// not changed — only the day it is read against has. Clearing the key is
// what lets the new day's answer through.
_lastQueuesJson = '';
});
_fetchQueues();
}
/// See [HomepageArrivalPrecedence]. Kept as a one-line forwarder so the call
/// site reads the same as it did while the rule itself is reachable from a
/// test — a precedence contract that can only be exercised by building the
@@ -1388,14 +1523,21 @@ class _HomepageState extends State<Homepage>
...await getSkippedOrderIds(),
};
final activeOrders = itemsV2.whereType<Map<String, dynamic>>().where((
booking,
) {
final status = (booking['orderstatus']?.toString().toLowerCase() ?? '')
.trim();
if (status != 'active') return false;
return !closedIds.contains((booking['orderid'] ?? '').toString());
}).toList();
// ── Through the same day filter as the queue ──
//
// These are merged into the trip by [_tripStops], and a row this call
// carries that the queue does not is **appended** — so an unfinished
// stop still reporting `active` from a shift two days ago walked past
// [_todayOnly] and back onto Home through the side door, wearing a LIVE
// mark. One day, one rule, however the row arrived.
final activeOrders = _todayOnly(
itemsV2.whereType<Map<String, dynamic>>().where((booking) {
final status =
(booking['orderstatus']?.toString().toLowerCase() ?? '').trim();
if (status != 'active') return false;
return !closedIds.contains((booking['orderid'] ?? '').toString());
}).toList(),
);
if (mounted) {
setState(() {
@@ -2048,7 +2190,7 @@ class _HomepageState extends State<Homepage>
stage: rung,
placeName: place,
count: ids.length,
lines: BagManifest.forGroup(batch),
lines: OrderManifest.forGroup(batch),
onConfirm: (outcome) async {
setState(() => _busyStopIds.addAll(ids));
try {
@@ -2069,9 +2211,9 @@ class _HomepageState extends State<Homepage>
}
if (refusal != null) return refusal;
if (rung == StopStatus.arrived) {
await saveBagLabels({
for (final line in BagManifest.forGroup(loaded))
line.orderId: line.bag,
await saveOrderLabels({
for (final line in OrderManifest.forGroup(loaded))
line.orderId: line.label,
});
}
if (missing.isNotEmpty) {
@@ -2230,8 +2372,8 @@ class _HomepageState extends State<Homepage>
count: ids.length,
// Named, with the bag each one travels in — this is the list he checks
// against the shelf in front of him. One order, one bag; see
// [BagManifest].
lines: BagManifest.forGroup(stops),
// [OrderManifest].
lines: OrderManifest.forGroup(stops),
onConfirm: (outcome) async {
setState(() => _busyStopIds.addAll(ids));
try {
@@ -2259,11 +2401,11 @@ class _HomepageState extends State<Homepage>
// Joe is Bag 1 of the five that left this counter. Deriving that
// later from whatever list is on screen breaks it the moment one is
// delivered, so it is written down at the one moment it is true and
// read back unchanged for the rest of the round. See [BagManifest].
// read back unchanged for the rest of the round. See [OrderManifest].
if (action == SelectionAction.pickUp) {
await saveBagLabels({
for (final line in BagManifest.forGroup(loaded))
line.orderId: line.bag,
await saveOrderLabels({
for (final line in OrderManifest.forGroup(loaded))
line.orderId: line.label,
});
}
if (missing.isNotEmpty) {
@@ -3738,6 +3880,9 @@ class _HomepageState extends State<Homepage>
// Trip 1 must not be counted by the bar while Trip 2
// is on screen. See [_selectedPendingIds].
onSelect: (index) {
// His choice from here on, even if it is an empty
// slot — see [_settleTripTab].
_tripTabChosen = true;
if (index == _selectedTripIndex) return;
setState(() {
_selectedTripIndex = index;

83
lib/views/Dashboard/home/pickup_preview_sheet.dart
View File

@@ -3,7 +3,8 @@ import 'package:lucide_icons_flutter/lucide_icons.dart';
import 'package:flutter_screenutil/flutter_screenutil.dart';
import 'package:latlong2/latlong.dart' show LatLng;
import 'package:miler/data/bag_manifest.dart';
import 'package:miler/data/stop_area.dart';
import 'package:miler/data/order_manifest.dart';
import 'package:miler/views/helpers/constants/miler_surface.dart';
import 'package:miler/views/Dashboard/pickups/route_metrics.dart';
import 'package:miler/views/Dashboard/pickups/stop_type.dart';
@@ -53,7 +54,7 @@ import 'package:miler/views/helpers/widgets/miler_sheet_kit.dart';
/// [ ➤ Start navigation ] [ 📞 ]
/// ```
///
/// The manifest is read straight off [BagManifest] — the same source as the
/// The manifest is read straight off [OrderManifest] — the same source as the
/// card, the confirmation sheet and the row, so the number he checks against the
/// shelf cannot differ between the screen he decided on and the screen he
/// confirms on. **One order is one bag**, here as everywhere.
@@ -63,7 +64,7 @@ class PickupPreviewSheet extends StatelessWidget {
final String placeName;
/// Every order the rider collects here, in route order.
final List<BagLine> lines;
final List<ManifestLine> lines;
/// Straight-line metres from the rider to the place. Null when unknown —
/// nothing is invented, exactly as on the card.
@@ -100,7 +101,7 @@ class PickupPreviewSheet extends StatelessWidget {
static Future<void> show(
BuildContext context, {
required String placeName,
required List<BagLine> lines,
required List<ManifestLine> lines,
required double? meters,
required Duration ride,
double? riderLat,
@@ -147,20 +148,13 @@ class PickupPreviewSheet extends StatelessWidget {
/// every order here shares one counter, so they share one address, and
/// taking both from the same row means the pin and the words can never
/// describe different places.
String get _address {
if (lines.isEmpty) return '';
final stop = lines.first.stop;
for (final key in const [
'pickupaddress',
'PickupAddress',
'pickup_address',
'address',
]) {
final raw = (stop[key] ?? '').toString().trim();
if (raw.isNotEmpty && raw.toLowerCase() != 'null') return raw;
}
return '';
}
///
/// The four key names it reads live in [pickupAddressOf] now, shared with the
/// route card behind this sheet — the card had no address at all while this
/// one did, and a counter that is named on the sheet and anonymous on the
/// card is the same payload answering two different questions.
String get _address =>
lines.isEmpty ? '' : pickupAddressOf(lines.first.stop);
static double _d(dynamic v) {
if (v == null) return 0;
@@ -438,32 +432,37 @@ class PickupPreviewSheet extends StatelessWidget {
),
),
),
SizedBox(width: 10.w),
// Ranked under the name, exactly as on the route
// The counter's own printed label, where there is
// one. Ranked under the name, exactly as on the route
// timeline: w700 slate against a w500 mid-tone name
// made a column of shelf references the first thing
// read on a manifest of people.
Container(
padding: EdgeInsets.symmetric(
horizontal: 7.w,
vertical: 3.h,
),
decoration: BoxDecoration(
color: MilerSurface.canvas,
borderRadius: BorderRadius.circular(
DesignConstants.radiusLg,
// made a column of references the first thing read on
// a manifest of people. Absent on a route whose
// counters print nothing, which is most of them — the
// row is then the person, which is what it is for.
if (line.label.isNotEmpty) ...[
SizedBox(width: 10.w),
Container(
padding: EdgeInsets.symmetric(
horizontal: 7.w,
vertical: 3.h,
),
decoration: BoxDecoration(
color: MilerSurface.canvas,
borderRadius: BorderRadius.circular(
DesignConstants.radiusLg,
),
),
child: Text(
line.label,
maxLines: 1,
style: MilerType.label.copyWith(
fontSize: 12.sp,
fontWeight: FontWeight.w600,
color: ColorConstants.secondaryText,
),
),
),
child: Text(
line.bag,
maxLines: 1,
style: MilerType.label.copyWith(
fontSize: 12.sp,
fontWeight: FontWeight.w600,
color: ColorConstants.secondaryText,
),
),
),
],
],
),
),
@@ -474,7 +473,7 @@ class PickupPreviewSheet extends StatelessWidget {
),
SizedBox(height: 8.h),
Text(
BagManifest.countLabel(lines.length),
OrderManifest.countLabel(lines.length),
style: MilerType.micro.copyWith(
fontSize: 12.5.sp,
fontWeight: FontWeight.w600,

370
lib/views/Dashboard/home/route_timeline.dart
View File

@@ -2,7 +2,7 @@ import 'package:flutter/material.dart';
import 'package:lucide_icons_flutter/lucide_icons.dart';
import 'package:flutter_screenutil/flutter_screenutil.dart';
import 'package:miler/data/bag_manifest.dart';
import 'package:miler/data/order_manifest.dart';
import 'package:miler/views/helpers/constants/miler_surface.dart';
import 'package:miler/data/service_profile.dart';
import 'package:miler/data/stop_area.dart';
@@ -87,7 +87,7 @@ import 'package:miler/views/helpers/constants/miler_type.dart';
/// One pickup place and every order the rider collects there.
///
/// Built by the page from the trip's own stops — this holds no state of its
/// own and derives no counts. The bag lines come from [BagManifest.forGroup],
/// own and derives no counts. The bag lines come from [OrderManifest.forGroup],
/// which is the single source for "how many bags" and "which bag": the count is
/// `orders.length` because a bag is what an order arrives in, and the identity
/// is the printed label or the order's position **in this group**. The timeline
@@ -101,6 +101,26 @@ class RouteGroup {
/// which case the group is drawn flat (see [RouteTimeline]).
final String name;
/// The street the counter is on — where [name] actually is.
///
/// ── Why a name was not enough ──
///
/// The card gave the place a name, a load and a distance, and then expected
/// the rider to know where "Vidhya Kitchen" is. He often does; on his first
/// week, or on a kitchen the hub added yesterday, he does not — and the only
/// way to the address was to tap through to the preview sheet, which is a
/// sheet and a dismiss to answer *where am I going*, the plainest question
/// the card exists for.
///
/// It sits directly above the load, so the header reads as one descending
/// statement: **what this place is, where it is, what is waiting there**.
/// Put below the load it would have separated the counts from the journey
/// figures they are read against.
///
/// Empty is normal and prints nothing — a payload without an address, or a
/// flat stop whose own name already *is* the address.
final String location;
/// The orders still shown on Home, in route order.
final List<Map<String, dynamic>> stops;
@@ -112,7 +132,7 @@ class RouteGroup {
/// the rider has collected Bag 1 and it leaves Home, numbering the four that
/// remain from the visible list would renumber Bag 2 as Bag 1 — and he would
/// be reading a different number off the phone from the one printed on the
/// shelf. See [BagManifest].
/// shelf. See [OrderManifest].
final List<Map<String, dynamic>> allStops;
/// The trip index of the first stop, for travel time and for numbering.
@@ -207,6 +227,7 @@ class RouteGroup {
const RouteGroup({
required this.key,
required this.name,
this.location = '',
required this.stops,
required this.allStops,
required this.firstIndex,
@@ -256,17 +277,17 @@ class RouteGroup {
/// The manifest is built from [allStops] and then filtered, never built from
/// [stops]: the count and the identity both come from the pickup group the
/// rider was handed, not from whatever is left of it.
List<BagLine> get manifest {
List<ManifestLine> get manifest {
final shown = {for (final s in stops) (s['orderid'] ?? '').toString()};
return [
for (final line in BagManifest.forGroup(allStops))
for (final line in OrderManifest.forGroup(allStops))
if (shown.contains(line.orderId)) line,
];
}
/// `5 orders · 5 bags`. The two halves of the rule, side by side, so the
/// rider can check the shelf against the phone without doing arithmetic.
String get countLabel => BagManifest.countLabel(stops.length);
String get countLabel => OrderManifest.countLabel(stops.length);
/// Orders off this counter the rider has not taken on yet.
int get pendingCount =>
@@ -1200,7 +1221,7 @@ class PickupTimelineGroup extends StatelessWidget {
}
if (group.isSettled) {
final n = group.allStops.length;
return '$n ${n == 1 ? 'bag' : 'bags'} collected';
return n == 1 ? '1 collected' : '$n collected';
}
return <String>[
// ── A flat node is a stop, and a stop has a position ──
@@ -1210,12 +1231,24 @@ class PickupTimelineGroup extends StatelessWidget {
// in the run — the trip's own index, which does **not** renumber as stops
// finish, so a stop is never renamed mid-shift.
if (group.flat) 'Stop ${group.firstIndex + 1}' else group.countLabel,
// How much of this counter is not his yet. A group can hold one accepted
// order and one still pending, and the count above cannot say so alone.
if (!group.flat &&
group.pendingCount > 0 &&
group.pendingCount < group.stops.length)
'${group.pendingCount} to accept',
// ── How much of this counter is still waiting on him ──
//
// The chip beside it states the group's **own rung** with a fraction —
// `Pending 8/8` on an untouched counter, `Accepted 1/2` on one he has
// started. That answers the all-pending case, which used to say nothing
// at all: a fresh morning where the card read `Pending` and `10 bags` and
// left the rider to join them into *ten decisions are waiting on me*.
//
// It cannot answer the **mixed** case, and that is what this clause is
// for. A group holding one accepted order and one pending one is on the
// accepted rung, so the chip says `Accepted 1/2` — true, and silent about
// the one still to decide. The two never overlap: this appears only when
// some but not all of the counter is pending, which is precisely when the
// chip is showing a different rung.
// ── The selection count is not stated here ──
//
// It used to append `· 5 selected`, which made this the **third** place
@@ -1253,6 +1286,10 @@ class PickupTimelineGroup extends StatelessWidget {
final journey = rejected || group.isSettled ? '' : group.journeyLabel;
final showJourney = journey.isNotEmpty && twoColumn;
// Suppressed on a place the rider has finished with and on one he declined:
// the address is wayfinding, and there is nowhere left to go.
final location = rejected || group.isSettled ? '' : group.location;
final load = [
_loadLine(chosen),
if (journey.isNotEmpty && !twoColumn) journey,
@@ -1361,7 +1398,12 @@ class PickupTimelineGroup extends StatelessWidget {
// rider needs them: where, how much, how far. Unaffected by
// the two-column break — a reader hears the same three facts
// either way.
label: [group.name, load, if (showJourney) journey].join(', '),
label: [
group.name,
if (location.isNotEmpty) location,
load,
if (showJourney) journey,
].join(', '),
// The non-flat hint said "Opens the pickup preview" — a
// sentence about a tap this header stopped owning when the
// preview moved to the utility circle. A wrong hint is worse
@@ -1472,6 +1514,49 @@ class PickupTimelineGroup extends StatelessWidget {
// that row was already spending on a `Spacer`. Same
// reading order — identity, load, state — and the
// geometry is now identical in every state.
// ── Where the counter is, above what is on it ──
//
// Between the name and the load, because that is
// the order the questions arrive in: which place,
// where is it, how much is waiting. A pin rather
// than a label — "Pickup location" would be a word
// spent saying what the glyph and the position
// already say.
//
// Two lines, matching the name above it: real
// Coimbatore addresses are long, and an address cut
// to `Gandhipuram Main…` answers nothing a blank
// line would not have answered. Set in the page's
// quiet grey — it is orientation, not a figure the
// rider acts on.
if (location.isNotEmpty) ...[
SizedBox(height: 3.h),
Row(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Padding(
padding: EdgeInsets.only(top: 1.h),
child: Icon(
LucideIcons.mapPin,
size: 12.sp,
color: ColorConstants.secondaryText,
),
),
SizedBox(width: 5.w),
Flexible(
child: Text(
location,
maxLines: 2,
overflow: TextOverflow.ellipsis,
style: MilerType.micro.copyWith(
fontSize: 12.5.sp,
color: ColorConstants.secondaryText,
),
),
),
],
),
],
SizedBox(height: 4.h),
Row(
children: [
@@ -1620,23 +1705,38 @@ class PickupTimelineGroup extends StatelessWidget {
// silence was worse than the repetition: a rider scanning a run had to
// infer "not mine yet" from the *absence* of a word, which is the one thing
// a glance cannot do.
// ── Pending is neutral, because nothing has gone wrong ──
// ── Pending has its own amber, and it is not the warning one ──
//
// It was amber, on the argument that undecided work "wants something" and
// should therefore be visible. The argument is right about visibility and
// wrong about the colour: amber is this app's exception hue — a skipped
// stop, a late run, a bag that never arrived — and on a fresh morning every
// kitchen is pending, so the whole screen opened in warning.
// It was grey, and before that it was [ColorConstants.warning]. Both were
// half right. Grey said "nothing has gone wrong", which is true; warning
// said "this wants something from you", which is also true — and warning
// is the hue this app spends on a skip, a short payment, a bag that never
// came, so a morning where every kitchen is pending opened the whole screen
// in exception and taught the rider to stop reading the colour.
//
// A state that is true of *all* the work is not an exception; it is the
// starting condition. Spending the attention colour on it leaves nothing
// to say with when a stop genuinely does go wrong, and a rider who sees
// amber on every group learns to stop reading it. Neutral, and the reason
// it is still readable is that it sits on its own metadata line rather
// than competing with the kitchen name.
StopState.pending => const _StateWord(
label: 'Pending',
color: ColorConstants.secondaryText,
// [ColorConstants.pendingAmber] is the third answer: a gold that reads as
// *waiting* rather than as *wrong*, far enough from the burnt orange of
// warning that Pending and Skipped are two distinct marks down a run. The
// words differ too; this is what makes them differ at a glance.
// ── And it says how many ──
//
// A bare `Pending` made the rider join two facts to get the one he wants.
// The card said `Pending` and, twenty points above, `10 orders · 10 bags`;
// *ten decisions are waiting on me* was the arithmetic between them, and on
// a fresh morning — every group pending, nothing accepted — that was the
// whole screen asking him to do it.
//
// Stated as a fraction because that is what Accepted has always done here,
// and the two must read as one vocabulary: `Pending 10/10` on a counter
// untouched, `Pending 2/4` on one half-taken, `Accepted 2/4` from the other
// side of the same decision. The bare word survives where a fraction would
// be noise — a flat parcel stop is one order, and `Pending 1/1` says
// nothing `Pending` does not.
StopState.pending => _StateWord(
label: group.groupSize > 1
? 'Pending ${group.pendingCount}/${group.groupSize}'
: 'Pending',
color: ColorConstants.pendingAmber,
),
// ── "Accepted" alone does not say how much of the counter he took ──
//
@@ -1649,19 +1749,25 @@ class PickupTimelineGroup extends StatelessWidget {
// Only where there is more than one order to be a fraction of — a parcel
// route is one order per place, and `Accepted (1 of 1)` is noise.
StopState.accepted => _StateWord(
// Brand only on the group he is riding to; slate on the ones he has taken
// but is not working. Red marks the mission, not the commitment — and it
// is now the only thing on the card that can be confused with amber, so
// the two states read apart at a glance.
// ── Accepted is green ──
//
// It was brand red on the group being ridden to and slate on the rest,
// which made the word carry two facts at once — *taken on* and *this is
// the one you are working* — and the second was the louder of them. A
// rider glancing down a run read the red as the state.
//
// Green says the one thing the word is for: this is yours, it is settled,
// nothing here needs deciding. Which one he is *on* is already said three
// ways that do not need a hue — the lit node, the larger title, and the
// Navigate button that only the current place carries.
//
// `Accepted (2 of 4)` truncated to `Accepted (2 o…` the moment the row
// also carried Navigate, Call and the "i" — which is every accepted
// group. A state that ellipsises has lost the number it exists to state.
label: group.groupSize > 1
? 'Accepted ${group.onRungCount}/${group.groupSize}'
: 'Accepted',
color: isCurrent
? ColorConstants.primary
: ColorConstants.onSurfaceVariant,
color: ColorConstants.acceptGreen,
),
// ── The one the rider must not miss ──
//
@@ -1674,9 +1780,19 @@ class PickupTimelineGroup extends StatelessWidget {
// fact is *this is the one he is on* — and each says which rung it is.
StopState.arrived => const LiveMark(label: 'Arrived'),
StopState.active => const LiveMark(),
// ── Picked is blue, now that green means accepted ──
//
// It was green, back when green was free. It cannot stay green beside an
// accepted state that is also green: the two rungs a rider most needs to
// tell apart on one counter — *taken on* and *in my hands* — would be one
// colour and two words.
//
// Blue is not an arbitrary third: it is [ColorConstants.deliveryAccent],
// what this app already paints the delivery leg in, and a picked bag has
// become exactly that. The colour says where the work went.
StopState.collected || StopState.done => const _StateWord(
label: 'Collected',
color: ColorConstants.acceptGreen,
color: ColorConstants.pickedBlue,
),
// ── The two ends of "not going to happen here" ──
//
@@ -1715,7 +1831,7 @@ class PickupTimelineGroup extends StatelessWidget {
// ── The body: the journey, the selection helper, then the milestones ─────
Widget _body(BuildContext context, List<BagLine> manifest, int chosen) {
Widget _body(BuildContext context, List<ManifestLine> manifest, int chosen) {
final ids = _choosableIds;
final selectable = _isChoosable(group.state) && onToggleSelect != null;
@@ -1864,7 +1980,7 @@ class PickupTimelineGroup extends StatelessWidget {
/// bag* — the two facts he matches against a shelf — and everything else is one
/// tap away in the sheet that already exists.
class PickupTimelineStep extends StatelessWidget {
final BagLine line;
final ManifestLine line;
/// 1-based position **within its own pickup group**, which is also its bag
/// position when the kitchen printed no label. Never route-global.
@@ -2013,9 +2129,7 @@ class PickupTimelineStep extends StatelessWidget {
child: Semantics(
button: true,
checked: selectable ? selected : null,
label: selectable
? 'Select $customer, ${line.bag}'
: '$customer, ${line.bag}',
label: selectable ? 'Select $customer' : customer,
excludeSemantics: true,
child: InkWell(
onTap: selectable && !busy
@@ -2070,7 +2184,11 @@ class PickupTimelineStep extends StatelessWidget {
),
),
_OrderOpenBlock(
bag: rejected ? 'Rejected' : line.bag,
// The counter's own printed label when there is one,
// and the word `Rejected` where the row has been
// declined. Never an invented number — see
// [OrderManifest.labelFor].
label: rejected ? 'Rejected' : line.label,
orderId: line.orderId,
selected: selected,
onTap: canOpen ? onOpen : null,
@@ -2087,23 +2205,34 @@ class PickupTimelineStep extends StatelessWidget {
}
}
/// `Bag 1 ›` over the order's own id — the step's way into its detail sheet.
/// The step's way into its detail sheet: the counter's printed label, when
/// there is one, and the chevron that opens the order.
///
/// One block rather than three loose elements, because they answer one
/// question between them: *which order is this, and show me it*. The chevron is
/// the affordance; the bag and the id are what it is about.
/// ── It used to manufacture a reference ──
///
/// The tag read `Bag 1 … Bag n`, falling back to the order's position in its
/// group whenever the payload printed nothing — so on the common route, where
/// no counter prints labels, every row carried a shelf reference the shelf had
/// never heard of. It was the app numbering its own list and drawing the result
/// as a physical fact, two columns from a rail that numbers the same rows.
///
/// What the counter really printed is a fact about an object in the rider's
/// hands, so that still shows, verbatim. Where nothing was printed the corner
/// carries the chevron alone, which is the affordance the block existed for.
/// The neighbourhood a stop is in. One implementation, shared with the
/// Deliveries queue — see [areaOf].
String _areaOf(Map<String, dynamic> stop) => areaOf(stop);
class _OrderOpenBlock extends StatelessWidget {
final String bag;
/// The counter's own printed label, or `''` when it printed none.
final String label;
final String orderId;
final bool selected;
final VoidCallback? onTap;
const _OrderOpenBlock({
required this.bag,
required this.label,
required this.orderId,
required this.selected,
required this.onTap,
@@ -2115,7 +2244,10 @@ class _OrderOpenBlock extends StatelessWidget {
return Semantics(
button: onTap != null,
label: id.isEmpty ? bag : '$bag, order $id',
label: [
if (label.isNotEmpty) label,
if (id.isNotEmpty) 'order $id',
].join(', '),
hint: onTap == null ? null : 'Opens order details',
excludeSemantics: true,
child: InkWell(
@@ -2128,99 +2260,73 @@ class _OrderOpenBlock extends StatelessWidget {
child: Row(
mainAxisSize: MainAxisSize.min,
children: [
ConstrainedBox(
// Capped so a kitchen's own long printed label (`DG-100042-A`)
// cannot take the customer's name with it.
//
// ── And the column stops growing before the name does ──
//
// `Bag 1` is a shelf reference: it is *compared*, not read as
// prose, so it does not need to keep pace with a rider's text
// size. Left to scale it took ~150pt of a 320pt row at 2×, and
// the thing that yielded was the customer's name — which is
// the one item on the row the brief says must yield last.
//
// Clamped at 1.25×, which keeps it comfortably legible against
// a physical shelf while handing the rest of the row back to
// the name and the area.
constraints: BoxConstraints(maxWidth: 104.w),
child: Column(
crossAxisAlignment: CrossAxisAlignment.end,
mainAxisSize: MainAxisSize.min,
children: [
// ── One order, one bag ──
//
// Read straight off [BagManifest]: never a quantity, never a
// route-global number. Right-aligned on every row so a
// column of them lines up against a shelf being counted.
if (label.isNotEmpty)
ConstrainedBox(
// Capped so a kitchen's own long printed label
// (`DG-100042-A`) cannot take the customer's name with it.
//
// ── And the column stops growing before the name does ──
//
// A printed label is *compared*, not read as prose, so it
// does not need to keep pace with a rider's text size. Left
// to scale it took ~150pt of a 320pt row at 2×, and the
// thing that yielded was the customer's name — the one item
// on the row the brief says must yield last.
//
// Clamped at 1.25×, which keeps it legible against a
// physical shelf while handing the rest of the row back to
// the name and the area.
constraints: BoxConstraints(maxWidth: 104.w),
child: Container(
padding: EdgeInsets.symmetric(
horizontal: 7.w,
vertical: 3.h,
),
decoration: BoxDecoration(
// White, because these rows live inside the canvas
// well: layer-1-on-canvas, the same 1.29 step the rest
// of the system stands on. (Canvas-on-canvas was
// invisible the moment the well returned.)
color: selected
? ColorConstants.primary.withValues(alpha: 0.10)
: MilerSurface.working,
borderRadius: BorderRadius.circular(
DesignConstants.radiusLg,
),
),
// ── It ranks under the name, not over it ──
//
// Drawn at w700 in full slate this sat *above* the
// customer, who is w500 in the mid-tone until he is
// ticked. So on a fresh route — every row undecided,
// which is how the screen opens — the boldest thing on
// every line was a shelf number, and the eye read a
// column of bags before it read a single person.
//
// The reference still needs to be scannable against a
// physical shelf, so it keeps a weight of its own: it
// steps to w600 in the mid-tone, one rung under the
// undecided name, and follows the row up to slate the
// moment the row is taken. The bag never leads; it
// travels with whatever the row currently is.
// ── And it is a tag, because it is a label ──
//
// A bag number is a physical reference — the sticker on
// the shelf — not a sentence, and every delivery app the
// rider carries sets that kind of fact as a small tag.
// The fill is the page's canvas tone, the only grey that
// measurably stands on this white panel (1.29:1), so the
// tag reads as an object without borrowing a border. It
// still ranks under the name: quiet ink at rest, brand
// tint the moment the row is ticked.
Container(
padding: EdgeInsets.symmetric(
horizontal: 7.w,
vertical: 3.h,
),
decoration: BoxDecoration(
// White, because these rows live inside the canvas
// well: layer-1-on-canvas, the same 1.29 step the
// rest of the system stands on. (Canvas-on-canvas
// was invisible the moment the well returned.)
// ticked — so on a fresh route the boldest thing on every
// line was a shelf reference, and the eye read a column of
// them before it read a single person. It steps to w600 in
// the mid-tone instead, one rung under the undecided name,
// and follows the row up to slate the moment it is taken.
child: Text(
label,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: MilerType.label.copyWith(
fontSize: 12.sp,
fontWeight: selected
? FontWeight.w700
: FontWeight.w600,
color: selected
? ColorConstants.primary.withValues(alpha: 0.10)
: MilerSurface.working,
borderRadius: BorderRadius.circular(
DesignConstants.radiusLg,
),
),
child: Text(
bag,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: MilerType.label.copyWith(
fontSize: 12.sp,
fontWeight: selected
? FontWeight.w700
: FontWeight.w600,
color: selected
? ColorConstants.primary
: ColorConstants.secondaryText,
),
? ColorConstants.primary
: ColorConstants.secondaryText,
),
),
// ── The reference is not on the row any more ──
//
// It is what the office reads down a phone once, when
// something has gone wrong. The line it occupied now
// carries the drop area, which is what the rider is
// deciding on every time he looks at the list. The id is on
// the detail sheet this block opens, and on the Activity
// record — both places the rare question is actually asked.
],
),
),
),
// ── The order id is not on the row ──
//
// It is what the office reads down a phone once, when something
// has gone wrong. The line it occupied carries the drop area,
// which is what the rider is deciding on every time he looks at
// the list. The id is on the detail sheet this block opens, and
// on the Activity record — both places the rare question is
// actually asked.
if (onTap != null)
Icon(
LucideIcons.chevronRight,
@@ -2629,7 +2735,7 @@ class _StepNode extends StatelessWidget {
//
// It keeps its **number**. The numeral is the order's bag identity, matched
// against a printed label on a shelf, and it must not change or disappear
// because the rider accepted it — see [BagManifest]. So accepted is a
// because the rider accepted it — see [OrderManifest]. So accepted is a
// filled disc with a white numeral, not a tick: a tick would claim work
// that has not happened.
final filled = selected || done || accepted;

29
lib/views/Dashboard/home/stop_action_sheet.dart
View File

@@ -7,7 +7,7 @@ import 'package:flutter_screenutil/flutter_screenutil.dart';
import 'package:image_picker/image_picker.dart';
import 'package:miler/Models/stop_status.dart';
import 'package:miler/views/helpers/constants/miler_surface.dart';
import 'package:miler/data/bag_manifest.dart';
import 'package:miler/data/order_manifest.dart';
import 'package:miler/data/service_profile.dart';
import 'package:miler/views/helpers/constants/Colorconstants.dart';
import 'package:miler/views/helpers/constants/design_constants.dart';
@@ -94,7 +94,7 @@ class StopActionSheet extends StatefulWidget {
///
/// Empty renders the sheet as it was — a heading, a count and the slide —
/// which is correct for a rung that covers a single anonymous stop.
final List<BagLine> lines;
final List<ManifestLine> lines;
/// Runs the write, given what the rider actually confirmed. Returns null on
/// success, or a message to show without closing — the sheet stays open so he
@@ -117,7 +117,7 @@ class StopActionSheet extends StatefulWidget {
required String placeName,
required int count,
required Future<String?> Function(RungOutcome) onConfirm,
List<BagLine> lines = const [],
List<ManifestLine> lines = const [],
}) async {
// Through the kit — which also gives this sheet the app's entrance curve.
// It was the one sheet still on Flutter's default 250ms decelerate: the
@@ -188,11 +188,11 @@ class _StopActionSheetState extends State<StopActionSheet> {
}
/// `5 orders · 5 bags` — the rule, stated where he can check it against the
/// shelf. See [BagManifest]. Once he reports a shortfall it counts what he is
/// shelf. See [OrderManifest]. Once he reports a shortfall it counts what he is
/// actually leaving with, and names the gap rather than quietly shrinking.
String get _subtitle => _missing.isEmpty
? BagManifest.countLabel(widget.count)
: '${BagManifest.countLabel(_loaded)} · ${_missing.length} missing';
? OrderManifest.countLabel(widget.count)
: '${OrderManifest.countLabel(_loaded)} · ${_missing.length} missing';
/// What the slide will actually change, in the rider's words. "Slide to
/// update" said nothing a rider could be wrong about; these name the claim —
@@ -223,7 +223,7 @@ class _StopActionSheetState extends State<StopActionSheet> {
}
if (_missing.isEmpty) {
return (
'Make sure all ${widget.count} bags are loaded before continuing.',
'Make sure all ${widget.count} orders are loaded before continuing.',
false,
);
}
@@ -426,7 +426,7 @@ class _StopActionSheetState extends State<StopActionSheet> {
color: ColorConstants.errorRed,
),
label: Text(
'Report missing bag',
'Report a missing order',
style: TextStyle(
fontSize: 14.sp,
fontWeight: FontWeight.w700,
@@ -443,7 +443,7 @@ class _StopActionSheetState extends State<StopActionSheet> {
Expanded(
child: Text(
_missing.isEmpty
? 'Tap any bag the counter could not supply'
? 'Tap any order the counter could not supply'
: '${_missing.length} marked missing',
style: TextStyle(
fontSize: 13.5.sp,
@@ -588,9 +588,16 @@ class _StopActionSheetState extends State<StopActionSheet> {
SizedBox(width: 10.w),
// The same tag the route rows wear — one language for one
// fact, from Home to the sheet it opens. White stands on the
// manifest's tinted panel; a missing bag keeps the error ink
// manifest's tinted panel; a missing order keeps the error ink
// in the same body so the exception is the colour, not the
// shape.
//
// Drawn whenever there is something to say: the counter's own
// printed label, or `Missing` once the rider has reported a
// shortfall. A route whose counters print nothing shows the tag
// only on the exception, which is the one time it carries a
// fact the row does not already state.
if (gone || line.label.isNotEmpty)
Container(
padding: EdgeInsets.symmetric(horizontal: 7.w, vertical: 3.h),
decoration: BoxDecoration(
@@ -602,7 +609,7 @@ class _StopActionSheetState extends State<StopActionSheet> {
),
),
child: Text(
gone ? 'Missing' : line.bag,
gone ? 'Missing' : line.label,
maxLines: 1,
style: TextStyle(
fontSize: 12.5.sp,

60
lib/views/Dashboard/home/stop_card.dart
View File

@@ -66,10 +66,10 @@ class StopCard extends StatelessWidget {
/// Time at the door, shown in the card's header.
final Duration service;
/// Which bag this order travels in — `Bag 3`, or the label the kitchen
/// printed. One order, one bag; the count is never a separate figure. See
/// [BagManifest].
final String bag;
/// Which label this order travels in — `Bag 3`, or the label the kitchen
/// printed. One order, one label; the count is never a separate figure. See
/// [OrderManifest].
final String label;
/// True when this card sits under a heading that already names its pickup
/// location.
@@ -122,7 +122,7 @@ class StopCard extends StatelessWidget {
required this.state,
required this.address,
required this.service,
this.bag = '',
this.label = '',
this.groupedUnderSource = false,
this.selected = false,
this.busy = false,
@@ -256,7 +256,7 @@ class StopCard extends StatelessWidget {
SizedBox(height: 12.h),
_factsRow(
kind,
bagShownAbove: twoLeg && !grouped && bag.isNotEmpty,
labelShownAbove: twoLeg && !grouped && label.isNotEmpty,
),
if (action != null) ...[SizedBox(height: 16.h), action],
],
@@ -318,7 +318,7 @@ class StopCard extends StatelessWidget {
/// `→ Joe · Bag 1` — the far end, in one line.
///
/// Everything the second leg used to spend a whole block on: who it is for,
/// and which bag it is. The address is one tap away in the detail sheet,
/// and which label it is. The address is one tap away in the detail sheet,
/// where a rider going to a *kitchen* has no use for it yet.
Widget _dropLine(String customer) {
return Row(
@@ -343,7 +343,10 @@ class StopCard extends StatelessWidget {
),
),
),
if (bag.isNotEmpty) ...[SizedBox(width: 10.w), _BagChip(label: bag)],
if (label.isNotEmpty) ...[
SizedBox(width: 10.w),
_LabelChip(label: label),
],
],
);
}
@@ -352,7 +355,7 @@ class StopCard extends StatelessWidget {
///
/// This is the line a rider re-reads at a red light, so nothing on it is
/// under 14sp and none of it is in a box.
Widget _factsRow(StopKind kind, {required bool bagShownAbove}) {
Widget _factsRow(StopKind kind, {required bool labelShownAbove}) {
final due = DateTime.tryParse(
(stop['expected_pickup_time'] ?? stop['eta'] ?? '').toString().trim(),
);
@@ -393,33 +396,33 @@ class StopCard extends StatelessWidget {
),
],
),
// What is in it, and which bag it is. The bag appears here whenever the
// drop line above is not already carrying it — a card must never be
// silent about which box this order is, and it must never say it twice.
// What is in it, and the counter's own label where there is one. It
// appears here whenever the drop line above is not already carrying it:
// a card must never say the same thing twice.
Builder(
builder: (_) {
final label = bag.isNotEmpty ? bag : stopBagLabel(stop);
final printed = label.isNotEmpty ? label : stopPrintedLabel(stop);
final meta = _MetaLine(
deliver: kind.hasDelivery ? _qty(deliveryParcelCount(stop)) : 0,
collect: kind.hasPickup ? _qty(pickupParcelCount(stop)) : 0,
cash: cash,
muted: _rejected || state == StopState.done,
// On a meal run the parcel counts are the one-bag rule restated
// On a meal run the parcel counts are the one-label rule restated
// as an item count, which is exactly the second number this app
// does not allow. Only the money survives.
countsHidden: ServiceProfile.active.deliversToCustomer,
);
final showBag = !bagShownAbove && label.isNotEmpty;
if (!showBag && meta.isEmpty) return const SizedBox.shrink();
final showLabel = !labelShownAbove && printed.isNotEmpty;
if (!showLabel && meta.isEmpty) return const SizedBox.shrink();
return Padding(
padding: EdgeInsets.only(top: 8.h),
child: Row(
children: [
if (!meta.isEmpty) Flexible(child: meta),
if (showBag) ...[
if (showLabel) ...[
if (!meta.isEmpty) SizedBox(width: 10.w),
_BagChip(label: label),
_LabelChip(label: printed),
],
],
),
@@ -441,7 +444,7 @@ class StopCard extends StatelessWidget {
/// journey and the bar offers the claim, and neither duplicates the other.
///
/// A stop that is already *arrived* is the one exception: the single-order
/// case ("one bag, one counter") would otherwise make him tick a card he is
/// case ("one label, one counter") would otherwise make him tick a card he is
/// looking at to reach a control that talks about "the selection". That
/// button opens the same slide sheet the bar does, over the same batch.
Widget? _primaryAction() {
@@ -598,16 +601,19 @@ class _IconAction extends StatelessWidget {
/// the card has exactly one colour to spend. It is a chip rather than plain
/// text because it is read *against an object* — a bordered word is findable on
/// a card at arm's length in a way a run of grey text is not.
class _BagChip extends StatelessWidget {
class _LabelChip extends StatelessWidget {
final String label;
const _BagChip({required this.label});
const _LabelChip({required this.label});
/// Backend labels are codes — `DG-1042`, `BAG-1` — and derived ones already
/// read `Bag 3`. The word belongs on both, and the test for "already has it"
/// is the *word*, not the prefix: `BAG-1` starts with those three letters and
/// is still a code, so it becomes `Bag BAG-1` exactly as it always read.
String get _text =>
label.toLowerCase().startsWith('bag ') ? label : 'Bag $label';
/// ── The word is gone; the code is not ──
///
/// This prefixed everything with `Bag ` — so a counter's own code rendered
/// as `Bag DG-1042`, and a number the app had derived rendered as `Bag 3`
/// and read like something stencilled on an object nobody had stencilled.
///
/// What a counter prints is printed on it already. It is shown exactly as it
/// was sent, and nothing is shown at all where nothing was sent.
String get _text => label;
@override
Widget build(BuildContext context) {

21
lib/views/Dashboard/home/stop_detail_sheet.dart
View File

@@ -51,10 +51,10 @@ class StopDetailSheet extends StatelessWidget {
final double? riderLat;
final double? riderLng;
/// The bag this order travels in, as the caller's store recorded it at the
/// The label this order travels in, as the caller's store recorded it at the
/// counter. Empty falls back to the payload's own `baglabel`, and a line
/// with neither simply has no Bag row — nothing is invented.
final String bag;
final String label;
/// Orders the rider is carrying — what turns a raw `pickup` row into the
/// delivery leg. Empty (Home's caller) leaves the raw kind in charge.
@@ -91,7 +91,7 @@ class StopDetailSheet extends StatelessWidget {
this.stopCount = 0,
this.riderLat,
this.riderLng,
this.bag = '',
this.label = '',
this.collectedIds = const {},
this.ofOrder = false,
});
@@ -102,7 +102,7 @@ class StopDetailSheet extends StatelessWidget {
required Map<String, dynamic> stop,
required int stopNumber,
int stopCount = 0,
String bag = '',
String label = '',
Set<String> collectedIds = const {},
double? riderLat,
double? riderLng,
@@ -119,7 +119,7 @@ class StopDetailSheet extends StatelessWidget {
stop: stop,
stopNumber: stopNumber,
stopCount: stopCount,
bag: bag,
label: label,
collectedIds: collectedIds,
riderLat: riderLat,
riderLng: riderLng,
@@ -721,15 +721,18 @@ class StopDetailSheet extends StatelessWidget {
Widget _detailGrid() {
final rows = <MapEntry<String, String>>[
// Whose counter the bag came off — the fact the delivery card carries
// Whose counter the label came off — the fact the delivery card carries
// ("PICKED UP FROM …") and this sheet used to drop. Only on the drop
// leg: on a pickup the header IS the source context. One reader,
// [stopSourceName], as the project rule demands.
MapEntry('From', _isDropLeg ? stopSourceName(stop) : ''),
// The bag is what a rider matches against a shelf, so it outranks the
// reference. Stored pairing first ([bag], written at the counter), the
// The label is what a rider matches against a shelf, so it outranks the
// reference. Stored pairing first ([label], written at the counter), the
// kitchen-printed label as fallback, absent on a line with no load.
MapEntry('Bag', bag.isNotEmpty ? bag : _s(['baglabel', 'BagLabel'])),
MapEntry(
'Label',
label.isNotEmpty ? label : _s(['baglabel', 'BagLabel']),
),
MapEntry('Order', _s(['orderid', 'OrderId'])),
MapEntry('Product', _s(['description', 'productname', 'product'])),
MapEntry('Weight', () {

90
lib/views/Dashboard/home/trip.dart
View File

@@ -254,8 +254,17 @@ class Trip {
///
/// Returns `this` unchanged when nothing has been collected yet, so the
/// common case allocates nothing.
/// ── Declined work is not outstanding work ──
///
/// [rejectedIds] is the set the rider's own decision writes, and it has to be
/// passed in because a decline is **local first**: the stop stays in the
/// payload reading `assigned` until the backend catches up, so
/// `stopStatusOf` cannot see it and the figures counted a stop the rider had
/// refused. He declined four of eight and the card still measured the
/// kilometres to all eight.
Trip outstanding({
Set<String> collectedIds = const <String>{},
Set<String> rejectedIds = const <String>{},
double? originLat,
double? originLng,
}) {
@@ -263,7 +272,9 @@ class Trip {
for (final s in stops)
if (!WorkBoundary.pickupComplete(s, collectedIds: collectedIds) &&
!stopStatusOf(s).isCancelled &&
!stopStatusOf(s).isSkipped)
!stopStatusOf(s).isSkipped &&
!stopStatusOf(s).isRejected &&
!rejectedIds.contains((s['orderid'] ?? '').toString()))
s,
];
if (left.length == stops.length) return this;
@@ -300,6 +311,35 @@ class Trip {
'${RouteMetricsHelper.formatClock(e)}';
}
/// The slot as a **clock range**, or `''` when it has none.
///
/// ── Why a day part is not printed at clock position ──
///
/// [slotLabel] answers "what is this trip called" and names a whole day part
/// as *Morning* / *Afternoon* / *Evening*, which is right for a heading.
/// It is wrong wherever the app is printing a live figure.
///
/// Two things happen when it lands there. The word is a **label pretending to
/// be data**: it sits where "3h 10m left" sits, in the corner a rider checks
/// for how much time he has, and answers with a noun he cannot act on. And it
/// is redundant twice over — the trip is already numbered `Trip 1`, and the
/// number *is* the day part, so `Trip 1 · Morning` says one thing twice.
///
/// This became visible when trips started being placed by day part at all:
/// before that they carried no window, [slotLabel] fell through to "Today's
/// route", and the same call sites printed nothing. So the fix is not to undo
/// the placement — it is to stop reading a heading as a measurement.
///
/// Returns a range only when the hub sent a real one: `10:00 AM – 1:00 PM`.
String get slotClockLabel {
final s = slotStart;
final e = slotEnd;
if (s == null || e == null) return '';
if (DayPart.spans(s, e)) return '';
return '${RouteMetricsHelper.formatClock(s)} – '
'${RouteMetricsHelper.formatClock(e)}';
}
/// True when the slot window has already closed.
bool isExpired([DateTime? now]) {
final e = slotEnd;
@@ -410,15 +450,47 @@ class Trip {
DateTime? get _earliestDue {
DateTime? best;
for (final s in stops) {
final due = _parseTimestamp(
s['expected_pickup_time'] ?? s['expectedpickuptime'] ?? s['eta'],
);
final due = dayPartTimeOf(s);
if (due == null) continue;
if (best == null || due.isBefore(best)) best = due;
}
return best;
}
/// The clock that decides which part of the day a stop belongs to.
///
/// ── Due time first, assignment time second ──
///
/// The right answer is when the work is *due*: an order to be collected at
/// 10am is morning work whenever the hub happened to raise it. That is
/// `expected_pickup_time`, and where the backend sends it nothing here
/// changes.
///
/// Where it does not — which is the live Doormile contract today — the day
/// part had nothing to read at all, and every stop fell into the undated
/// `day:` bucket. One trip, no day part, and [TripSlots.slots] put it in the
/// first free slot: **everything was Trip 1, all day**. A rider given an
/// evening run opened Home to find it filed under the morning.
///
/// So the fallback is when the work reached him — `assignedat`, merged onto
/// the row by [WorkRepository] from the assignment ledger. It is the hub's
/// own act as the phone observed it, and it is what dispatch means on the
/// telephone: work handed over in the morning is the morning run. Approximate
/// where a due time would be exact, and exactly right for the common case,
/// which is a slot assigned at the top of the slot it is for.
///
/// `eta` is read last and usually answers nothing — on the v1 adapter it is
/// a duration, not a clock, and [_parseTimestamp] rejects it rather than
/// inventing a 15th of the month out of "15 min".
static DateTime? dayPartTimeOf(Map<String, dynamic> stop) =>
_parseTimestamp(
stop['expected_pickup_time'] ??
stop['expectedpickuptime'] ??
stop['assignedat'] ??
stop['assignedon'] ??
stop['eta'],
);
/// Address components every stop on this trip shares — city, state,
/// pincode and so on. Cached per build by the caller.
List<String> get sharedAddressTail => commonAddressTail([
@@ -663,11 +735,11 @@ class Trip {
from = slotFrom;
to = slotTo;
} else {
final due = _parseTimestamp(
stop['expected_pickup_time'] ??
stop['expectedpickuptime'] ??
stop['eta'],
);
// Due time where the hub sends one, and the moment the work reached
// the rider where it does not — see [Trip.dayPartTimeOf]. Without the
// second half every stop landed in the undated bucket below and the
// whole day rendered as Trip 1.
final due = dayPartTimeOf(stop);
if (due != null) {
// Morning, afternoon or evening — see [DayPart]. Not a rolling
// window: two stops due an hour apart are on the same run, and the

89
lib/views/Dashboard/home/trip_brief_strip.dart
View File

@@ -418,65 +418,30 @@ class _TripBriefStripState extends State<TripBriefStrip> {
// matching the one above the bar, so the bar sits evenly between
// the two things it separates.
SizedBox(height: 8.h),
Row(
children: [
// ── The journey leads the line now ──
//
// It used to be the *fallback* — shown only when there was no
// shift and no slot, because the clock had the row. With the
// ratio gone there is space for both, and how long and how far
// is the pair a rider is actually planning against. It yields
// while the grid below is open so nothing prints twice.
Flexible(
child: _open ? const SizedBox.shrink() : _journeyGlance(),
),
const Spacer(),
// The clock keeps its own colour rules — the one line here
// allowed to carry bad news; see [_timeLeftLine]. It prints
// nothing at all when the hub has set neither a shift nor a
// slot, which is when the journey has the row to itself.
Flexible(child: _timeLeftLine()),
],
),
// ── The journey glance is gone from the collapsed head ──
//
// It printed `≈50 min · 2.4 km` under the bar, and it was the third
// place the same estimate appeared: the grid one tap below states
// Duration and Distance as two of its four figures, and every group
// on the route under it carries its own leg in the right-hand
// column the rider scans down.
//
// Collapsed is a *summary* state, and what a summary is for is the
// one fact the card is answering with — how much is left, and the
// bar that measures it. An estimate repeated at 12.5pt beside it
// added a number to read without adding anything to know, and it is
// the number a rider trusts least: a straight-line distance at an
// average speed, printed where it reads like a promise.
//
// Nothing is lost. Open the card and both figures are there, stated
// properly, with the parcels and the cash beside them.
Row(children: [const Spacer(), Flexible(child: _timeLeftLine())]),
],
),
),
);
}
/// The collapsed panel's journey, in one quiet line: `≈4h · 38.9 km`.
///
/// Only the figures that exist — a route with no coordinates prints no
/// kilometres rather than a zero — and never a colour: this is context, and
/// the headline beside it is the thing being contextualised.
Widget _journeyGlance() {
final duration = roundTripDuration(_trip.totalDuration);
final parts = <String>[
if (duration > Duration.zero) '\u2248${formatTripDuration(duration)}',
if (_trip.routeMeters > 0)
RouteMetricsHelper.formatDistance(_trip.routeMeters),
];
if (parts.isEmpty) return const SizedBox.shrink();
// Scale-down, never ellipsis: this line is nothing but figures, and
// `10.3 …` is the unit cut off the number it qualifies — seen the first
// time it shared a row with the headline, both flexible.
return FittedBox(
fit: BoxFit.scaleDown,
alignment: Alignment.centerLeft,
child: Text(
parts.join(' \u00b7 '),
maxLines: 1,
style: TextStyle(
fontSize: 12.5.sp,
fontWeight: FontWeight.w600,
fontFeatures: const [FontFeature.tabularFigures()],
color: ColorConstants.secondaryText,
fontFamily: FontConstants.fontFamily,
),
),
);
}
/// The one line on this widget that can carry bad news, so it is the one line
/// that is allowed to change colour.
Widget _timeLeftLine() {
@@ -490,13 +455,19 @@ class _TripBriefStripState extends State<TripBriefStrip> {
// inventing a state — see the note on [ShiftBanner] for why an absent
// shift is not the rider's problem to solve.
//
// And when the trip has no slot either, say nothing AT ALL:
// `slotLabel`'s fallback is the words "Today's route", which set at
// clock position read as a fact the rider should be able to act on. A
// And when the trip has no clock window either, say nothing AT ALL. A
// headline row carries a live figure or it carries silence — a label
// pretending to be data is worse than the gap it fills.
if (_trip.slotStart == null) return const SizedBox.shrink();
text = _trip.slotLabel;
// pretending to be data is worse than the gap it fills, and `slotLabel`
// has two fallbacks that are exactly that: the words "Today's route", and
// the day part's name. **Morning** where "3h 10m left" belongs is a noun
// in the corner a rider checks for how much time he has; the trip tab
// above already says which part of the day this is, in a number.
//
// See [Trip.slotClockLabel], which is empty unless the hub sent a real
// range.
final window = _trip.slotClockLabel;
if (window.isEmpty) return const SizedBox.shrink();
text = window;
color = ColorConstants.secondaryText;
} else if (left == Duration.zero) {
text = 'Shift ended';

144
lib/views/Dashboard/home/trip_card.dart
View File

@@ -16,7 +16,8 @@ import 'package:miler/views/helpers/constants/design_constants.dart';
import 'package:miler/views/helpers/constants/miler_type.dart';
import 'package:miler/views/helpers/constants/Font_constant.dart';
import 'package:miler/Models/stop_status.dart';
import 'package:miler/data/bag_manifest.dart';
import 'package:miler/data/order_manifest.dart';
import 'package:miler/data/stop_area.dart';
import 'package:miler/data/milk_run.dart';
import 'package:miler/data/service_profile.dart';
@@ -258,6 +259,10 @@ class TripCard extends StatelessWidget {
// on the same footing. See [Trip.outstanding].
remaining: trip.outstanding(
collectedIds: collectedIds,
// Work he has declined is not work in front of him — see the note on
// [Trip.outstanding]. Without this the Distance cell measured a route
// through stops the rider had refused.
rejectedIds: rejectedIds,
originLat: riderLat,
originLng: riderLng,
),
@@ -311,7 +316,7 @@ class TripCard extends StatelessWidget {
for (var i = 0; i < trip.stops.length; i++) {
if (_stateOf(trip.stops[i]) != rung) continue;
final stop = trip.stops[i];
final key = MilkRun.sourceKeyOf(stop);
final key = MilkRun.sourceKeyOf(stop, within: trip.stops);
final grouped = ServiceProfile.active.sourceIsKitchen && key.isNotEmpty;
final stops = grouped
? [
@@ -430,13 +435,22 @@ class TripCard extends StatelessWidget {
// the screen. See [RouteGroup.allStops].
for (var i = 0; i < trip.stops.length; i++) {
final stop = trip.stops[i];
// Key on the id where there is one, falling back to the name: the id is
// what the hub controls, but a payload that only carries a name still has
// to group rather than collapsing every stop into one nameless pile.
// ── One reader for "which counter is this", not two ──
//
// This built its own key — `stopSourceId`, falling back to
// `stopSourceName` — while [MilkRun.sourceKeyOf] is the function that
// exists to answer exactly this, and is what the bulk collect, the
// per-kitchen gate and `sameSourceAs` all key on.
//
// They did not agree. `stopSourceId` reads `kitchenid` and `sourceid`;
// `sourceKeyOf` reads those **and `pickuplocationid`** — so a row
// identified only by its location id was one place according to the
// collect and a different one according to the card that offers it. That
// is the same two-readers-one-question failure `sourceNameOf` documents,
// repeated on the id, and it splits a kitchen's orders across two groups
// on the screen while the collect still treats them as one.
final key = grouped
? (stopSourceId(stop).isNotEmpty
? stopSourceId(stop)
: stopSourceName(stop))
? MilkRun.sourceKeyOf(stop, within: trip.stops)
: 'stop:${_idOf(stop)}';
if (!buckets.containsKey(key)) {
buckets[key] = <int>[];
@@ -473,17 +487,56 @@ class TripCard extends StatelessWidget {
groups.add(() {
final stops = visible;
final first = all.first;
// ── An unnamed counter is named by where it is ──
//
// A grouped place with no source name fell through to
// `MilkRun.navigationLabel`, which answers with the **customer** — so
// the heading over a dropdown read as one more order rather than as the
// place the orders under it are collected from.
//
// The address is what names a place the payload did not name, and it is
// what the rider wants off that line anyway: he is deciding where to
// ride, not who to hand a bag to.
final place = compactAddress(pickupAddressOf(first));
// ── When a lone stop is a *place*, and when it is the stop ──
//
// `flat` means the header **is** the stop: no counter above it worth
// naming, so the card is titled with the customer and opens the detail
// sheet instead of a list. That is always right on a parcel route,
// where the rider goes to one door for one consignment.
//
// On a kitchen line it was reached by a different route and gave the
// wrong answer. A lone stop was flat whenever the payload carried **no
// source name** — and a missing name is a gap in the data, not evidence
// that there is no counter. So an order whose row lost its kitchen name
// was drawn as a bare header with the customer's name on it, sitting
// above the dropdown its seven siblings were in: seven bags in a list
// and one stranded over it, off the same shelf.
//
// [MilkRun.sourceKeyOf] now groups such a row back in by its address,
// which fixes that case at the root. This is the same correction one
// level down, for a place that genuinely does hold a single order: on a
// kitchen line a lone stop is only flat when there is **nothing at all**
// to name its place with — no counter name and no address. With an
// address it is a place holding one order, headed by where it is, with
// the order in the list under it.
final flat =
all.length == 1 && (!grouped || stopSourceName(first).isEmpty);
// A grouped place is named by its counter. A flat one *is* the stop, so
// it is named by the customer — `MilkRun.navigationLabel` answers
// "pickup" for a parcel that has not been collected yet, which is a
// description of the leg rather than a name the rider can read off a
// gate.
all.length == 1 &&
(!grouped || (stopSourceName(first).isEmpty && place.isEmpty));
// A grouped place is named by its counter, or failing that by where it
// is. A flat one *is* the stop, so it is named by the customer —
// `MilkRun.navigationLabel` answers "pickup" for a parcel that has not
// been collected yet, which is a description of the leg rather than a
// name the rider can read off a gate.
final name = flat
? BagManifest.customerOf(first)
? OrderManifest.customerOf(first)
: (grouped
? stopSourceName(first)
? (stopSourceName(first).trim().isNotEmpty
? stopSourceName(first)
: place)
: MilkRun.navigationLabel(first));
return RouteGroup(
key: key,
@@ -493,6 +546,20 @@ class TripCard extends StatelessWidget {
name: name.trim().isEmpty
? MilkRun.navigationLabel(first)
: name.trim(),
// ── The counter's street, under its name ──
//
// Grouped places only. A flat node *is* the stop and is already named
// by its customer or its own address, so an address line under it
// would print the same place twice; a kitchen is a name the rider has
// to convert into a location, and until now the only thing that could
// do that conversion was the preview sheet.
//
// Trimmed through [compactAddress] — the geocoder appends
// `Tamil Nadu, 641002, India` to every row, which is three
// components that are identical on every stop of every route and
// would push the part that names the street off the end of the line.
// Not repeated when it is already the heading — see [name] above.
location: flat || name.trim() == place ? '' : place,
stops: stops,
allStops: all,
firstIndex: indices.first,
@@ -706,13 +773,12 @@ class TripCard extends StatelessWidget {
for (var i = 0; i < trip.stops.length; i++) {
if (!_showsOnHome(_stateOf(trip.stops[i]))) continue;
// Key on the id where there is one, falling back to the name: the id is
// what the hub controls, but a payload that only carries a name still has
// to group rather than collapsing every stop into one nameless pile.
// [MilkRun.sourceKeyOf], the same reader [routeGroups] uses and the same
// one the bulk collect keys on. This had its own id-then-name expression,
// which misses `pickuplocationid` and therefore split a kitchen the
// collect still treats as one — see the note in [routeGroups].
final stop = trip.stops[i];
final key = stopSourceId(stop).isNotEmpty
? stopSourceId(stop)
: stopSourceName(stop);
final key = MilkRun.sourceKeyOf(stop);
if (!groups.containsKey(key)) {
groups[key] = <int>[];
order.add(key);
@@ -804,11 +870,11 @@ class TripCard extends StatelessWidget {
// him comparing "5 meals" on the phone against a shelf of bags.
// The count he can *check* is orders against bags, and under
// this workflow they are the same number by definition. See
// [BagManifest].
// [OrderManifest].
Text(
pending > 0
? '${BagManifest.countLabel(indices.length)} · $pending to accept'
: BagManifest.countLabel(indices.length),
? '${OrderManifest.countLabel(indices.length)} · $pending to accept'
: OrderManifest.countLabel(indices.length),
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
@@ -1204,7 +1270,7 @@ class TripCard extends StatelessWidget {
state: state,
address: address,
service: roundTripDuration(Trip.serviceTimeFor(stop)),
bag: _bagOf(stop),
label: _labelOf(stop),
// The kitchen heading above already names where this came from.
groupedUnderSource: ServiceProfile.active.sourceIsKitchen,
selected: selectedIds.contains(id),
@@ -1258,21 +1324,19 @@ class TripCard extends StatelessWidget {
// `_tag` is gone — it built the tinted Deliver / Collect / ₹ chips. See
// [_MetaLine], which says the same three things on one uncoloured line.
/// Which bag this order travels in.
/// The label the counter printed on this order, or `''`.
///
/// Derived from its position in **its own pickup group**, not from the whole
/// route: the rider counts bags off one counter at a time, so the third order
/// from Kitchen 2 is *its* Bag 3 and not the route's ninth. A label the
/// kitchen actually printed always wins — see [BagManifest].
String _bagOf(Map<String, dynamic> stop) {
if (!ServiceProfile.active.sourceIsKitchen) return stopBagLabel(stop);
final key = MilkRun.sourceKeyOf(stop);
final group = [
for (final s in trip.stops)
if (MilkRun.sourceKeyOf(s) == key) s,
];
return BagManifest.bagFor(stop, group);
}
/// ── It used to be derived, and that was the problem ──
///
/// This computed the order's position in its own pickup group and returned
/// `Bag 3` — the app numbering a list it had built and presenting the result
/// as something stencilled on an object. On a route where no counter prints
/// labels that was every row, and it sat two columns from a rail numbering
/// the same rows.
///
/// Only what the payload actually carries survives. See
/// [OrderManifest.labelFor].
String _labelOf(Map<String, dynamic> stop) => OrderManifest.labelFor(stop);
// ── Footer: accept remaining, or go work the trip ──────────────────────
Widget _footerBar(List<String> pendingIds) {

85
lib/views/Dashboard/pickups/card.dart
View File

@@ -36,23 +36,23 @@ class PickupCard extends StatelessWidget {
final bool enabled;
final bool isSkipped;
/// The bag this order travels in, as recorded at the counter. Empty on a
/// parcel route, where there is no load to match against. See [BagManifest].
final String bag;
/// The label this order travels in, as recorded at the counter. Empty on a
/// parcel route, where there is no load to match against. See [OrderManifest].
final String label;
/// Orders the rider is carrying.
///
/// Needed because "picked up" is not a *status* on this screen — the accepted
/// store normalises these rows to `accepted`, and what actually records the
/// hand-over is the collected set. Without it, [MilkRun.workingKind] reads a
/// bag already in the rider's box as still needing collection, and the button
/// label already in the rider's box as still needing collection, and the button
/// says **Start Pickup** for a delivery.
final Set<String> collectedIds;
/// Orders whose delivery leg the rider has actually started.
///
/// Distinct from [collectedIds] on purpose, and the distinction is the whole
/// point of the chip: a bag in his box is **PICKED**, a round he has set off
/// point of the chip: a label in his box is **PICKED**, a round he has set off
/// on is **ACTIVE**. The backend cannot answer this — `pickup-complete`
/// stamps a hyperlocal consignment `Out_for_Delivery` at the counter — so the
/// rung is resolved through [MilkRun.stageOf] against this set rather than
@@ -67,7 +67,7 @@ class PickupCard extends StatelessWidget {
this.riderSpeedMps,
this.enabled = true,
this.isSkipped = false,
this.bag = '',
this.label = '',
this.collectedIds = const {},
this.outForDeliveryIds = const {},
});
@@ -97,7 +97,7 @@ class PickupCard extends StatelessWidget {
//
// The booking adapter stamps `type: pickup` on every row it builds, so a
// milk-run order the rider has already collected still described itself as
// a pickup — and this card offered **Start Pickup** for a bag sitting in
// a pickup — and this card offered **Start Pickup** for a label sitting in
// his box. See [MilkRun.workingKind].
final StopKind kind = MilkRun.workingKind(item, collectedIds: collectedIds);
@@ -201,7 +201,7 @@ class PickupCard extends StatelessWidget {
// ── Identity left, state and journey right ──
//
// The distance and ETA had a full-width row of their own under
// the bag — a fifth storey on a card the rider reads at a red
// the label — a fifth storey on a card the rider reads at a red
// light. Home's group node and this queue's own UP NEXT tile
// already carry the journey as a narrow right-hand column at
// the headline's shoulder; the live card was the one surface
@@ -272,7 +272,7 @@ class PickupCard extends StatelessWidget {
// ── The pairing, as one object ──
//
// `Bag 1 · Joe`, not a bag chip in one place and a
// `Bag 1 · Joe`, not a label chip in one place and a
// name in another. The join between them is the
// entire operational risk on a meal run, and making
// the rider do it himself at a gate is where the
@@ -280,10 +280,10 @@ class PickupCard extends StatelessWidget {
// the headline above, so the pair is spatial here;
// the written form earns its place further down the
// queue — see [_LaterRow] — and on the manifest.)
if (bag.isNotEmpty) ...[
if (label.isNotEmpty) ...[
SizedBox(height: 14.h),
_BagPair(
bag: bag,
_LabelPair(
label: label,
customer: '',
muted: !enabled,
size: 15.5,
@@ -371,7 +371,7 @@ class PickupCard extends StatelessWidget {
//
// Once the food is in the box the pickup is history — but it is
// still what establishes custody, and on a run with two kitchens
// it is how he knows which shelf this bag came off. So it stays,
// it is how he knows which shelf this label came off. So it stays,
// one line, under a hairline, at half the weight of the name
// above.
if (dropLeads && pickupName.isNotEmpty) ...[
@@ -534,7 +534,7 @@ class PickupCard extends StatelessWidget {
// because this method opens the map screen directly rather than through
// `startPickup`, and a stop that reached it in the pickup phase would put
// the rider through a map, an I'VE ARRIVED and a confirmation sheet for a
// bag he is supposed to collect at the counter with the rest of them. See
// label he is supposed to collect at the counter with the rest of them. See
// [MilkRun.worksOnOwnScreen].
if (!MilkRun.worksOnOwnScreen(item, collectedIds: collectedIds)) {
AppFeedback.info(
@@ -919,7 +919,7 @@ class _SquareIconButton extends StatelessWidget {
/// ```
/// NOW one task card, full weight, one big action
/// UP NEXT who and where, quietly — no action
/// LATER one line each: bag, name, distance
/// LATER one line each: label, name, distance
/// SKIPPED the reason, and the way back in
/// ```
///
@@ -963,8 +963,8 @@ class _QueueRow {
final QueueDensity density;
final int displayStep;
/// The bag this order travels in, as recorded at the counter.
final String bag;
/// The label this order travels in, as recorded at the counter.
final String label;
/// Why a skipped stop was skipped. Read from the skip cache rather than the
/// stop, because the stop is refetched from the API every three seconds and
@@ -975,14 +975,14 @@ class _QueueRow {
: stop = null,
density = QueueDensity.later,
displayStep = 0,
bag = '',
label = '',
reason = '';
const _QueueRow.stop({
required this.stop,
required this.density,
required this.displayStep,
required this.bag,
required this.label,
this.reason = '',
}) : heading = null,
count = 0;
@@ -1079,33 +1079,38 @@ class _QueueHeading extends StatelessWidget {
///
/// ── Why they are one line and not two facts ──
///
/// The rider is holding a bag and looking for a door. Printing the bag in one
/// The rider is holding a label and looking for a door. Printing the label in one
/// place and the customer in another makes him do the join himself, on a phone,
/// at a gate — and that join is the entire operational risk on a meal run: five
/// near-identical lunch bags, one confident rider, the wrong door.
///
/// So they are written the way he thinks them.
class _BagPair extends StatelessWidget {
final String bag;
class _LabelPair extends StatelessWidget {
final String label;
final String customer;
final bool muted;
/// Bigger on the live card, quieter down the queue.
final double size;
const _BagPair({
required this.bag,
const _LabelPair({
required this.label,
required this.customer,
this.muted = false,
this.size = 15,
});
String get _bagText =>
bag.toLowerCase().startsWith('bag ') ? bag : 'Bag $bag';
/// ── The word is gone; the code is not ──
///
/// This prefixed everything with `Bag `, so a counter's own code rendered as
/// `Bag DG-1042` and an app-derived number rendered as `Bag 3` — a reference
/// to an object nobody had labelled. What a counter prints is shown exactly
/// as it was sent, and nothing is shown where nothing was sent.
String get _labelText => label;
@override
Widget build(BuildContext context) {
if (bag.isEmpty) return const SizedBox.shrink();
if (label.isEmpty) return const SizedBox.shrink();
return Row(
mainAxisSize: MainAxisSize.min,
@@ -1119,7 +1124,7 @@ class _BagPair extends StatelessWidget {
borderRadius: BorderRadius.circular(DesignConstants.radiusLg),
),
child: Text(
_bagText,
_labelText,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
@@ -1223,14 +1228,14 @@ class _TaskChip extends StatelessWidget {
/// notes, no money. Preparing is a glance; acting is the card above.
class _NextCard extends StatelessWidget {
final Map<String, dynamic> item;
final String bag;
final String label;
final double? distanceMeters;
final double? riderSpeedMps;
final VoidCallback onOpen;
const _NextCard({
required this.item,
required this.bag,
required this.label,
required this.distanceMeters,
required this.riderSpeedMps,
required this.onOpen,
@@ -1293,9 +1298,9 @@ class _NextCard extends StatelessWidget {
),
),
],
if (bag.isNotEmpty) ...[
if (label.isNotEmpty) ...[
SizedBox(height: 10.h),
_BagPair(bag: bag, customer: '', muted: true, size: 14),
_LabelPair(label: label, customer: '', muted: true, size: 14),
],
],
),
@@ -1312,13 +1317,13 @@ class _NextCard extends StatelessWidget {
/// take in at once.
class _LaterRow extends StatelessWidget {
final Map<String, dynamic> item;
final String bag;
final String label;
final double? distanceMeters;
final VoidCallback onOpen;
const _LaterRow({
required this.item,
required this.bag,
required this.label,
required this.distanceMeters,
required this.onOpen,
});
@@ -1333,8 +1338,8 @@ class _LaterRow extends StatelessWidget {
padding: EdgeInsets.symmetric(horizontal: 20.w, vertical: 12.h),
child: Row(
children: [
if (bag.isNotEmpty) ...[
_BagPair(bag: bag, customer: '', muted: true, size: 13),
if (label.isNotEmpty) ...[
_LabelPair(label: label, customer: '', muted: true, size: 13),
SizedBox(width: 12.w),
],
Expanded(
@@ -1375,14 +1380,14 @@ class _LaterRow extends StatelessWidget {
/// and nothing else.
class _SkippedRow extends StatelessWidget {
final Map<String, dynamic> item;
final String bag;
final String label;
final String reason;
final VoidCallback onResume;
final VoidCallback onOpen;
const _SkippedRow({
required this.item,
required this.bag,
required this.label,
required this.reason,
required this.onResume,
required this.onOpen,
@@ -1441,8 +1446,8 @@ class _SkippedRow extends StatelessWidget {
SizedBox(height: 12.h),
Row(
children: [
if (bag.isNotEmpty) ...[
_BagPair(bag: bag, customer: '', muted: true, size: 13.5),
if (label.isNotEmpty) ...[
_LabelPair(label: label, customer: '', muted: true, size: 13.5),
SizedBox(width: 12.w),
],
Expanded(

2
lib/views/Dashboard/pickups/collect_payment.dart
View File

@@ -116,7 +116,7 @@ extension _MethodUi on _Method {
String get label => this == _Method.cash ? 'Cash' : 'UPI / QR';
String get blurb => this == _Method.cash
? 'Notes and coins, into your bag'
? 'Notes and coins, kept on you'
: 'Customer scans and pays';
IconData get icon =>

82
lib/views/Dashboard/pickups/delivery_actions.dart
View File

@@ -227,7 +227,11 @@ Future<String> resolveConsignmentId(Map<String, dynamic> stop) async {
/// rider can retry this until his battery dies.
/// • **At a hub.** A cross-city parcel is `Inwarded_at_Hub` and will be
/// delivered by somebody else. There is nothing here for him to start.
/// • **Refused.** The server gave a reason and it was thrown away.
/// • **Refused.** The server gave a reason and it was thrown away. It is
/// read now — and *translated*, because the reason arrives as a state
/// machine talking to itself (`consignment is Inwarded_At_Hub, not
/// Collected_By_Miler`) and that is not a sentence for a rider. See
/// [_refusalSentence].
/// • **Unreachable.** The only one where "check your connection" is true.
///
/// Telling a rider to check a working connection, about a parcel that is not
@@ -318,10 +322,10 @@ Future<bool> releaseForDelivery(Map<String, dynamic> stop) async {
// account for, and one 400 carrying the backend's own sentence is worth more
// than a client-side refusal that invents one. A hyperlocal consignment the
// pivot has not finished releasing is let through; a hub-routed one is
// refused by the server, and the rider is told what the server said.
// refused by the server, and the rider is told what the server *meant* —
// translated out of the state machine's vocabulary, see [_refusalSentence].
// A hold that cannot exist on this line is a bad read, not a fact about the
// stop. See [_handoffHoldIsPossible].
final heldElsewhere = state.awaitsHub && _handoffHoldIsPossible;
if (state.awaitsHub && !_handoffHoldIsPossible) {
debugPrint(
'[MILKRUN] $consignmentId read as ${state.name} on a line with no '
@@ -333,11 +337,16 @@ Future<bool> releaseForDelivery(Map<String, dynamic> stop) async {
!(state.awaitsHub && !_handoffHoldIsPossible) &&
state != ConsignmentState.unknown) {
debugPrint('[MILKRUN] $consignmentId is ${state.name} — not releasable');
lastReleaseFailure = heldElsewhere
// The honest answer for a cross-city parcel: it is not his round, and
// saying so without naming a building he has never been to.
? "This one has already been handed on — it's not yours to deliver."
: 'This parcel cannot be started yet. Ask your office to check it.';
// One sentence per state, written once — see
// [ConsignmentStateX.startRefusalSentence]. This branch and the refusal
// below are the same answer arrived at from two directions (a state the
// app read, and a state the server named), and they used to word it
// differently: a cross-city parcel blocked here said "it's not yours to
// deliver" while the identical parcel blocked one request later read out
// a database enum.
lastReleaseFailure =
state.startRefusalSentence ??
'This parcel cannot be started yet. Ask your office to check it.';
return false;
}
@@ -361,16 +370,63 @@ Future<bool> releaseForDelivery(Map<String, dynamic> stop) async {
final after = await ConsignmentGate.stateOf(consignmentId);
if (after.isDeliverable || after.isDelivered) return true;
// `status: 0` is the request never leaving; anything else is the server
// answering, and its own words beat a guess about the network.
// `status: 0` is the request never leaving, and it is the one failure that
// is really about the connection.
lastReleaseFailure = res.status == 0
? 'Could not reach your office. Check your connection and slide again.'
: (res.message.trim().isNotEmpty
? res.message.trim()
: 'Your office would not start this delivery.');
: _refusalSentence(res, after);
return false;
}
/// The rider's version of a refused **Start ride**.
///
/// ── What the rider was actually reading ──
///
/// The server's own words were passed straight to the screen, on the argument
/// that one refusal carrying the backend's reason beats a client-side guess
/// that invents one. That argument holds for *whose* answer it is. It does not
/// hold for what the answer turned out to be: `start-delivery` refuses with an
/// assertion about its own model — **"consignment is Inwarded_At_Hub, not
/// Collected_By_Miler"** — and that is what a rider saw on the slider, in
/// database vocabulary, with no way to tell it from a crash.
///
/// The reason is worth keeping; the wording was never the server's to write.
/// So the state is what travels, and [ConsignmentStateX.startRefusalSentence]
/// says it once, in one place, in words that answer the only two questions he
/// has: is this mine, and will sliding again help.
///
/// ── Three sources for that state, best first ──
///
/// 1. **A fresh read** — [after], asked immediately after the refusal, which
/// is the newest thing anyone knows about the consignment.
/// 2. **The refusal itself.** The read can fail — the row need not carry a
/// status and the detail route 404s on older deployments — and when it
/// does the refusal is the only thing left that knows. See
/// [consignmentStateNamedInRefusal] for why reading it is safe.
/// 3. **The failure code.** `INVALID_STATE` alone still says the one useful
/// thing: the consignment has moved on from the rung this press acts at,
/// so sliding again is not the answer.
///
/// Prose from the server is still preferred over a generic sentence — some
/// routes really do answer in words meant for a person. What is filtered out
/// is the wire vocabulary. See [namesWireState].
String _refusalSentence(ApiResult res, ConsignmentState after) {
final state = after != ConsignmentState.unknown
? after
: consignmentStateNamedInRefusal(res.message);
final fromState = state.startRefusalSentence;
if (fromState != null) return fromState;
final said = res.message.trim();
if (said.isNotEmpty && !namesWireState(said)) return said;
return res.isInvalidState
? 'Your office has already moved this parcel on, so it cannot be '
'started from here. Ask them to check it.'
: 'Your office would not start this delivery.';
}
/// Brings this device into line with a delivery the server already has.
///
/// The same local bookkeeping a successful `deliver` performs — the order

524
lib/views/Dashboard/pickups/pickups.dart
View File

@@ -77,6 +77,7 @@ import 'package:miler/data/order_events.dart';
import 'package:miler/data/route_order.dart';
import 'package:miler/data/stop_area.dart';
import 'package:miler/data/stop_contact.dart';
import 'package:miler/data/service_day.dart';
import 'package:miler/data/work_domain.dart';
import 'package:miler/data/work_repository.dart';
import 'package:miler/data/miler_api.dart';
@@ -291,6 +292,28 @@ class MyPickups extends StatefulWidget {
}
}
/// True when [stop] is part of the route the rider actually rode.
///
/// The completed store is not a list of finished deliveries — it is where every
/// order that left the rider's hands is filed, whatever ended it. A stop he
/// **declined** on Home is in there (`terminalStatus: 'rejected'`) and so is
/// one the office **cancelled**. Neither was ever ridden to, so neither belongs
/// on a progress rail: they inflate its count and they are drawn in states that
/// assert something false — `rejected` reads as work still ahead of him,
/// `cancelled` reads as green, completed work.
///
/// A **skip** is not in that group and is deliberately kept. It is a door he
/// went to and could not finish, which is unfinished business, and the rail has
/// an amber node for exactly that.
///
/// Top-level rather than a method so [_railStops]' rule can be exercised
/// without building the screen — the arithmetic it protects is four lines and
/// took a rider's whole rail with it when it was wrong.
bool wasRiddenTo(Map<String, dynamic> stop) {
final status = stopStatusOf(stop);
return !status.isRejected && !status.isCancelled;
}
class _MyPickupsState extends State<MyPickups>
with AutomaticKeepAliveClientMixin, WidgetsBindingObserver {
final PickupProvider _provider = PickupProvider();
@@ -428,6 +451,65 @@ class _MyPickupsState extends State<MyPickups>
/// Refreshed with every fetch. See [_railStops] for why the rail needs them.
List<Map<String, dynamic>> _completedToday = <Map<String, dynamic>>[];
/// Notices when the day underneath the queue has moved on.
///
/// [_fetchPicked] filters against the service day *as read when it ran*, so
/// the queue on screen is only ever as fresh as the last fetch. See
/// [_rolloverCheck].
final ServiceDayRollover _day = ServiceDayRollover();
/// Fires at the next local midnight. See [_armRollover].
Timer? _rollover;
/// This queue's stops, for today and no other day.
///
/// ── Why Deliveries needed the same filter Home just got ──
///
/// The two screens read the same call. `GET /miler/bookings` returns the
/// rider's whole **open** set, so a stop he picked up on Tuesday and never
/// closed came back on Wednesday, went through [WorkBoundary.deliveryQueue]
/// as perfectly workable — it *is* collected and it *is* unclosed — and sat
/// in this morning's round. Worse than a stale row: the bar at the foot of
/// this screen offers to start the whole round, so yesterday's leftovers
/// were work the rider could be sent out on.
///
/// The rule and every part of its reasoning is [ServiceDay.onlyToday],
/// shared with Home so the two screens cannot disagree about which day it
/// is. What is local is only *which* day — the one this screen is showing.
///
/// The completed store is not put through it: [getCompletedBookings] already
/// prunes itself to today on read.
List<Map<String, dynamic>> _todayOnly(List<Map<String, dynamic>> stops) {
_day.rollIfNeeded();
return ServiceDay.onlyToday(stops, now: _day.day, where: 'MYPICKUPS');
}
/// ── The day ending under a queue that is already open ──
///
/// [ServiceDay] answers "which day is this row" at read time, which is right
/// for the data and not sufficient for the screen: the filter runs at fetch
/// time. A rider who leaves this tab open through 23:59, or backgrounds the
/// app on it and picks the phone up at six, is looking at a queue filtered
/// against a day that has ended.
///
/// A timer to the next local midnight for the app left in the foreground,
/// and resume for every other case — both platforms suspend timers in the
/// background. Both land in [_rolloverCheck], which is idempotent. The same
/// arrangement Home and Activity use.
void _armRollover() {
_rollover?.cancel();
_rollover = Timer(_day.untilNextDay, _rolloverCheck);
}
/// Turns the queue over when the service day has moved on.
void _rolloverCheck() {
if (!mounted) return;
_armRollover();
if (!_day.rollIfNeeded()) return;
debugPrint('[MYPICKUPS] the day rolled over to ${_day.day} — refetching');
_fetchPicked(force: true);
}
// ══════════════════════════════════════════════════════════════════════
// THE MILK RUN'S ROUND
//
@@ -467,20 +549,59 @@ class _MyPickupsState extends State<MyPickups>
/// The completed stops come from the same store the Activity tab reads, so
/// the two agree about what was finished, and they lead because they were
/// done first. The open ones follow in the hub's order.
///
/// ── Why the rail was counting stops the rider never rode ──
///
/// The completed store is not a list of finished *deliveries*. It is where
/// every order that left the rider's hands is filed, whatever ended it — and
/// **a declined stop is filed there too** (`addCompletedBookings(...,
/// terminalStatus: 'rejected')`, from Home's decline). That was invisible for
/// as long as nothing read the store as a route.
///
/// This reads it as a route, and the arithmetic was plainly wrong: a rider
/// who took one order out of five and declined the other four got a rail of
/// **five** nodes. Worse than the count, each wore the wrong colour —
/// `rejected` maps to [StopProgress.pending], so four stops he had refused
/// were drawn ahead of him as work still to come, and a `cancelled` one is
/// [StopStatusX.isWorkComplete] and draws **green**, claiming a delivery that
/// never happened.
///
/// So the rail draws what he actually rode. A skip stays — it is unfinished
/// business and the rail has an amber node to say so, which is the whole
/// reason that colour exists. A stop he declined and a stop the office called
/// off are not on his route at all.
///
/// ── And it draws the trip it is labelled with ──
///
/// The strip is headed `Trip 2 · 10:00 AM – 1:00 PM` — see [_buildTripRail] —
/// while the store it reads holds the **whole day**, so on a second run the
/// heading named one trip and the nodes counted two. Completed stops are kept
/// to the trip in front of the rider whenever both numbers are known;
/// anything unplaced is kept, because dropping a stop for want of a trip
/// number would understate a day the rider really did work.
///
/// With no open stops there is no current trip and nothing is scoped away:
/// a rider who has just closed his last stop still sees the full green rail,
/// which is the case this getter was written for.
List<Map<String, dynamic>> get _railStops {
final open = _visibleStops;
if (_completedToday.isEmpty) return open;
final openKeys = open.map(_getOrderKey).toSet();
final done = _completedToday
.where((o) => !openKeys.contains(_getOrderKey(o)))
.toList()
.reversed // the store hands them back newest first
.toList();
final trip = _currentTripNumber;
final done = <Map<String, dynamic>>[
// The store hands them back newest first; the rail reads in route order.
for (final o in _completedToday.reversed)
if (!openKeys.contains(_getOrderKey(o)) && wasRiddenTo(o))
if (trip == null || (_tripNumberOf(o) ?? trip) == trip) o,
];
return [...done, ...open];
}
/// Progress state for every stop on the accepted trip, in the admin's fixed
/// order — what drives the red→green rail at the top of Bookings.
///
@@ -545,9 +666,28 @@ class _MyPickupsState extends State<MyPickups>
hubLng: _currentLocation?.longitude,
);
// ── The number is the slot, not the position in the list ──
//
// This read `i + 1` over the trips themselves, and it agreed with Home only
// by accident: while nothing could place a trip by day part, every run fell
// into one undated bucket and position and slot were the same number.
//
// They are not any more. [Trip.dayPartTimeOf] places a run in the part of
// the day it was assigned in, so a rider whose whole day is an afternoon
// run has one trip — at **slot 1**, which Home's tabs and the hub both call
// Trip 2, and which this method would have called Trip 1. That is precisely
// the failure the doc above says it exists to prevent, arriving through the
// arithmetic rather than through the input.
//
// [TripSlots.slots] is the same laying-out Home's tab bar uses, including
// its fallback to arrival order when the day parts cannot place every trip
// — so the two screens cannot produce different numbers for one stop
// without the tabs themselves being wrong.
final slots = trips.slots;
return <String, int>{
for (var i = 0; i < trips.length; i++)
for (final id in trips[i].orderIds) id: i + 1,
for (var i = 0; i < slots.length; i++)
if (slots[i] != null)
for (final id in slots[i]!.orderIds) id: i + 1,
};
}
@@ -629,12 +769,12 @@ class _MyPickupsState extends State<MyPickups>
///
/// Read once per refresh rather than per card: it is one preferences hit, and
/// a `FutureBuilder` per row would blink a bagless card in on every rebuild.
Map<String, String> _bagLabels = const {};
Map<String, String> _orderLabels = const {};
Future<void> _loadBagLabels() async {
final labels = await getBagLabels();
Future<void> _loadOrderLabels() async {
final labels = await getOrderLabels();
if (!mounted) return;
setState(() => _bagLabels = labels);
setState(() => _orderLabels = labels);
}
/// ── The queue, in the order it will be worked ──
@@ -722,7 +862,7 @@ class _MyPickupsState extends State<MyPickups>
_visibleStops,
_visibleStops.indexOf(stop),
),
bag: _bagLabels[(stop['orderid'] ?? '').toString()] ?? '',
label: _orderLabels[(stop['orderid'] ?? '').toString()] ?? '',
reason: _skippedOrdersCache[_getOrderKey(stop)] ?? '',
),
);
@@ -870,7 +1010,11 @@ class _MyPickupsState extends State<MyPickups>
// The number leads and the window follows it, because the number is the
// shared name and the window is the detail: "Trip 2 · 10:00 AM – 1:00 PM".
final tripNo = _currentTripNumber;
final window = trip.slotStart != null ? trip.slotLabel : null;
// A clock range only. The day part's name would print `Trip 1 · Morning`,
// which is the same fact twice — the number *is* the day part. See
// [Trip.slotClockLabel].
final clock = trip.slotClockLabel;
final window = clock.isEmpty ? null : clock;
final label = tripNo == null
? (window ?? 'Your route')
: window == null
@@ -1023,12 +1167,14 @@ class _MyPickupsState extends State<MyPickups>
BottomPage.currentTab.addListener(_onTabChanged);
// Run these in parallel
_armRollover();
_restoreSkips();
_restoreClosedToday();
_restoreActivePickup();
_initializeLocation(); // Don't block
_fetchPicked();
_loadBagLabels();
_loadOrderLabels();
_startPollingStream();
}
@@ -1178,6 +1324,11 @@ class _MyPickupsState extends State<MyPickups>
@override
void didChangeAppLifecycleState(AppLifecycleState state) {
super.didChangeAppLifecycleState(state);
// Before the early return below: a resume that does not change the
// foreground flag still has to notice a midnight that passed while the
// phone was in the rider's pocket, which is the case the timer cannot
// cover — both platforms suspend timers in the background.
if (state == AppLifecycleState.resumed) _rolloverCheck();
final bool foreground = state == AppLifecycleState.resumed;
if (foreground == _pollForeground) return;
_pollForeground = foreground;
@@ -1280,6 +1431,7 @@ class _MyPickupsState extends State<MyPickups>
WidgetsBinding.instance.removeObserver(this);
BottomPage.currentTab.removeListener(_onTabChanged);
_pollerSubscription?.cancel();
_rollover?.cancel();
for (final timer in _pickupTimers.values) {
timer.cancel();
}
@@ -1376,114 +1528,8 @@ class _MyPickupsState extends State<MyPickups>
];
// ══════════════════════════════════════════════════════════════════════
// START DELIVERY — the load leaves the counter
//
// ── Why this is a press and not a side effect of the pickup ──
//
// The release used to ride along with `pickup-complete`, back on Home: the
// rider slid to confirm five bags at a kitchen and the same gesture posted
// all five consignments `Out_for_Delivery`. The hub's board then showed five
// *active* deliveries for food still on the shelf in front of him, and there
// was no moment left in the day that meant "I have set off" — picked and
// out-for-delivery had been collapsed into one claim.
//
// They are two different claims about where the load is, made minutes or an
// hour apart, and only the rider can make the second one. So it is his press,
// on the tab that holds the load.
//
// ── Why one bar for the whole load ──
//
// `POST /miler/deliveries/start` takes a batch because the gesture is one
// press after the last counter. Releasing per card would be five presses for
// one act and would leave the round half-open — some rows deliverable, some
// refused at the door by a server the rider cannot argue with.
// ══════════════════════════════════════════════════════════════════════
/// Orders in the rider's hands that he has not yet declared himself riding.
///
/// The bar's subject, and the reason it appears at all: an empty answer means
/// the whole load is already on the road and there is nothing left to press.
///
/// Empty on every line but the milk run, and deliberately: a logistics parcel
/// is collected *for the hub* and delivered by somebody else, so its rider
/// has no round to start and must never be shown a control that says he has.
/// [MilkRun.navigatesToCustomer] asks the same question one stop at a time.
List<Map<String, dynamic>> get _unreleased => !_isMilkRun
? const []
: [
for (final s in _visibleStops)
// The same three exclusions the queue itself applies, so the bar
// can never count a row the rider cannot see: work he has already
// closed, work he has put down, and work already on the road.
if (!stopStatusOf(s).isWorkComplete &&
!stopStatusOf(s).isCancelled &&
!stopStatusOf(s).isSkipped &&
!_completedOrderKeys.contains(_getOrderKey(s)) &&
_needsRelease(s))
s,
];
/// Whether this stop is still waiting on the rider's **Start delivery**.
///
/// ── Read from the consignment, not from a flag in this app ──
///
/// Two backend behaviours are live at once and the app must not care which
/// it is talking to. `pickup-complete` either leaves a hyperlocal
/// consignment `Out_for_Delivery` (as it does today) or stops it at
/// `Collected_By_Miler` and waits for `start-delivery` — a server-side
/// setting, not something this app is told about.
///
/// So the row is asked. `consignmentstatus` ships on every
/// `GET /miler/bookings` row, and it answers the question exactly: needing
/// release means needing release, and already out for delivery means the bar
/// has nothing to offer. **No feature flag is mirrored here**, because a
/// mirrored flag is a second source of truth that can be wrong.
///
/// ── The rider's press decides this, not the server's rung ──
///
/// This read the consignment state first and only fell back to the local
/// sets when the row carried none. That is the right instinct — a local flag
/// must never outrank a server fact — and it produced the wrong answer for
/// the case that is live on production today.
///
/// Two backend behaviours ship at once. With `MILER_COLLECTED_STATE_ENABLED`
/// **on**, `pickup-complete` stops at `Collected_By_Miler` and this method's
/// old reading is exactly right. With it **off** — compatibility mode, which
/// is the default and what the app meets in production — `pickup-complete`
/// releases the consignment itself, so a stop arrives on this tab already
/// `Out_for_Delivery`, `needsRelease` answers false, and the round starts
/// itself. The rider never sees PICKED and **Start delivery** never appears:
/// he collects at the kitchen and the app has him on the road before he has
/// left the counter.
///
/// So the two questions are separated, because they were never the same one:
///
/// ```
/// may this be delivered? → the consignment. ConsignmentGate, deliver
/// has he set off? → the rider. this method
/// ```
///
/// Nothing here contradicts the server. A stop the app holds at PICKED is
/// still `Out_for_Delivery` on the wire, `deliver` is still gated on the
/// consignment's own state, and pressing **Start delivery** on a consignment
/// that is already released costs no request at all — `releaseForDelivery`
/// returns true on sight of a deliverable state. What changes is only which
/// of the two facts the rider's card is showing him, and the answer is the
/// one he can act on.
///
/// The consignment state stays the fallback for a stop this device has no
/// record of — collected on another handset, or after a reinstall.
bool _needsRelease(Map<String, dynamic> stop) {
final id = MilkRun.idOf(stop);
// He pressed it. Nothing outranks that.
if (_outForDeliveryIds.contains(id)) return false;
// He collected it here and has not pressed it.
if (_collectedIds.contains(id)) return true;
return consignmentStateFromRaw(stop['consignmentstatus']).needsRelease;
}
/// True while the round is being marked started, so the bar cannot be
/// double-pressed.
/// True while a round is being marked started, so [startRound] cannot run
/// twice over the same stop.
bool _starting = false;
/// Sets off: releases each collected consignment for delivery, server first.
@@ -1508,28 +1554,48 @@ class _MyPickupsState extends State<MyPickups>
///
/// **The local set is written only for what the server released.** A stop
/// whose consignment could not be reached or was refused keeps its PICKED
/// word and stays on the bar, because the alternative — showing ACTIVE for
/// a consignment the hub still calls collected — is the fiction that made
/// `deliver` fail at the door with nothing on screen to explain why.
/// word, because the alternative — showing ACTIVE for a consignment the hub
/// still calls collected — is the fiction that made `deliver` fail at the
/// door with nothing on screen to explain why.
///
/// Returns the number of orders actually released.
/// ── The bar that used to call this is gone ──
///
/// There was a **Start delivery** bar pinned above the nav on this screen:
/// `5 orders in hand`, one press, release the lot. It was removed at the
/// rider's request, and the argument for it does not survive contact with how
/// the round is actually ridden.
///
/// It existed because "I have set off" is a claim only the rider can make,
/// and that is still true — but he already makes it, once per stop, when he
/// slides **Start ride** on the map. That slider calls straight into this
/// method (see `map.dart`), so the release was never exclusive to the bar:
/// the bar was a second way to make the same claim, earlier, in bulk, for
/// stops he had not set off for yet.
///
/// Which is what made it worth removing rather than merely redundant. A
/// batch release says the whole load is on the road at a moment when at most
/// one bag is, so the hub's board read *active* for four stops still in the
/// rider's box — the exact failure the bar was introduced to fix, moved one
/// step later in the day. Releasing per stop, at the moment he rides to it,
/// is the honest version of the same act.
///
/// Nothing is stranded: a consignment that needs releasing is released when
/// he sets off for it, and one already released costs no request at all —
/// `releaseForDelivery` returns true on sight of a deliverable state.
///
/// Still takes a list, because the caller passes one and a batch of one is
/// the common case. Returns the number of orders actually released.
Future<int> startRound(List<Map<String, dynamic>> stops) async {
if (_starting || stops.isEmpty) return 0;
setState(() => _starting = true);
try {
final released = <String>[];
var unreachable = 0;
for (final stop in stops) {
final orderId = MilkRun.idOf(stop);
if (orderId.isEmpty) continue;
if (await releaseForDelivery(stop)) {
released.add(orderId);
} else {
unreachable++;
}
if (await releaseForDelivery(stop)) released.add(orderId);
}
_unreleasedFailures = unreachable;
if (released.isEmpty) return 0;
await addOutForDeliveryOrderIds(released);
@@ -1548,52 +1614,16 @@ class _MyPickupsState extends State<MyPickups>
}
}
/// How many stops the last [startRound] could not release. Read once by
/// [_startWholeRound] to word the message honestly.
int _unreleasedFailures = 0;
/// Scroll extent to reserve under the queue for whatever floats over it.
///
/// Reads the same two conditions the slot itself reads, so the floor and the
/// surface can never disagree about which one is on screen.
/// Reads the same condition the slot itself reads, so the floor and the
/// surface can never disagree about what is on screen.
double _bottomReservation(BuildContext context) => bottomReservationFor(
inset: BottomPage.bottomInset(context),
live: _liveOnThisScreen.isNotEmpty,
unreleased: _unreleased.isNotEmpty,
idle: 8.h,
);
Future<void> _startWholeRound() async {
final stops = _unreleased;
final n = await startRound(stops);
if (!mounted) return;
final held = _unreleasedFailures;
if (n == 0) {
// One stop, one reason: say it. `releaseForDelivery` knows whether the
// parcel is at a hub, missing its reference, refused, or genuinely
// unreachable — see [lastReleaseFailure] — and "check your connection"
// is true for only the last of those.
//
// A whole round that failed keeps the general wording: with several
// stops there is no single reason to give, and the per-stop detail is in
// the log.
AppFeedback.errorGlobal(
held == 1
? (lastReleaseFailure ??
'Could not start that delivery. Check your connection and '
'try again.')
: 'Could not start the round. Check your connection and try again.',
);
return;
}
AppFeedback.successGlobal(
held > 0
? '$n started · $held could not be started'
: (n == 1 ? 'Delivery started' : '$n deliveries started'),
);
}
/// Marks a stop as finished (picked up or cancelled) in local state right
/// away, so the UI unblocks without waiting for the backend/poll to catch up:
/// it leaves the active banner, drops out of the top list, and no longer
@@ -1874,7 +1904,7 @@ class _MyPickupsState extends State<MyPickups>
// The bag each order is in, re-read with the list it labels: a pickup that
// happened on Home a moment ago must show its bags here without the rider
// pulling to refresh.
unawaited(_loadBagLabels());
unawaited(_loadOrderLabels());
try {
final prefs = await SharedPreferences.getInstance();
final userId = prefs.getInt('userId') ?? prefs.getInt('userid') ?? 0;
@@ -1934,7 +1964,7 @@ class _MyPickupsState extends State<MyPickups>
}
}
final items = mergedOrders.values.toList();
var items = mergedOrders.values.toList();
debugPrint('[MYPICKUPS] Merged items count: ${items.length}');
// Today's finished stops, for the rail. Read on every fetch rather than
@@ -1957,6 +1987,21 @@ class _MyPickupsState extends State<MyPickups>
debugPrint('[MYPICKUPS] Merged $added accepted bookings from Home');
}
// ── Today's, and only today's ──
//
// Applied here, once, on the merged day: after both endpoints and the
// accepted store, and before anything is derived from it. Everything
// below reads this list — the trip numbering, the milk run's whole-day
// set, the delivery queue, the rail — so filtering at one boundary is
// what stops a count above the queue from totalling a different set of
// days than the queue under it.
//
// `_completedToday` is deliberately not put through it: the completed
// store prunes itself to today on read, and it was already correct.
//
// See [_todayOnly], and [ServiceDay.onlyToday] for the rule Home shares.
items = _todayOnly(items);
// ── The day's shape, before any of this screen's filtering ──
//
// Everything today: what is assigned, what he took, what he finished.
@@ -3206,7 +3251,7 @@ class _MyPickupsState extends State<MyPickups>
// The pairing recorded at the
// counter — same store as the
// card, so the two agree.
bag: row.bag,
label: row.label,
// The carried set — what turns
// a raw pickup row into the
// delivery leg the sheet must
@@ -3236,14 +3281,14 @@ class _MyPickupsState extends State<MyPickups>
distanceMeters,
riderSpeedMps:
_currentLocation?.speed,
bag: row.bag,
label: row.label,
collectedIds: _collectedIds,
outForDeliveryIds:
_outForDeliveryIds,
),
QueueDensity.next => _NextCard(
item: item,
bag: row.bag,
label: row.label,
distanceMeters:
distanceMeters,
riderSpeedMps:
@@ -3252,7 +3297,7 @@ class _MyPickupsState extends State<MyPickups>
),
QueueDensity.later => _LaterRow(
item: item,
bag: row.bag,
label: row.label,
distanceMeters:
distanceMeters,
onOpen: open,
@@ -3260,7 +3305,7 @@ class _MyPickupsState extends State<MyPickups>
QueueDensity.skipped =>
_SkippedRow(
item: item,
bag: row.bag,
label: row.label,
reason: row.reason,
onOpen: open,
onResume: () =>
@@ -3347,13 +3392,6 @@ class _MyPickupsState extends State<MyPickups>
}
},
)
: _unreleased.isNotEmpty
? StartRoundBar(
key: const ValueKey('start-round'),
count: _unreleased.length,
busy: _starting,
onPressed: _startWholeRound,
)
: const SizedBox.shrink(key: ValueKey('none')),
),
),
@@ -3366,113 +3404,27 @@ class _MyPickupsState extends State<MyPickups>
}
}
/// ─────────────────────────────────────────────────────────────────────────
/// START DELIVERY — one press, the whole load
///
/// The bar the rider hits after the last counter. It states what it is about to
/// act on — `5 orders in hand` — because the press releases every one of them,
/// and a control acting on a set the rider cannot see is one he learns not to
/// trust.
///
/// ── Not a slide ──
///
/// Slides are reserved for the writes a resting thumb must not be able to make:
/// "picked" is the rider asserting he is holding somebody's lunch, "delivered"
/// that he has handed it over. Setting off is neither irreversible nor a claim
/// about somebody else's property — pressing it early costs a hub board that
/// reads *active* a few minutes early — so it is a button, at the size of every
/// other primary action in the app.
///
/// It sits above the floating nav bar rather than under it: [BottomPage] owns
/// that inset, and using it here is what keeps the button clear of the tab
/// strip on a tall phone.
/// How much scroll extent the queue must leave under itself.
///
/// ── Why this is a function and not a number ──
///
/// It was two branches and a magic constant: the unreleased case was built
/// from its bar's own pieces, and the live case was a flat `80.h` that forgot
/// the device inset entirely — so on a gesture-navigation phone the last row of
/// the run sat behind the banner *and* behind the navigation, with its controls
/// unreachable and no way to scroll to them.
/// It was two branches and a magic constant, and the live case was a flat
/// `80.h` that forgot the device inset entirely — so on a gesture-navigation
/// phone the last row of the run sat behind the banner *and* behind the
/// navigation, with its controls unreachable and no way to scroll to them.
///
/// One rule, reading the same two conditions the slot itself reads, so the
/// floor and the surface can never disagree about which one is on screen. Each
/// surface states its own height, because the thing that overlays a list is the
/// only thing that knows how much of the list it covers.
/// One rule, reading the same condition the slot itself reads, so the floor and
/// the surface can never disagree about what is on screen. The surface states
/// its own height, because the thing that overlays a list is the only thing
/// that knows how much of the list it covers.
///
/// ── One surface, where there were two ──
///
/// The other was the **Start delivery** bar, and it is gone with the control —
/// see the note above `startRound`. Nothing floats over this
/// list now except the live strip.
double bottomReservationFor({
required double inset,
required bool live,
required bool unreleased,
double idle = 8,
}) {
if (live) return inset + ActivePickupBanner.maxHeight;
if (unreleased) return inset + StartRoundBar.maxHeight;
return inset + idle;
}
class StartRoundBar extends StatelessWidget {
/// The tallest this bar gets, excluding the device inset. See
/// [ActivePickupBanner.maxHeight] for why the surface declares its own.
static double get maxHeight => ButtonSizes.primary + 54.h;
final int count;
final bool busy;
final VoidCallback onPressed;
const StartRoundBar({
super.key,
required this.count,
required this.busy,
required this.onPressed,
});
@override
Widget build(BuildContext context) {
return Container(
padding: EdgeInsets.fromLTRB(
16.w,
12.h,
16.w,
BottomPage.bottomInset(context) + 10.h,
),
decoration: BoxDecoration(
color: ColorConstants.pureSurface,
boxShadow: [
// The list scrolls under this, so the edge has to read as an edge — a
// shadow rather than a rule, for the same reason the route cards have
// one: a hairline is not there on a scratched screen in sun, and a
// rule across a scrolling list reads as a divider between two rows.
BoxShadow(
color: ColorConstants.slateText.withValues(alpha: 0.10),
blurRadius: 18,
offset: const Offset(0, -4),
),
],
),
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'$count ${count == 1 ? 'order' : 'orders'} in hand',
style: TextStyle(
fontSize: 13.sp,
fontWeight: FontWeight.w600,
color: ColorConstants.secondaryText,
fontFamily: FontConstants.fontFamily,
),
),
SizedBox(height: 8.h),
MilerButton(
label: 'Start delivery',
icon: LucideIcons.truck,
color: ColorConstants.primary,
loading: busy,
onPressed: busy ? null : onPressed,
),
],
),
);
}
}
}) => live ? inset + ActivePickupBanner.maxHeight : inset + idle;

4
lib/views/Dashboard/pickups/sheet.dart
View File

@@ -1237,12 +1237,12 @@ class _StopBrief extends StatelessWidget {
/// `Bag 5 · Vidhya Kitchen`, whichever halves exist; the trimmed booking
/// reference only as a last resort.
String _subtitle(String orderId) {
final bag = (pickup['baglabel'] ?? pickup['BagLabel'] ?? '')
final printed = (pickup['baglabel'] ?? pickup['BagLabel'] ?? '')
.toString()
.trim();
final source = stopSourceName(pickup);
final line = [
if (bag.isNotEmpty) bag,
if (printed.isNotEmpty) printed,
if (source.isNotEmpty) source,
].join(' \u00b7 ');
if (line.isNotEmpty) return line;

14
lib/views/Dashboard/pickups/stop_type.dart
View File

@@ -169,12 +169,18 @@ String stopSourceId(Map<String, dynamic> item) =>
.toString()
.trim();
/// The label physically on the bag, matched at the kitchen and read at the door.
/// The label the counter physically printed on an order, matched at the kitchen
/// and read at the door. Empty when it printed none.
///
/// Ten near-identical lunch bags is where mis-delivery comes from, and no OTP or
/// Ten near-identical lunches is where mis-delivery comes from, and no OTP or
/// photo catches it — the rider is confident, he is just at the wrong door with
/// the wrong bag. A printed label on the card is the cheapest thing that does.
String stopBagLabel(Map<String, dynamic> item) =>
/// the wrong one. A printed label on the card is the cheapest thing that does.
///
/// The key names are the wire's and stay as the wire spells them; what the app
/// does with the value is its own business. Nothing is derived here — a counter
/// that prints nothing yields `''`, and every screen then shows no tag rather
/// than a number the app made up. See [OrderManifest.labelFor].
String stopPrintedLabel(Map<String, dynamic> item) =>
(item['baglabel'] ??
item['BagLabel'] ??
item['bagid'] ??

38
lib/views/helpers/constants/Colorconstants.dart
View File

@@ -107,6 +107,44 @@ class ColorConstants {
static const Color onWarning = Color(0xFFFFFFFF);
static const Color warningContainer = Color(0xFFFEF3C7);
/// **Waiting on the rider** — the state word on a stop he has not decided yet.
///
/// ── Why a fourth amber, and not one of the three above ──
///
/// Pending was neutral grey, on a real argument: on a fresh morning *every*
/// stop is pending, so painting them all in the exception hue opens the whole
/// screen in warning and leaves nothing to say with when something actually
/// goes wrong. That argument is still right about [warning], which is this
/// app's word for *something has gone off plan* — a skipped stop, a short
/// payment, a bag that never arrived.
///
/// What it got wrong is that "nobody has done anything about this yet" is
/// itself worth a colour. A rider scanning a run had to infer it from the
/// *absence* of one, which is the single thing a glance cannot do, and
/// undecided work is precisely the work the screen exists to move.
///
/// So it gets its own: a gold that reads as "waiting" rather than as
/// "wrong", far enough round the wheel from the burnt orange of [warning]
/// that a pending stop and a skipped one are two different marks — and dark
/// enough to be *text*, which no honest yellow on a light ground can be
/// without going most of the way to brown. 5.54:1 on white, 4.83:1 on the
/// canvas, 4.81:1 on [cardSurface]: AA at the 13.5sp these words are set at,
/// on every surface Home draws them on.
static const Color pendingAmber = Color(0xFF8A6100);
/// **In the rider's hands** — collected from the counter, not yet delivered.
///
/// Green is the wrong end of the story for it. [acceptGreen] now marks the
/// moment the rider *takes a stop on*, and green everywhere else in this app
/// means finished — so a bag that has been picked up but not delivered would
/// have worn either "already decided" or "already done", and it is neither.
///
/// This is the app's own delivery hue, which is exactly what a picked bag has
/// become: work that has left the pickup leg and belongs to the round. Same
/// value as [deliveryAccent], named separately so the two can part company if
/// the route map ever needs its own.
static const Color pickedBlue = deliveryAccent;
// Extended Color Palette for Professional UI
/// Captions, labels and secondary body text — the second most-used colour in
/// the app after [slateText], on 89 call sites across every screen.

12
lib/views/helpers/widgets/app_widgets.dart
View File

@@ -1989,7 +1989,7 @@ class ErrorRetry extends StatelessWidget {
/// ─────────────────────────────────────────────────────────────────────────
class StopSourceLine extends StatelessWidget {
final String source;
final String bagLabel;
final String printedLabel;
/// Dims both when the stop is not actionable, matching the card around it.
final bool muted;
@@ -2001,12 +2001,12 @@ class StopSourceLine extends StatelessWidget {
const StopSourceLine({
super.key,
required this.source,
required this.bagLabel,
required this.printedLabel,
this.muted = false,
this.topGap = 6,
});
bool get _isEmpty => source.isEmpty && bagLabel.isEmpty;
bool get _isEmpty => source.isEmpty && printedLabel.isEmpty;
@override
Widget build(BuildContext context) {
@@ -2053,12 +2053,12 @@ class StopSourceLine extends StatelessWidget {
),
),
),
if (source.isNotEmpty && bagLabel.isNotEmpty)
if (source.isNotEmpty && printedLabel.isNotEmpty)
const SizedBox(width: 8),
if (bagLabel.isNotEmpty)
if (printedLabel.isNotEmpty)
Flexible(
child: Text(
'Bag $bagLabel',
printedLabel,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(