sgerp-frontend-lib 0.1.4 → 0.2.0

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

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * VRPToolbox Statistics Calculator
+ * Processes VRP payload and result to calculate fleet statistics, timeline data, and utilization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFleetStats = calculateFleetStats;
+exports.processVRPStatistics = processVRPStatistics;
+const vrpStatsUtils_1 = require("./vrpStatsUtils");
+const VEHICLE_COLORS = [
+    'red',
+    'blue',
+    'green',
+    'orange',
+    'purple',
+    'brown',
+    'magenta',
+    'teal',
+];
+/**
+ * Calculate fleet-wide statistics from processed vehicles
+ */
+function calculateFleetStats(vehicles) {
+    let totalSlack = 0;
+    let totalDistance = 0;
+    let totalDrivingTime = 0;
+    let totalBreakTime = 0;
+    vehicles.forEach((vehicle) => {
+        totalDistance += parseFloat(vehicle.totalDistance || '0');
+        vehicle.timelineWaypoints.forEach((wp) => {
+            totalSlack += wp.adjustedSlack || 0;
+            totalDrivingTime += wp.travel_time_from_prev || 0;
+            totalBreakTime += wp.nodeBreakDuration || 0;
+        });
+    });
+    return {
+        totalSlack: (0, vrpStatsUtils_1.formatSeconds)(totalSlack),
+        totalDistance: totalDistance.toFixed(2),
+        totalDrivingTime: (0, vrpStatsUtils_1.formatSeconds)(totalDrivingTime),
+        totalBreakTime: (0, vrpStatsUtils_1.formatSeconds)(totalBreakTime),
+    };
+}
+/**
+ * Process VRP result and payload to generate vehicle statistics
+ */
+async function processVRPStatistics(result, payload) {
+    if (!result || !result.vehicles) {
+        console.warn('No vehicles in result', result);
+        return [];
+    }
+    const inputVehicles = (payload === null || payload === void 0 ? void 0 : payload.vehicles) || [];
+    const vehicleList = Array.isArray(result.vehicles)
+        ? result.vehicles
+            .filter((v) => v.nodes && v.nodes.length > 0) // Only vehicles with nodes
+            .map((v) => ({
+            agent_id: v.agent_id,
+            nodes: v.nodes,
+        }))
+        : Object.entries(result.vehicles)
+            .filter(([id, nodes]) => nodes && nodes.length > 0) // Only vehicles with nodes
+            .map(([id, nodes]) => ({
+            agent_id: id,
+            nodes: nodes,
+        }));
+    const vehicles = await Promise.all(vehicleList.map(async (vehicleData, index) => {
+        var _a, _b, _c, _d;
+        const inputVehicle = inputVehicles.find((v) => v.agent_id === vehicleData.agent_id);
+        let vehicleBreakDuration = 0;
+        if (inputVehicle &&
+            typeof inputVehicle.dynamic_break_duration === 'number') {
+            vehicleBreakDuration = inputVehicle.dynamic_break_duration;
+        }
+        let sortedNodes = JSON.parse(JSON.stringify(vehicleData.nodes));
+        sortedNodes.sort((a, b) => new Date(a.scheduled_ts).getTime() - new Date(b.scheduled_ts).getTime());
+        // Add start/end nodes if vehicle has start/end times
+        if (inputVehicle) {
+            if (inputVehicle.start_time) {
+                const startNode = ((payload === null || payload === void 0 ? void 0 : payload.nodes) || []).find((n) => { var _a; return n.uid === ((_a = inputVehicle.partial_route) === null || _a === void 0 ? void 0 : _a[0]); }) || vehicleData.nodes[0];
+                if (startNode) {
+                    sortedNodes.unshift({
+                        lat: startNode.lat,
+                        lon: startNode.lon,
+                        scheduled_ts: inputVehicle.start_time,
+                        location_name: 'Start',
+                        node_type: 'vehicle_start',
+                        service_time: 0,
+                    });
+                }
+            }
+            if (inputVehicle.end_time) {
+                const lastRouteUid = (_a = inputVehicle.partial_route) === null || _a === void 0 ? void 0 : _a[((_b = inputVehicle.partial_route) === null || _b === void 0 ? void 0 : _b.length) - 1];
+                const endNode = ((payload === null || payload === void 0 ? void 0 : payload.nodes) || []).find((n) => n.uid === lastRouteUid) ||
+                    vehicleData.nodes[vehicleData.nodes.length - 1];
+                if (endNode) {
+                    sortedNodes.push({
+                        lat: endNode.lat,
+                        lon: endNode.lon,
+                        scheduled_ts: inputVehicle.end_time,
+                        location_name: 'End',
+                        node_type: 'vehicle_end',
+                        service_time: 0,
+                    });
+                }
+            }
+        }
+        // Process nodes with travel times, breaks, and slack
+        const processedNodes = sortedNodes.map((node, idx, array) => {
+            const prevNode = array[idx - 1];
+            let prevNodeDepartureTime;
+            if (prevNode) {
+                let prevNodeActualBreakDuration = 0;
+                let prevNodeEffectiveSlack = 0;
+                if (typeof prevNode.dynamic_break_time === 'number') {
+                    prevNodeActualBreakDuration = prevNode.dynamic_break_time;
+                    prevNodeEffectiveSlack = prevNode.slack || 0;
+                }
+                else {
+                    const prevNodeBreakCount = prevNode.dynamic_break || 0;
+                    prevNodeActualBreakDuration =
+                        prevNodeBreakCount * vehicleBreakDuration;
+                    prevNodeEffectiveSlack = Math.max(0, (prevNode.slack || 0) - prevNodeActualBreakDuration);
+                }
+                const prevScheduled = new Date(prevNode.scheduled_ts);
+                const departureMs = prevScheduled.getTime() +
+                    ((prevNode.service_time || 0) +
+                        prevNodeEffectiveSlack +
+                        prevNodeActualBreakDuration) *
+                        1000;
+                prevNodeDepartureTime = new Date(departureMs);
+            }
+            let travel_time_from_prev = 0;
+            if (prevNode && node.node_type !== 'vehicle_end') {
+                const nodeScheduled = new Date(node.scheduled_ts);
+                if (prevNodeDepartureTime) {
+                    travel_time_from_prev =
+                        (nodeScheduled.getTime() - prevNodeDepartureTime.getTime()) /
+                            1000;
+                }
+            }
+            let nodeBreakDuration = 0;
+            let adjustedSlack = 0;
+            if (typeof node.dynamic_break_time === 'number') {
+                nodeBreakDuration = node.dynamic_break_time;
+                adjustedSlack = node.slack || 0;
+            }
+            else {
+                const nodeBreakCount = node.dynamic_break || 0;
+                nodeBreakDuration = nodeBreakCount * vehicleBreakDuration;
+                adjustedSlack = Math.max(0, (node.slack || 0) - nodeBreakDuration);
+            }
+            return Object.assign(Object.assign({}, node), { travel_time_from_prev,
+                nodeBreakDuration,
+                adjustedSlack, service_time: node.service_time || 0 });
+        });
+        // Calculate total distance (try multiple methods)
+        let totalDistance = 0;
+        const lastNode = processedNodes[processedNodes.length - 1];
+        // Method 1: Use scheduled_cumulative_dist if available
+        if (lastNode &&
+            typeof lastNode.scheduled_cumulative_dist === 'number') {
+            totalDistance = lastNode.scheduled_cumulative_dist / 1000;
+        }
+        // Method 2: Fallback to Euclidean distance
+        else if (processedNodes.length > 1) {
+            for (let i = 1; i < processedNodes.length; i++) {
+                const prev = processedNodes[i - 1];
+                const curr = processedNodes[i];
+                totalDistance += (0, vrpStatsUtils_1.getDistanceFromLatLonInKm)(prev.lat, prev.lon, curr.lat, curr.lon);
+            }
+        }
+        // Calculate total time
+        let totalTime = 0;
+        if (processedNodes.length > 0 && lastNode) {
+            const startTime = new Date(processedNodes[0].scheduled_ts);
+            const endTime = new Date(lastNode.scheduled_ts);
+            totalTime = (endTime.getTime() - startTime.getTime()) / 1000;
+        }
+        // Calculate utilization over time
+        const utilizationData = [];
+        const vehicleCapacity = (inputVehicle === null || inputVehicle === void 0 ? void 0 : inputVehicle.capacity) || (inputVehicle === null || inputVehicle === void 0 ? void 0 : inputVehicle.limits) || {};
+        const totalCapacity = Object.values(vehicleCapacity).reduce((sum, val) => sum + val, 0);
+        const currentLoad = {};
+        // Initialize load for prebook_cvrptw mode
+        if (((_d = (_c = payload.engine_settings) === null || _c === void 0 ? void 0 : _c.calculation_parameters) === null || _d === void 0 ? void 0 : _d.scheduling_mode) ===
+            'prebook_cvrptw') {
+            const inputNodes = payload.nodes || [];
+            const allDemands = inputNodes
+                .filter((n) => n.node_type === 'dropoff' &&
+                n.demand &&
+                vehicleData.nodes.some((vn) => vn.booking_uid && vn.booking_uid === n.booking_uid))
+                .flatMap((n) => Object.entries(n.demand));
+            for (const [key, value] of allDemands) {
+                currentLoad[key] = (currentLoad[key] || 0) + Math.abs(value);
+            }
+        }
+        else {
+            Object.keys(vehicleCapacity).forEach((key) => (currentLoad[key] = 0));
+        }
+        // Track utilization at each node
+        processedNodes.forEach((node) => {
+            const originalNode = (payload.nodes || []).find((n) => n.uid === node.uid || n.id === node.uid);
+            if (originalNode === null || originalNode === void 0 ? void 0 : originalNode.demand) {
+                if (node.node_type === 'dropoff') {
+                    for (const [key, value] of Object.entries(originalNode.demand)) {
+                        currentLoad[key] =
+                            (currentLoad[key] || 0) - Math.abs(value);
+                    }
+                }
+                else if (node.node_type === 'pickup') {
+                    for (const [key, value] of Object.entries(originalNode.demand)) {
+                        currentLoad[key] =
+                            (currentLoad[key] || 0) + Math.abs(value);
+                    }
+                }
+            }
+            let utilizationAfter = 0;
+            if (totalCapacity > 0) {
+                const totalLoad = Object.values(currentLoad).reduce((sum, val) => sum + val, 0);
+                utilizationAfter = (totalLoad / totalCapacity) * 100;
+            }
+            utilizationData.push({
+                time: node.scheduled_ts,
+                utilization: Math.max(0, Math.min(100, utilizationAfter)),
+            });
+        });
+        // Calculate vehicle-specific stats
+        const vehicleStats = processedNodes.reduce((acc, node) => {
+            acc.slack += node.adjustedSlack || 0;
+            acc.breakTime += node.nodeBreakDuration || 0;
+            acc.drivingTime += node.travel_time_from_prev || 0;
+            return acc;
+        }, { slack: 0, breakTime: 0, drivingTime: 0 });
+        return {
+            vehicleId: vehicleData.agent_id,
+            vehicleName: (inputVehicle === null || inputVehicle === void 0 ? void 0 : inputVehicle.service_number) || vehicleData.agent_id,
+            timelineWaypoints: processedNodes,
+            utilizationData: utilizationData,
+            color: VEHICLE_COLORS[index % VEHICLE_COLORS.length],
+            totalDistance: totalDistance.toFixed(2),
+            totalTime: (0, vrpStatsUtils_1.formatSeconds)(totalTime),
+            totalSlack: (0, vrpStatsUtils_1.formatSeconds)(vehicleStats.slack),
+            totalBreakTime: (0, vrpStatsUtils_1.formatSeconds)(vehicleStats.breakTime),
+            totalDrivingTime: (0, vrpStatsUtils_1.formatSeconds)(vehicleStats.drivingTime),
+        };
+    }));
+    return vehicles;
+}

