@fleetbase/fleetops-engine 0.4.20 → 0.4.22

package/composer.json

@@ -1,6 +1,6 @@
 {
     "name": "fleetbase/fleetops-api",
-    "version": "0.4.20",
+    "version": "0.4.22",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "keywords": [
         "fleetbase-extension",

package/extension.json

@@ -1,6 +1,6 @@
 {
     "name": "Fleet-Ops",
-    "version": "0.4.20",
+    "version": "0.4.22",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "repository": "https://github.com/fleetbase/fleetops",
     "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fleetbase/fleetops-engine",
-    "version": "0.4.20",
+    "version": "0.4.22",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "fleetbase": {
         "route": "fleet-ops"

package/server/config/fleetops.php

@@ -22,6 +22,25 @@ return [
         'db' => env('DB_CONNECTION', 'mysql')
     ],
 
+     /*
+    |--------------------------------------------------------------------------
+    | OSRM
+    |--------------------------------------------------------------------------
+    */
+    'osrm' => [
+        'host' => env('OSRM_HOST', 'https://bundle.routing.fleetbase.io')
+    ],
+
+     /*
+    |--------------------------------------------------------------------------
+    | Distance Matrix Calculator 
+    | Options: "calculate", "google", "osrm"
+    |--------------------------------------------------------------------------
+    */
+    'distance_matrix' => [
+        'provider' => env('DISTANCE_MATRIX_PROVIDER', 'calculate')
+    ],
+
     /*
     |--------------------------------------------------------------------------
     | Navigator App

package/server/src/Console/Commands/DispatchAdhocOrders.php

@@ -7,6 +7,7 @@ use Fleetbase\FleetOps\Models\Order;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\LaravelMysqlSpatial\Types\Point;
 use Illuminate\Console\Command;
+use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Support\Carbon;
 
 class DispatchAdhocOrders extends Command
@@ -28,52 +29,56 @@ class DispatchAdhocOrders extends Command
     /**
      * Execute the console command.
      *
-     * This method is responsible for the main logic of the command.
-     * It fetches dispatchable orders, notifies about the current time and number of orders,
-     * and then dispatches each order if there are nearby drivers.
-     *
-     * @return int
+     * Processes and dispatches ad-hoc orders based on their scheduled dispatch time and driver availability.
+     * Orders without an assigned driver and that have surpassed the dispatch time threshold are considered for dispatch.
+     * The command supports sandbox and testing modes for different operational environments.
      */
-    public function handle()
+    public function handle(): void
     {
-        // Set UTC as default timezone
         date_default_timezone_set('UTC');
 
-        // Get all dispatchable orders
+        $sandboxMode = Utils::castBoolean($this->option('sandbox'));
+        $this->info('Running in ' . ($sandboxMode ? 'sandbox' : 'production') . ' mode.');
+
         $orders = $this->getDispatchableOrders();
 
-        // Notify Current Time and # of Orders in Alera
-        $this->alert('Found (' . $orders->count() . ') Orders to be Dispatched -- Current Time: ' . Carbon::now()->toDateTimeString());
+        $this->alert($orders->count() . ' orders found for ad-hoc dispatch. Current Time: ' . Carbon::now()->toDateTimeString());
 
-        // Iterate for each order
-        $orders->each(
-            function ($order) {
-                $pickup   = $order->getPickupLocation();
-                $distance = $order->getAdhocPingDistance();
+        foreach ($orders as $order) {
+            $pickup   = $order->getPickupLocation();
+            $distance = $order->getAdhocPingDistance();
 
-                if (!Utils::isPoint($pickup)) {
-                    return;
-                }
+            if (!Utils::isPoint($pickup)) {
+                $this->error('Invalid pickup location for order ' . $order->public_id);
+                continue;
+            }
 
-                // Get nearby drivers for this order
-                $drivers = $this->getNearbyDriversForOrder($order, $pickup, $distance);
+            $drivers = $this->getNearbyDriversForOrder($order, $pickup, $distance);
 
-                // Inform
-                $this->alert('Found (' . $drivers->count() . ') driver within ' . $distance . ' meters of the pickup location for order ' . $order->public_id);
+            $this->line('Checking order ' . $order->public_id . ' for nearby drivers within ' . $distance . ' meters.');
 
-                // Dispatch if there is nearby drivers
-                if ($drivers->count()) {
-                    $order->dispatch(true);
-                    $this->info('Order ' . $order->public_id . ' dispatched!');
+            if ($drivers->count()) {
+                $order->dispatch(true);
+                $this->info('Order ' . $order->public_id . ' dispatched successfully to ' . $drivers->count() . ' nearby drivers.');
+                foreach ($drivers as $driver) {
+                    $this->info('Pinging driver ' . $driver->name . ' (' . $driver->public_id . ') ...');
                 }
+            } else {
+                $this->warn('No available drivers found for order ' . $order->public_id);
             }
-        );
+        }
     }
 
     /**
-     * Fetches dispatchable orders based on certain criteria.
+     * Fetches ad-hoc dispatchable orders based on certain criteria.
+     *
+     * Retrieves orders that are marked as ad-hoc and have not been dispatched yet. The orders
+     * are filtered by their scheduled dispatch time, order status, and whether a driver has been
+     * assigned to them. The method also applies filters based on sandbox mode.
+     *
+     * @return Collection returns a collection of orders that meet the criteria
      */
-    public function getDispatchableOrders(): \Illuminate\Database\Eloquent\Collection
+    public function getDispatchableOrders(): Collection
     {
         $sandbox  = Utils::castBoolean($this->option('sandbox'));
         $interval = 4;
@@ -100,8 +105,17 @@ class DispatchAdhocOrders extends Command
 
     /**
      * Fetches nearby drivers for a given order based on the pickup location and distance.
+     *
+     * Retrieves drivers who are within a specified distance from the pickup location of the order.
+     * The method supports a testing mode to simulate driver availability.
+     *
+     * @param Order $order    the order for which drivers are being sought
+     * @param Point $pickup   the geographic point representing the pickup location
+     * @param int   $distance the maximum distance (in meters) within which drivers should be located
+     *
+     * @return Collection returns a collection of nearby drivers
      */
-    public function getNearbyDriversForOrder(Order $order, Point $pickup, int $distance): \Illuminate\Database\Eloquent\Collection
+    public function getNearbyDriversForOrder(Order $order, Point $pickup, int $distance): Collection
     {
         $testing = Utils::castBoolean($this->option('testing'));
 

package/server/src/Console/Commands/DispatchOrders.php

@@ -14,7 +14,7 @@ class DispatchOrders extends Command
      *
      * @var string
      */
-    protected $signature = 'fleetops:dispatch-orders {--sandbox=false}';
+    protected $signature = 'fleetops:dispatch-orders {--sandbox=false : Whether to use the sandbox database for testing purposes.}';
 
     /**
      * The console command description.
@@ -26,41 +26,47 @@ class DispatchOrders extends Command
     /**
      * Execute the console command.
      *
-     * @return int
+     * Processes and dispatches orders that are scheduled for today. Orders are
+     * filtered based on their dispatch status, scheduled time, and other criteria.
+     * The command allows for a sandbox mode for testing.
      */
-    public function handle()
+    public function handle(): void
     {
         // Set UTC as default timezone
         date_default_timezone_set('UTC');
 
+        $sandboxMode = Utils::castBoolean($this->option('sandbox'));
+        $this->info('Running in ' . ($sandboxMode ? 'sandbox' : 'production') . ' mode.');
+
         // Get all scheduled dispatchable orders
-        $orders = $this->getScheduledOrders();
+        $orders = $this->getScheduledOrders($sandboxMode);
 
-        // Notify Current Time and # of Orders in Alera
-        $this->alert('Found (' . $orders->count() . ') Orders Scheduled for Dispatched -- Current Time: ' . Carbon::now()->toDateTimeString());
+        $this->alert('Found ' . $orders->count() . ' orders scheduled for dispatch. Current Time: ' . Carbon::now()->toDateTimeString());
 
         // Dispatch each order
-        $orders->each(
-            function ($order) {
-                if ($order->shouldDispatch()) {
-                    $order->dispatch();
-
-                    $this->info('Order ' . $order->public_id . ' dispatched! (' . $order->scheduled_at . ')');
-                } else {
-                    $this->warn('Order ' . $order->public_id . ' will be dispatched today today AT ' . $order->scheduled_at);
-                }
+        foreach ($orders as $order) {
+            if ($order->shouldDispatch()) {
+                $order->dispatch();
+                $this->info('Order ' . $order->public_id . ' dispatched successfully (' . $order->scheduled_at . ').');
+            } else {
+                $this->warn('Order ' . $order->public_id . ' is not ready for dispatch (' . $order->scheduled_at . ').');
             }
-        );
+        }
     }
 
     /**
-     * Fetches scheduled dispatchable orders based on certain criteria.
+     * Fetches scheduled dispatchable orders.
+     *
+     * Retrieves orders that are scheduled for today and have not yet been dispatched.
+     * Filters orders based on dispatch status, order status, and scheduled date.
+     *
+     * @param bool $sandboxMode whether to use the sandbox database
+     *
+     * @return \Illuminate\Database\Eloquent\Collection returns a collection of orders that meet the criteria
      */
-    public function getScheduledOrders(): \Illuminate\Database\Eloquent\Collection
+    protected function getScheduledOrders(bool $sandboxMode): \Illuminate\Database\Eloquent\Collection
     {
-        $sandbox = Utils::castBoolean($this->option('sandbox'));
-
-        return Order::on($sandbox ? 'sandbox' : 'mysql')
+        return Order::on($sandboxMode ? 'sandbox' : 'mysql')
             ->withoutGlobalScopes()
             ->where('dispatched', 0)
             ->whereIn('status', ['pending', 'created'])

package/server/src/Console/Commands/FixInvalidPolymorphicRelationTypeNamespaces.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace Fleetbase\FleetOps\Console\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Str;
+
+class FixInvalidPolymorphicRelationTypeNamespaces extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'fleetops:fix-invalid-polymorphic-relation-type-namespaces';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Fixes invalid namespaces in polymorphic relations across multiple models';
+
+    /**
+     * Handle the console command execution.
+     *
+     * Iterates over a predefined list of models and their respective polymorphic columns,
+     * calling a method to fix invalid namespace references in these polymorphic relations.
+     * This allows correction across multiple models in a single command execution.
+     *
+     * @return void
+     */
+    public function handle()
+    {
+        $models = [
+            ['model' => \Fleetbase\FleetOps\Models\Order::class, 'columns' => ['customer_type', 'facilitator_type']],
+            ['model' => \Fleetbase\FleetOps\Models\Place::class, 'columns' => ['owner_type']],
+            ['model' => \Fleetbase\FleetOps\Models\Entity::class, 'columns' => ['customer_type']],
+            ['model' => \Fleetbase\FleetOps\Models\PurchaseRate::class, 'columns' => ['customer_type']],
+        ];
+
+        foreach ($models as $modelConfig) {
+            $this->fixModelRelations($modelConfig['model'], $modelConfig['columns']);
+        }
+    }
+
+    /**
+     * Fixes invalid namespace references in polymorphic relations for a specific model.
+     *
+     * Given a model class and an array of its polymorphic relation columns, this method
+     * iterates through each record of the model, correcting any invalid namespaces in
+     * these columns. It outputs information about the process, including the number of
+     * records updated. This function is designed to be reusable for different models.
+     *
+     * @param string $modelClass the class name of the model to be processed
+     * @param array  $columns    an array of column names that have polymorphic relations
+     */
+    protected function fixModelRelations(string $modelClass, array $columns): void
+    {
+        $modelInstance = new $modelClass();
+        $modelName     = class_basename($modelInstance);
+
+        $this->info("Processing $modelName...");
+
+        $records = $modelInstance::query();
+        foreach ($columns as $column) {
+            $records->orWhereNotNull($column);
+        }
+        $records      = $records->get();
+        $updatedCount = 0;
+        $this->alert('Checking ' . $records->count() . ' ' . Str::plural($modelName, $records->count()) . ' for invalid polymorphic relation type namespaces.');
+
+        foreach ($records as $record) {
+            foreach ($columns as $column) {
+                if (isset($record->$column)) {
+                    $original           = $record->$column;
+                    $normalizedOriginal = ltrim($original, '\\');
+
+                    if (Str::startsWith($normalizedOriginal, 'Fleetbase\Models')) {
+                        $newNamespace    = Str::replaceFirst('Fleetbase\Models', 'Fleetbase\FleetOps\Models', $normalizedOriginal);
+                        $record->$column = $newNamespace;
+                        $updatedCount++;
+
+                        $this->info("{$modelName} ID {$record->id}: Corrected namespace from '$original' to '$newNamespace'.");
+                    }
+                }
+            }
+
+            if ($record->isDirty()) {
+                $record->save();
+                $this->info("Saved changes for $modelName ID {$record->public_id}.");
+            }
+        }
+
+        $this->info("Finished processing $modelName. Total updated records: $updatedCount.");
+    }
+}

package/server/src/Console/Commands/TrackOrderDistanceAndTime.php

@@ -13,7 +13,7 @@ class TrackOrderDistanceAndTime extends Command
      *
      * @var string
      */
-    protected $signature = 'fleetops:update-estimations';
+    protected $signature = 'fleetops:update-estimations {--provider : The distance and time calculation provider (calculate, google, or osrm)}';
 
     /**
      * The console command description.
@@ -32,31 +32,64 @@ class TrackOrderDistanceAndTime extends Command
         // Set UTC as default timezone
         date_default_timezone_set('UTC');
 
-        // Get all active/ready order
-        $orders = $this->getActiveOrders();
+        // Determine the provider
+        $provider = $this->option('provider');
+        if (!$provider) {
+            $provider = config('fleetops.distance_matrix.provider');
+        }
+        $this->info("Using '{$provider}' as the provider for calculations.");
 
-        // Track updated orders
-        $updated = [];
+        // Get all active/ready orders
+        $orders = $this->getActiveOrders();
 
-        // Notify Current Time and # of Orders in Alera
-        $this->alert('Found (' . $orders->count() . ') Orders to update Tracking Estimation -- Current Time: ' . Carbon::now()->toDateTimeString());
+        // Notify Current Time and # of Orders
+        $this->alert('Found ' . $orders->count() . ' orders to update tracking estimations. Current Time: ' . Carbon::now()->toDateTimeString());
 
         // Update for each order
-        $orders->each(
-            function ($order) use (&$updated) {
-                $updated[] = $order->setDistanceAndTime()->id;
+        $updated = 0;
+        foreach ($orders as $order) {
+            try {
+                // Update order distance and time estimations based on the provider
+                $order->setDistanceAndTime(['provider' => $provider]);
+                $updated++;
+                $this->info("Order ID {$order->id} - Distance & Time estimations updated.");
+            } catch (\Exception $e) {
+                $this->error("Failed to update Order ID {$order->id} - Error: " . $e->getMessage());
             }
-        );
+        }
 
-        // Update info
-        $this->info('Updated ' . count($updated) . '/' . $orders->count() . ' orders Distance & Time Estimations.');
+        // Summary info
+        $this->info("Updated $updated/" . $orders->count() . " orders' Distance & Time Estimations.");
     }
 
     /**
-     * Fetches active orders.
+     * Retrieves active orders that meet specific criteria.
+     *
+     * This method returns a collection of active orders with the following conditions:
+     * - Not in 'completed' or 'canceled' status.
+     * - Not marked as deleted (`deleted_at` is null).
+     * - Associated with a company (`company_uuid` is not null).
+     * - The order process has started (`started` is not null).
+     * - Contains a payload (`payload` relationship exists).
+     * - Created within the past month.
+     *
+     * The result includes related payload data, waypoints, and information about pickup and dropoff points.
+     * Global scopes are not applied to this query.
+     *
+     * @return \Illuminate\Database\Eloquent\Collection collection of relevant Order objects
      */
-    public function getActiveOrders(): \Illuminate\Database\Eloquent\Collection
+    protected function getActiveOrders()
     {
-        return Order::whereNotIn('status', ['completed', 'canceled'])->whereNull(['deleted_at'])->whereNotNull('company_uuid')->whereHas('payload')->with(['payload', 'payload.waypoints', 'payload.pickup', 'payload.dropoff'])->withoutGlobalScopes()->get();
+        $oneMonthAgo = Carbon::now()->subMonth();
+
+        return Order::whereNotIn('status', ['completed', 'canceled'])
+                    ->whereNull('deleted_at')
+                    ->whereNotNull('company_uuid')
+                    ->whereNotNull('started')
+                    ->where('created_at', '>=', $oneMonthAgo)
+                    ->whereHas('payload')
+                    ->with(['payload', 'payload.waypoints', 'payload.pickup', 'payload.dropoff'])
+                    ->withoutGlobalScopes()
+                    ->get();
     }
 }

package/server/src/Models/Order.php

@@ -1505,13 +1505,11 @@ class Order extends Model
      *
      * @return Order the updated Order instance
      */
-    public function setDistanceAndTime(): Order
+    public function setDistanceAndTime($options = []): Order
     {
         $origin      = $this->getCurrentOriginPosition();
         $destination = $this->getDestinationPosition();
-
-        $matrix = Utils::getDrivingDistanceAndTime($origin, $destination);
-
+        $matrix      = Utils::getDrivingDistanceAndTime($origin, $destination, $options);
         if ($origin === null || $destination === null) {
             return $this;
         }

package/server/src/Models/Place.php

@@ -3,6 +3,7 @@
 namespace Fleetbase\FleetOps\Models;
 
 use Fleetbase\Casts\Json;
+use Fleetbase\Casts\PolymorphicType;
 use Fleetbase\FleetOps\Casts\Point;
 use Fleetbase\FleetOps\Support\Geocoding;
 use Fleetbase\FleetOps\Support\Utils;
@@ -114,8 +115,9 @@ class Place extends Model
      * @var array
      */
     protected $casts = [
-        'meta'     => Json::class,
-        'location' => Point::class,
+        'meta'          => Json::class,
+        'location'      => Point::class,
+        'owner_type'    => PolymorphicType::class,
     ];
 
     /**

package/server/src/Models/PurchaseRate.php

@@ -3,6 +3,7 @@
 namespace Fleetbase\FleetOps\Models;
 
 use Fleetbase\Casts\Json;
+use Fleetbase\Casts\PolymorphicType;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\Models\Model;
 use Fleetbase\Traits\HasApiModelBehavior;
@@ -57,7 +58,8 @@ class PurchaseRate extends Model
      * @var array
      */
     protected $casts = [
-        'meta' => Json::class,
+        'meta'             => Json::class,
+        'customer_type'    => PolymorphicType::class,
     ];
 
     /**

package/server/src/Providers/FleetOpsServiceProvider.php

@@ -48,6 +48,7 @@ class FleetOpsServiceProvider extends CoreServiceProvider
         \Fleetbase\FleetOps\Console\Commands\TrackOrderDistanceAndTime::class,
         \Fleetbase\FleetOps\Console\Commands\FixDriverCompanies::class,
         \Fleetbase\FleetOps\Console\Commands\FixLegacyOrderConfigs::class,
+        \Fleetbase\FleetOps\Console\Commands\FixInvalidPolymorphicRelationTypeNamespaces::class,
     ];
 
     /**

package/server/src/Support/Algo.php

@@ -28,28 +28,4 @@ class Algo
 
         return $result;
     }
-
-    /**
-     * Calculates driving distance and time using Google distance matric.
-     *
-     * @return array
-     */
-    public static function calculateDrivingDistanceAndTime($lat1, $long1, $lat2, $long2)
-    {
-        $url =
-            'https://maps.googleapis.com/maps/api/distancematrix/json?origins=' . $lat1 . ',' . $long1 . '&destinations=' . $lat2 . ',' . $long2 . '&mode=driving&key=' . config('services.google.key');
-        $ch = curl_init();
-        curl_setopt($ch, CURLOPT_URL, $url);
-        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
-        curl_setopt($ch, CURLOPT_PROXYPORT, 3128);
-        curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
-        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
-        $response = curl_exec($ch);
-        curl_close($ch);
-        $response_a = json_decode($response, true);
-        $dist       = $response_a['rows'][0]['elements'][0]['distance']['value'];
-        $time       = $response_a['rows'][0]['elements'][0]['duration']['value'];
-
-        return ['distance' => $dist, 'time' => $time];
-    }
 }

package/server/src/Support/DistanceMatrix.php

@@ -14,7 +14,7 @@ namespace Fleetbase\FleetOps\Support;
  * @license  https://opensource.org/licenses/MIT MIT License
  * @author   Ronald A. Richardson
  */
-class DistanceMatrix
+class DistanceMatrix implements \JsonSerializable
 {
     public ?float $distance;
     public ?float $time;
@@ -24,4 +24,12 @@ class DistanceMatrix
         $this->distance = $distance;
         $this->time     = $time;
     }
+
+    public function jsonSerialize()
+    {
+        return [
+            'distance' => $this->distance,
+            'time'     => $this->time,
+        ];
+    }
 }

package/server/src/Support/OSRM.php

@@ -35,6 +35,13 @@ class OSRM
         }
 
         $coordinates = "{$start->getLng()},{$start->getLat()};{$end->getLng()},{$end->getLat()}";
+
+        return static::getRouteFromCoordinatesString($coordinates, $queryParameters);
+    }
+
+    public static function getRouteFromCoordinatesString(string $coordinates, array $queryParameters = [])
+    {
+        $cacheKey    = 'getRouteFromCoordinatesString:' . md5($coordinates . serialize($queryParameters));
         $url         = self::$baseUrl . "/route/v1/driving/{$coordinates}";
         $response    = Http::get($url, $queryParameters);
         $data        = $response->json();

package/server/src/Support/Utils.php

@@ -3,6 +3,7 @@
 namespace Fleetbase\FleetOps\Support;
 
 use Fleetbase\FleetOps\Flow\Activity;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
 use Fleetbase\Support\Utils as FleetbaseUtils;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Facades\DB;
@@ -95,11 +96,11 @@ class Utils extends FleetbaseUtils
     /**
      * Unpacks a mysql POINT column from binary to array.
      */
-    public static function mysqlPointAsGeometry(string $rawPoint): \Fleetbase\LaravelMysqlSpatial\Types\Point
+    public static function mysqlPointAsGeometry(string $rawPoint): Point
     {
         $coordinates = static::unpackPoint($rawPoint);
 
-        return new \Fleetbase\LaravelMysqlSpatial\Types\Point($coordinates['lon'], $coordinates['lat']);
+        return new Point($coordinates['lon'], $coordinates['lat']);
     }
 
     /**
@@ -162,7 +163,7 @@ class Utils extends FleetbaseUtils
     public static function isCoordinates($coordinates): bool
     {
         try {
-            return static::getPointFromMixed($coordinates) instanceof \Fleetbase\LaravelMysqlSpatial\Types\Point;
+            return static::getPointFromMixed($coordinates) instanceof Point;
         } catch (\Throwable $e) {
             return false;
         }
@@ -175,9 +176,9 @@ class Utils extends FleetbaseUtils
      *
      * @param mixed $coordinates the coordinates input value to extract a coordinate from
      *
-     * @return \Fleetbase\LaravelMysqlSpatial\Types\Point the extracted Point object
+     * @return Point the extracted Point object
      */
-    public static function getPointFromMixed($coordinates): ?\Fleetbase\LaravelMysqlSpatial\Types\Point
+    public static function getPointFromMixed($coordinates): ?Point
     {
         $latitude  = null;
         $longitude = null;
@@ -199,7 +200,7 @@ class Utils extends FleetbaseUtils
             $coordinates = $coordinates->getSpatialValue();
         }
 
-        if ($coordinates instanceof \Fleetbase\LaravelMysqlSpatial\Types\Point) {
+        if ($coordinates instanceof Point) {
             $latitude  = $coordinates->getLat();
             $longitude = $coordinates->getLng();
         } elseif (static::isGeoJson($coordinates)) {
@@ -216,7 +217,7 @@ class Utils extends FleetbaseUtils
 
             if (static::isJson($coordinatesJson)) {
                 try {
-                    $coordinates = \Fleetbase\LaravelMysqlSpatial\Types\Point::fromJson($coordinatesJson);
+                    $coordinates = Point::fromJson($coordinatesJson);
                 } catch (\Throwable $e) {
                     if ($coordinatesInGeoJson) {
                         return static::getPointFromMixed($coordinatesInGeoJson);
@@ -312,7 +313,7 @@ class Utils extends FleetbaseUtils
             $longitude = $coords[1];
         }
 
-        if ($coordinates instanceof \Fleetbase\LaravelMysqlSpatial\Types\Point) {
+        if ($coordinates instanceof Point) {
             return $coordinates;
         }
 
@@ -321,7 +322,7 @@ class Utils extends FleetbaseUtils
             throw new \Exception('Attempted to resolve Point from invalid location.');
         }
 
-        return new \Fleetbase\LaravelMysqlSpatial\Types\Point((float) $latitude, (float) $longitude);
+        return new Point((float) $latitude, (float) $longitude);
     }
 
     /**
@@ -334,7 +335,7 @@ class Utils extends FleetbaseUtils
      */
     public static function isCoordinatesStrict($coordinates)
     {
-        return static::getPointFromCoordinatesStrict($coordinates) instanceof \Fleetbase\LaravelMysqlSpatial\Types\Point;
+        return static::getPointFromCoordinatesStrict($coordinates) instanceof Point;
     }
 
     /**
@@ -343,15 +344,15 @@ class Utils extends FleetbaseUtils
      *
      * @param mixed $coordinates the coordinates, which can be an array, object, or string
      *
-     * @return \Fleetbase\LaravelMysqlSpatial\Types\Point Returns the Point instance
+     * @return Point Returns the Point instance
      */
-    public static function getPointFromCoordinatesStrict($coordinates): ?\Fleetbase\LaravelMysqlSpatial\Types\Point
+    public static function getPointFromCoordinatesStrict($coordinates): ?Point
     {
         if ($coordinates instanceof \Fleetbase\LaravelMysqlSpatial\Eloquent\SpatialExpression) {
             $coordinates = $coordinates->getSpatialValue();
         }
 
-        if ($coordinates instanceof \Fleetbase\LaravelMysqlSpatial\Types\Point) {
+        if ($coordinates instanceof Point) {
             return $coordinates;
         }
 
@@ -363,7 +364,7 @@ class Utils extends FleetbaseUtils
             }
 
             if (static::isJson($coordinatesJson)) {
-                $coordinates = \Fleetbase\LaravelMysqlSpatial\Types\Point::fromJson($coordinatesJson);
+                $coordinates = Point::fromJson($coordinatesJson);
             }
         }
 
@@ -372,7 +373,7 @@ class Utils extends FleetbaseUtils
             $longitude = static::or($coordinates, ['lon', '_lon', 'long', 'lng', '_lng', '_longitude', 'longitude', 'y', '1']);
 
             if (is_numeric($latitude) && is_numeric($longitude)) {
-                $coordinates = new \Fleetbase\LaravelMysqlSpatial\Types\Point((float) $latitude, (float) $longitude);
+                $coordinates = new Point((float) $latitude, (float) $longitude);
             }
         }
 
@@ -412,11 +413,11 @@ class Utils extends FleetbaseUtils
             $longitude = $coords[1];
 
             if (is_numeric($latitude) && is_numeric($longitude)) {
-                $coordinates = new \Fleetbase\LaravelMysqlSpatial\Types\Point((float) $latitude, (float) $longitude);
+                $coordinates = new Point((float) $latitude, (float) $longitude);
             }
         }
 
-        if ($coordinates instanceof \Fleetbase\LaravelMysqlSpatial\Types\Point) {
+        if ($coordinates instanceof Point) {
             return $coordinates;
         }
 
@@ -444,7 +445,7 @@ class Utils extends FleetbaseUtils
             $coordinates = $coordinates->location;
         }
 
-        if ($coordinates instanceof \Fleetbase\LaravelMysqlSpatial\Types\Point) {
+        if ($coordinates instanceof Point) {
             $latitude  = $coordinates->getLat();
             $longitude = $coordinates->getLng();
         } elseif (is_array($coordinates) || is_object($coordinates)) {
@@ -534,22 +535,22 @@ class Utils extends FleetbaseUtils
      *
      * @param mixed $coordinates the input value representing a location or set of coordinates
      *
-     * @return \Fleetbase\LaravelMysqlSpatial\Types\Point the extracted point value
+     * @return Point the extracted point value
      */
-    public static function getPointFromCoordinates($coordinates): \Fleetbase\LaravelMysqlSpatial\Types\Point
+    public static function getPointFromCoordinates($coordinates): Point
     {
-        if ($coordinates instanceof \Fleetbase\LaravelMysqlSpatial\Types\Point) {
+        if ($coordinates instanceof Point) {
             return $coordinates;
         }
 
         if (is_null($coordinates) || !static::isCoordinates($coordinates)) {
-            return new \Fleetbase\LaravelMysqlSpatial\Types\Point(0, 0);
+            return new Point(0, 0);
         }
 
         $latitude  = static::getLatitudeFromCoordinates($coordinates);
         $longitude = static::getLongitudeFromCoordinates($coordinates);
 
-        return new \Fleetbase\LaravelMysqlSpatial\Types\Point($latitude, $longitude);
+        return new Point($latitude, $longitude);
     }
 
     /**
@@ -563,19 +564,19 @@ class Utils extends FleetbaseUtils
     {
         $wkt = 'POINT(0 0)';
 
-        if ($point instanceof \Fleetbase\LaravelMysqlSpatial\Types\Point) {
+        if ($point instanceof Point) {
             $wkt = $point->toWKT();
         }
 
         if (is_array($point)) {
             $json = json_encode($point);
-            $p    = \Fleetbase\LaravelMysqlSpatial\Types\Point::fromJson($json);
+            $p    = Point::fromJson($json);
 
             $wkt = $p->toWkt();
         }
 
         if (is_string($point)) {
-            $p = \Fleetbase\LaravelMysqlSpatial\Types\Point::fromString($point);
+            $p = Point::fromString($point);
 
             $wkt = $p->toWKT();
         }
@@ -605,133 +606,75 @@ class Utils extends FleetbaseUtils
      *
      * @param string $data the binary string representing the point
      *
-     * @return \Fleetbase\LaravelMysqlSpatial\Types\Point the Laravel MySQL Spatial Point instance
+     * @return Point the Laravel MySQL Spatial Point instance
      */
-    public static function rawPointToPoint(string $data): \Fleetbase\LaravelMysqlSpatial\Types\Point
+    public static function rawPointToPoint(string $data): Point
     {
         // Use the `unpack` function to extract the X, Y, and SRID values from the binary string.
         $res = unpack('lSRID/CByteOrder/lTypeInfo/dX/dY', $data);
 
         // Return a new Laravel MySQL Spatial Point instance with the X, Y, and SRID values.
-        return new \Fleetbase\LaravelMysqlSpatial\Types\Point($res['X'], $res['Y'], $res['SRID']);
+        return new Point($res['X'], $res['Y'], $res['SRID']);
     }
 
     /**
-     * Calculates driving distance and time using Google distance matrix.
-     * Returns distance in meters and time in seconds.
+     * Calculates the driving distance and time between two points.
      *
-     * @param \Fleetbase\FleetOps\Models\Place|\Fleetbase\LaravelMysqlSpatial\Types\Point|array $origin
-     * @param \Fleetbase\FleetOps\Models\Place|\Fleetbase\LaravelMysqlSpatial\Types\Point|array $destination
+     * This function attempts to find the driving distance and time from the origin to the destination
+     * using various map APIs. It first attempts to resolve the origin and destination from various input types
+     * into geographical coordinates. Then, based on the provider specified in the options or defaulting to configured provider,
+     * it queries the respective service for the driving distance and time. The result is returned as a DistanceMatrix
+     * object with the distance in meters and the time in seconds.
+     *
+     * @param mixed $origin      The origin of the journey. Can be a Place model, a string, or an array with latitude and longitude.
+     * @param mixed $destination The destination of the journey. Similar to the origin, it accepts multiple input types.
+     *
+     * @return DistanceMatrix an object containing the distance and time of the journey
+     *
+     * @throws \Throwable throws any exception encountered during the resolution of points or API calls
      */
-    public static function getDrivingDistanceAndTime($origin, $destination): DistanceMatrix
+    public static function getDrivingDistanceAndTime($origin, $destination, $options = []): DistanceMatrix
     {
-        if ($origin instanceof \Fleetbase\FleetOps\Models\Place) {
-            $origin = static::createObject(
-                [
-                    'latitude'  => $origin->location->getLat(),
-                    'longitude' => $origin->location->getLng(),
-                ]
-            );
-        } else {
-            try {
-                $point  = static::getPointFromMixed($origin);
-                $origin = static::createObject(
-                    [
-                        'latitude'  => $point->getLat(),
-                        'longitude' => $point->getLng(),
-                    ]
-                );
-            } catch (\Throwable $e) {
-                if (app()->bound('sentry')) {
-                    app('sentry')->captureException($e);
-                }
-                // create dummy $origin
-                $origin = static::createObject(
-                    [
-                        'latitude'  => 0,
-                        'longitude' => 0,
-                    ]
-                );
-            }
-        }
-
-        if ($destination instanceof \Fleetbase\FleetOps\Models\Place) {
-            $destination = static::createObject(
-                [
-                    'latitude'  => $destination->location->getLat(),
-                    'longitude' => $destination->location->getLng(),
-                ]
-            );
-        } else {
-            try {
-                $point       = static::getPointFromMixed($destination);
-                $destination = static::createObject(
-                    [
-                        'latitude'  => $point->getLat(),
-                        'longitude' => $point->getLng(),
-                    ]
-                );
-            } catch (\Throwable $e) {
-                if (app()->bound('sentry')) {
-                    app('sentry')->captureException($e);
-                }
-                // create dummy $destination
-                $destination = static::createObject(
-                    [
-                        'latitude'  => 0,
-                        'longitude' => 0,
-                    ]
-                );
-            }
-        }
-
-        $cacheKey = $origin->latitude . ':' . $origin->longitude . ':' . $destination->latitude . ':' . $destination->longitude;
-
-        // check cache for results
-        $cachedResult = Redis::get($cacheKey);
-
-        if ($cachedResult) {
-            $json = json_decode($cachedResult);
-
-            if (!empty($json->distance) && !empty($json->time)) {
-                return new DistanceMatrix($json->distance, $json->time);
-            }
+        $origin       = static::getPointFromMixed($origin);
+        $destination  = static::getPointFromMixed($destination);
+        $origins      = $origin->getLat() . ',' . $origin->getLng();
+        $destinations = $destination->getLat() . ',' . $destination->getLng();
+
+        // Create empty distance matric
+        $distanceMatrix = new DistanceMatrix(0, 0);
+        $provider       = data_get($options, 'provider', config('fleetops.distance_matrix.provider'));
+        switch ($provider) {
+            case 'calculate':
+                $distanceMatrix = static::calculateDrivingDistanceAndTime($origins, $destinations);
+                break;
+
+            case 'osrm':
+                $distanceMatrix = static::getDistanceMatrixFromOSRM($origins, $destinations);
+                break;
+
+            case 'google':
+            default:
+                $distanceMatrix = static::getDistanceMatrixFromGoogle($origins, $destinations);
+                break;
         }
 
-        $response = Http::get(
-            'https://maps.googleapis.com/maps/api/distancematrix/json',
-            [
-                'origins'      => $origin->latitude . ',' . $origin->longitude,
-                'destinations' => $destination->latitude . ',' . $destination->longitude,
-                'mode'         => 'driving',
-                'key'          => env('GOOGLE_MAPS_API_KEY'),
-            ]
-        )->json();
-
-        $distance = data_get($response, 'rows.0.elements.0.distance.value');
-        $time     = data_get($response, 'rows.0.elements.0.duration.value');
-
-        $result = static::createObject(
-            [
-                'distance' => $distance,
-                'time'     => $time,
-            ]
-        );
-
-        // cache result
-        Redis::set($cacheKey, json_encode($result));
-
-        return new DistanceMatrix($distance, $time);
+        return $distanceMatrix;
     }
 
     /**
-     * Calculates driving distance and time using Google distance matrix for multiple origins or destinations.
-     * Returns distance in meters and time in seconds.
+     * Computes a distance matrix for multiple origins and destinations.
      *
-     * @param Place|Point|array $origins
-     * @param Place|Point|array $destinations
+     * This function is designed to handle arrays of origins and destinations to calculate a distance matrix.
+     * It converts the input arrays into a string format suitable for the map API request. The provider specified
+     * in the options (default is Google) determines which map service API is used for the calculations.
+     *
+     * @param array|\Illuminate\Support\Collection $origins      array or collection of origin points
+     * @param array|\Illuminate\Support\Collection $destinations array or collection of destination points
+     * @param array                                $options      options for API calls, like the provider and mode of transport
+     *
+     * @return DistanceMatrix an object representing the distance and time between the furthest origins and destinations
      */
-    public static function distanceMatrix($origins = [], $destinations = []): DistanceMatrix
+    public static function distanceMatrix($origins = [], $destinations = [], $options = []): DistanceMatrix
     {
         if ($origins instanceof \Illuminate\Support\Collection) {
             $origins = $origins->all();
@@ -741,57 +684,83 @@ class Utils extends FleetbaseUtils
             $destinations = $destinations->all();
         }
 
-        $origins = array_map(
-            function ($origin) {
-                $point  = static::getPointFromMixed($origin);
-                $origin = static::createObject(
-                    [
-                        'latitude'  => $point->getLat(),
-                        'longitude' => $point->getLng(),
-                    ]
-                );
-
-                return $origin;
-            },
-            $origins
-        );
+        // Convert origins and destinatinos to string
+        $origins      = static::createCoordinateStringFromPlacesArray($origins);
+        $destinations = static::createCoordinateStringFromPlacesArray($destinations);
+
+        // Create empty distance matric
+        $distanceMatrix = new DistanceMatrix(0, 0);
+        $provider       = data_get($options, 'provider', config('fleetops.distance_matrix.provider'));
+        switch ($provider) {
+            case 'calculate':
+                $distanceMatrix = static::calculateDrivingDistanceAndTime($origins, $destinations);
+                break;
+
+            case 'osrm':
+                $distanceMatrix = static::getDistanceMatrixFromOSRM($origins, $destinations);
+                break;
+
+            case 'google':
+            default:
+                $distanceMatrix = static::getDistanceMatrixFromGoogle($origins, $destinations);
+                break;
+        }
 
-        $destinations = array_map(
-            function ($destination) {
-                $point       = static::getPointFromMixed($destination);
-                $destination = static::createObject(
-                    [
-                        'latitude'  => $point->getLat(),
-                        'longitude' => $point->getLng(),
-                    ]
-                );
-
-                return $destination;
-            },
-            $destinations
-        );
+        return $distanceMatrix;
+    }
 
-        // get url ready string for origins
-        $originsString = implode('|', array_map(
-            function ($origin) {
-                return $origin->latitude . ',' . $origin->longitude;
+    /**
+     * Converts an array of places into a coordinate string.
+     *
+     * Accepts an array of places (or any type that can be converted into geographical points)
+     * and converts each into a 'latitude,longitude' format. These coordinates are then concatenated into a single string,
+     * separated by the specified separator. The function gracefully handles any errors in the conversion process.
+     *
+     * @param array  $places    array of places to be converted into coordinates
+     * @param string $separator separator used to concatenate the coordinates into a single string
+     *
+     * @return string a concatenated string of coordinates
+     */
+    public static function createCoordinateStringFromPlacesArray(array $places = [], $separator = '|'): string
+    {
+        $coordinates = array_map(
+            function ($place) {
+                try {
+                    $point       = static::getPointFromMixed($place);
+                } catch (\Throwable $e) {
+                    $point = new Point(0, 0);
+                }
+
+                return $point;
             },
-            $origins
-        ));
+            $places
+        );
 
-        // get url ready string for origins
-        $destinationString = implode('|', array_map(
-            function ($destination) {
-                return $destination->latitude . ',' . $destination->longitude;
+        return implode($separator, array_map(
+            function ($point) {
+                return $point->getLat() . ',' . $point->getLng();
             },
-            $destinations
+            $coordinates
         ));
+    }
 
-        $cacheKey = md5($originsString . '_' . $destinationString);
-
-        // check cache for results
+    /**
+     * Retrieves a distance matrix using the Google Distance Matrix API.
+     *
+     * This function calculates the distance and time between origins and destinations using the Google API.
+     * It first checks if there is a cached result in Redis and, if not, performs an API call to Google.
+     * The results are then cached in Redis and returned as a DistanceMatrix object.
+     *
+     * @param string $origins      a string of origins in 'latitude,longitude' format, separated by a specified delimiter
+     * @param string $destinations a string of destinations in a similar format to origins
+     * @param array  $options      additional options for the API call, like the mode of transport
+     *
+     * @return DistanceMatrix the distance and time between the given origins and destinations
+     */
+    public static function getDistanceMatrixFromGoogle(string $origins, string $destinations, $options = []): DistanceMatrix
+    {
+        $cacheKey     = md5($origins . '_' . $destinations);
         $cachedResult = Redis::get($cacheKey);
-
         if ($cachedResult) {
             $json = json_decode($cachedResult);
 
@@ -803,9 +772,9 @@ class Utils extends FleetbaseUtils
         $response = Http::withOptions(['verify' => false])->get(
             'https://maps.googleapis.com/maps/api/distancematrix/json',
             [
-                'origins'      => $originsString,
-                'destinations' => $destinationString,
-                'mode'         => 'driving',
+                'origins'      => $origins,
+                'destinations' => $destinations,
+                'mode'         => data_get($options, 'mode', 'driving'),
                 'key'          => env('GOOGLE_MAPS_API_KEY'),
             ]
         )->json();
@@ -813,17 +782,69 @@ class Utils extends FleetbaseUtils
         $distance = (float) data_get($response, 'rows.0.elements.0.distance.value', 0);
         $time     = (float) data_get($response, 'rows.0.elements.0.duration.value', 0);
 
-        $result = static::createObject(
-            [
-                'distance' => $distance,
-                'time'     => $time,
-            ]
-        );
+        // Create distance matrix
+        $distanceMatrix = new DistanceMatrix($distance, $time);
 
-        // cache result
-        Redis::set($cacheKey, json_encode($result));
+        // Cache distance matrix
+        Redis::set($cacheKey, json_encode($distanceMatrix));
 
-        return new DistanceMatrix($distance, $time);
+        return $distanceMatrix;
+    }
+
+    /**
+     * Calculates distance and time between points using the OSRM API.
+     *
+     * Similar to the Google Distance Matrix function, this uses the OSRM (Open Source Routing Machine) API.
+     * It first checks for cached results before making a new API request. The origins and destinations are
+     * reformatted to the OSRM API requirement and the response is parsed into a DistanceMatrix object.
+     *
+     * @param string $origins      comma-separated string of origin coordinates
+     * @param string $destinations comma-separated string of destination coordinates
+     *
+     * @return DistanceMatrix an object containing the distance and time for the specified journey
+     */
+    public static function getDistanceMatrixFromOSRM(string $origins, string $destinations): DistanceMatrix
+    {
+        $cacheKey     = md5($origins . '_' . $destinations);
+        $cachedResult = Redis::get($cacheKey);
+        if ($cachedResult) {
+            $json = json_decode($cachedResult);
+
+            if (!empty($json->distance) && !empty($json->time)) {
+                return new DistanceMatrix($json->distance, $json->time);
+            }
+        }
+
+        // OSRM uses semi-colon to delimit coordinates so replace any `|` as we typically use with `;`
+        $origins           = Str::replace('|', ';', $origins);
+        $destinations      = Str::replace('|', ';', $destinations);
+        $coordinatesString = $origins . ';' . $destinations;
+        // Split the string into individual coordinates
+        $coordinatesArray = explode(';', $coordinatesString);
+
+        // Reverse the latitude and longitude in each coordinate
+        $reversedCoordinates = array_map(function ($coordinate) {
+            $parts = explode(',', $coordinate);
+            if (count($parts) == 2) {
+                return $parts[1] . ',' . $parts[0]; // Swap latitude and longitude
+            }
+
+            return $coordinate; // Return original if it's not a valid coordinate
+        }, $coordinatesArray);
+
+        // Join the reversed coordinates back into a string
+        $reversedCoordinatesString = implode(';', $reversedCoordinates);
+        $response                  = OSRM::getRouteFromCoordinatesString($reversedCoordinatesString);
+        $distance                  = (float) data_get($response, 'routes.0.distance', 0);
+        $time                      = (float) data_get($response, 'routes.0.duration', 0);
+
+        // Create distance matrix
+        $distanceMatrix = new DistanceMatrix($distance, $time);
+
+        // Cache distance matrix
+        Redis::set($cacheKey, json_encode($distanceMatrix));
+
+        return $distanceMatrix;
     }
 
     /**
@@ -883,13 +904,13 @@ class Utils extends FleetbaseUtils
      * https://en.wikipedia.org/wiki/Great-circle_distance#Formulas
      * https://en.wikipedia.org/wiki/Antipodal_point
      *
-     * @param \Fleetbase\LaravelMysqlSpatial\Types\Point Starting point
-     * @param \Fleetbase\LaravelMysqlSpatial\Types\Point Ending point
+     * @param Point Starting point
+     * @param Point Ending point
      * @param float $earthRadius Mean earth radius in [m]
      *
      * @return float Distance between points in [m] (same as earthRadius)
      */
-    public static function vincentyGreatCircleDistance(\Fleetbase\LaravelMysqlSpatial\Types\Point $from, \Fleetbase\LaravelMysqlSpatial\Types\Point $to, float $earthRadius = 6371000): float
+    public static function vincentyGreatCircleDistance(Point $from, Point $to, float $earthRadius = 6371000): float
     {
         // convert from degrees to radians
         $latFrom = deg2rad($from->getLat());
@@ -910,7 +931,7 @@ class Utils extends FleetbaseUtils
     /**
      * Finds the nearest timezone for a given coordinate point.
      */
-    public static function getNearestTimezone(\Fleetbase\LaravelMysqlSpatial\Types\Point $location, string $countryCode = ''): string
+    public static function getNearestTimezone(Point $location, string $countryCode = ''): string
     {
         $timezoneIds = \DateTimeZone::listIdentifiers(\DateTimeZone::PER_COUNTRY, $countryCode);
         $lat         = $location->getLat();
@@ -1010,7 +1031,7 @@ class Utils extends FleetbaseUtils
 
     public static function isPoint($point): bool
     {
-        return $point instanceof \Fleetbase\LaravelMysqlSpatial\Types\Point;
+        return $point instanceof Point;
     }
 
     /**
@@ -1275,7 +1296,7 @@ class Utils extends FleetbaseUtils
      *
      * @return float the heading in degrees from the starting point to the ending point
      */
-    public static function calculateHeading(\Fleetbase\LaravelMysqlSpatial\Types\Point $point1, \Fleetbase\LaravelMysqlSpatial\Types\Point $point2): float
+    public static function calculateHeading(Point $point1, Point $point2): float
     {
         // Extract latitude and longitude from Point objects
         $lat1 = $point1->getLat();

package/server/src/routes.php

@@ -12,9 +12,6 @@ use Illuminate\Support\Facades\Route;
 | is assigned the "api" middleware group. Enjoy building your API!
 |
 */
-
-Route::get('fleet-ops-test', 'Fleetbase\FleetOps\Http\Controllers\Controller@test');
-
 Route::prefix(config('fleetops.api.routing.prefix', null))->namespace('Fleetbase\FleetOps\Http\Controllers')->group(
     function ($router) {
         /*