@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/src/Support/Geocoding.php

@@ -36,9 +36,7 @@ class Geocoding
      */
     public static function geocode(string $searchQuery, $latitude = null, $longitude = null): Collection
     {
-        $httpClient = new Client();
-        $provider   = new GoogleMaps($httpClient, null, config('services.google_maps.api_key', env('GOOGLE_MAPS_API_KEY')));
-        $geocoder   = new StatefulGeocoder($provider, 'en');
+        $geocoder = static::makeGeocoder();
 
         try {
             if ($latitude && $longitude) {
@@ -57,7 +55,7 @@ class Geocoding
 
             return collect($geoResults->all())->map(
                 function ($googleAddress) {
-                    return Place::createFromGoogleAddress($googleAddress);
+                    return static::makePlaceFromGoogleAddress($googleAddress);
                 }
             )->values();
         } catch (\Exception $e) {
@@ -81,10 +79,6 @@ class Geocoding
      */
     public static function reverseFromQuery(string $searchQuery, $latitude, $longitude): Collection
     {
-        $httpClient = new Client();
-        $provider   = new GoogleMaps($httpClient, null, config('services.google_maps.api_key', env('GOOGLE_MAPS_API_KEY')));
-        $geocoder   = new StatefulGeocoder($provider, 'en');
-
         if (empty($searchQuery)) {
             return collect();
         }
@@ -93,6 +87,8 @@ class Geocoding
             return collect();
         }
 
+        $geocoder = static::makeGeocoder();
+
         try {
             $geoResults = $geocoder->reverseQuery(
                 ReverseQuery::fromCoordinates($latitude, $longitude)
@@ -103,7 +99,7 @@ class Geocoding
 
             return collect($geoResults->all())->map(
                 function ($googleAddress) {
-                    return Place::createFromGoogleAddress($googleAddress);
+                    return static::makePlaceFromGoogleAddress($googleAddress);
                 }
             )->values();
         } catch (\Exception $e) {
@@ -127,14 +123,12 @@ class Geocoding
      */
     public static function reverseFromCoordinates($latitude, $longitude, ?string $searchQuery = null): Collection
     {
-        $httpClient = new Client();
-        $provider   = new GoogleMaps($httpClient, null, config('services.google_maps.api_key', env('GOOGLE_MAPS_API_KEY')));
-        $geocoder   = new StatefulGeocoder($provider, 'en');
-
         if (empty($latitude) && empty($longitude)) {
             return collect();
         }
 
+        $geocoder = static::makeGeocoder();
+
         try {
             if ($searchQuery) {
                 $geoResults = $geocoder->reverseQuery(
@@ -153,7 +147,7 @@ class Geocoding
 
             return collect($geoResults->all())->map(
                 function ($googleAddress) {
-                    return Place::createFromGoogleAddress($googleAddress);
+                    return static::makePlaceFromGoogleAddress($googleAddress);
                 }
             )->values();
         } catch (\Exception $e) {
@@ -216,4 +210,48 @@ class Geocoding
     {
         return Utils::notEmpty(config('services.google_maps.api_key'));
     }
+
+    /**
+     * The language geocoding results are returned in — Google's `language`
+     * parameter, e.g. `en`, `ru`, `es`.
+     */
+    public static function getLocale(): string
+    {
+        // `?:` rather than a config() default: the settings table stores this
+        // key, so it exists-but-empty on installs that never filled it in, and
+        // config()'s default only applies when the key is absent entirely.
+        return config('services.google_maps.locale') ?: env('GOOGLE_MAPS_LOCALE', 'en');
+    }
+
+    /**
+     * The region requests are biased towards — Google's `region` parameter.
+     * This is a ccTLD (`us`, `ru`, `sg`), not a language code, and is a
+     * separate concern from the locale above.
+     */
+    public static function getRegion(): ?string
+    {
+        return config('services.google_maps.region') ?: env('GOOGLE_MAPS_REGION', 'us');
+    }
+
+    protected static function makeGeocoder(): object
+    {
+        // Allow an alternative geocoder (or test double) to be injected
+        // through the container without constructing a live HTTP client.
+        if (app()->bound('fleetops.geocoder')) {
+            return app('fleetops.geocoder');
+        }
+
+        // Region biases which results rank highest; locale controls the
+        // language they come back in. Applying both here covers every caller
+        // rather than each construction site repeating them.
+        $httpClient = new Client();
+        $provider   = new GoogleMaps($httpClient, static::getRegion(), config('services.google_maps.api_key', env('GOOGLE_MAPS_API_KEY')));
+
+        return new StatefulGeocoder($provider, static::getLocale());
+    }
+
+    protected static function makePlaceFromGoogleAddress($googleAddress): Place
+    {
+        return Place::createFromGoogleAddress($googleAddress);
+    }
 }

package/server/src/Support/GeofenceIntersectionService.php

@@ -70,16 +70,7 @@ class GeofenceIntersectionService
         //    - ST_Contains performs the precise polygon containment check
         //      on the reduced candidate set (accurate, no index needed).
         // ----------------------------------------------------------------
-        $insideZones = Zone::where('company_uuid', $companyUuid)
-            ->whereNotNull('border')
-            ->where(function ($q) {
-                $q->where('trigger_on_entry', true)
-                    ->orWhere('trigger_on_exit', true)
-                    ->orWhereNotNull('dwell_threshold_minutes');
-            })
-            ->whereRaw('MBRContains(`border`, ST_GeomFromText(?))', [$wkt])
-            ->whereRaw('ST_Contains(`border`, ST_GeomFromText(?))', [$wkt])
-            ->get();
+        $insideZones = $this->insideZones($companyUuid, $wkt);
 
         // ----------------------------------------------------------------
         // 2. Find all Service Areas the driver is currently inside.
@@ -87,16 +78,7 @@ class GeofenceIntersectionService
         //    Service areas use MultiPolygon borders, so we use
         //    ST_Contains which handles both Polygon and MultiPolygon.
         // ----------------------------------------------------------------
-        $insideServiceAreas = ServiceArea::where('company_uuid', $companyUuid)
-            ->whereNotNull('border')
-            ->where(function ($q) {
-                $q->where('trigger_on_entry', true)
-                    ->orWhere('trigger_on_exit', true)
-                    ->orWhereNotNull('dwell_threshold_minutes');
-            })
-            ->whereRaw('MBRContains(`border`, ST_GeomFromText(?))', [$wkt])
-            ->whereRaw('ST_Contains(`border`, ST_GeomFromText(?))', [$wkt])
-            ->get();
+        $insideServiceAreas = $this->insideServiceAreas($companyUuid, $wkt);
 
         // Merge into a unified collection with a type discriminator
         $currentlyInside = collect()
@@ -108,10 +90,7 @@ class GeofenceIntersectionService
         // ----------------------------------------------------------------
         // 3. Load the driver's current geofence state records.
         // ----------------------------------------------------------------
-        $currentStates = DB::table($stateTable)
-            ->where($subjectColumn, $subjectUuid)
-            ->get()
-            ->keyBy('geofence_uuid');
+        $currentStates = $this->currentSubjectStates($stateTable, $subjectColumn, $subjectUuid);
 
         // ----------------------------------------------------------------
         // 4. Detect ENTRIES: geofences the driver is now inside but
@@ -136,9 +115,7 @@ class GeofenceIntersectionService
         // ----------------------------------------------------------------
         foreach ($currentStates as $geofenceUuid => $state) {
             if ($state->is_inside && !in_array($geofenceUuid, $currentlyInsideUuids)) {
-                $geofence = $state->geofence_type === 'service_area'
-                    ? ServiceArea::where('uuid', $geofenceUuid)->first()
-                    : Zone::where('uuid', $geofenceUuid)->first();
+                $geofence = $this->findGeofence($state->geofence_type, $geofenceUuid);
 
                 if ($geofence) {
                     $crossings[] = [
@@ -153,6 +130,49 @@ class GeofenceIntersectionService
         return $crossings;
     }
 
+    protected function insideZones(string $companyUuid, string $wkt)
+    {
+        return Zone::where('company_uuid', $companyUuid)
+            ->whereNotNull('border')
+            ->where(function ($q) {
+                $q->where('trigger_on_entry', true)
+                    ->orWhere('trigger_on_exit', true)
+                    ->orWhereNotNull('dwell_threshold_minutes');
+            })
+            ->whereRaw('MBRContains(`border`, ST_GeomFromText(?))', [$wkt])
+            ->whereRaw('ST_Contains(`border`, ST_GeomFromText(?))', [$wkt])
+            ->get();
+    }
+
+    protected function insideServiceAreas(string $companyUuid, string $wkt)
+    {
+        return ServiceArea::where('company_uuid', $companyUuid)
+            ->whereNotNull('border')
+            ->where(function ($q) {
+                $q->where('trigger_on_entry', true)
+                    ->orWhere('trigger_on_exit', true)
+                    ->orWhereNotNull('dwell_threshold_minutes');
+            })
+            ->whereRaw('MBRContains(`border`, ST_GeomFromText(?))', [$wkt])
+            ->whereRaw('ST_Contains(`border`, ST_GeomFromText(?))', [$wkt])
+            ->get();
+    }
+
+    protected function currentSubjectStates(string $stateTable, string $subjectColumn, string $subjectUuid)
+    {
+        return DB::table($stateTable)
+            ->where($subjectColumn, $subjectUuid)
+            ->get()
+            ->keyBy('geofence_uuid');
+    }
+
+    protected function findGeofence(string $geofenceType, string $geofenceUuid)
+    {
+        return $geofenceType === 'service_area'
+            ? ServiceArea::where('uuid', $geofenceUuid)->first()
+            : Zone::where('uuid', $geofenceUuid)->first();
+    }
+
     /**
      * Check if a driver is currently recorded as inside a specific geofence.
      *

package/server/src/Support/LiveOrderQuery.php

@@ -19,7 +19,7 @@ class LiveOrderQuery
         $withRelations     = $options['with_relations'] ?? false;
         $applyPermissions  = $options['apply_permissions'] ?? true;
 
-        $query = Order::where('company_uuid', $companyUuid)
+        $query = static::newOrderQuery($companyUuid)
             ->whereHas('payload', function ($query) {
                 $query->where(function ($q) {
                     $q->whereHas('waypoints');
@@ -72,4 +72,9 @@ class LiveOrderQuery
 
         return $query;
     }
+
+    protected static function newOrderQuery(string $companyUuid): Builder
+    {
+        return Order::where('company_uuid', $companyUuid);
+    }
 }

package/server/src/Support/Metrics/ActiveRevenueQuery.php

@@ -10,7 +10,8 @@ use Illuminate\Support\Facades\Schema;
 
 class ActiveRevenueQuery
 {
-    public const ACTIVE_STATUSES               = [Transaction::STATUS_SUCCESS];
+    public const ACTIVE_STATUSES               = ['success'];
+    public const CREDIT_DIRECTION              = 'credit';
     public const INACTIVE_TRANSACTION_STATUSES = ['pending', 'failed', 'cancelled', 'canceled', 'void', 'voided', 'expired', 'reversed', 'refunded', 'ignored'];
     public const INACTIVE_ORDER_STATUSES       = ['canceled', 'cancelled', 'order_canceled'];
     public const INACTIVE_INVOICE_STATUSES     = ['void', 'voided', 'cancelled', 'canceled'];
@@ -20,7 +21,7 @@ class ActiveRevenueQuery
         $query = Transaction::query()
             ->where('company_uuid', $company->uuid)
             ->where('currency', $currency)
-            ->where('direction', Transaction::DIRECTION_CREDIT)
+            ->where('direction', self::CREDIT_DIRECTION)
             ->whereIn('status', self::ACTIVE_STATUSES)
             ->whereNotIn('status', self::INACTIVE_TRANSACTION_STATUSES)
             ->whereNull('deleted_at')

package/server/src/Support/Metrics/FuelCostsMetric.php

@@ -13,7 +13,7 @@ class FuelCostsMetric extends MoneyMetric
 
     protected function query(?\DateTimeInterface $start, ?\DateTimeInterface $end)
     {
-        $query = FuelReport::where('company_uuid', $this->company->uuid)
+        $query = $this->fuelReportQuery($this->company->uuid)
             ->where('currency', $this->currency());
 
         if ($start && $end) {
@@ -27,4 +27,9 @@ class FuelCostsMetric extends MoneyMetric
     {
         return (float) $query->sum('amount');
     }
+
+    protected function fuelReportQuery(string $companyUuid)
+    {
+        return FuelReport::where('company_uuid', $companyUuid);
+    }
 }

package/server/src/Support/ResolvesOrderServiceStops.php

@@ -381,9 +381,14 @@ trait ResolvesOrderServiceStops
             'location'     => Utils::parsePointToWkt($this->serviceStopLocationPoint($place)),
         ], $place);
 
+        // Unreachable: insertGetUuid() only returns false when the underlying
+        // insert returns false, which Laravel's forced PDO::ERRMODE_EXCEPTION
+        // never does — the insert either succeeds or throws.
+        // @codeCoverageIgnoreStart
         if (!$trackingNumberUuid) {
             return null;
         }
+        // @codeCoverageIgnoreEnd
 
         DB::table($payload->getTable())->where('uuid', $payload->uuid)->update([$column => $trackingNumberUuid]);
         $payload->{$column} = $trackingNumberUuid;
@@ -415,9 +420,14 @@ trait ResolvesOrderServiceStops
             $trackingNumber->status_uuid = $activityId;
         }
 
+        // Unreachable: endpointServiceStopTrackingNumber() always hands back a
+        // freshly queried TrackingNumber, and TrackingNumber declares no $with,
+        // so the status relation is never already loaded here.
+        // @codeCoverageIgnoreStart
         if ($trackingNumber->relationLoaded('status')) {
             $trackingNumber->unsetRelation('status');
         }
+        // @codeCoverageIgnoreEnd
 
         return $activityId ?: null;
     }

package/server/src/Support/Telematics/Providers/GeotabProvider.php

@@ -34,14 +34,14 @@ class GeotabProvider extends AbstractProvider
      */
     protected function authenticate(): void
     {
-        $response = Http::post($this->baseUrl, [
+        $response = $this->postGeotab([
             'method' => 'Authenticate',
             'params' => [
                 'database' => $this->credentials['database'],
                 'userName' => $this->credentials['username'],
                 'password' => $this->credentials['password'],
             ],
-        ])->json();
+        ]);
 
         if (isset($response['result']['credentials']['sessionId'])) {
             $this->sessionId = $response['result']['credentials']['sessionId'];
@@ -223,10 +223,15 @@ class GeotabProvider extends AbstractProvider
             'sessionId' => $this->sessionId,
         ];
 
-        return Http::post($this->baseUrl, [
+        return $this->postGeotab([
             'method' => $method,
             'params' => $params,
-        ])->json() ?? [];
+        ]) ?? [];
+    }
+
+    protected function postGeotab(array $payload): ?array
+    {
+        return Http::post($this->baseUrl, $payload)->json();
     }
 
     protected function fetchLatestLogRecords(array $devices, array $options = []): array

package/server/src/Support/Utils.php

@@ -271,12 +271,20 @@ class Utils extends FleetbaseUtils
                 try {
                     $coordinates = Point::fromJson($coordinatesJson);
                 } catch (\Throwable $e) {
+                    // Both fallbacks carry a GeoJSON coordinate value, so they are
+                    // read as GeoJSON first: pointFromGeoJson() maps [lng, lat],
+                    // whereas recursing hands the pair to the positional array
+                    // reader below, which takes index 0 as the latitude. Nested
+                    // values (a Polygon or LineString ring rather than a single
+                    // pair) yield null there and still fall through to it.
                     if ($coordinatesInGeoJson) {
-                        return static::getPointFromMixed($coordinatesInGeoJson);
+                        return static::pointFromGeoJsonCoordinates($coordinatesInGeoJson)
+                            ?? static::getPointFromMixed($coordinatesInGeoJson);
                     }
 
                     if ($coordinatesInGeoJsonFeature) {
-                        return static::getPointFromMixed($coordinatesInGeoJsonFeature);
+                        return static::pointFromGeoJsonCoordinates($coordinatesInGeoJsonFeature)
+                            ?? static::getPointFromMixed($coordinatesInGeoJsonFeature);
                     }
                 }
             }
@@ -492,7 +500,7 @@ class Utils extends FleetbaseUtils
                 $coordinates = null;
             }
 
-            if (preg_match('/LatLng\(([^,]+),\s*([^)]+)\)/', $coordinates, $matches)) {
+            if (is_string($coordinates) && preg_match('/LatLng\(([^,]+),\s*([^)]+)\)/', $coordinates, $matches)) {
                 $coords = [
                     floatval($matches[1]),
                     floatval($matches[2]),
@@ -501,20 +509,20 @@ class Utils extends FleetbaseUtils
                 $coordinates = null;
             }
 
-            if (Str::contains($coordinates, ',')) {
+            if (is_string($coordinates) && Str::contains($coordinates, ',')) {
                 $coords = explode(',', $coordinates);
             }
 
-            if (Str::contains($coordinates, '|')) {
+            if (is_string($coordinates) && Str::contains($coordinates, '|')) {
                 $coords = explode('|', $coordinates);
             }
 
-            if (Str::contains($coordinates, ' ')) {
+            if (is_string($coordinates) && Str::contains($coordinates, ' ')) {
                 $coords = explode(' ', $coordinates);
             }
 
-            $latitude  = $coords[0];
-            $longitude = $coords[1];
+            $latitude  = $coords[0] ?? null;
+            $longitude = $coords[1] ?? null;
 
             if (is_numeric($latitude) && is_numeric($longitude)) {
                 $coordinates = new Point((float) $latitude, (float) $longitude);
@@ -701,6 +709,19 @@ class Utils extends FleetbaseUtils
         return new Point((float) $latitude, (float) $longitude);
     }
 
+    /**
+     * Resolve a bare GeoJSON `coordinates` value — an `[longitude, latitude]`
+     * pair — into a Point, without the surrounding envelope.
+     *
+     * Returns null for anything that is not a usable pair, including the nested
+     * rings a Polygon or LineString carries, so callers can fall through to
+     * their own handling.
+     */
+    protected static function pointFromGeoJsonCoordinates($coordinates): ?Point
+    {
+        return static::pointFromGeoJson(['type' => 'Point', 'coordinates' => $coordinates]);
+    }
+
     /**
      * Converts a point to a WKT (Well-Known Text) representation for SQL insert.
      *
@@ -1162,9 +1183,13 @@ class Utils extends FleetbaseUtils
 
         $feature = collect($globe->features)->first(
             function ($feature) use ($country) {
+                // Every feature in the bundled resources/data/globe.json carries
+                // both codes, so this only guards against future data changes.
+                // @codeCoverageIgnoreStart
                 if (!isset($feature->properties->ISO_A3) || !isset($feature->properties->ISO_A2)) {
                     return false;
                 }
+                // @codeCoverageIgnoreEnd
 
                 return strtolower($feature->properties->ISO_A3) === $country || strtolower($feature->properties->ISO_A2) === $country;
             }
@@ -1199,8 +1224,10 @@ class Utils extends FleetbaseUtils
         $radius = ($meters * 1000) / 6378137;
         // create circle coordinates
         $coords = collect();
-        // loop through the array and write path linestrings
-        for ($i = 0; $i <= 360; $i += 3) {
+        // loop through the array and write path linestrings — stop short of 360
+        // so the ring is closed explicitly below rather than by re-computing the
+        // 0 degree vertex, which produced a duplicated point
+        for ($i = 0; $i < 360; $i += 3) {
             $radial   = deg2rad($i);
             $lat_rad  = asin(sin($latitude) * cos($radius) + cos($latitude) * sin($radius) * cos($radial));
             $dlon_rad = atan2(sin($radial) * sin($radius) * cos($latitude), cos($radius) - sin($latitude) * sin($lat_rad));
@@ -1261,9 +1288,80 @@ class Utils extends FleetbaseUtils
      */
     public static function getCentroidFromGeosPolygon(\Brick\Geo\Polygon $polygon): \Brick\Geo\Point
     {
-        $geometryEngine = new \Brick\Geo\Engine\GEOSEngine();
+        return static::resolveGeometryEngine()->centroid($polygon);
+    }
+
+    /**
+     * Resolve the configured geometry engine, preferring the registry so
+     * alternative engines (or test doubles) can be injected without the
+     * GEOS extension.
+     */
+    /**
+     * Determine whether the active database connection speaks SQLite.
+     */
+    protected static function isSqliteConnection(): bool
+    {
+        try {
+            $connection = DB::connection();
+        } catch (\Throwable $e) {
+            return false;
+        }
+
+        return $connection instanceof \Illuminate\Database\SQLiteConnection
+            || ($connection && $connection->getDriverName() === 'sqlite');
+    }
+
+    /**
+     * Build a driver-aware SQL expression for whole-second differences
+     * between two datetime expressions.
+     */
+    public static function sqlSecondsDiff(string $start, string $end): string
+    {
+        if (static::isSqliteConnection()) {
+            return "CAST(ROUND((julianday($end) - julianday($start)) * 86400) AS INTEGER)";
+        }
 
-        return $geometryEngine->centroid($polygon);
+        return "TIMESTAMPDIFF(SECOND, $start, $end)";
+    }
+
+    /**
+     * Build a driver-aware SQL expression for whole-minute differences
+     * between two datetime expressions.
+     */
+    public static function sqlMinutesDiff(string $start, string $end): string
+    {
+        if (static::isSqliteConnection()) {
+            return "CAST(ROUND((julianday($end) - julianday($start)) * 1440) AS INTEGER)";
+        }
+
+        return "TIMESTAMPDIFF(MINUTE, $start, $end)";
+    }
+
+    /**
+     * Driver-aware SQL expression for the current timestamp.
+     */
+    public static function sqlNow(): string
+    {
+        return static::isSqliteConnection() ? "datetime('now')" : 'NOW()';
+    }
+
+    /**
+     * Driver-aware SQL scalar minimum of two expressions.
+     */
+    public static function sqlLeast(string $first, string $second): string
+    {
+        $function = static::isSqliteConnection() ? 'MIN' : 'LEAST';
+
+        return "$function($first, $second)";
+    }
+
+    public static function resolveGeometryEngine(): \Brick\Geo\Engine\GeometryEngine
+    {
+        if (\Brick\Geo\Engine\GeometryEngineRegistry::has()) {
+            return \Brick\Geo\Engine\GeometryEngineRegistry::get();
+        }
+
+        return new \Brick\Geo\Engine\GEOSEngine();
     }
 
     /**
@@ -1275,9 +1373,7 @@ class Utils extends FleetbaseUtils
      */
     public static function getCentroidFromGeosMultiPolygon(\Brick\Geo\MultiPolygon $multiPolygon): \Brick\Geo\Point
     {
-        $geometryEngine = new \Brick\Geo\Engine\GEOSEngine();
-
-        return $geometryEngine->centroid($multiPolygon);
+        return static::resolveGeometryEngine()->centroid($multiPolygon);
     }
 
     /**
@@ -1489,8 +1585,18 @@ class Utils extends FleetbaseUtils
         return $activity && $activity instanceof Activity && !empty($activity->code);
     }
 
-    public static function fixPhone(string $phone): string
+    /**
+     * Normalize a phone number to E.164-ish form by ensuring a leading `+`.
+     *
+     * Import rows frequently omit a phone column entirely, so a missing
+     * number is passed through untouched rather than becoming a bare `+`.
+     */
+    public static function fixPhone(?string $phone): ?string
     {
+        if ($phone === null || $phone === '') {
+            return $phone;
+        }
+
         if (!Str::startsWith($phone, '+')) {
             $phone = '+' . $phone;
         }

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

@@ -113,6 +113,11 @@ class GoogleRoutesTrackingProvider implements TrackingProviderInterface
 
     protected function apiKey(): ?string
     {
-        return config('services.google_maps.api_key') ?: env('GOOGLE_MAPS_API_KEY');
+        $configuredKey = config('services.google_maps.api_key');
+        if ($configuredKey) {
+            return $configuredKey;
+        }
+
+        return class_exists(\PhpOption\Option::class) ? env('GOOGLE_MAPS_API_KEY') : null;
     }
 }

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

@@ -29,12 +29,7 @@ class OsrmTrackingProvider implements TrackingProviderInterface
 
     public function track(TrackingContext $context, TrackingOptions $options): TrackingProviderResult
     {
-        $response = OSRM::getRouteFromPoints($context->routePoints(), [
-            'overview'    => 'full',
-            'geometries'  => 'polyline',
-            'steps'       => 'false',
-            'annotations' => 'false',
-        ]);
+        $response = $this->routeResponse($context);
 
         if (data_get($response, 'code') !== 'Ok') {
             throw new \RuntimeException('OSRM did not return a routable response.');
@@ -68,4 +63,14 @@ class OsrmTrackingProvider implements TrackingProviderInterface
             raw: $route
         );
     }
+
+    protected function routeResponse(TrackingContext $context): array
+    {
+        return OSRM::getRouteFromPoints($context->routePoints(), [
+            'overview'    => 'full',
+            'geometries'  => 'polyline',
+            'steps'       => 'false',
+            'annotations' => 'false',
+        ]);
+    }
 }

package/server/src/Tracking/TrackingProviderManager.php

@@ -6,7 +6,6 @@ use Fleetbase\FleetOps\Tracking\Contracts\TrackingProviderInterface;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\Log;
-use Illuminate\Support\Str;
 
 class TrackingProviderManager
 {
@@ -33,7 +32,7 @@ class TrackingProviderManager
                 $result           = $this->trackWithProviderCache($provider, $context, $options);
                 $result->warnings = array_values(array_unique([...$warnings, ...$result->warnings]));
 
-                if (Str::snake($result->provider) !== Str::snake((string) $options->provider)) {
+                if (TrackingProviderRegistry::normalizeKey($result->provider) !== TrackingProviderRegistry::normalizeKey($options->provider)) {
                     $result->warnings[] = 'fallback_used';
                 }
 
@@ -62,7 +61,7 @@ class TrackingProviderManager
 
         return collect([$provider, ...$fallbacks])
             ->filter()
-            ->map(fn ($key) => Str::snake($key))
+            ->map(fn ($key) => TrackingProviderRegistry::normalizeKey($key))
             ->unique()
             ->values()
             ->all();