package/dist/sgerp/simulation-logic/vrpStatsUtils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * VRPToolbox Statistics Utilities
+ * Helper functions for calculating and formatting VRP statistics
+ */
+/**
+ * Format seconds into HH:MM:SS format
+ */
+export declare function formatSeconds(seconds: number): string;
+/**
+ * Calculate distance between two lat/lon coordinates in kilometers (Haversine formula)
+ */
+export declare function getDistanceFromLatLonInKm(lat1: number, lon1: number, lat2: number, lon2: number): number;
+/**
+ * Convert timestamp to display Date (handles timezone conversions)
+ */
+export declare function toDisplayDate(ts: string): Date;
+//# sourceMappingURL=vrpStatsUtils.d.ts.map

package/dist/sgerp/simulation-logic/vrpStatsUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vrpStatsUtils.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/simulation-logic/vrpStatsUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAUrD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,MAAM,CAaR;AAMD;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAc9C"}

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

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * VRPToolbox Statistics Utilities
+ * Helper functions for calculating and formatting VRP statistics
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSeconds = formatSeconds;
+exports.getDistanceFromLatLonInKm = getDistanceFromLatLonInKm;
+exports.toDisplayDate = toDisplayDate;
+/**
+ * Format seconds into HH:MM:SS format
+ */
+function formatSeconds(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const remainingSeconds = Math.floor(seconds % 60);
+    const formattedHours = String(hours).padStart(2, '0');
+    const formattedMinutes = String(minutes).padStart(2, '0');
+    const formattedSeconds = String(remainingSeconds).padStart(2, '0');
+    return `${formattedHours}:${formattedMinutes}:${formattedSeconds}`;
+}
+/**
+ * Calculate distance between two lat/lon coordinates in kilometers (Haversine formula)
+ */
+function getDistanceFromLatLonInKm(lat1, lon1, lat2, lon2) {
+    const R = 6371; // Earth's radius in km
+    const dLat = deg2rad(lat2 - lat1);
+    const dLon = deg2rad(lon2 - lon1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(deg2rad(lat1)) *
+            Math.cos(deg2rad(lat2)) *
+            Math.sin(dLon / 2) *
+            Math.sin(dLon / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    const d = R * c;
+    return d;
+}
+function deg2rad(deg) {
+    return deg * (Math.PI / 180);
+}
+/**
+ * Convert timestamp to display Date (handles timezone conversions)
+ */
+function toDisplayDate(ts) {
+    // Parse as UTC and return as local Date object
+    const date = new Date(ts);
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds()));
+}

