sgerp-frontend-lib 0.1.0 → 0.1.2

package/dist/sgerp/simulation-logic/fetchUtils.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchVehicles = fetchVehicles;
+exports.fetchBookings = fetchBookings;
+exports.fetchNodes = fetchNodes;
+exports.fetchDrivers = fetchDrivers;
+exports.fetchDriversByProject = fetchDriversByProject;
+exports.fetchOperationsLocationsByProject = fetchOperationsLocationsByProject;
+exports.fetchGeofences = fetchGeofences;
+exports.fetchSimulationGeofence = fetchSimulationGeofence;
+exports.fetchSimulationData = fetchSimulationData;
+const client_1 = require("@/sgerplib/sgerp/api/client");
+/**
+ * Fetch vehicles for a simulation
+ * Uses fetchAll() to get all vehicles regardless of count
+ */
+async function fetchVehicles(api, simulationId) {
+    await api.collections.vehicle.fetchAll({
+        simulation_id__in: simulationId,
+        only_fields: 'id,agent_id,driver_id,service_number,registration_number,lat,lon,gps_modified_at,in_use,color,routing_engine_settings,simulation_id,start_time,end_time,modified_at,capacity,bearing,geofence_ids,project_id',
+        not__is_invalidated: true,
+        order_by: 'id' // Order by ID ascending for consistent ordering
+    });
+    return api.collections.vehicle.models;
+}
+/**
+ * Fetch bookings for a simulation using the microservices API
+ * Based on dashviewer approach: model=booking&booking_type=customer&simulation_id__in=...
+ * Uses fetchAll() to get all bookings regardless of count
+ */
+async function fetchBookings(api, simulationId) {
+    await api.collections.booking.fetchAll({
+        booking_type: 'customer',
+        simulation_id__in: simulationId,
+        //not__is_invalidated: true,
+        only_fields: 'min_pickup_time,max_dropoff_time,created_at,id,uid,simulation_id,state,pickup_location_lat,pickup_location_lon,dropoff_location_lat,dropoff_location_lon,pickup_location_name,dropoff_location_name,pickup_service_time,dropoff_service_time,planned_pickup_time,planned_dropoff_time,customer_id,booking_type,modified_at,demand,actual_dropoff_time,fail_to_board_time,cancellation_time,data',
+        not__is_invalidated: true
+    });
+    return api.collections.booking.models;
+}
+/**
+ * Fetch nodes for a simulation
+ * Uses fetchAll() to get all nodes regardless of count
+ */
+async function fetchNodes(api, simulationId) {
+    await api.collections.node.fetchAll({
+        simulation_id__in: simulationId,
+        only_fields: 'id,uid,booking_id,booking_uid,simulation_id,assigned_vehicle_id,lat,lon,node_type,scheduled_ts,location_name,display_name,demand,status,service_time,open_time_ts,close_time_ts,data,modified_at',
+        not__is_invalidated: true
+    });
+    return api.collections.node.models;
+}
+/**
+ * Fetch drivers for vehicles from legacy Tastypie API
+ * Extracts driver_id values from vehicles and fetches them using id__in
+ * Uses legacy API because it includes username field
+ * Uses a separate collection context to avoid interfering with main drivers page
+ */
+async function fetchDrivers(api, vehicles) {
+    var _a;
+    // Extract unique driver IDs from vehicles
+    const driverIds = vehicles
+        .map(v => v.driver_id)
+        .filter((id) => id != null && id > 0);
+    const uniqueDriverIds = [...new Set(driverIds)];
+    if (uniqueDriverIds.length === 0) {
+        return [];
+    }
+    // Fetch drivers from legacy Tastypie API (includes username field)
+    const response = await client_1.APIClient.get(`/api/v2/driver/?id__in=${uniqueDriverIds.join(',')}&limit=1000`);
+    const drivers = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.objects) || [];
+    // Use context-specific collection to avoid interfering with main drivers page
+    const driverCollection = api.getCollection('driver', 'simulation-detail');
+    driverCollection.add(drivers);
+    return drivers;
+}
+/**
+ * Fetch all drivers for a project from microservices GET API
+ * Used for driver assignment page where we need all available drivers
+ * Uses first_name and id fields for display
+ * Uses a separate collection context to avoid interfering with main drivers page
+ */
+async function fetchDriversByProject(api, projectId) {
+    // Use context-specific collection to avoid interfering with main drivers page
+    const driverCollection = api.getCollection('driver', 'simulation-detail');
+    // Fetch drivers from microservices GET API
+    await driverCollection.fetchAll({
+        project_id: projectId,
+        only_fields: 'id,first_name,last_name,project_id'
+    });
+    return driverCollection.models;
+}
+/**
+ * Fetch operations locations (depots) for a project from microservices GET API
+ * Used for driver assignment page to show depot locations where buses can go (e.g., for lunch breaks)
+ * Uses a separate collection context to avoid interfering with main operations locations page
+ */
+async function fetchOperationsLocationsByProject(api, projectId) {
+    // Use context-specific collection to avoid interfering with main operations locations page
+    const operationsLocationCollection = api.getCollection('operationslocation', 'simulation-detail');
+    // Fetch operations locations from microservices GET API
+    await operationsLocationCollection.fetchAll({
+        project_id: projectId,
+        only_fields: 'id,name,code,external_id,point,address,postal_code,group_id,project_id,h3,created_at,modified_at'
+    });
+    return operationsLocationCollection.models;
+}
+/**
+ * Fetch geofence IDs from simulation's geofences_zones field
+ * Uses Tastypie API to get the geofences_zones array
+ */
+async function fetchSimulationGeofenceZones(simulationId) {
+    var _a;
+    try {
+        const response = await client_1.APIClient.get(`/api/v2/simulation/${simulationId}?only_fields=geofences_zones`);
+        const geofencesZones = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.geofences_zones) || [];
+        // Extract geofence IDs from "/api/v2/geofence/16" format
+        const geofenceIds = geofencesZones
+            .map((zone) => {
+            const match = zone.match(/\/geofence\/(\d+)/);
+            return match ? parseInt(match[1], 10) : null;
+        })
+            .filter((id) => id !== null);
+        return geofenceIds;
+    }
+    catch (error) {
+        console.error('[fetchSimulationGeofenceZones] Failed to fetch:', error);
+        return [];
+    }
+}
+/**
+ * Fetch geofences for vehicles and simulation
+ * Extracts geofence_ids from vehicles and geofences_zones from simulation
+ * Merges both sets and fetches all unique geofences
+ * Uses a separate collection context to avoid interfering with main geofences page
+ */
+async function fetchGeofences(api, vehicles, simulationId) {
+    // Extract unique geofence IDs from vehicles
+    // Handle both number format (1840) and string format ("/api/v2/geofence/1840")
+    const vehicleGeofenceIds = vehicles
+        .flatMap(v => v.geofence_ids || [])
+        .map((id) => {
+        if (id == null) {
+            return null;
+        }
+        if (typeof id === 'number') {
+            return id;
+        }
+        // Extract number from string like "/api/v2/geofence/1840"
+        if (typeof id === 'string') {
+            const match = id.match(/\/geofence\/(\d+)/);
+            return match ? parseInt(match[1], 10) : null;
+        }
+        return null;
+    })
+        .filter((id) => id !== null);
+    // Fetch geofence IDs from simulation's geofences_zones field
+    const simulationGeofenceIds = simulationId
+        ? await fetchSimulationGeofenceZones(simulationId)
+        : [];
+    // Merge both sets of geofence IDs
+    const allGeofenceIds = [...vehicleGeofenceIds, ...simulationGeofenceIds];
+    const uniqueGeofenceIds = [...new Set(allGeofenceIds)];
+    if (uniqueGeofenceIds.length === 0) {
+        return [];
+    }
+    // Use context-specific collection to avoid interfering with main geofences page
+    const geofenceCollection = api.getCollection('geofence', 'simulation-detail');
+    // Fetch geofences using GET API
+    await geofenceCollection.fetch({
+        key__in: uniqueGeofenceIds.join(','),
+        only_fields: 'id,key,name,geometry,project_id'
+    });
+    return geofenceCollection.models;
+}
+/**
+ * Fetch main geofence for simulation
+ * Fetches the simulation's main geofence_id (UUID) using id filter
+ * Uses a separate collection context to avoid interfering with main geofences page
+ */
+async function fetchSimulationGeofence(api, simulation) {
+    var _a, _b;
+    console.log('[fetchSimulationGeofence] Simulation:', simulation);
+    console.log('[fetchSimulationGeofence] geofence_id:', simulation === null || simulation === void 0 ? void 0 : simulation.geofence_id);
+    if (!(simulation === null || simulation === void 0 ? void 0 : simulation.geofence_id)) {
+        console.log('[fetchSimulationGeofence] No geofence_id found, returning null');
+        return null;
+    }
+    // Fetch the main geofence using id filter (geofence_id is a UUID string)
+    console.log('[fetchSimulationGeofence] Fetching geofence by id:', simulation.geofence_id);
+    const response = await client_1.APIClient.get(`/api/v2/microservices/get?model=geofence&id=${simulation.geofence_id}&only_fields=id,key,name,geometry,project_id`);
+    const geofence = ((_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.objects) === null || _b === void 0 ? void 0 : _b[0]) || null;
+    console.log('[fetchSimulationGeofence] Fetched geofence:', geofence);
+    // Use context-specific collection to avoid interfering with main geofences page
+    // Add to collection if found
+    if (geofence) {
+        const geofenceCollection = api.getCollection('geofence', 'simulation-detail');
+        geofenceCollection.add([geofence]);
+    }
+    return geofence;
+}
+/**
+ * Fetch all data needed for simulation page
+ */
+async function fetchSimulationData(api, simulationId, simulation = null) {
+    // First fetch vehicles, bookings, and nodes in parallel
+    const [vehicles, bookings, nodes] = await Promise.all([
+        fetchVehicles(api, simulationId),
+        fetchBookings(api, simulationId),
+        fetchNodes(api, simulationId)
+    ]);
+    // Then fetch drivers, geofences, and main simulation geofence based on the data
+    const [drivers, geofences, mainGeofence] = await Promise.all([
+        fetchDrivers(api, vehicles),
+        fetchGeofences(api, vehicles, simulationId),
+        fetchSimulationGeofence(api, simulation)
+    ]);
+    return {
+        vehicles,
+        bookings,
+        nodes,
+        drivers,
+        geofences,
+        mainGeofence
+    };
+}

