275 lines
9.8 KiB
JavaScript
275 lines
9.8 KiB
JavaScript
/**
|
|
* The dispatch preview's data model.
|
|
*
|
|
* The optimiser answers with a zoned tree — `zones[].riders[].orders[]` — plus
|
|
* a flat `details[]` list, and every edit on the preview page has to keep both
|
|
* in step: the board renders from the tree, and the commit payload is built
|
|
* from the flat list. Doing that in one place is what stops an order being
|
|
* shown against one rider and assigned to another.
|
|
*
|
|
* Ported from the Express Console's `dispatch/Preview.js`, where these were
|
|
* module-local; the logic is unchanged.
|
|
*/
|
|
|
|
// Flatten the API's zoned shape into [{ rider_id, rider_name, orders }] for
|
|
// the Reconcile tab UI and the reconcile-API payload.
|
|
export const extractRiders = (previewData) => {
|
|
if (!previewData) return [];
|
|
const map = new Map();
|
|
// De-dupe by orderid across the whole tree. A rider can legitimately appear
|
|
// in multiple zones (one per delivery suburb), so the same rider_id is
|
|
// visited more than once. Without this guard, any stale copy left behind
|
|
// by applyReconcileResponse gets concatenated into the rider's orders and
|
|
// the same orderid is sent twice to /deliveries/createdeliveries.
|
|
const seenOrderIds = new Set();
|
|
const push = (riderId, riderName, orders) => {
|
|
if (riderId == null) return;
|
|
const key = String(riderId);
|
|
if (!map.has(key)) {
|
|
map.set(key, { rider_id: riderId, rider_name: riderName, orders: [] });
|
|
}
|
|
const entry = map.get(key);
|
|
(orders || []).forEach((o, oIdx) => {
|
|
const resolvedOrderId = o?.orderid || o?.bookingno || o?.bookingid || o?.order_id || o?.booking_id || o?.consignment_id || o?.id || `ord-${oIdx + 1}`;
|
|
const oid = String(resolvedOrderId);
|
|
if (oid) {
|
|
if (seenOrderIds.has(oid)) return;
|
|
seenOrderIds.add(oid);
|
|
}
|
|
entry.orders.push({
|
|
...o,
|
|
orderid: resolvedOrderId
|
|
});
|
|
});
|
|
if (!entry.rider_name && riderName) entry.rider_name = riderName;
|
|
};
|
|
|
|
if (Array.isArray(previewData.zones) && previewData.zones.length) {
|
|
previewData.zones.forEach((z) => {
|
|
(z.riders || []).forEach((r) => {
|
|
const id = r.rider_id ?? r.userid;
|
|
const name = r.rider_name || r.username || `Rider ${id}`;
|
|
push(id, name, r.orders);
|
|
});
|
|
});
|
|
} else if (Array.isArray(previewData.details)) {
|
|
previewData.details.forEach((o) => {
|
|
const id = o.rider_id ?? o.userid;
|
|
const name = o.rider_name || o.ridername || `Rider ${id}`;
|
|
push(id, name, [o]);
|
|
});
|
|
}
|
|
return Array.from(map.values());
|
|
};
|
|
|
|
// Reverse of extractRiders — flatten rider-grouped list into a details-style
|
|
// array (used as the Assign Orders payload).
|
|
export const flattenRiders = (riders) => {
|
|
const out = [];
|
|
riders.forEach((r) => {
|
|
// Go backend types Deliveries.userid as int — coerce here so any
|
|
// upstream string (AI response, riders API, change-rider edit) gets
|
|
// normalised before the JSON body is built.
|
|
const ridNum = Number(r.rider_id);
|
|
const rid = Number.isFinite(ridNum) ? ridNum : r.rider_id;
|
|
(r.orders || []).forEach((o) => {
|
|
out.push({
|
|
...o,
|
|
rider_id: rid,
|
|
userid: rid,
|
|
rider_name: r.rider_name,
|
|
rider: r.rider_name
|
|
});
|
|
});
|
|
});
|
|
return out;
|
|
};
|
|
|
|
// Move one order from oldRiderId -> newRiderId inside dispatchPreviewData.
|
|
// Mutates both the zones[].riders[].orders[] tree (so the Dispatch tab
|
|
// renders the change) AND the flat details[] list (so Assign Orders picks
|
|
// it up). Returns a NEW preview object (immutable update).
|
|
export const moveOrderInPreviewData = (preview, { orderId, newRiderId, newRiderName }) => {
|
|
if (!preview) return preview;
|
|
const next = JSON.parse(JSON.stringify(preview));
|
|
|
|
// 1) Update flat details list
|
|
if (Array.isArray(next.details)) {
|
|
next.details = next.details.map((o) =>
|
|
String(o.orderid) === String(orderId)
|
|
? { ...o, rider_id: newRiderId, userid: newRiderId, rider_name: newRiderName, rider: newRiderName }
|
|
: o
|
|
);
|
|
}
|
|
|
|
// 2) Move within zones[].riders[].orders[]
|
|
if (Array.isArray(next.zones)) {
|
|
let movedOrder = null;
|
|
let homeZoneIdx = -1;
|
|
|
|
for (let zi = 0; zi < next.zones.length && !movedOrder; zi++) {
|
|
const zone = next.zones[zi];
|
|
if (!Array.isArray(zone.riders)) continue;
|
|
for (let ri = 0; ri < zone.riders.length && !movedOrder; ri++) {
|
|
const r = zone.riders[ri];
|
|
if (!Array.isArray(r.orders)) continue;
|
|
const oi = r.orders.findIndex((o) => String(o.orderid) === String(orderId));
|
|
if (oi !== -1) {
|
|
movedOrder = r.orders[oi];
|
|
r.orders.splice(oi, 1);
|
|
homeZoneIdx = zi;
|
|
// A rider left with zero orders after this move is a ghost entry —
|
|
// Dispatch's rider list renders every zone.riders[] entry
|
|
// unconditionally, so it would keep showing as a clickable
|
|
// 0-trips/0km/₹0 card with nothing inside once its last order is
|
|
// reassigned elsewhere. Drop it from the zone entirely.
|
|
if (r.orders.length === 0) {
|
|
zone.riders.splice(ri, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (movedOrder) {
|
|
const updated = {
|
|
...movedOrder,
|
|
rider_id: newRiderId,
|
|
userid: newRiderId,
|
|
rider_name: newRiderName,
|
|
rider: newRiderName
|
|
};
|
|
let placed = false;
|
|
for (const zone of next.zones) {
|
|
if (!Array.isArray(zone.riders)) continue;
|
|
const target = zone.riders.find(
|
|
(r) => String(r.rider_id ?? r.userid) === String(newRiderId)
|
|
);
|
|
if (target) {
|
|
target.orders = target.orders || [];
|
|
target.orders.push(updated);
|
|
placed = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!placed && homeZoneIdx >= 0) {
|
|
next.zones[homeZoneIdx].riders.push({
|
|
rider_id: newRiderId,
|
|
userid: newRiderId,
|
|
rider_name: newRiderName,
|
|
orders: [updated]
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return next;
|
|
};
|
|
|
|
// Merge a reconcile-API response { riders:[{rider_id, orders}] } back into
|
|
// dispatchPreviewData. Replaces each rider's orders[] in zones (preserving
|
|
// zone containment), then rebuilds the flat details list from the new tree.
|
|
export const applyReconcileResponse = (preview, response) => {
|
|
if (!preview || !Array.isArray(response?.riders)) return preview;
|
|
const next = JSON.parse(JSON.stringify(preview));
|
|
|
|
const newOrdersByRider = new Map(
|
|
response.riders.map((r) => [String(r.rider_id), r.orders || []])
|
|
);
|
|
|
|
if (Array.isArray(next.zones) && next.zones.length) {
|
|
// Pass 1: wipe every existing copy of a responding rider's orders across
|
|
// ALL zones. The server's reconciled list is the single source of truth,
|
|
// and a rider can be present in multiple zones (one per delivery suburb).
|
|
// The previous "update first match, delete from map" loop left stale
|
|
// copies in the other zones, which extractRiders then concatenated into
|
|
// duplicate orderids — surfacing as duplicate deliveries on Assign.
|
|
next.zones.forEach((zone) => {
|
|
if (!Array.isArray(zone.riders)) return;
|
|
zone.riders.forEach((r) => {
|
|
const key = String(r.rider_id ?? r.userid);
|
|
if (newOrdersByRider.has(key)) r.orders = [];
|
|
});
|
|
});
|
|
|
|
// Pass 2: drop the reconciled orders onto the first zone that already
|
|
// lists the rider. If the rider isn't anywhere in the tree, append a
|
|
// fresh rider entry to zone[0].
|
|
newOrdersByRider.forEach((orders, riderKey) => {
|
|
let placed = false;
|
|
for (const zone of next.zones) {
|
|
if (!Array.isArray(zone.riders)) continue;
|
|
const target = zone.riders.find(
|
|
(r) => String(r.rider_id ?? r.userid) === riderKey
|
|
);
|
|
if (target) {
|
|
target.orders = orders;
|
|
placed = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!placed) {
|
|
const target = next.zones[0];
|
|
target.riders = target.riders || [];
|
|
target.riders.push({
|
|
rider_id: Number(riderKey) || riderKey,
|
|
rider_name: orders[0]?.rider_name || `Rider ${riderKey}`,
|
|
orders
|
|
});
|
|
}
|
|
});
|
|
|
|
// Same ghost-rider cleanup as moveOrderInPreviewData: if the reconcile
|
|
// response came back with an empty orders[] for a rider (every stop it
|
|
// had got reassigned elsewhere during reconciliation), don't leave that
|
|
// rider sitting in the tree as a 0-trips/0km/₹0 card with nothing inside.
|
|
next.zones.forEach((zone) => {
|
|
if (!Array.isArray(zone.riders)) return;
|
|
zone.riders = zone.riders.filter((r) => Array.isArray(r.orders) && r.orders.length > 0);
|
|
});
|
|
} else {
|
|
next.zones = [
|
|
{
|
|
zone_name: 'Reconciled',
|
|
riders: response.riders.map((r) => ({
|
|
rider_id: r.rider_id,
|
|
rider_name: r.rider_name || `Rider ${r.rider_id}`,
|
|
orders: r.orders || []
|
|
}))
|
|
}
|
|
];
|
|
}
|
|
|
|
// Rebuild flat details from the updated zones->riders->orders tree.
|
|
const flatDetails = [];
|
|
next.zones.forEach((zone) => {
|
|
(zone.riders || []).forEach((r) => {
|
|
(r.orders || []).forEach((o) => {
|
|
flatDetails.push({
|
|
...o,
|
|
rider_id: r.rider_id,
|
|
userid: r.rider_id,
|
|
rider_name: r.rider_name,
|
|
rider: r.rider_name
|
|
});
|
|
});
|
|
});
|
|
});
|
|
next.details = flatDetails;
|
|
|
|
return next;
|
|
};
|
|
|
|
// The delivery amount, recomputed from the rate card the solver echoed back.
|
|
// Applied at render time so the commit payload always reflects the current
|
|
// state of the tree without a synchronising effect.
|
|
export function computeDeliveryAmounts(list) {
|
|
return list.map((item) => {
|
|
const cumulativeKms = Number(item.cumulativekms || 0);
|
|
const minKm = Number(item.minkm || 0);
|
|
const basePrice = Number(item.baseprice || 0);
|
|
const pricePerKm = Number(item.priceperkm || 0);
|
|
if (cumulativeKms <= minKm) return { ...item, deliveryamt: basePrice };
|
|
return { ...item, deliveryamt: (cumulativeKms - minKm) * pricePerKm + basePrice };
|
|
});
|
|
}
|