package/dist/sgerp/utils/timezone.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Timezone utility functions
+ */
+/**
+ * Get the effective timezone based on the current mode
+ * In VRPToolbox mode, uses the VRP timezone selector
+ * Otherwise, uses the project timezone (or falls back to UTC)
+ *
+ * @param mode - The current effective mode ('vrptoolbox' or other)
+ * @param vrpTimezone - The timezone selected in VRPToolbox mode
+ * @param projectTimezone - The project's configured timezone
+ * @returns The effective timezone string (e.g., 'UTC', 'Asia/Singapore')
+ */
+export declare function getEffectiveTimezone(mode: string, vrpTimezone: string, projectTimezone?: string): string;
+//# sourceMappingURL=timezone.d.ts.map

package/dist/sgerp/utils/timezone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timezone.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/utils/timezone.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,eAAe,CAAC,EAAE,MAAM,GACvB,MAAM,CAER"}

package/dist/sgerp/utils/timezone.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Timezone utility functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEffectiveTimezone = getEffectiveTimezone;
+/**
+ * Get the effective timezone based on the current mode
+ * In VRPToolbox mode, uses the VRP timezone selector
+ * Otherwise, uses the project timezone (or falls back to UTC)
+ *
+ * @param mode - The current effective mode ('vrptoolbox' or other)
+ * @param vrpTimezone - The timezone selected in VRPToolbox mode
+ * @param projectTimezone - The project's configured timezone
+ * @returns The effective timezone string (e.g., 'UTC', 'Asia/Singapore')
+ */
+function getEffectiveTimezone(mode, vrpTimezone, projectTimezone) {
+    return mode === 'vrptoolbox' ? vrpTimezone : (projectTimezone || 'UTC');
+}

