@fleetbase/fleetops-engine 0.6.46 → 0.6.48

package/server/src/Support/OrderTracker.php

@@ -2,598 +2,23 @@
 
 namespace Fleetbase\FleetOps\Support;
 
-use Fleetbase\FleetOps\Models\Driver;
 use Fleetbase\FleetOps\Models\Order;
-use Fleetbase\FleetOps\Models\Payload;
-use Fleetbase\FleetOps\Models\Place;
-use Fleetbase\FleetOps\Models\Waypoint;
-use Fleetbase\LaravelMysqlSpatial\Types\Point;
-use Illuminate\Support\Arr;
-use Illuminate\Support\Carbon;
-use Illuminate\Support\Collection;
-use Illuminate\Support\Facades\Cache;
-use Illuminate\Support\Facades\Log;
-use Illuminate\Support\Str;
+use Fleetbase\FleetOps\Tracking\TrackingIntelligenceService;
+use Fleetbase\FleetOps\Tracking\TrackingOptions;
 
-/**
- * Class OrderTracker.
- *
- * Provides functionality to track an order's progress, calculate ETA, and retrieve various order-related data.
- */
 class OrderTracker
 {
-    /** @var Order The order being tracked */
-    protected Order $order;
-
-    /** @var Payload The payload associated with the order */
-    protected Payload $payload;
-
-    /** @var Driver The driver assigned to the order */
-    protected ?Driver $driver;
-
-    /** @var bool Flag to indicate if the order has multiple dropoff points */
-    protected bool $isMultipleDropOrder = false;
-
-    /**
-     * Constructor for OrderTracker.
-     *
-     * @param Order $order the order to track
-     */
-    public function __construct(Order $order)
-    {
-        $order->loadAssignedDriver();
-
-        $this->order   = $order;
-        $this->payload = $order->getPayload(function ($payload) {
-            $payload->loadMissing(['pickup', 'dropoff', 'waypoints', 'waypointMarkers']);
-        });
-        $this->isMultipleDropOrder = $this->payload->isMultipleDropOrder;
-        $this->driver              = $order->driverAssigned;
-    }
-
-    /**
-     * Get the current location of the driver or starting point.
-     *
-     * @return Point|null the current location of the driver, or null if unavailable
-     */
-    public function getDriverCurrentLocation(): ?Point
-    {
-        if ($this->driver) {
-            return $this->driver->location;
-        }
-
-        $startingPoint = $this->payload->getPickupOrCurrentWaypoint();
-        if ($startingPoint) {
-            return $startingPoint->location;
-        }
-
-        return null;
-    }
-
-    /**
-     * Get the percentage progress of the order.
-     *
-     * @return int|float the percentage of the order progress
-     */
-    public function getOrderProgressPercentage(): int|float
-    {
-        $totalDistance     = $this->getTotalDistance();
-        $completedDistance = $this->getCompletedDistance();
-        $cannotUseDistance = $totalDistance == -1 || $completedDistance == -1 || $completedDistance === 0;
-
-        // Get order percentage by activity if distance-based progress is not available
-        if ($cannotUseDistance) {
-            /** @var Collection $activities */
-            $activities    = $this->order->orderConfig ? $this->order->orderConfig->activities() : collect();
-            $totalActivity = $activities->count();
-            if ($totalActivity === 0) {
-                return 100; // No activities, so treat it as 100% complete
-            }
-
-            // Calculate completed activities
-            $completedActivity = $activities->filter(function ($activity) {
-                return $activity->isCompleted($this->order);
-            })->count();
-
-            // Return progress percentage based on completed activities
-            return round(($completedActivity / $totalActivity) * 100, 2);
-        }
-
-        if ($totalDistance === 0) {
-            return 100;
-        }
-
-        return round(($completedDistance / $totalDistance) * 100, 2);
-    }
-
-    /**
-     * Get the total distance for the order.
-     *
-     * @return int|float the total distance of the order in meters
-     */
-    public function getTotalDistance(): int|float
-    {
-        $points   = $this->getAllDestinationPoints()->toArray();
-        if (count($points) < 2) {
-            return -1;
-        }
-
-        try {
-            $response = OSRM::getRouteFromPoints($points);
-            if (isset($response['code']) && $response['code'] === 'Ok') {
-                $route = Arr::first($response['routes']);
-                if ($route) {
-                    return data_get($route, 'distance', 0);
-                }
-            }
-        } catch (\Exception $e) {
-            Log::warning('Error loading OSRM routes from order points.', [$e]);
-
-            return -1;
-        }
-
-        return -1;
-    }
-
-    /**
-     * Get the completed distance by the driver.
-     *
-     * @return float the completed distance in meters
-     */
-    public function getCompletedDistance(): float
-    {
-        $points = $this->getCompletedDestinationPoints()->toArray();
-        if (count($points) < 2) {
-            return -1;
-        }
-
-        try {
-            $response = OSRM::getRouteFromPoints($points);
-            if (isset($response['code']) && $response['code'] === 'Ok') {
-                $route = Arr::first($response['routes']);
-                if ($route) {
-                    return data_get($route, 'distance', 0);
-                }
-            }
-        } catch (\Exception $e) {
-            Log::warning('Error loading OSRM routes from order points.', [$e]);
-
-            return -1;
-        }
-
-        return -1;
-    }
-
-    /**
-     * Get the estimated time of arrival (ETA) for the current destination.
-     *
-     * @return float the ETA in seconds or -1 if unable to calculate
-     */
-    public function getCurrentDestinationETA(): float
-    {
-        $start              = $this->getDriverCurrentLocation();
-        $currentDestination = $this->getCurrentDestination();
-        $end                = $currentDestination ? $currentDestination->location : null;
-        if ($start == $end) {
-            $nextDestination = $this->getNextDestination();
-            if ($nextDestination) {
-                $end = $nextDestination->location;
-            }
-        }
-
-        if (!$start || !$end) {
-            return -1;
-        }
-
-        // Convert SpatialExpression to Point objects
-        $start = Utils::getPointFromMixed($start);
-        $end   = Utils::getPointFromMixed($end);
-
-        if (!$start || !$end) {
-            return -1;
-        }
-
-        try {
-            $response = OSRM::getRoute($start, $end);
-            if (isset($response['code']) && $response['code'] === 'Ok') {
-                $route = Arr::first($response['routes']);
-                if ($route) {
-                    return data_get($route, 'duration', -1);
-                }
-            }
-        } catch (\Exception $e) {
-            Log::warning('Error loading OSRM route from start and end points.', [$e]);
-
-            return -1;
-        }
-
-        return -1;
-    }
-
-    public function getWaypointETA(Waypoint|Place $waypoint): float
-    {
-        if ($waypoint instanceof Waypoint) {
-            $waypoint->loadMissing('place');
-            $waypoint = $waypoint->place;
-        }
-
-        $start              = $this->getDriverCurrentLocation();
-        $end                = $waypoint->location;
-
-        // Convert SpatialExpression to Point objects
-        $start = Utils::getPointFromMixed($start);
-        $end   = Utils::getPointFromMixed($end);
-
-        if (!$start || !$end) {
-            return -1;
-        }
-
-        try {
-            $response           = OSRM::getRoute($start, $end);
-            if (isset($response['code']) && $response['code'] === 'Ok') {
-                $route = Arr::first($response['routes']);
-                if ($route) {
-                    return data_get($route, 'duration', -1);
-                }
-            }
-        } catch (\Exception $e) {
-            Log::warning('Error loading OSRM routes from start and end points.', [$e]);
-
-            return -1;
-        }
-
-        return -1;
-    }
-
-    /**
-     * Get the estimated time of arrival (ETA) for the completion of the order.
-     *
-     * @return float the ETA in seconds or -1 if unable to calculate
-     */
-    public function getCompletionETA(): float
-    {
-        $start    = $this->getDriverCurrentLocation();
-        $end      = $this->payload->getDropoffOrLastWaypoint()->location;
-
-        // Convert SpatialExpression to Point objects
-        $start = Utils::getPointFromMixed($start);
-        $end   = Utils::getPointFromMixed($end);
-
-        if (!$start || !$end) {
-            return -1;
-        }
-
-        try {
-            $response = OSRM::getRoute($start, $end);
-            if (isset($response['code']) && $response['code'] === 'Ok') {
-                $route = Arr::first($response['routes']);
-                if ($route) {
-                    return data_get($route, 'duration', -1);
-                }
-            }
-        } catch (\Exception $e) {
-            Log::warning('Error loading OSRM routes from start and end points.', [$e]);
-
-            return -1;
-        }
-
-        return -1;
-    }
-
-    /**
-     * Get the estimated completion time of the order.
-     *
-     * @return Carbon the estimated completion time
-     */
-    public function getEstimatedCompletionTime(): ?Carbon
-    {
-        $currentEtaCompletion = $this->getCompletionETA();
-
-        return now()->addSeconds($currentEtaCompletion);
-    }
-
-    /**
-     * Get the start time of the order.
-     *
-     * @return Carbon the time the order started
-     */
-    public function getOrderStartTime(): ?Carbon
+    public function __construct(protected Order $order)
     {
-        return $this->order->started_at;
     }
 
-    /**
-     * Get the completion time of the order, if completed.
-     *
-     * @return Carbon|null the time the order was completed, or null if not completed
-     */
-    public function getOrderCompletionTime(): ?Carbon
+    public function eta(array $options = []): array
     {
-        return $this->order->completed_at;
+        return app(TrackingIntelligenceService::class)->eta($this->order, TrackingOptions::fromArray($options));
     }
 
-    /**
-     * Get all destinations (pickup, waypoints, dropoff) for the order.
-     *
-     * @return Collection a collection of all destination places
-     */
-    public function getAllDestinations(): Collection
+    public function toArray(array $options = []): array
     {
-        return collect([$this->payload->pickup, ...$this->payload->waypoints, $this->payload->dropoff])->filter();
-    }
-
-    /**
-     * Get all destination points (pickup, waypoints, dropoff) as spatial points.
-     *
-     * @return Collection a collection of Point objects for each destination
-     */
-    public function getAllDestinationPoints(): Collection
-    {
-        return $this->getAllDestinations()->map(function (Place $place) {
-            return $place->location;
-        })->filter()->values();
-    }
-
-    /**
-     * Get the current destination the driver is heading to.
-     *
-     * @return Place|null the current destination place object, or null if not available
-     */
-    public function getCurrentDestination(): ?Place
-    {
-        if ($this->isMultipleDropOrder) {
-            if ($this->payload->waypoints) {
-                $destination = null;
-
-                if (Str::isUuid($this->payload->current_waypoint_uuid)) {
-                    $destination = $this->payload->waypoints->firstWhere('uuid', $this->payload->current_waypoint_uuid);
-                }
-
-                if (!$destination) {
-                    $destination = $this->payload->waypoints->first();
-                }
-
-                return $destination;
-            }
-
-            return null;
-        }
-
-        if ($this->order->status === 'created' || $this->order->status === 'dispatched' || $this->order->status === 'pending') {
-            return $this->payload->pickup;
-        }
-
-        return $this->payload->dropoff;
-    }
-
-    /**
-     * Get the completed destinations of the order.
-     *
-     * @return Collection a collection of completed destination places
-     */
-    public function getCompletedDestinations(): Collection
-    {
-        if ($this->isMultipleDropOrder) {
-            return $this->payload->waypointMarkers->filter(
-                function (Waypoint $waypoint) {
-                    return $this->isWaypointCompleted($waypoint);
-                }
-            )->map(
-                function (Waypoint $waypoint) {
-                    $waypoint->loadMissing('place');
-
-                    return $waypoint->place;
-                }
-            );
-        }
-
-        if ($this->order->status === 'created' || $this->order->status === 'dispatched' || $this->order->status === 'pending') {
-            return collect();
-        }
-
-        if ($this->order->status === 'completed') {
-            return collect([$this->getPickup(), $this->getDropoff()]);
-        }
-
-        return collect([$this->getPickup()]);
-    }
-
-    /**
-     * Get the completed destination points as spatial points.
-     *
-     * @return Collection a collection of Point objects representing the completed destination points
-     */
-    public function getCompletedDestinationPoints(): Collection
-    {
-        return $this->getCompletedDestinations()->map(function (Place $place) {
-            return $place->location;
-        })->filter()->values();
-    }
-
-    /**
-     * Get the next destination that the driver should go to.
-     *
-     * @return Place|null the next destination place, or null if not available
-     */
-    public function getNextDestination(): ?Place
-    {
-        if ($this->isMultipleDropOrder) {
-            /** @var Waypoint $nextWaypoint */
-            $nextWaypoint = $this->payload->waypointMarkers->filter(function (Waypoint $waypoint) {
-                return $this->isWaypointNotCompleted($waypoint) && $this->isWaypointNotCurrentDestination($waypoint);
-            })->first();
-
-            if ($nextWaypoint) {
-                $nextWaypoint->loadMissing('place');
-
-                return $nextWaypoint->place;
-            }
-        }
-
-        return $this->payload->dropoff;
-    }
-
-    /**
-     * Check if a waypoint has been completed.
-     *
-     * @param Waypoint $waypoint the waypoint to check
-     *
-     * @return bool true if the waypoint is completed or canceled, otherwise false
-     */
-    public function isWaypointCompleted(Waypoint $waypoint): bool
-    {
-        $waypoint->loadMissing(['trackingNumber', 'trackingNumber.status']);
-        $status = strtolower($waypoint->status_code);
-
-        return $status === 'completed' || $status === 'canceled';
-    }
-
-    /**
-     * Check if a waypoint is not completed.
-     *
-     * @param Waypoint $waypoint the waypoint to check
-     *
-     * @return bool true if the waypoint is not completed, otherwise false
-     */
-    public function isWaypointNotCompleted(Waypoint $waypoint): bool
-    {
-        return !$this->isWaypointCompleted($waypoint);
-    }
-
-    /**
-     * Check if a waypoint is the current destination.
-     *
-     * @param Waypoint $waypoint the waypoint to check
-     *
-     * @return bool true if the waypoint is the current destination, otherwise false
-     */
-    public function isWaypointCurrentDestination(Waypoint $waypoint): bool
-    {
-        if (!$this->payload->current_waypoint_uuid) {
-            $currentDestination = $this->getCurrentDestination();
-
-            return $currentDestination->uuid === $waypoint->place_uuid;
-        }
-
-        return $waypoint->place_uuid === $this->payload->current_waypoint_uuid;
-    }
-
-    /**
-     * Check if a waypoint is not the current destination.
-     *
-     * @param Waypoint $waypoint the waypoint to check
-     *
-     * @return bool true if the waypoint is not the current destination, otherwise false
-     */
-    public function isWaypointNotCurrentDestination(Waypoint $waypoint): bool
-    {
-        return !$this->isWaypointCurrentDestination($waypoint);
-    }
-
-    /**
-     * Get the pickup location of the order.
-     *
-     * @return Place the pickup place of the order
-     */
-    public function getPickup(): ?Place
-    {
-        return $this->payload->pickup;
-    }
-
-    /**
-     * Get the dropoff location of the order.
-     *
-     * @return Place the dropoff place of the order
-     */
-    public function getDropoff(): ?Place
-    {
-        return $this->payload->dropoff;
-    }
-
-    public function eta(): array
-    {
-        // Generate cache key based on order UUID and updated_at timestamp
-        $cacheKey = 'order_eta:' . $this->order->uuid . ':' . optional($this->order->updated_at)->timestamp;
-
-        // Return cached data if available
-        return Cache::remember($cacheKey, 60, function () {
-            // Load missing waypoints and places
-            $waypoints = $this->payload->getAllStops();
-
-            // ETA's
-            $eta = [];
-            foreach ($waypoints as $waypoint) {
-                $eta[$waypoint->uuid] = $this->getWaypointETA($waypoint);
-            }
-
-            return $eta;
-        });
-    }
-
-    /**
-     * Get all key tracker information as an array.
-     * Cached for 60 seconds to avoid repeated OSRM calls.
-     */
-    public function toArray(): array
-    {
-        // Generate cache key based on order UUID and updated_at timestamp
-        $cacheKey = 'order_tracker:' . $this->order->uuid . ':' . optional($this->order->updated_at)->timestamp;
-
-        // Return cached data if available
-        return Cache::remember($cacheKey, 60, function () {
-            // Early return for completed orders - skip expensive OSRM calls
-            if (in_array($this->order->status, ['completed', 'canceled'])) {
-                return [
-                    'driver_current_location'             => null,
-                    'progress_percentage'                 => 100,
-                    'total_distance'                      => 0,
-                    'completed_distance'                  => 0,
-                    'current_destination_eta'             => 0,
-                    'completion_eta'                      => 0,
-                    'estimated_completion_time'           => null,
-                    'estimated_completion_time_formatted' => null,
-                    'start_time'                          => $this->getOrderStartTime(),
-                    'completion_time'                     => $this->getOrderCompletionTime(),
-                    'current_destination'                 => null,
-                    'next_destination'                    => null,
-                    'first_waypoint_completed'            => true,
-                    'last_waypoint_completed'             => true,
-                ];
-            }
-
-            // Wrap OSRM-dependent calculations in try-catch for graceful degradation
-            try {
-                $totalDistance         = $this->getTotalDistance();
-                $completedDistance     = $this->getCompletedDistance();
-                $currentDestinationEta = $this->getCurrentDestinationETA();
-                $completionEta         = $this->getCompletionETA();
-            } catch (\Exception $e) {
-                Log::warning('OrderTracker: Failed to calculate distances/ETAs', ['error' => $e->getMessage()]);
-                $totalDistance         = 0;
-                $completedDistance     = 0;
-                $currentDestinationEta = 0;
-                $completionEta         = 0;
-            }
-
-            $estimatedCompletionTime = $this->getEstimatedCompletionTime();
-            $orderProgressPercentage = $this->getOrderProgressPercentage();
-
-            return [
-                'driver_current_location'             => $this->getDriverCurrentLocation(),
-                'progress_percentage'                 => $orderProgressPercentage,
-                'total_distance'                      => $totalDistance,
-                'completed_distance'                  => $completedDistance,
-                'current_destination_eta'             => $currentDestinationEta,
-                'completion_eta'                      => $completionEta,
-                'estimated_completion_time'           => $estimatedCompletionTime,
-                'estimated_completion_time_formatted' => $estimatedCompletionTime instanceof Carbon ? $estimatedCompletionTime->format('M jS, Y H:i') : null,
-                'start_time'                          => $this->getOrderStartTime(),
-                'completion_time'                     => $this->getOrderCompletionTime(),
-                'current_destination'                 => $this->getCurrentDestination(),
-                'next_destination'                    => $this->getNextDestination(),
-                'first_waypoint_completed'            => $orderProgressPercentage > 10,
-                'last_waypoint_completed'             => $orderProgressPercentage === 100 || $this->order->status === 'completed',
-            ];
-        });
+        return app(TrackingIntelligenceService::class)->track($this->order, TrackingOptions::fromArray($options));
     }
 }

