) : (
@@ -887,6 +1030,14 @@ export default function MultipleOrders() {
| # |
Customer |
+ {/* Only in customer-pickup mode, and deliberately BEFORE the
+ delivery address: a geocoded sender line is the one thing
+ on this screen the operator has not seen with their own
+ eyes. A coarse "Edayarpalayam, Coimbatore" resolves to a
+ landmark in that locality, not the kitchen, and a rider
+ sent there arrives at the wrong door. Better caught here
+ than after thirteen orders are live. */}
+ {isCustomerPickup && Collect from | }
Address |
Qty |
Cash (₹) |
@@ -905,6 +1056,30 @@ export default function MultipleOrders() {
{row.firstname || '—'}
{row.contactno || '—'}
+ {isCustomerPickup && (
+
+ {row.__pickup ? (
+ <>
+
+ {row.__pickup.locationname || 'Customer Pickup'}
+
+
+ {row.__pickup.address}
+
+
+ ) : (
+
+ Fell back to hub
+
+ )}
+ |
+ )}
{needsAddress ? (
statusesInGroup(tab), [tab]);
+ /* Which end of each booking is a facility. This page reads RAW bookings
+ rather than the deliveries feed, so it has to classify for itself — but
+ against the same shared anchor list, so a row cannot read "customer
+ pickup" here and "hub run" on Dispatch. */
+ const { data: flowAnchors = [] } = useFlowAnchors((bookings || []).map((b) => b?.tenantid));
+
const rows = useMemo(
() =>
(zoneBookings || [])
@@ -315,17 +327,37 @@ export default function Orders() {
customer?.firstname ||
customer?.name ||
(row.appcustomerid ? `Customer #${row.appcustomerid}` : 'Drop');
+ /* "Pickup" alone reads as "collected from our hub", which is what it
+ always meant. Once it can also mean a doorstep, the row has to say
+ which — otherwise two very different journeys look identical in the
+ list. Silent on an ordinary hub run, so the label only appears
+ where it carries information. */
+ const flow = classifyBooking(row, flowAnchors);
+ const isCustomerPickup = flow.flow !== FLOW.FORWARD && flow.pickupSource === 'customer';
return (
- Pickup
+
+ {isCustomerPickup ? 'Customer pickup' : 'Pickup'}
+
{row.pickupaddress ? ` · ${row.pickupaddress}` : ' · —'}
-
- {dropName}
- {row.deliveryaddress ? ` · ${row.deliveryaddress}` : ''}
- {row.parcels?.length > 1 ? ` · ${row.parcels.length} parcels` : ''}
-
+ {/* Collapsed, a multi-drop row reads as ONE pickup request that
+ created several shipments — never as one of them. The flat
+ `deliveryaddress` it would otherwise show is destination 0
+ mirrored by CreateCxBooking, so on a three-drop pickup it is
+ Chennai standing in for all three. Open the row for the legs. */}
+ {isMultiDrop(row) ? (
+
+ {dropSummary(row)}
+
+ ) : (
+
+ {dropName}
+ {row.deliveryaddress ? ` · ${row.deliveryaddress}` : ''}
+ {row.parcels?.length > 1 ? ` · ${row.parcels.length} parcels` : ''}
+
+ )}
);
},
@@ -361,6 +393,21 @@ export default function Orders() {
return ;
}
if (rawStatus === 'converted_to_consignment') {
+ /* THE ONE THAT WOULD SILENTLY LIE.
+ `pickupbookings.consignmentid` names the FIRST leg only — set
+ that way at pickup-complete so single-drop screens keep working
+ — and `consignmentstatus` is joined from it. On a three-drop
+ pickup that is Chennai's status wearing the whole booking's
+ name, and rendering it here would confidently report "Delivered"
+ while two parcels are still in transit.
+
+ A multi-drop row therefore shows the PICKUP's own state, which
+ is genuinely finished once the rider has collected. Per-leg
+ status lives in the drawer, read from each destination's own
+ stage. */
+ if (isMultiDrop(row)) {
+ return ;
+ }
const cStatus = row.consignmentstatus ?? row.consignment_status;
return ;
}
@@ -476,6 +523,18 @@ export default function Orders() {
{!isAllZones && (
· Zone: {selectedZone.hubname}
)}
+ {/* Search runs over the flat booking columns, and `deliveryaddress`
+ is destination 0 mirrored by CreateCxBooking. Searching
+ "Ernakulam" on a three-drop pickup whose first drop is Chennai
+ therefore finds nothing. The list has no destination array to
+ index — it carries only the counts, deliberately — so the honest
+ fix is to say which drop is searched rather than to fail
+ silently. */}
+ {debouncedSearch && (
+
+ {' '}· search covers the order number, pickup, notes and the first drop only
+
+ )}
{/* A capped scan means an order really can be missing from this tab.
Say so — a silently short list is what sent operators hunting for
an order they had just created. */}
@@ -493,6 +552,12 @@ export default function Orders() {
columns={columns}
rows={rows}
getRowId={(row) => row.bookingid}
+ /* Opens the drops for ANY booking, not only multi-drop ones: the
+ per-destination recipient, instructions and COD exist nowhere else
+ in the console, and a row that is clickable only sometimes is worse
+ than one that always is. The checkbox cell stops propagation, so
+ this does not fight selection. */
+ onRowClick={(row) => setDropsRow(row)}
loading={isLoading}
refreshing={isFetching && !isLoading}
selectedIds={tab === 'pending' && !isAllZones ? selectedIds : undefined}
@@ -630,6 +695,15 @@ export default function Orders() {
})
}
/>
+
+ {
+ if (!next) setDropsRow(null);
+ }}
+ bookingId={dropsRow?.bookingid}
+ bookingNo={dropsRow?.bookingno || (dropsRow ? `#${dropsRow.bookingid}` : undefined)}
+ />
);
}
diff --git a/tests/fixtures/doormile-logistics-test.xlsx b/tests/fixtures/doormile-logistics-test.xlsx
new file mode 100644
index 0000000..39e0093
Binary files /dev/null and b/tests/fixtures/doormile-logistics-test.xlsx differ
diff --git a/tests/fixtures/jayanthi-kitchen-route.xls b/tests/fixtures/jayanthi-kitchen-route.xls
new file mode 100644
index 0000000..a00ab7f
Binary files /dev/null and b/tests/fixtures/jayanthi-kitchen-route.xls differ
diff --git a/tests/integration/bulkUpload.test.js b/tests/integration/bulkUpload.test.js
new file mode 100644
index 0000000..13e11bd
--- /dev/null
+++ b/tests/integration/bulkUpload.test.js
@@ -0,0 +1,459 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as XLSX from 'xlsx';
+
+import {
+ SHEET_HEADER_MAP,
+ cleanReceiverName,
+ normalizeHeader,
+ requiredSheetColumns
+} from '@/lib/bulkOrderColumns';
+import { buildBulkBookingPayloads, buildParcels } from '@/lib/bulkOrderPayload';
+import { FLOW, buildAnchors, classifyBooking } from '@/lib/orderFlow';
+import { calculateTotalCharge } from '@/lib/distance';
+
+/**
+ * Bulk upload, end to end, against a REAL tenant file.
+ *
+ * `tests/fixtures/jayanthi-kitchen-route.xls` is an actual export a tenant
+ * uploaded: 13 lunch deliveries around Coimbatore, leaving from THREE different
+ * home kitchens — Jayanthi (6 drops), Latha (3), Manjusha (4).
+ *
+ * That file is the whole reason this suite exists. The page's bulk path was
+ * built on the assumption that one upload has one origin: it parsed the sheet's
+ * Sender columns and then overwrote every row's pickup with the single business
+ * location the operator had selected. Uploading this file therefore booked all
+ * 13 orders against one kitchen and silently erased the other two — the rider
+ * would be sent to Edayarpalayam for parcels sitting in Kavundampalayam.
+ *
+ * These tests drive the REAL modules the page imports — the real header map,
+ * the real payload builder, the real flow classifier. Nothing is reimplemented
+ * here, so a passing test is a statement about what the page does rather than
+ * about a copy of it that happens to agree today.
+ *
+ * The one thing deliberately NOT exercised is network geocoding. The fixture
+ * carries Receiver Latitude/Longitude for every row, so drops need no lookup;
+ * sender coordinates are injected from a stub table below, standing in for what
+ * the geocoder returns. That keeps the suite hermetic and deterministic while
+ * still covering every transformation that decides what goes on the wire.
+ */
+
+const FIXTURE = path.join(__dirname, '..', 'fixtures', 'jayanthi-kitchen-route.xls');
+
+// The tenant's selected business location — one origin, as the page has always
+// assumed. Coordinates are Jayanthi's kitchen.
+const BUSINESS_LOCATION = {
+ tenantlocationid: 31,
+ tenantid: 4,
+ hubid: 7,
+ locationname: 'Jayanthi Kitchen',
+ address: 'Edayarpalayam, Coimbatore, Tamil Nadu 641025',
+ city: 'Coimbatore',
+ pincode: '641025',
+ latitude: 11.0168,
+ longitude: 76.9558
+};
+
+const DOORMILE_HUB = {
+ hubid: 7,
+ hubname: 'Coimbatore Gandhipuram Hub',
+ latitude: 11.0168,
+ longitude: 76.9558
+};
+
+/* Stands in for the geocoder. Keyed by the sheet's exact Sender Address text —
+ the three kitchens the file actually contains. */
+const SENDER_COORDS = {
+ 'Edayarpalayam, Coimbatore, Tamil Nadu 641025': { lat: 11.0168, lng: 76.9558 },
+ 'Kavundampalayam, 641030': { lat: 11.0447, lng: 76.9382 },
+ 'Ramakrishnamill, Ganapathy, Coimbatore - 641006': { lat: 11.0296, lng: 76.9891 }
+};
+
+const RATE = { basePrice: 40, pricePerKm: 8, minKm: 5 };
+const DELIVERY_TIME = '2026-09-01 09:00:00';
+
+// ---- the page's own parse, reproduced from MultipleOrders.processData -------
+// The mapping table and normalizer are imported, not copied; only the loop that
+// walks them is restated, because it lives inside a component.
+const parseFixture = () => {
+ const wb = XLSX.read(fs.readFileSync(FIXTURE), { type: 'buffer' });
+ const sheet = wb.Sheets[wb.SheetNames[0]];
+ const raw = XLSX.utils.sheet_to_json(sheet, { defval: '' });
+
+ const normalizedMap = {};
+ for (const key in SHEET_HEADER_MAP) normalizedMap[normalizeHeader(key)] = SHEET_HEADER_MAP[key];
+
+ const rows = raw.map((row, idx) => {
+ const out = { _rowkey: `csv-${idx}`, quantity: 1, collectionamt: 0 };
+ for (const key in row) {
+ const clean = normalizeHeader(key);
+ const mapped = normalizedMap[clean] || clean;
+ out[mapped] = mapped === 'firstname' ? cleanReceiverName(row[key]) : row[key];
+ }
+ return out;
+ });
+
+ return { raw, rows, headers: Object.keys(raw[0]).map(normalizeHeader) };
+};
+
+/** Straight-line km, standing in for the OSRM call the page makes. Only used to
+ * give each row a plausible price so the payload has a real number in it. */
+const km = (a, b) => {
+ const toRad = (d) => (d * Math.PI) / 180;
+ const dLat = toRad(b.lat - a.lat);
+ const dLon = toRad(b.lng - a.lng);
+ const h =
+ Math.sin(dLat / 2) ** 2 + Math.cos(toRad(a.lat)) * Math.cos(toRad(b.lat)) * Math.sin(dLon / 2) ** 2;
+ return Math.round(6371 * 2 * Math.atan2(Math.sqrt(h), Math.sqrt(1 - h)));
+};
+
+/** Rows as the page holds them after processing: coordinates resolved, price
+ * computed, and `__pickup` attached when the run collects from customers. */
+const processRows = (rows, { customerPickup }) =>
+ rows.map((row) => {
+ const senderAddress = String(row.locationaddress || '').trim();
+ const coords = SENDER_COORDS[senderAddress];
+ const pickup =
+ customerPickup && coords
+ ? {
+ locationname: row.locationname || 'Customer Pickup',
+ contactno: String(row.locationcontact || '').replace(/\D/g, '').slice(0, 10),
+ address: senderAddress,
+ city: '',
+ pincode: '',
+ latitude: coords.lat,
+ longitude: coords.lng
+ }
+ : null;
+
+ const origin = pickup || BUSINESS_LOCATION;
+ const distance = km(
+ { lat: Number(origin.latitude), lng: Number(origin.longitude) },
+ { lat: Number(row.latitude), lng: Number(row.longitude) }
+ );
+
+ return {
+ ...row,
+ __pickup: pickup,
+ __pickupFellBack: customerPickup && !pickup,
+ distance,
+ totalcharge: calculateTotalCharge(distance, RATE.basePrice, RATE.pricePerKm, RATE.minKm)
+ };
+ });
+
+const anchors = buildAnchors({ hubs: [DOORMILE_HUB], tenantLocations: [BUSINESS_LOCATION] });
+
+const payloadsFor = (mode) =>
+ buildBulkBookingPayloads({
+ rows: processRows(parseFixture().rows, { customerPickup: mode === 'customer' }),
+ sharedPickup: BUSINESS_LOCATION,
+ tenantId: 4,
+ tenantLocationId: 31,
+ deliverytime: DELIVERY_TIME,
+ notes: 'Lunch run',
+ anchors
+ });
+
+describe('bulk upload — Jayanthi_Kitchen_Route.xls', () => {
+ describe('the file itself', () => {
+ it('should be a single sheet of 13 delivery rows', () => {
+ const { raw } = parseFixture();
+ expect(raw).toHaveLength(13);
+ });
+
+ it('should carry three distinct sender kitchens, not one', () => {
+ // The premise of the whole feature. If this ever collapses to one, the
+ // fixture has been replaced and these tests no longer prove anything.
+ const { rows } = parseFixture();
+ const senders = new Set(rows.map((r) => r.locationaddress));
+ expect(senders.size).toBe(3);
+ expect([...senders].sort()).toEqual([
+ 'Edayarpalayam, Coimbatore, Tamil Nadu 641025',
+ 'Kavundampalayam, 641030',
+ 'Ramakrishnamill, Ganapathy, Coimbatore - 641006'
+ ]);
+ });
+
+ it('should split as 6 / 3 / 4 across the three kitchens', () => {
+ const { rows } = parseFixture();
+ const counts = rows.reduce((acc, r) => {
+ acc[r.locationname] = (acc[r.locationname] || 0) + 1;
+ return acc;
+ }, {});
+ expect(counts).toEqual({ Jayanthi: 6, Latha: 3, Manjusha: 4 });
+ });
+ });
+
+ describe('header mapping', () => {
+ it('should map every sheet column the app knows about', () => {
+ const { raw } = parseFixture();
+ const normalizedMap = {};
+ for (const key in SHEET_HEADER_MAP) normalizedMap[normalizeHeader(key)] = SHEET_HEADER_MAP[key];
+
+ const unmapped = Object.keys(raw[0]).filter((h) => !normalizedMap[normalizeHeader(h)]);
+ // "Address id" is the tenant's own upstream record id. It is carried
+ // through unmapped and unused, which is correct — it means nothing here.
+ expect(unmapped).toEqual(['Address id']);
+ });
+
+ it('should tolerate the whitespace and casing the real header row carries', () => {
+ // The live header is "Pickup Date (YYYY-MMM-DD )" — note the space before
+ // the bracket. normalizeHeader strips ALL whitespace, which is the only
+ // reason this column resolves; a mapping keyed on the literal string
+ // would miss it.
+ expect(normalizeHeader('Pickup Date (YYYY-MMM-DD )')).toBe('pickupdate(yyyy-mmm-dd)');
+ expect(SHEET_HEADER_MAP['pickupdate(yyyy-mmm-dd)']).toBe('date');
+ });
+
+ it('should report no missing required columns', () => {
+ const { headers } = parseFixture();
+ const missing = requiredSheetColumns().filter((c) => !headers.includes(normalizeHeader(c)));
+ expect(missing).toEqual([]);
+ });
+
+ it('should give every row a delivery address and usable coordinates', () => {
+ const { rows } = parseFixture();
+ rows.forEach((row) => {
+ expect(String(row.address || '').trim()).not.toBe('');
+ expect(Number(row.latitude)).toBeGreaterThan(10);
+ expect(Number(row.longitude)).toBeGreaterThan(76);
+ });
+ });
+
+ it('should leave delivery city and pincode empty, because the sheet has no such columns', () => {
+ // Documented rather than asserted-away. bulkOrderColumns maps
+ // `receivercity`/`receiverpincode` speculatively — this real file proves
+ // the tenant does not send them, so deliverycity/deliverypincode go to the
+ // backend blank on every row of every upload from this tenant.
+ const { rows } = parseFixture();
+ expect(rows.every((r) => !r.city)).toBe(true);
+ expect(rows.every((r) => !r.postcode)).toBe(true);
+ });
+ });
+
+ describe('parcels — quantity and description', () => {
+ it('should expand quantity into one parcel entry per item', () => {
+ // Not cosmetic: the app reads quantity back as `parcels.length`
+ // everywhere downstream, so a 5-item order collapsed to one entry tells
+ // the rider to collect one bag.
+ expect(buildParcels({ quantity: 5, description: 'Low GI Carb Meal' })).toHaveLength(5);
+ expect(buildParcels({ quantity: 1 })).toHaveLength(1);
+ });
+
+ it('should never emit zero parcels, whatever the sheet says', () => {
+ [0, -3, '', null, undefined, 'abc', 1.4].forEach((quantity) => {
+ expect(buildParcels({ quantity }).length).toBeGreaterThanOrEqual(1);
+ });
+ });
+
+ it("should carry the sheet's own item description, not a placeholder", () => {
+ const [parcel] = buildParcels({ quantity: 1, description: 'Economy Lunch Lunch - Jayanthi-Delivery' });
+ expect(parcel.itemdescription).toBe('Economy Lunch Lunch - Jayanthi-Delivery');
+ });
+
+ it('should fall back to a generic description only when the sheet gives none', () => {
+ expect(buildParcels({ quantity: 1, description: ' ' })[0].itemdescription).toBe('Order');
+ });
+
+ it('should produce 19 parcels across the 13 rows of the real file', () => {
+ // 2+1+1+2+1+1+1+5+1+1+1+1+1 = 19. Before quantity was honoured this was 13.
+ const total = payloadsFor('hub').reduce((sum, b) => sum + b.parcels.length, 0);
+ expect(total).toBe(19);
+ });
+ });
+
+ describe('hub mode — every row collected from the one selected location', () => {
+ const payloads = payloadsFor('hub');
+
+ it('should produce one booking per sheet row', () => {
+ expect(payloads).toHaveLength(13);
+ });
+
+ it('should write the business location as the pickup on every row', () => {
+ payloads.forEach((b) => {
+ expect(b.pickupaddress).toBe(BUSINESS_LOCATION.address);
+ expect(b.pickuplatitude).toBe(BUSINESS_LOCATION.latitude);
+ expect(b.pickuplongitude).toBe(BUSINESS_LOCATION.longitude);
+ });
+ });
+
+ it('should classify every row as an ordinary hub run', () => {
+ payloads.forEach((b) => expect(b.ordertype).toBe(FLOW.FORWARD));
+ });
+
+ it('should carry each receiver through to the booking', () => {
+ expect(payloads[0].customer_name).toBe('Lalitha');
+ expect(payloads[0].customer_phone).toBe('9843174920');
+ expect(payloads[0].deliveryaddress).toContain('Lalitha boutique 36 Railway mens colony');
+ expect(payloads[0].deliverylatitude).toBeCloseTo(11.0506991, 6);
+ });
+
+ it('should send phone numbers as strings even though the sheet types them as numbers', () => {
+ // XLSX parses a phone cell as a Number. A number on the wire where the
+ // backend expects a string is the kind of thing that 400s the whole batch.
+ payloads.forEach((b) => {
+ expect(typeof b.customer_phone).toBe('string');
+ expect(b.customer_phone).toMatch(/^\d{10}$/);
+ });
+ });
+
+ it('should price every row and never send a zero or NaN charge', () => {
+ payloads.forEach((b) => {
+ expect(Number.isFinite(b.finalprice)).toBe(true);
+ expect(b.finalprice).toBeGreaterThanOrEqual(RATE.basePrice);
+ });
+ });
+
+ it('should stamp the servicing hub so the orders land in a zone', () => {
+ payloads.forEach((b) => {
+ expect(b.sourcehubid).toBe(7);
+ expect(b.hubid).toBe(7);
+ expect(b.tenantlocationid).toBe(31);
+ });
+ });
+ });
+
+ describe('customer-pickup mode — the case this file actually is', () => {
+ const payloads = payloadsFor('customer');
+
+ it('should give each row the pickup its OWN sender column names', () => {
+ // The defect this replaces: all 13 previously carried Jayanthi's address.
+ const byAddress = payloads.reduce((acc, b) => {
+ acc[b.pickupaddress] = (acc[b.pickupaddress] || 0) + 1;
+ return acc;
+ }, {});
+ expect(byAddress).toEqual({
+ 'Edayarpalayam, Coimbatore, Tamil Nadu 641025': 6,
+ 'Kavundampalayam, 641030': 3,
+ 'Ramakrishnamill, Ganapathy, Coimbatore - 641006': 4
+ });
+ });
+
+ it('should not write one origin across rows that came from another kitchen', () => {
+ // Row 8 is Kishore, collected at Latha's kitchen in Kavundampalayam.
+ const kishore = payloads.find((b) => b.customer_name === 'Kishore');
+ expect(kishore.pickupaddress).toBe('Kavundampalayam, 641030');
+ expect(kishore.pickuplatitude).toBeCloseTo(11.0447, 4);
+ expect(kishore.pickuplatitude).not.toBe(BUSINESS_LOCATION.latitude);
+ });
+
+ it('should give every row real pickup coordinates, never 0,0', () => {
+ payloads.forEach((b) => {
+ expect(b.pickuplatitude).not.toBe(0);
+ expect(b.pickuplongitude).not.toBe(0);
+ });
+ });
+
+ it('should classify a kitchen that IS a registered location as a hub run, not a doorstep', () => {
+ // Jayanthi's kitchen is the tenant's registered business location. Rows
+ // leaving it are hub pickups whatever mode the operator chose — the flow
+ // follows the facts, not the toggle.
+ const jayanthi = payloads.filter(
+ (b) => b.pickupaddress === 'Edayarpalayam, Coimbatore, Tamil Nadu 641025'
+ );
+ expect(jayanthi).toHaveLength(6);
+ jayanthi.forEach((b) => expect(b.ordertype).toBe(FLOW.FORWARD));
+ });
+
+ it("should classify the two UNREGISTERED kitchens as point-to-point collections", () => {
+ const others = payloads.filter(
+ (b) => b.pickupaddress !== 'Edayarpalayam, Coimbatore, Tamil Nadu 641025'
+ );
+ expect(others).toHaveLength(7);
+ others.forEach((b) => expect(b.ordertype).toBe(FLOW.P2P));
+ });
+
+ it('should price each row from ITS OWN kitchen, not from the shared hub', () => {
+ // The pricing consequence. Measuring every row from one hub bills a
+ // cross-town leg no rider ever makes.
+ const hub = payloadsFor('hub');
+ const kishoreHub = hub.find((b) => b.customer_name === 'Kishore');
+ const kishoreOwn = payloads.find((b) => b.customer_name === 'Kishore');
+ expect(kishoreOwn.finalprice).not.toBe(kishoreHub.finalprice);
+ });
+ });
+
+ describe('collection points on the dispatch board', () => {
+ /* Bookings as the board would read them back after creation. */
+ const asBookings = payloadsFor('customer').map((b, i) => ({
+ bookingid: 1000 + i,
+ pickuplatitude: b.pickuplatitude,
+ pickuplongitude: b.pickuplongitude,
+ deliverylatitude: b.deliverylatitude,
+ deliverylongitude: b.deliverylongitude,
+ pickupaddress: b.pickupaddress
+ }));
+
+ it('should draw exactly three collection pins, not thirteen and not one', () => {
+ // One pin per real kitchen. Grouping per booking would stack six markers
+ // on Jayanthi's door; grouping by tenant name — what the console did
+ // before — would draw a single pin for all three.
+ const keys = new Set(asBookings.map((b) => classifyBooking(b, anchors).pickupPointKey));
+ expect(keys.size).toBe(3);
+ });
+
+ it('should group the six Jayanthi rows onto one pin', () => {
+ const jayanthiKeys = new Set(
+ asBookings
+ .filter((b) => b.pickupaddress === 'Edayarpalayam, Coimbatore, Tamil Nadu 641025')
+ .map((b) => classifyBooking(b, anchors).pickupPointKey)
+ );
+ expect(jayanthiKeys.size).toBe(1);
+ });
+
+ it('should keep the three kitchens on separate pins', () => {
+ const byAddress = new Map();
+ asBookings.forEach((b) => {
+ byAddress.set(b.pickupaddress, classifyBooking(b, anchors).pickupPointKey);
+ });
+ expect(new Set(byAddress.values()).size).toBe(3);
+ });
+ });
+
+ describe('regression guards', () => {
+ it('should never lose a row between sheet and wire', () => {
+ const { raw } = parseFixture();
+ expect(payloadsFor('hub')).toHaveLength(raw.length);
+ expect(payloadsFor('customer')).toHaveLength(raw.length);
+ });
+
+ it('should keep sheet order, so the preview an operator approved is what is sent', () => {
+ const { rows } = parseFixture();
+ const names = payloadsFor('customer').map((b) => b.customer_name);
+ expect(names).toEqual(rows.map((r) => r.firstname));
+ });
+
+ it('should put the same delivery time on every booking in one run', () => {
+ payloadsFor('hub').forEach((b) => expect(b.deliverytime).toBe(DELIVERY_TIME));
+ });
+
+ it('should apply the run-level note to every booking', () => {
+ payloadsFor('hub').forEach((b) => expect(b.notes).toBe('Lunch run'));
+ });
+
+ it('should send a numeric tenantid, not the string the form holds', () => {
+ payloadsFor('hub').forEach((b) => expect(b.tenantid).toBe(4));
+ });
+
+ it('should fall back to the shared hub when a sender address will not geocode', () => {
+ // The row is still booked — dropping it silently would be worse — but it
+ // is booked at the hub, and the page tells the operator how many did this.
+ const rows = processRows(parseFixture().rows, { customerPickup: true }).map((r) =>
+ r.customer_name === 'Kishore' ? r : { ...r, __pickup: null, __pickupFellBack: true }
+ );
+ const payloads = buildBulkBookingPayloads({
+ rows,
+ sharedPickup: BUSINESS_LOCATION,
+ tenantId: 4,
+ tenantLocationId: 31,
+ deliverytime: DELIVERY_TIME,
+ anchors
+ });
+ expect(payloads).toHaveLength(13);
+ payloads.forEach((b) => {
+ expect(b.pickupaddress).toBe(BUSINESS_LOCATION.address);
+ expect(b.ordertype).toBe(FLOW.FORWARD);
+ });
+ });
+ });
+});
diff --git a/tests/integration/logisticsBulkUpload.test.js b/tests/integration/logisticsBulkUpload.test.js
new file mode 100644
index 0000000..324486f
--- /dev/null
+++ b/tests/integration/logisticsBulkUpload.test.js
@@ -0,0 +1,298 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as XLSX from 'xlsx';
+
+import { SHEET_HEADER_MAP, cleanReceiverName, normalizeHeader, requiredSheetColumns } from '@/lib/bulkOrderColumns';
+import { buildBulkBookingPayloads } from '@/lib/bulkOrderPayload';
+import { PICKUP_SOURCE_TYPE, buildAnchors, classifyBooking } from '@/lib/orderFlow';
+
+/**
+ * Bulk upload for the LOGISTICS path — the base-handover flow.
+ *
+ * `tests/fixtures/doormile-logistics-test.xlsx` exists because the tenant's own
+ * export (jayanthi-kitchen-route.xls, covered by bulkUpload.test.js) is 13 lunch
+ * drops entirely inside Coimbatore. Every row of it is hyperlocal, so uploading
+ * it exercises none of the intercity path: no parcel is ever routed to a base,
+ * and the rider is never told to hand one over.
+ *
+ * This fixture keeps that file's exact column titles — so it travels through
+ * the same header map and the same page code — and varies only the delivery
+ * end, which is what the routing decision is made from. 16 rows: 11 that must
+ * route through a base, 5 that must go straight to the customer.
+ *
+ * WHAT THIS SUITE DOES AND DOES NOT ASSERT.
+ *
+ * The routing decision is the BACKEND's, made in Go by isHyperlocalBooking.
+ * Re-implementing that rule here would only prove that two copies of it agree
+ * with each other today — the exact trap this repo's other suites call out. So
+ * the destinations are asserted against the real rule in
+ * doormile_backend/controllers/logisticsRouting_test.go, and what is asserted
+ * HERE is what the console is actually responsible for: that every row survives
+ * the sheet-to-wire transform with the fields the backend needs to make that
+ * decision, and that the pickup source type goes out correctly.
+ */
+
+const FIXTURE = path.join(__dirname, '..', 'fixtures', 'doormile-logistics-test.xlsx');
+
+// The tenant's selected pickup location — Jayanthi's kitchen, which is also a
+// registered site, at the same coordinates as the Coimbatore hub.
+const BUSINESS_LOCATION = {
+ tenantlocationid: 31,
+ tenantid: 4,
+ hubid: 7,
+ locationname: 'Jayanthi Kitchen',
+ address: 'Edayarpalayam, Coimbatore, Tamil Nadu 641025',
+ city: 'Coimbatore',
+ pincode: '641025',
+ latitude: 11.0168,
+ longitude: 76.9558
+};
+
+const DOORMILE_BASE = {
+ hubid: 7,
+ hubname: 'Coimbatore Gandhipuram Hub',
+ address: '14 Avinashi Road, Peelamedu, Coimbatore',
+ pincode: '641004',
+ latitude: 11.0272,
+ longitude: 76.9905
+};
+
+const DELIVERY_TIME = '2026-09-02 09:00:00';
+
+/** The page's own parse (MultipleOrders.processData), with the real map. */
+const parseFixture = () => {
+ const wb = XLSX.read(fs.readFileSync(FIXTURE), { type: 'buffer' });
+ const sheet = wb.Sheets[wb.SheetNames[0]];
+ const raw = XLSX.utils.sheet_to_json(sheet, { defval: '' });
+
+ const normalizedMap = {};
+ for (const key in SHEET_HEADER_MAP) normalizedMap[normalizeHeader(key)] = SHEET_HEADER_MAP[key];
+
+ const rows = raw.map((row, idx) => {
+ const out = { _rowkey: `csv-${idx}`, quantity: 1, collectionamt: 0 };
+ for (const key in row) {
+ const clean = normalizeHeader(key);
+ const mapped = normalizedMap[clean] || clean;
+ out[mapped] = mapped === 'firstname' ? cleanReceiverName(row[key]) : row[key];
+ }
+ return out;
+ });
+
+ return { raw, rows, headers: Object.keys(raw[0]).map(normalizeHeader) };
+};
+
+const processRows = (rows) =>
+ rows.map((row) => ({ ...row, __pickup: null, distance: 10, totalcharge: 120 }));
+
+const anchors = buildAnchors({ hubs: [DOORMILE_BASE], tenantLocations: [BUSINESS_LOCATION] });
+
+const payloads = buildBulkBookingPayloads({
+ rows: processRows(parseFixture().rows),
+ sharedPickup: BUSINESS_LOCATION,
+ tenantId: 4,
+ tenantLocationId: 31,
+ deliverytime: DELIVERY_TIME,
+ anchors
+});
+
+/** Same rule the backend applies, stated once here ONLY to partition the
+ * fixture for counting — never to assert an individual row's routing, which is
+ * the backend test's job. */
+const differentPostalArea = (p) =>
+ !(String(p.pickuppincode).length >= 3 &&
+ String(p.deliverypincode).length >= 3 &&
+ String(p.pickuppincode).slice(0, 3) === String(p.deliverypincode).slice(0, 3));
+
+describe('logistics bulk upload — doormile-logistics-test.xlsx', () => {
+ describe('the fixture itself', () => {
+ it('should be a single sheet of 16 rows', () => {
+ const { raw } = parseFixture();
+ expect(raw).toHaveLength(16);
+ });
+
+ it('should use the tenant sheet\'s own column titles, so nothing new has to be learned', () => {
+ const { headers } = parseFixture();
+ ['sendername*', 'senderphone*', 'senderaddress*', 'receivername*', 'receiveralternatephone*', 'itemdescription*']
+ .forEach((h) => expect(headers).toContain(h));
+ });
+
+ it('should report no missing required columns', () => {
+ const { headers } = parseFixture();
+ const missing = requiredSheetColumns().filter((c) => !headers.includes(normalizeHeader(c)));
+ expect(missing).toEqual([]);
+ });
+
+ it('should carry a pincode column, which the tenant file does not', () => {
+ // Without one, every row lands on the backend's distance fallback and the
+ // prefix rule — the thing that actually decides intercity — never runs.
+ const { headers } = parseFixture();
+ expect(headers).toContain('receiverpincode');
+ expect(SHEET_HEADER_MAP.receiverpincode).toBe('postcode');
+ });
+
+ it('should leave from ONE origin, so the delivery end is the only variable', () => {
+ const { rows } = parseFixture();
+ const senders = new Set(rows.map((r) => String(r.locationaddress).trim()));
+ expect(senders.size).toBe(1);
+ });
+
+ it('should actually split both ways, or it is testing nothing', () => {
+ // A fixture that turned out to be all-hyperlocal would pass every other
+ // assertion here and still exercise none of the handover path — which is
+ // precisely what is wrong with the tenant's own export.
+ const viaBase = payloads.filter(differentPostalArea);
+ expect(viaBase.length).toBeGreaterThanOrEqual(10);
+ expect(payloads.length - viaBase.length).toBeGreaterThanOrEqual(4);
+ });
+ });
+
+ describe('what the backend needs in order to route at all', () => {
+ it('should produce one booking per sheet row, losing none', () => {
+ expect(payloads).toHaveLength(16);
+ });
+
+ it('should give every row a pickup pincode, or nothing can be compared', () => {
+ payloads.forEach((p) => expect(String(p.pickuppincode)).toHaveLength(6));
+ });
+
+ it('should give every row real pickup coordinates, never 0,0', () => {
+ payloads.forEach((p) => {
+ expect(p.pickuplatitude).not.toBe(0);
+ expect(p.pickuplongitude).not.toBe(0);
+ });
+ });
+
+ it('should give every row delivery coordinates, so the distance fallback can run', () => {
+ // Three rows deliberately carry no usable pincode. For those, coordinates
+ // are the ONLY thing the backend can decide from.
+ payloads.forEach((p) => {
+ expect(Number(p.deliverylatitude)).not.toBe(0);
+ expect(Number(p.deliverylongitude)).not.toBe(0);
+ });
+ });
+
+ it('should carry the delivery pincode through as a string, not a number', () => {
+ // A pincode read as a number loses a leading zero and stops being 6 long,
+ // which silently changes which 3-digit area it compares as.
+ payloads.filter((p) => p.deliverypincode !== '').forEach((p) => {
+ expect(typeof p.deliverypincode).toBe('string');
+ });
+ });
+
+ it('should preserve the rows that intentionally have no usable pincode', () => {
+ // These are the fallback cases and must NOT be quietly filled in.
+ const unusable = payloads.filter((p) => String(p.deliverypincode).length < 3);
+ expect(unusable.length).toBe(3);
+ });
+ });
+
+ describe('pickup source — what kind of place these leave from', () => {
+ it('should name a source type on every single booking', () => {
+ // "customer" is a value, never an omission — an absent field reads as
+ // "nobody filled this in", which is a different fact from "front door".
+ payloads.forEach((p) => {
+ expect(p.pickup_source_type).toBeDefined();
+ expect(Object.values(PICKUP_SOURCE_TYPE)).toContain(p.pickup_source_type);
+ });
+ });
+
+ it('should call a collection at the client\'s registered site a merchant pickup', () => {
+ // Jayanthi's kitchen is a registered tenant location. Geometrically it is
+ // a facility, but to a rider it is a shop, not a base — and titling the
+ // stop "base" is what made every logistics pickup read as the rider's own
+ // office.
+ payloads.forEach((p) => expect(p.pickup_source_type).toBe(PICKUP_SOURCE_TYPE.MERCHANT));
+ });
+
+ it('should not name a base on a pickup that is not from one', () => {
+ payloads.forEach((p) => expect(p.pickuphubid).toBeUndefined());
+ });
+
+ it('should stamp the servicing base so the orders land in a zone', () => {
+ payloads.forEach((p) => {
+ expect(p.sourcehubid).toBe(DOORMILE_BASE.hubid);
+ expect(p.hubid).toBe(DOORMILE_BASE.hubid);
+ });
+ });
+
+ it('should read back as a merchant pickup once the row returns from the server', () => {
+ // The write path and the read path must tell the same story.
+ const readBack = classifyBooking(
+ { ...payloads[0], bookingid: 1, pickup_source_type: payloads[0].pickup_source_type },
+ anchors
+ );
+ expect(readBack.pickupSourceType).toBe(PICKUP_SOURCE_TYPE.MERCHANT);
+ expect(readBack.sourceTypeFromServer).toBe(true);
+ });
+ });
+
+ describe('a base-origin upload — the Base → Customer case', () => {
+ // Same sheet, but the operator has selected a BASE as the pickup point
+ // rather than a client site. This is the AC-2 journey: Home must show the
+ // base as the actual pickup source.
+ const fromBase = buildBulkBookingPayloads({
+ rows: processRows(parseFixture().rows),
+ sharedPickup: {
+ ...DOORMILE_BASE,
+ latitude: DOORMILE_BASE.latitude,
+ longitude: DOORMILE_BASE.longitude,
+ pincode: DOORMILE_BASE.pincode,
+ address: DOORMILE_BASE.address
+ },
+ tenantId: 4,
+ tenantLocationId: '',
+ deliverytime: DELIVERY_TIME,
+ anchors
+ });
+
+ it('should classify every row as a base pickup', () => {
+ fromBase.forEach((p) => expect(p.pickup_source_type).toBe(PICKUP_SOURCE_TYPE.HUB));
+ });
+
+ it('should carry the base id, which is what keys the rider handover', () => {
+ fromBase.forEach((p) => expect(p.pickuphubid).toBe(DOORMILE_BASE.hubid));
+ });
+
+ it('should put the base address on the booking, not a customer door', () => {
+ fromBase.forEach((p) => expect(p.pickupaddress).toBe(DOORMILE_BASE.address));
+ });
+ });
+
+ describe('the rest of the row survives the transform', () => {
+ it('should carry every receiver name through in sheet order', () => {
+ const { rows } = parseFixture();
+ payloads.forEach((p, i) => expect(p.customer_name).toBe(rows[i].firstname));
+ });
+
+ it('should send phone numbers as strings even though the sheet types them as numbers', () => {
+ payloads.forEach((p) => expect(typeof p.customer_phone).toBe('string'));
+ });
+
+ it('should expand quantity into one parcel entry per item', () => {
+ const { rows } = parseFixture();
+ payloads.forEach((p, i) => {
+ expect(p.parcels.length).toBe(Math.max(1, Number(rows[i].quantity) || 1));
+ });
+ });
+
+ it('should keep the COD rows, which must survive a base leg', () => {
+ // Three rows carry cash to collect. A parcel handed over at a base and
+ // carried onward still has money attached to it at the far end.
+ const { rows } = parseFixture();
+ const cod = rows.filter((r) => Number(r.collectionamt) > 0);
+ expect(cod.length).toBe(3);
+ });
+
+ it('should put the same delivery time on every booking in one run', () => {
+ payloads.forEach((p) => expect(p.deliverytime).toBe(DELIVERY_TIME));
+ });
+
+ it('should ignore the human-readable notes column rather than send it', () => {
+ // The sheet carries an "Expected Routing" column for whoever is running
+ // the test by hand. It must not reach the wire.
+ payloads.forEach((p) => {
+ expect(Object.keys(p).some((k) => k.toLowerCase().includes('expected'))).toBe(false);
+ });
+ });
+ });
+});
diff --git a/tests/lib/DataTable.test.jsx b/tests/lib/DataTable.test.jsx
new file mode 100644
index 0000000..0314af6
--- /dev/null
+++ b/tests/lib/DataTable.test.jsx
@@ -0,0 +1,119 @@
+import React, { useState } from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+
+jest.mock('lucide-react', () => ({
+ Check: () => ,
+ Minus: () => ,
+ ArrowDown: () => ,
+ ArrowUp: () => ,
+ ChevronsUpDown: () => ,
+ Inbox: () => ,
+ ChevronLeft: () => ,
+ ChevronRight: () => ,
+ ChevronsLeft: () => ,
+ ChevronsRight: () => ,
+}));
+
+import { DataTable } from '@/components/ds/DataTable';
+
+const COLUMNS = [
+ { key: 'id', header: 'ID' },
+ { key: 'title', header: 'Title' },
+];
+
+const createMockRows = (count = 60) =>
+ Array.from({ length: count }, (_, i) => ({
+ id: `order-${i + 1}`,
+ title: `Order #${i + 1}`,
+ }));
+
+function TestTableWrapper({
+ rowCount = 60,
+ pageSize = 25,
+ selectAllPages = true,
+ initialSelected = [],
+}) {
+ const [selectedIds, setSelectedIds] = useState(initialSelected);
+ const rows = createMockRows(rowCount);
+
+ return (
+
+ {selectedIds.length}
+ row.id}
+ pageSize={pageSize}
+ selectAllPages={selectAllPages}
+ selectedIds={selectedIds}
+ onSelectionChange={setSelectedIds}
+ />
+ |