package/dist/sgerp/vrptoolbox-analyzer.d.ts

@@ -0,0 +1,39 @@
+interface Vehicle {
+    agent_id: string;
+    characteristics?: Record<string, any>;
+    start_time?: number;
+    end_time?: number;
+    geofence_ids: any[];
+    assigned_nodes: any[];
+    labels?: string[];
+    capacity: number | Record<string, number>;
+}
+interface Node {
+    node_type: string;
+    vehicle_characteristics: Record<string, any>;
+    open_time_ts: number;
+    close_time_ts: number;
+    geofence_id: any[];
+    geofence_ids?: any[];
+    demand: number | Record<string, number>;
+    vehicle_labels?: {
+        or?: string[];
+        and?: string[];
+    };
+    booking_uid: string;
+}
+interface PipelineObject {
+    request: {
+        vehicles: Vehicle[];
+        nodes: Node[];
+    };
+    result: {
+        rejected_bookings: {
+            uid: string;
+        }[];
+        vehicles: Record<string, any>;
+    };
+}
+export declare function analyzePipelineObject(pipelineObject: PipelineObject): Record<string, any>;
+export type { PipelineObject, Vehicle, Node };
+//# sourceMappingURL=vrptoolbox-analyzer.d.ts.map

package/dist/sgerp/vrptoolbox-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vrptoolbox-analyzer.d.ts","sourceRoot":"","sources":["../../sgerplib/sgerp/vrptoolbox-analyzer.ts"],"names":[],"mappings":"AAAA,UAAU,OAAO;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,GAAG,EAAE,CAAC;IACpB,cAAc,EAAE,GAAG,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED,UAAU,IAAI;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,GAAG,EAAE,CAAC;IACnB,YAAY,CAAC,EAAE,GAAG,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,cAAc,CAAC,EAAE;QACf,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;KAChB,CAAC;IACF,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,cAAc;IACtB,OAAO,EAAE;QACP,QAAQ,EAAE,OAAO,EAAE,CAAC;QACpB,KAAK,EAAE,IAAI,EAAE,CAAC;KACf,CAAC;IACF,MAAM,EAAE;QACN,iBAAiB,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QACrC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAC/B,CAAC;CACH;AAwQD,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,cAAc,GAC7B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAkCrB;AAED,YAAY,EAAE,cAAc,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC"}