package/server/src/Support/Utils.php

@@ -392,7 +392,7 @@ class Utils extends FleetbaseUtils
             return null;
         }
 
-        if (preg_match("/POINT\\(\\s*([-+]?\\d*\\.?\\d+)\\s+([-+]?\\d*\\.?\\d+)\\s*\\)/i", $expressionValue, $matches)) {
+        if (preg_match('/POINT\\(\\s*([-+]?\\d*\\.?\\d+)\\s+([-+]?\\d*\\.?\\d+)\\s*\\)/i', $expressionValue, $matches)) {
             return sprintf('POINT(%s %s)', $matches[1], $matches[2]);
         }
 

package/server/src/Tracking/Contracts/TrackingProviderInterface.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Fleetbase\FleetOps\Tracking\Contracts;
+
+use Fleetbase\FleetOps\Tracking\TrackingContext;
+use Fleetbase\FleetOps\Tracking\TrackingOptions;
+use Fleetbase\FleetOps\Tracking\TrackingProviderCapabilities;
+use Fleetbase\FleetOps\Tracking\TrackingProviderResult;
+
+interface TrackingProviderInterface
+{
+    public function key(): string;
+
+    public function capabilities(): TrackingProviderCapabilities;
+
+    public function canTrack(TrackingContext $context): bool;
+
+    public function track(TrackingContext $context, TrackingOptions $options): TrackingProviderResult;
+}

package/server/src/Tracking/Providers/CalculatedTrackingProvider.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Fleetbase\FleetOps\Tracking\Providers;
+
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\FleetOps\Tracking\Contracts\TrackingProviderInterface;
+use Fleetbase\FleetOps\Tracking\TrackingContext;
+use Fleetbase\FleetOps\Tracking\TrackingOptions;
+use Fleetbase\FleetOps\Tracking\TrackingProviderCapabilities;
+use Fleetbase\FleetOps\Tracking\TrackingProviderResult;
+
+class CalculatedTrackingProvider implements TrackingProviderInterface
+{
+    public function key(): string
+    {
+        return 'calculated';
+    }
+
+    public function capabilities(): TrackingProviderCapabilities
+    {
+        return new TrackingProviderCapabilities();
+    }
+
+    public function canTrack(TrackingContext $context): bool
+    {
+        return $context->canRoute();
+    }
+
+    public function track(TrackingContext $context, TrackingOptions $options): TrackingProviderResult
+    {
+        $points   = $context->routePoints();
+        $distance = 0;
+        $legs     = [];
+
+        for ($i = 0; $i < count($points) - 1; $i++) {
+            $legDistance = Utils::vincentyGreatCircleDistance($points[$i], $points[$i + 1]);
+            $legDuration = $this->durationFromDistance($legDistance, $options);
+            $distance += $legDistance;
+            $legs[] = [
+                'index'                 => $i,
+                'distance_m'            => $legDistance,
+                'duration_s'            => $legDuration,
+                'duration_in_traffic_s' => null,
+                'provider'              => $this->key(),
+            ];
+        }
+
+        return new TrackingProviderResult(
+            provider: $this->key(),
+            distanceMeters: $distance,
+            durationSeconds: $this->durationFromDistance($distance, $options),
+            durationInTrafficSeconds: null,
+            legs: $legs,
+            warnings: ['calculated_route_used'],
+            confidence: 'low'
+        );
+    }
+
+    protected function durationFromDistance(float $distanceMeters, TrackingOptions $options): float
+    {
+        $metersPerSecond = max($options->defaultVehicleSpeedKph, 1) * 1000 / 3600;
+
+        return round($distanceMeters / $metersPerSecond);
+    }
+}