package/dist/sgerp/simulation-logic/index.js

@@ -1,11 +1,31 @@
+"use strict";
 /**
  * Simulation page logic utilities
  * Inspired by dashviewer's SimulationPage/logic structure
  */
-export { fetchVehicles, fetchBookings, fetchNodes, fetchDrivers, fetchDriversByProject, fetchOperationsLocationsByProject, fetchSimulationData } from './fetchUtils';
-export { createIndexMaps, attachReferences } from './referenceUtils';
-export { calculateBoundingBoxCenter } from './mapUtils';
-export { vehicleComplexRearrange, buildVehicleRouteMap } from './manualEditUtils';
-export { shiftNodeTimestamps, shiftWaypointTimestamps } from './timeShiftUtils';
-export { calculateVehicleRoute, hasRouteChanged } from './routeCalculationUtils';
-export { processUnassignResponse } from './optimisticUpdateUtils';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUnassignResponse = exports.hasRouteChanged = exports.calculateVehicleRoute = exports.shiftWaypointTimestamps = exports.shiftNodeTimestamps = exports.buildVehicleRouteMap = exports.vehicleComplexRearrange = exports.calculateBoundingBoxCenter = exports.attachReferences = exports.createIndexMaps = exports.fetchSimulationData = exports.fetchOperationsLocationsByProject = exports.fetchDriversByProject = exports.fetchDrivers = exports.fetchNodes = exports.fetchBookings = exports.fetchVehicles = void 0;
+var fetchUtils_1 = require("./fetchUtils");
+Object.defineProperty(exports, "fetchVehicles", { enumerable: true, get: function () { return fetchUtils_1.fetchVehicles; } });
+Object.defineProperty(exports, "fetchBookings", { enumerable: true, get: function () { return fetchUtils_1.fetchBookings; } });
+Object.defineProperty(exports, "fetchNodes", { enumerable: true, get: function () { return fetchUtils_1.fetchNodes; } });
+Object.defineProperty(exports, "fetchDrivers", { enumerable: true, get: function () { return fetchUtils_1.fetchDrivers; } });
+Object.defineProperty(exports, "fetchDriversByProject", { enumerable: true, get: function () { return fetchUtils_1.fetchDriversByProject; } });
+Object.defineProperty(exports, "fetchOperationsLocationsByProject", { enumerable: true, get: function () { return fetchUtils_1.fetchOperationsLocationsByProject; } });
+Object.defineProperty(exports, "fetchSimulationData", { enumerable: true, get: function () { return fetchUtils_1.fetchSimulationData; } });
+var referenceUtils_1 = require("./referenceUtils");
+Object.defineProperty(exports, "createIndexMaps", { enumerable: true, get: function () { return referenceUtils_1.createIndexMaps; } });
+Object.defineProperty(exports, "attachReferences", { enumerable: true, get: function () { return referenceUtils_1.attachReferences; } });
+var mapUtils_1 = require("./mapUtils");
+Object.defineProperty(exports, "calculateBoundingBoxCenter", { enumerable: true, get: function () { return mapUtils_1.calculateBoundingBoxCenter; } });
+var manualEditUtils_1 = require("./manualEditUtils");
+Object.defineProperty(exports, "vehicleComplexRearrange", { enumerable: true, get: function () { return manualEditUtils_1.vehicleComplexRearrange; } });
+Object.defineProperty(exports, "buildVehicleRouteMap", { enumerable: true, get: function () { return manualEditUtils_1.buildVehicleRouteMap; } });
+var timeShiftUtils_1 = require("./timeShiftUtils");
+Object.defineProperty(exports, "shiftNodeTimestamps", { enumerable: true, get: function () { return timeShiftUtils_1.shiftNodeTimestamps; } });
+Object.defineProperty(exports, "shiftWaypointTimestamps", { enumerable: true, get: function () { return timeShiftUtils_1.shiftWaypointTimestamps; } });
+var routeCalculationUtils_1 = require("./routeCalculationUtils");
+Object.defineProperty(exports, "calculateVehicleRoute", { enumerable: true, get: function () { return routeCalculationUtils_1.calculateVehicleRoute; } });
+Object.defineProperty(exports, "hasRouteChanged", { enumerable: true, get: function () { return routeCalculationUtils_1.hasRouteChanged; } });
+var optimisticUpdateUtils_1 = require("./optimisticUpdateUtils");
+Object.defineProperty(exports, "processUnassignResponse", { enumerable: true, get: function () { return optimisticUpdateUtils_1.processUnassignResponse; } });