package/dist/sgerp/vrptoolbox-analyzer.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzePipelineObject = analyzePipelineObject;
+const DEFAULT_SEAT_TYPE = "passenger";
+function getCapacity(value, defaultSeatType = DEFAULT_SEAT_TYPE) {
+    return typeof value === "object" ? value : { [DEFAULT_SEAT_TYPE]: value };
+}
+function checkCharacteristics(node, vehicle) {
+    const reasons = [];
+    const messages = [];
+    if (!vehicle.characteristics) {
+        return [reasons, messages];
+    }
+    const vehicleChars = vehicle.characteristics;
+    const agentId = vehicle.agent_id;
+    const nodeType = node.node_type;
+    Object.entries(node.vehicle_characteristics).forEach(([char, value]) => {
+        const vehicleVar = vehicleChars[char];
+        if (vehicleVar === undefined) {
+            reasons.push({
+                violation: `${char}_availability_violation`,
+                vehicle_value: vehicleVar,
+                char: char,
+                vehicle_characteristics: vehicleChars,
+            });
+            messages.push(`${nodeType} can not be assigned to vehicle ${agentId} because characteristic ${char} is not available in vehicle ${JSON.stringify(vehicleChars)}`);
+        }
+        else if (typeof value === "object") {
+            const minVal = value.min;
+            const maxVal = value.max;
+            if (minVal !== undefined && vehicleVar < minVal) {
+                reasons.push({
+                    violation: `${char}_min_violation`,
+                    vehicle_value: vehicleVar,
+                    required_min: minVal,
+                    vehicle: agentId,
+                });
+                messages.push(`${nodeType} can not be assigned to vehicle ${agentId} because of ${char}.min violation: ${vehicleVar} < ${minVal}`);
+            }
+            if (maxVal !== undefined && vehicleVar > maxVal) {
+                reasons.push({
+                    violation: `${char}_max_violation`,
+                    vehicle_value: vehicleVar,
+                    required_max: maxVal,
+                    vehicle: agentId,
+                });
+                messages.push(`${nodeType} can not be assigned to vehicle ${agentId} because of ${char}.max violation: ${vehicleVar} > ${maxVal}`);
+            }
+        }
+        else if (value !== vehicleVar) {
+            reasons.push({
+                violation: `${char}_value_violation`,
+                required_value: value,
+                vehicle_value: vehicleVar,
+            });
+            messages.push(`can not be assigned to vehicle ${agentId} - ${char}_value_violation`);
+        }
+    });
+    return [reasons, messages];
+}
+function checkStartTimeEndTimeConstraints(node, vehicle) {
+    const reasons = [];
+    const messages = [];
+    const agentId = vehicle.agent_id;
+    const nodeType = node.node_type;
+    if (vehicle.start_time !== undefined) {
+        if (vehicle.start_time > node.close_time_ts) {
+            reasons.push({
+                violation: "start_time_violation",
+                node_close_time: node.close_time_ts,
+                vehicle_start_time: vehicle.start_time,
+            });
+            messages.push(`${nodeType} can not be assigned to vehicle ${agentId} - start_time_violation: ${vehicle.start_time} > ${node.close_time_ts}`);
+        }
+    }
+    if (vehicle.end_time !== undefined) {
+        if (vehicle.end_time < node.open_time_ts) {
+            reasons.push({
+                violation: "end_time_violation",
+                node_open_time: node.open_time_ts,
+                vehicle_end_time: vehicle.end_time,
+            });
+            messages.push(`${nodeType} can not be assigned to vehicle ${agentId} - end_time_violation: ${vehicle.end_time} < ${node.open_time_ts}`);
+        }
+    }
+    return [reasons, messages];
+}
+function checkGeofenceConstraints(node, vehicle) {
+    const reasons = [];
+    const messages = [];
+    const agentId = vehicle.agent_id;
+    if (node.geofence_ids === undefined && node.geofence_id) {
+        node.geofence_ids = [node.geofence_id];
+    }
+    if (node.geofence_ids && node.geofence_ids.length > 0 && node.geofence_ids[0] !== null) {
+        const vehicleGeofenceIds = new Set(vehicle.geofence_ids);
+        const nodeGeofenceIds = new Set(node.geofence_ids);
+        if (vehicleGeofenceIds.size > 0 &&
+            !Array.from(nodeGeofenceIds).some((id) => vehicleGeofenceIds.has(id))) {
+            reasons.push({
+                violation: "geofence_violation",
+                node_geofence_ids: node.geofence_ids,
+                vehicle_geofence_ids: vehicle.geofence_ids,
+            });
+            messages.push(`can not be assigned to vehicle ${agentId} - geofence violations: ${JSON.stringify([...vehicleGeofenceIds])} vs ${JSON.stringify([...nodeGeofenceIds])}`);
+        }
+    }
+    return [reasons, messages];
+}
+function checkVehicleAssignedNodes(node, vehicle) {
+    const reasons = [];
+    const messages = [];
+    const agentId = vehicle.agent_id;
+    if (vehicle.assigned_nodes.length > 0) {
+        reasons.push({
+            violation: "vehicle_has_assigned_nodes",
+        });
+        messages.push(`vehicle ${agentId} has assigned nodes. Possibly change the first solution strategy to 16 or clear vehicles`);
+    }
+    return [reasons, messages];
+}
+function checkVehicleLabels(node, vehicle) {
+    const reasons = [];
+    const messages = [];
+    const agentId = vehicle.agent_id;
+    const nodeLabels = node.vehicle_labels;
+    if (!nodeLabels) {
+        return [reasons, messages];
+    }
+    const labelOrValues = new Set(nodeLabels.or || []);
+    const labelAndValues = new Set(nodeLabels.and || []);
+    const vehicleLabels = new Set(vehicle.labels || []);
+    if (labelOrValues.size > 0) {
+        if (!Array.from(labelOrValues).some((label) => vehicleLabels.has(label))) {
+            reasons.push({
+                violation: "vehicle and booking labels do not satisfy each other",
+            });
+            messages.push(`vehicle ${agentId} has labels ${JSON.stringify([...vehicleLabels])}. Booking: ${JSON.stringify(nodeLabels)}`);
+        }
+    }
+    if (labelAndValues.size > 0) {
+        if (!Array.from(labelAndValues).every((label) => vehicleLabels.has(label))) {
+            reasons.push({
+                violation: "vehicle and booking labels do not satisfy each other",
+            });
+            messages.push(`vehicle ${agentId} has labels ${JSON.stringify([...vehicleLabels])}. Booking: ${JSON.stringify(nodeLabels)}`);
+        }
+    }
+    return [reasons, messages];
+}
+function analyzeVehicles(nodeGroup, vehicles) {
+    const possibleReasons = {
+        messages: [],
+        impossibleVehicles: new Set(),
+        comments: [],
+    };
+    nodeGroup.forEach((node) => {
+        vehicles.forEach((vehicle) => {
+            const [reasons1, messages1] = checkCharacteristics(node, vehicle);
+            const [reasons2, messages2] = checkStartTimeEndTimeConstraints(node, vehicle);
+            const [reasons3, messages3] = checkGeofenceConstraints(node, vehicle);
+            const [reasons4, messages4] = checkVehicleAssignedNodes(node, vehicle);
+            const [reasons5, messages5] = checkVehicleLabels(node, vehicle);
+            if (reasons1.length > 0 ||
+                reasons2.length > 0 ||
+                reasons3.length > 0 ||
+                reasons4.length > 0 ||
+                reasons5.length > 0) {
+                possibleReasons.messages.push(...messages1, ...messages2, ...messages3, ...messages4, ...messages5);
+                possibleReasons.impossibleVehicles.add(vehicle.agent_id);
+            }
+        });
+    });
+    possibleReasons.impossibleVehicles = Array.from(possibleReasons.impossibleVehicles);
+    possibleReasons.impossibleVehiclesCount =
+        possibleReasons.impossibleVehicles.length;
+    if (possibleReasons.impossibleVehiclesCount === vehicles.length) {
+        possibleReasons.comments.push("all vehicles are impossible");
+    }
+    else {
+        const possibleVehicles = vehicles
+            .filter((vehicle) => !possibleReasons.impossibleVehicles.includes(vehicle.agent_id))
+            .map((vehicle) => vehicle.agent_id);
+        possibleReasons.comments.push({ possibleVehicles });
+    }
+    return possibleReasons;
+}
+function analyzePipelineObject(pipelineObject) {
+    const { vehicles, nodes } = pipelineObject.request;
+    const { rejected_bookings, vehicles: resultedVehicles } = pipelineObject.result;
+    const rejectedUids = new Set(rejected_bookings.map((b) => b.uid));
+    const rejectedNodes = nodes.filter((node) => rejectedUids.has(node.booking_uid));
+    const emptyVehicleUids = new Set(Object.entries(resultedVehicles)
+        .filter(([_, item]) => !item)
+        .map(([key, _]) => key));
+    const emptyVehicles = vehicles; // .filter(v => emptyVehicleUids.has(v.agent_id));
+    const possibleReasons = {};
+    const bookingNodes = {};
+    rejectedNodes.forEach((node) => {
+        const { booking_uid } = node;
+        if (!bookingNodes[booking_uid]) {
+            bookingNodes[booking_uid] = [];
+        }
+        bookingNodes[booking_uid].push(node);
+    });
+    Object.entries(bookingNodes).forEach(([booking_uid, node_group]) => {
+        possibleReasons[booking_uid] = analyzeVehicles(node_group, emptyVehicles);
+    });
+    return possibleReasons;
+}

package/dist/vrptoolbox/collection.d.ts

@@ -0,0 +1,16 @@
+import type { OptimizationJob } from './types/job';
+import { Collection } from '../sgerp/collection';
+/**
+ * Collection class for VRP Toolbox Optimization Jobs
+ */
+export declare class OptimizationJobCollection extends Collection<OptimizationJob> {
+    private baseUrl;
+    private username?;
+    private password?;
+    constructor(baseUrl: string, username?: string, password?: string);
+    /**
+     * Set authentication credentials
+     */
+    setCredentials(username: string, password: string): void;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/vrptoolbox/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../sgerplib/vrptoolbox/collection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAA0B,MAAM,aAAa,CAAC;AAE3E,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAqBjD;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,UAAU,CAAC,eAAe,CAAC;IACxE,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,CAAS;gBAEd,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAqCjE;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;CAIzD"}