package/dist/sgerp/simulation-logic/manualEditUtils.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vehicleComplexRearrange = vehicleComplexRearrange;
+exports.buildVehicleRouteMap = buildVehicleRouteMap;
+const client_1 = require("@/sgerplib/sgerp/api/client");
+/**
+ * Call the Manual Edit API to rearrange vehicle routes
+ *
+ * @param simulationId - The simulation ID
+ * @param vehicleRouteMap - Map of vehicle agent_id to array of node UIDs
+ * @param options - Optional settings
+ * @returns Promise with the API response
+ */
+async function vehicleComplexRearrange(simulationId, vehicleRouteMap, options = {}) {
+    var _a;
+    const { dryRun = false, notifyAssignment = false, strictTimeWindows = false, currentTime, } = options;
+    const requestPayload = {
+        simulation_id: simulationId,
+        dry_run: dryRun,
+        notify_assignment: notifyAssignment,
+        action: {
+            action_type: 'vehicle_complex_rearrange',
+            vehicle_route_map: vehicleRouteMap,
+            strict_time_windows: strictTimeWindows,
+        },
+    };
+    // Add current_time if provided
+    if (currentTime) {
+        requestPayload.current_time = currentTime;
+    }
+    try {
+        const response = await client_1.APIClient.post('/api/v2/microservices/edit', requestPayload);
+        return response.data;
+    }
+    catch (error) {
+        // Check if this is an axios error with response data
+        if (error && typeof error === 'object' && 'response' in error) {
+            const axiosError = error;
+            const errorData = (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.data;
+            // Handle both single error and array of errors
+            if (Array.isArray(errorData)) {
+                const errorMessages = errorData.map((e) => e.error).join('; ');
+                throw new Error(`Manual Edit API errors: ${errorMessages}`);
+            }
+            else if (errorData && 'error' in errorData) {
+                throw new Error(`Manual Edit API error: ${errorData.error} (${errorData.error_code})`);
+            }
+        }
+        // Re-throw the original error if we couldn't parse it
+        throw error;
+    }
+}
+/**
+ * Build a vehicle route map from nodes grouped by vehicle
+ *
+ * @param nodesByVehicle - Map of vehicle agent_id to array of nodes
+ * @returns Vehicle route map for Manual Edit API
+ */
+function buildVehicleRouteMap(nodesByVehicle) {
+    const routeMap = {};
+    nodesByVehicle.forEach((nodes, vehicleAgentId) => {
+        // Extract node UIDs in order
+        const route = nodes
+            .filter(node => node.uid) // Only include nodes with UIDs
+            .map(node => node.uid);
+        routeMap[vehicleAgentId] = { route };
+    });
+    return routeMap;
+}

package/dist/sgerp/simulation-logic/mapUtils.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateBoundingBoxCenter = calculateBoundingBoxCenter;
+/**
+ * Calculate bounding box center from vehicles and bookings
+ * Filters out invalid coordinates (0,0) and calculates the average center point
+ */
+function calculateBoundingBoxCenter(vehicles, bookings) {
+    const coordinates = [];
+    // Add vehicle coordinates (excluding 0,0)
+    vehicles.forEach(v => {
+        if (v.lat && v.lon && !(v.lat === 0 && v.lon === 0)) {
+            coordinates.push([v.lon, v.lat]);
+        }
+    });
+    // Add booking pickup locations
+    bookings.forEach(b => {
+        if (b.pickup_location_lat && b.pickup_location_lon) {
+            coordinates.push([b.pickup_location_lon, b.pickup_location_lat]);
+        }
+    });
+    // If no valid coordinates, return null
+    if (coordinates.length === 0) {
+        return { center: null, zoom: 13 };
+    }
+    // Calculate center (average of all coordinates)
+    const avgLon = coordinates.reduce((sum, c) => sum + c[0], 0) / coordinates.length;
+    const avgLat = coordinates.reduce((sum, c) => sum + c[1], 0) / coordinates.length;
+    // Calculate zoom level based on coordinate spread
+    // Get min/max for longitude and latitude
+    const lons = coordinates.map(c => c[0]);
+    const lats = coordinates.map(c => c[1]);
+    const lonSpread = Math.max(...lons) - Math.min(...lons);
+    const latSpread = Math.max(...lats) - Math.min(...lats);
+    const maxSpread = Math.max(lonSpread, latSpread);
+    // Calculate appropriate zoom level
+    // Rough approximation: zoom levels decrease as spread increases
+    let zoom = 13; // default
+    if (maxSpread > 1) {
+        zoom = 10;
+    }
+    else if (maxSpread > 0.5) {
+        zoom = 11;
+    }
+    else if (maxSpread > 0.2) {
+        zoom = 12;
+    }
+    else if (maxSpread > 0.05) {
+        zoom = 13;
+    }
+    else {
+        zoom = 14;
+    }
+    return {
+        center: [avgLon, avgLat],
+        zoom
+    };
+}

package/dist/sgerp/simulation-logic/optimisticUpdateUtils.js

@@ -1,9 +1,12 @@
+"use strict";
 /**
  * Optimistic update utilities for simulation data
  * Apply client-side updates based on API responses before refetching
  */
-import { BookingState } from '../types/simulation/booking';
-import { attachReferences } from './referenceUtils';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUnassignResponse = processUnassignResponse;
+const booking_1 = require("../types/simulation/booking");
+const referenceUtils_1 = require("./referenceUtils");
 /**
  * Process unassign response and update nodes/bookings optimistically
  * Applies all necessary transformations in the correct sequence
@@ -14,7 +17,7 @@ import { attachReferences } from './referenceUtils';
  * @param response - API response containing changed UIDs
  * @returns Updated nodes and bookings with references attached
  */
-export function processUnassignResponse(nodes, bookings, vehicles, response) {
+function processUnassignResponse(nodes, bookings, vehicles, response) {
     const changedNodeUids = new Set(response.changed_nodes_uids || []);
     const changedBookingUids = new Set(response.changed_bookings_uids || []);
     // Step 1: Update nodes - set status to 'new', clear assigned_vehicle_id and scheduled_ts
@@ -27,11 +30,11 @@ export function processUnassignResponse(nodes, bookings, vehicles, response) {
     // Step 2: Update bookings - set state to 'prepared'
     const updatedBookings = bookings.map(booking => {
         if (changedBookingUids.has(booking.uid)) {
-            return Object.assign(Object.assign({}, booking), { state: BookingState.PREPARED });
+            return Object.assign(Object.assign({}, booking), { state: booking_1.BookingState.PREPARED });
         }
         return booking;
     });
     // Step 3: Re-attach references between models
-    attachReferences(updatedBookings, vehicles, updatedNodes);
+    (0, referenceUtils_1.attachReferences)(updatedBookings, vehicles, updatedNodes);
     return { updatedNodes, updatedBookings };
 }

package/dist/sgerp/simulation-logic/referenceUtils.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIndexMaps = createIndexMaps;
+exports.attachReferences = attachReferences;
+/**
+ * Create index maps for fast lookups
+ * Similar to dashviewer's stateIndex
+ */
+function createIndexMaps(bookings, vehicles, nodes) {
+    const bookingMap = new Map();
+    const vehicleMap = new Map();
+    const nodeMap = new Map();
+    bookings.forEach(booking => {
+        bookingMap.set(booking.id, booking);
+    });
+    vehicles.forEach(vehicle => {
+        vehicleMap.set(vehicle.id, vehicle);
+    });
+    nodes.forEach(node => {
+        nodeMap.set(node.id, node);
+    });
+    return {
+        bookingMap,
+        vehicleMap,
+        nodeMap
+    };
+}
+/**
+ * Attach references between models
+ * Adapted from dashviewer's attachReferences function
+ */
+function attachReferences(bookings, vehicles, nodes) {
+    const { bookingMap, vehicleMap, nodeMap } = createIndexMaps(bookings, vehicles, nodes);
+    // Sort nodes by scheduled_ts
+    const sortedNodes = [...nodes].sort((a, b) => {
+        if (!a.scheduled_ts || !b.scheduled_ts)
+            return 0;
+        return new Date(a.scheduled_ts).getTime() - new Date(b.scheduled_ts).getTime();
+    });
+    // Initialize vehicle data structures
+    const vehicleData = new Map();
+    vehicles.forEach(vehicle => {
+        vehicleData.set(vehicle.id, {
+            assigned_nodes: [],
+            completed_nodes: [],
+            assigned_booking_uids: new Set(),
+            completed_booking_uids: new Set()
+        });
+    });
+    // Process each node and build relationships
+    sortedNodes.forEach(node => {
+        // Attach vehicle reference to node
+        if (node.assigned_vehicle_id) {
+            const vehicle = vehicleMap.get(node.assigned_vehicle_id);
+            if (vehicle) {
+                const vData = vehicleData.get(vehicle.id);
+                if (vData) {
+                    if (node.status === 'assigned') {
+                        vData.assigned_nodes.push(node);
+                        if (node.booking_uid) {
+                            vData.assigned_booking_uids.add(node.booking_uid);
+                        }
+                    }
+                    else if (node.status === 'completed') {
+                        vData.completed_nodes.push(node);
+                        if (node.booking_uid) {
+                            vData.completed_booking_uids.add(node.booking_uid);
+                        }
+                    }
+                }
+            }
+        }
+        // Attach booking reference to node
+        if (node.booking_id) {
+            const booking = bookingMap.get(node.booking_id);
+            if (booking) {
+                // Update booking with node information
+                if (node.node_type === 'pickup' && node.scheduled_ts) {
+                    booking.pickup_scheduled_ts = node.scheduled_ts;
+                    booking.planned_pickup_time = node.scheduled_ts;
+                    if (!booking.pickup_location_name) {
+                        booking.pickup_location_name = node.display_name || node.location_name || '';
+                    }
+                }
+                else if (node.node_type === 'dropoff' && node.scheduled_ts) {
+                    booking.dropoff_scheduled_ts = node.scheduled_ts;
+                    booking.planned_dropoff_time = node.scheduled_ts;
+                    if (!booking.dropoff_location_name) {
+                        booking.dropoff_location_name = node.display_name || node.location_name || '';
+                    }
+                }
+                // Attach vehicle to booking
+                if (node.assigned_vehicle_id) {
+                    const vehicle = vehicleMap.get(node.assigned_vehicle_id);
+                    if (vehicle) {
+                        booking.vehicle_id = node.assigned_vehicle_id;
+                        booking.service_number = vehicle.service_number;
+                        // Note: Driver names will be attached separately later
+                    }
+                }
+            }
+        }
+    });
+    return {
+        bookingMap,
+        vehicleMap,
+        nodeMap,
+        vehicleData
+    };
+}

package/dist/sgerp/simulation-logic/routeCalculationUtils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateVehicleRoute = calculateVehicleRoute;
+exports.hasRouteChanged = hasRouteChanged;
+const routing_1 = require("@/sgerplib/sgerp/routing");
+/**
+ * Calculate OSRM route for a vehicle based on its assigned nodes
+ */
+async function calculateVehicleRoute(vehicle, sortedNodes, defaultBackend) {
+    if (sortedNodes.length < 2) {
+        return null;
+    }
+    const coordinates = sortedNodes.map(node => [node.lat, node.lon]);
+    // Get routing engine settings from vehicle
+    const settings = vehicle.routing_engine_settings || {};
+    const routingEngineName = settings.routing_engine_name || 'osrm';
+    const url = settings.url || 'http://mapbox-osrm-proxy';
+    const roadNetwork = settings.road_network || 'van';
+    const key = settings.key || 'dmVyeSBzZWNyZXQga2V5';
+    const curb = settings.curb !== undefined ? settings.curb : false;
+    // Create routing engine
+    const routingEngine = new routing_1.RoutingEngine(routingEngineName, url, roadNetwork, key, defaultBackend);
+    // Calculate route
+    return new Promise((resolve) => {
+        routingEngine.route(coordinates, curb, (result, status, message) => {
+            if (status === 'ok' && (result === null || result === void 0 ? void 0 : result.osrmRoute)) {
+                resolve(result.osrmRoute);
+            }
+            else {
+                console.error(`Failed to calculate route for vehicle ${vehicle.id}:`, message);
+                resolve(null);
+            }
+        });
+    });
+}
+/**
+ * Check if a vehicle's route has changed by comparing node IDs
+ */
+function hasRouteChanged(existingNodes, newNodes) {
+    const existingNodeIds = (existingNodes === null || existingNodes === void 0 ? void 0 : existingNodes.map(n => n.id).join(',')) || '';
+    const newNodeIds = newNodes.map(n => n.id).join(',');
+    return existingNodeIds !== newNodeIds;
+}

package/dist/sgerp/simulation-logic/timeShiftUtils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shiftNodeTimestamps = shiftNodeTimestamps;
+exports.shiftWaypointTimestamps = shiftWaypointTimestamps;
+/**
+ * Calculate time difference in milliseconds between two timestamps
+ */
+function getTimeDiffMs(oldTime, newTime) {
+    return new Date(newTime).getTime() - new Date(oldTime).getTime();
+}
+/**
+ * Shift a timestamp by a given number of milliseconds
+ */
+function shiftTimestamp(timestamp, diffMs) {
+    if (!timestamp)
+        return null;
+    const date = new Date(timestamp);
+    const newDate = new Date(date.getTime() + diffMs);
+    return newDate.toISOString();
+}
+/**
+ * Shift all node scheduled timestamps by a time difference
+ * Note: open_time_ts and close_time_ts are NOT shifted as they represent
+ * fixed booking time window constraints, not planned arrival times
+ *
+ * @param nodes - Array of nodes to shift
+ * @param oldStartTime - Original start time (ISO string)
+ * @param newStartTime - New start time (ISO string)
+ * @returns New array of nodes with shifted scheduled_ts only
+ */
+function shiftNodeTimestamps(nodes, oldStartTime, newStartTime) {
+    const diffMs = getTimeDiffMs(oldStartTime, newStartTime);
+    if (diffMs === 0) {
+        // No change needed
+        return nodes;
+    }
+    return nodes.map(node => {
+        var _a;
+        return (Object.assign(Object.assign({}, node), { scheduled_ts: (_a = shiftTimestamp(node.scheduled_ts, diffMs)) !== null && _a !== void 0 ? _a : node.scheduled_ts }));
+    });
+}
+/**
+ * Shift waypoint node timestamps
+ * This is a helper for RouteDetailsTable waypoints structure
+ * Note: open_time_ts and close_time_ts are NOT shifted as they represent
+ * fixed booking time window constraints, not planned arrival times
+ *
+ * @param waypoints - Array of waypoints with nested nodes
+ * @param oldStartTime - Original start time (ISO string)
+ * @param newStartTime - New start time (ISO string)
+ * @returns New array of waypoints with shifted scheduled_ts only
+ */
+function shiftWaypointTimestamps(waypoints, oldStartTime, newStartTime) {
+    const diffMs = getTimeDiffMs(oldStartTime, newStartTime);
+    if (diffMs === 0) {
+        // No change needed
+        return waypoints;
+    }
+    return waypoints.map(waypoint => (Object.assign(Object.assign({}, waypoint), { nodes: waypoint.nodes.map(node => {
+            var _a;
+            return (Object.assign(Object.assign({}, node), { scheduled_ts: (_a = shiftTimestamp(node.scheduled_ts, diffMs)) !== null && _a !== void 0 ? _a : node.scheduled_ts }));
+        }) })));
+}