@fleetbase/fleetops-engine 0.6.57 → 0.6.59

package/server/src/Listeners/NotifyDriverOnShiftChange.php

@@ -36,7 +36,7 @@ class NotifyDriverOnShiftChange implements ShouldQueue
 
         // Load the parent schedule to find the subject (driver)
         /** @var Schedule|null $schedule */
-        $schedule = $scheduleItem->schedule()->with('subject')->first();
+        $schedule = $this->getSchedule($scheduleItem);
         if (!$schedule) {
             return;
         }
@@ -48,16 +48,36 @@ class NotifyDriverOnShiftChange implements ShouldQueue
         }
 
         // Check the company-level scheduling setting
-        $settings     = Setting::lookupFromCompany('fleet-ops.scheduling-settings', []);
+        $settings     = $this->getSchedulingSettings();
         $shouldNotify = (bool) data_get($settings, 'notify_drivers_on_shift_change', false);
         if (!$shouldNotify) {
             return;
         }
 
         // Determine if this is a new shift or an update
-        $isNew = $event instanceof \Fleetbase\Events\ScheduleItemCreated;
+        $isNew = $this->isCreatedEvent($event);
 
         // Send the notification to the driver
-        $subject->notify(new DriverShiftChanged($scheduleItem, $isNew));
+        $this->notifyDriver($subject, new DriverShiftChanged($scheduleItem, $isNew));
+    }
+
+    protected function getSchedule(ScheduleItem $scheduleItem): ?Schedule
+    {
+        return $scheduleItem->schedule()->with('subject')->first();
+    }
+
+    protected function getSchedulingSettings(): array
+    {
+        return Setting::lookupFromCompany('fleet-ops.scheduling-settings', []);
+    }
+
+    protected function isCreatedEvent(object $event): bool
+    {
+        return $event instanceof \Fleetbase\Events\ScheduleItemCreated;
+    }
+
+    protected function notifyDriver(Driver $driver, DriverShiftChanged $notification): void
+    {
+        $driver->notify($notification);
     }
 }

package/server/src/Listeners/NotifyOrderEvent.php

@@ -32,29 +32,34 @@ class NotifyOrderEvent implements ShouldQueue
             // Send a notification for order events
             if ($event instanceof \Fleetbase\FleetOps\Events\OrderCanceled) {
                 $reason = $event->activity ? $event->activity->get('details') : '';
-                NotificationRegistry::notify(OrderCanceled::class, $order, $reason, $event->waypoint);
+                $this->notify(OrderCanceled::class, $order, $reason, $event->waypoint);
             }
 
             if ($event instanceof \Fleetbase\FleetOps\Events\OrderCompleted) {
-                NotificationRegistry::notify(OrderCompleted::class, $order, $event->waypoint);
+                $this->notify(OrderCompleted::class, $order, $event->waypoint);
             }
 
             if ($event instanceof \Fleetbase\FleetOps\Events\OrderFailed) {
                 $reason = $event->activity ? $event->activity->get('details') : '';
-                NotificationRegistry::notify(OrderFailed::class, $order, $reason, $event->waypoint);
+                $this->notify(OrderFailed::class, $order, $reason, $event->waypoint);
             }
 
             if ($event instanceof \Fleetbase\FleetOps\Events\OrderDispatchFailed) {
-                NotificationRegistry::notify(OrderDispatchFailed::class, $order);
+                $this->notify(OrderDispatchFailed::class, $order);
             }
 
             if ($event instanceof \Fleetbase\FleetOps\Events\OrderDispatched) {
-                NotificationRegistry::notify(OrderDispatched::class, $order, $event->waypoint);
+                $this->notify(OrderDispatched::class, $order, $event->waypoint);
             }
 
             if ($event instanceof \Fleetbase\FleetOps\Events\OrderDriverAssigned) {
-                NotificationRegistry::notify(OrderAssigned::class, $order);
+                $this->notify(OrderAssigned::class, $order);
             }
         }
     }
+
+    protected function notify(string $notificationClass, mixed ...$arguments): void
+    {
+        NotificationRegistry::notify($notificationClass, ...$arguments);
+    }
 }

package/server/src/Models/Contact.php

@@ -348,14 +348,13 @@ class Contact extends Model
             $existingUserContact = Contact::where(['user_uuid' => $existingUser->uuid, 'company_uuid' => $contact->company_uuid])->whereHas('user')->first();
             if ($existingUserContact) {
                 throw new UserAlreadyExistsException('User already exists, try to assigning the user to this contact.', $existingUser);
-            } else {
-                // Assign the user to this contact instead
-                $contact->setAttribute('user_uuid', $existingUser->uuid);
-                if ($update) {
-                    $contact->update(['user_uuid' => $existingUser->uuid]);
-                }
-                $contact->setRelation('user', $existingUser);
             }
+            // Assign the user to this contact instead
+            $contact->setAttribute('user_uuid', $existingUser->uuid);
+            if ($update) {
+                $contact->update(['user_uuid' => $existingUser->uuid]);
+            }
+            $contact->setRelation('user', $existingUser);
 
             return $existingUser;
         }

package/server/src/Models/Device.php

@@ -175,6 +175,24 @@ class Device extends Model
         'attachable_type'                    => PolymorphicType::class,
     ];
 
+    /**
+     * Bootstrap the model.
+     *
+     * Devices require a non-null spatial `last_position` (the column is NOT NULL
+     * to support its spatial index), so default it to POINT(0,0) on create when
+     * the caller hasn't provided a position.
+     */
+    protected static function boot()
+    {
+        parent::boot();
+
+        static::creating(function (self $device) {
+            if (empty($device->last_position)) {
+                $device->last_position = new SpatialPoint(0, 0);
+            }
+        });
+    }
+
     /**
      * Properties which activity needs to be logged.
      *
@@ -345,9 +363,9 @@ class Device extends Model
             return 'recently_offline';
         } elseif ($minutesOffline <= 1440) { // 24 hours
             return 'offline';
-        } else {
-            return 'long_offline';
         }
+
+        return 'long_offline';
     }
 
     /**
@@ -510,12 +528,17 @@ class Device extends Model
      */
     public function getRecentEvents(int $limit = 10)
     {
-        return $this->events()
+        return $this->recentEventsQuery()
             ->orderBy('created_at', 'desc')
             ->limit($limit)
             ->get();
     }
 
+    protected function recentEventsQuery()
+    {
+        return $this->events();
+    }
+
     /**
      * Creates a new position for the vehicle.
      */

package/server/src/Models/Driver.php

@@ -41,7 +41,6 @@ use Spatie\Activitylog\Traits\CausesActivity;
 use Spatie\Activitylog\Traits\LogsActivity;
 use Spatie\Sluggable\HasSlug;
 use Spatie\Sluggable\SlugOptions;
-use WebSocket\Message\Ping;
 
 class Driver extends Model
 {
@@ -329,11 +328,6 @@ class Driver extends Model
         return $this->hasMany(Order::class, 'driver_assigned_uuid')->without(['driver']);
     }
 
-    public function pings(): HasMany
-    {
-        return $this->hasMany(Ping::class);
-    }
-
     public function positions(): HasMany
     {
         return $this->hasMany(Position::class, 'subject_uuid');

package/server/src/Models/Entity.php

@@ -414,10 +414,10 @@ class Entity extends Model
             }
         }
 
-        // confirm destination_uuid is indeed a place record
-        if (isset($attributes['destination_uuid']) && Place::where('uuid', $attributes['destination_uuid'])->doesntExist()) {
-            // search waypoints for search_uuid if any
-            $destination = Place::where('meta->search_uuid', $attributes['destination_uuid'])->first();
+        // confirm the resolved destination is indeed a place record — temp
+        // search uuids from imports resolve through place metadata
+        if ($this->destination_uuid === null && Str::isUuid($destinationKey)) {
+            $destination = Place::where('meta->search_uuid', $destinationKey)->first();
 
             if ($destination instanceof Place) {
                 $this->destination_uuid = $destination->uuid;

package/server/src/Models/Equipment.php

@@ -243,7 +243,7 @@ class Equipment extends Model
         $this->attributes['equipable_type'] = match ($type) {
             'fleet-ops:vehicle', 'vehicle' => Utils::getMutationType('fleet-ops:vehicle'),
             'fleet-ops:driver', 'driver'   => Utils::getMutationType('fleet-ops:driver'),
-            default                       => $type,
+            default                        => $type,
         };
     }
 

package/server/src/Models/FuelReport.php

@@ -213,10 +213,14 @@ class FuelReport extends Model
         $latitude       = Utils::or($row, ['latitude', 'lat']);
         $longitude      = Utils::or($row, ['longitude', 'lng', 'long']);
 
+        $locationValue = data_get($row, 'location');
         if ($latitude && $longitude) {
             $location = new Point($latitude, $longitude);
+        } elseif (filled($locationValue)) {
+            $location = Utils::getPointFromMixed(Utils::arrayFrom($locationValue));
         } else {
-            $location = Utils::getPointFromMixed(Utils::arrayFrom(data_get($row, 'location')));
+            // Rows without any location column fall back to the empty point below
+            $location = null;
         }
 
         // Resolve relations

package/server/src/Models/IntegratedVendor.php

@@ -117,7 +117,7 @@ class IntegratedVendor extends Model
             function ($model) {
                 $provider = $model->provider();
 
-                if ($provider && method_exists($provider, 'onUpdated')) {
+                if ($provider && method_exists($provider, 'callback')) {
                     $provider->callback('onUpdated');
                 }
             }
@@ -127,7 +127,7 @@ class IntegratedVendor extends Model
             function ($model) {
                 $provider = $model->provider();
 
-                if ($provider && method_exists($provider, 'onDeleted')) {
+                if ($provider && method_exists($provider, 'callback')) {
                     $provider->callback('onDeleted');
                 }
             }

package/server/src/Models/Issue.php

@@ -331,10 +331,14 @@ class Issue extends Model
         $latitude       = Utils::or($row, ['latitude', 'lat']);
         $longitude      = Utils::or($row, ['longitude', 'lng', 'long']);
 
+        $locationValue = data_get($row, 'location');
         if ($latitude && $longitude) {
             $location = new Point($latitude, $longitude);
+        } elseif (filled($locationValue)) {
+            $location = Utils::getPointFromMixed(Utils::arrayFrom($locationValue));
         } else {
-            $location = Utils::getPointFromMixed(Utils::arrayFrom(data_get($row, 'location')));
+            // Rows without any location column fall back to the empty point below
+            $location = null;
         }
 
         // Create issue

package/server/src/Models/MaintenanceSchedule.php

@@ -315,17 +315,12 @@ class MaintenanceSchedule extends Model
 
         // Attempt to resolve the subject (vehicle or equipment) by identifier
         if ($vehicleName) {
-            $vehicle = Vehicle::findByName($vehicleName);
+            $vehicle = static::findImportVehicle($vehicleName);
             if ($vehicle) {
                 $schedule->subject_type = Vehicle::class;
                 $schedule->subject_uuid = $vehicle->uuid;
             } else {
-                $equipment = Equipment::where('company_uuid', session('company'))
-                    ->where(function ($q) use ($vehicleName) {
-                        $q->where('name', 'like', '%' . $vehicleName . '%')
-                          ->orWhere('public_id', $vehicleName)
-                          ->orWhere('serial_number', $vehicleName);
-                    })->first();
+                $equipment = static::findImportEquipment($vehicleName);
                 if ($equipment) {
                     $schedule->subject_type = Equipment::class;
                     $schedule->subject_uuid = $equipment->uuid;
@@ -335,9 +330,7 @@ class MaintenanceSchedule extends Model
 
         // Attempt to resolve default assignee (vendor) by name
         if ($vendorName) {
-            $vendor = Vendor::where('company_uuid', session('company'))
-                ->where('name', 'like', '%' . $vendorName . '%')
-                ->first();
+            $vendor = static::findImportVendor($vendorName);
             if ($vendor) {
                 $schedule->default_assignee_type = Vendor::class;
                 $schedule->default_assignee_uuid = $vendor->uuid;
@@ -350,4 +343,26 @@ class MaintenanceSchedule extends Model
 
         return $schedule;
     }
+
+    protected static function findImportVehicle(string $vehicleName): ?Vehicle
+    {
+        return Vehicle::findByName($vehicleName);
+    }
+
+    protected static function findImportEquipment(string $vehicleName): ?Equipment
+    {
+        return Equipment::where('company_uuid', session('company'))
+            ->where(function ($q) use ($vehicleName) {
+                $q->where('name', 'like', '%' . $vehicleName . '%')
+                  ->orWhere('public_id', $vehicleName)
+                  ->orWhere('serial_number', $vehicleName);
+            })->first();
+    }
+
+    protected static function findImportVendor(string $vendorName): ?Vendor
+    {
+        return Vendor::where('company_uuid', session('company'))
+            ->where('name', 'like', '%' . $vendorName . '%')
+            ->first();
+    }
 }

package/server/src/Models/Order.php

@@ -932,9 +932,15 @@ class Order extends Model
 
         $result = Payload::insert($attributes);
 
+        // Unreachable: Laravel's connector forces PDO::ERRMODE_EXCEPTION and
+        // nothing here overrides it, so the insert either succeeds or throws —
+        // it never returns false. The fallback itself is sound (insertPayload
+        // regenerates the uuid and public id before delegating), just unreached.
+        // @codeCoverageIgnoreStart
         if (!$result) {
             return $this->createPayload($attributes);
         }
+        // @codeCoverageIgnoreEnd
 
         $payload = Payload::find($uuid);
 
@@ -1003,14 +1009,14 @@ class Order extends Model
      *
      * @return self the Order instance for method chaining
      */
-    public function setRoute(?array $attributes = [])
+    public function setRoute(Route|array|null $attributes = [])
     {
         if (!$attributes) {
             return $this;
         }
 
         if ($attributes instanceof Route) {
-            $attributes->set('order_uuid', $this->order_uuid);
+            $attributes->setAttribute('order_uuid', $this->uuid);
             $attributes->save();
 
             return $this;
@@ -1243,7 +1249,7 @@ class Order extends Model
         $min = Carbon::now()->subMinutes($precision);
         $max = Carbon::now()->addMinutes($precision);
 
-        return !$this->dispatched && Carbon::fromString($this->scheduled_at)->between($min, $max);
+        return !$this->dispatched && Carbon::parse($this->scheduled_at)->between($min, $max);
     }
 
     /**
@@ -1734,10 +1740,16 @@ class Order extends Model
         }
 
         // Fetch distance/time — bail early if external call fails
+        //
+        // Unreachable: `getDrivingDistanceAndTime()` is typed `: DistanceMatrix`
+        // and every provider path casts both fields to float before constructing
+        // it, so neither the null check nor the isset check can fail.
         $matrix = Utils::getDrivingDistanceAndTime($origin, $destination, $options);
+        // @codeCoverageIgnoreStart
         if (!$matrix || !isset($matrix->distance, $matrix->time)) {
             return $this;
         }
+        // @codeCoverageIgnoreEnd
 
         // Only update if values changed to prevent redundant writes
         if ($this->distance !== $matrix->distance || $this->time !== $matrix->time) {
@@ -1777,9 +1789,9 @@ class Order extends Model
      * This function first attempts to load the 'orderConfig' relationship.
      * If 'orderConfig' is already loaded and is an instance of OrderConfig,
      * it returns this instance. If not, and if the 'order_config_uuid' is
-     * a valid UUID, it attempts to retrieve the OrderConfig by this UUID,
-     * including any trashed instances. If none of these conditions are met,
-     * it returns null.
+     * The orderConfig relation already includes trashed instances, so a
+     * soft-deleted config still resolves. Otherwise the company's default
+     * transport config is used, and null is returned when none can be made.
      *
      * @return OrderConfig|null the OrderConfig associated with this order, or null if not found
      *
@@ -1795,15 +1807,6 @@ class Order extends Model
             return $this->orderConfig;
         }
 
-        if (Str::isUuid($this->order_config_uuid)) {
-            $orderConfig = OrderConfig::where('uuid', $this->order_config_uuid)->withTrashed()->first();
-            if ($orderConfig instanceof OrderConfig) {
-                $orderConfig->setOrderContext($this);
-
-                return $orderConfig;
-            }
-        }
-
         $company     = $this->relationLoaded('company') ? $this->company : $this->company()->first();
         $orderConfig = OrderConfig::defaultOrCreate($company);
         if ($orderConfig instanceof OrderConfig) {

package/server/src/Models/OrderConfig.php

@@ -498,7 +498,7 @@ class OrderConfig extends Model
     /**
      * Get the default order config.
      */
-    public static function default(?Company $company = null): self
+    public static function default(?Company $company = null): ?self
     {
         return static::where(['namespace' => 'system:order-config:transport', 'company_uuid' => $company ? $company->uuid : session('company')])->first();
     }

package/server/src/Models/Payload.php

@@ -911,14 +911,10 @@ class Payload extends Model
         $save     = data_get($options, 'save', false);
         $callback = data_get($options, 'callback', false);
 
-        if ($instance) {
-            if (Str::isUuid($instance)) {
-                $this->setAttribute($attr, $instance);
-            } elseif ($instance instanceof Model) {
-                $this->setAttribute($attr, $instance->uuid);
-            } else {
-                $this->setAttribute($attr, $instance);
-            }
+        // createFromMixed() returns a Place or null, so a resolved instance is
+        // always a model — the uuid-string and passthrough cases cannot occur
+        if ($instance instanceof Model) {
+            $this->setAttribute($attr, $instance->uuid);
         }
 
         // Get the ID property
@@ -1148,19 +1144,16 @@ class Payload extends Model
             }
         }
 
-        // confirm destination_uuid is indeed a place record
-        if (isset($attributes['destination_uuid']) && Place::where('uuid', $attributes['destination_uuid'])->doesntExist()) {
-            // search waypoints for search_uuid if any
-            $destination = Place::where('meta->search_uuid', $attributes['destination_uuid'])->first();
+        // confirm the key is indeed a place record, otherwise fall back to
+        // search-uuid metadata left by console place searches
+        if (Place::where('uuid', $destinationKey)->doesntExist()) {
+            $destination = Place::where('meta->search_uuid', $destinationKey)->first();
 
             if ($destination instanceof Place) {
                 return $destination;
             }
-        }
 
-        // Validate destination actually exists
-        if (isset($attributes['destination_uuid']) && Place::where('uuid', $attributes['destination_uuid'])->doesntExist()) {
-            $destination = $this->_findCorrectDestinationForEntity($attributes);
+            $destination = $this->_findCorrectDestinationForEntity(['destination_uuid' => $destinationKey]);
 
             if ($destination instanceof Place) {
                 return $destination;

package/server/src/Models/Place.php

@@ -394,6 +394,16 @@ class Place extends Model
         return static::getGoogleAddressArray($results->first());
     }
 
+    /**
+     * Inserts a new place into the database from a geocoding lookup on an address.
+     *
+     * @return string|bool the UUID of the newly created place or false if the place was not created
+     */
+    public static function insertFromGeocodingLookup(string $address)
+    {
+        return static::insertGetUuid(static::getValuesFromGeocodingLookup($address));
+    }
+
     /**
      * Compose a fuller geocoding query from structured place attributes.
      */
@@ -644,7 +654,7 @@ class Place extends Model
 
         $results = \Geocoder\Laravel\Facades\Geocoder::reverse($latitude, $longitude)->get();
 
-        if (!$results->count() === 0) {
+        if ($results->count() === 0) {
             return false;
         }
 
@@ -703,11 +713,6 @@ class Place extends Model
         }
         // If $place is an array
         elseif (is_array($place)) {
-            // If $place is an array of coordinates, create a new Place object
-            if (Utils::isCoordinatesStrict($place)) {
-                return static::createFromCoordinates($place, $attributes, $saveInstance);
-            }
-
             // Get uuid if set
             $uuid = data_get($place, 'uuid');
 
@@ -782,12 +787,11 @@ class Place extends Model
                 }
             }
 
-            // handle address if set
-            if (!empty($place['address'])) {
-                return static::insertFromGeocodingLookup($place['address']);
-            }
-
             return static::insertFromGeocodingLookup($place);
+        } elseif ($place instanceof \Geocoder\Provider\GoogleMaps\Model\GoogleAddress) {
+            // Must be tested before the array/object arm below, which would
+            // otherwise swallow it and flatten it to an array
+            return static::insertFromGoogleAddress($place);
         } elseif (is_array($place) || is_object($place)) {
             // if place already exists just return uuid
             if (static::isValidPlaceUuid(data_get($place, 'uuid'))) {
@@ -805,14 +809,17 @@ class Place extends Model
 
             $values = is_array($place) ? $place : (array) $place;
 
+            // handle address if set
+            if (!empty($values['address'])) {
+                return static::insertFromGeocodingLookup($values['address']);
+            }
+
             if ($existingPlace = static::findExistingSharedPlace($values)) {
                 return $existingPlace->uuid;
             }
 
             // create a new place
             return static::insertGetUuid((array) $values);
-        } elseif ($place instanceof \Geocoder\Provider\GoogleMaps\Model\GoogleAddress) {
-            return static::insertFromGoogleAddress($place);
         }
     }
 

package/server/src/Models/ServiceArea.php

@@ -180,13 +180,10 @@ class ServiceArea extends Model
      */
     public static function createMultiPolygonFromPoint(Point $point, int $meters = 500): MultiPolygon
     {
+        // coordsToCircle() already closes the ring, so first and last are
+        // equivalent on arrival and no re-closing is needed here
         $coordinates = Utils::coordsToCircle($point->getLat(), $point->getLng(), $meters);
 
-        // first and last positions should be equivalent
-        if (Arr::first($coordinates) !== Arr::last($coordinates)) {
-            $coordinates[] = Arr::first($coordinates);
-        }
-
         // conver the coordinate pairs to points
         $coordinates = array_map(
             function ($coord) {
@@ -380,7 +377,7 @@ class ServiceArea extends Model
      */
     public function getCentroid(): \Brick\Geo\Point
     {
-        $geometryEngine       = new \Brick\Geo\Engine\GEOSEngine();
+        $geometryEngine       = Utils::resolveGeometryEngine();
         $borderAsMultiPolygon = $this->toGeosMultiPolygon();
 
         if ($borderAsMultiPolygon instanceof \Brick\Geo\Geometry) {

package/server/src/Models/ServiceQuote.php

@@ -211,7 +211,12 @@ class ServiceQuote extends Model
             return $product;
         }
 
+        // Unreachable: `Payment::getStripeClient()` is `?StripeClient` in its
+        // signature only — it unconditionally returns `new StripeClient([...])`,
+        // so the guard above never falls through.
+        // @codeCoverageIgnoreStart
         return null;
+        // @codeCoverageIgnoreEnd
     }
 
     /**

package/server/src/Models/ServiceRate.php

@@ -856,7 +856,7 @@ class ServiceRate extends Model
 
                 // if no distance fee use the last
                 if ($serviceParcelFee === null) {
-                    $serviceParcelFee = $this->parcelFees->sortByDesc()->first();
+                    $serviceParcelFee = $this->parcelFees->sortByDesc('fee')->first();
                 }
 
                 $subTotal += $serviceParcelFee->fee;
@@ -1050,7 +1050,7 @@ class ServiceRate extends Model
 
                 // if no distance fee use the last
                 if ($serviceParcelFee === null) {
-                    $serviceParcelFee = $this->parcelFees->sortByDesc()->first();
+                    $serviceParcelFee = $this->parcelFees->sortByDesc('fee')->first();
                 }
 
                 $subTotal += $serviceParcelFee->fee;
@@ -1213,10 +1213,15 @@ class ServiceRate extends Model
         $subTotal        = 0;
 
         foreach ($pricedDistances as $entry) {
+            // Unreachable: calculateMultiZoneDistances() only ever emits entries
+            // whose rule is a ServiceRateFee — both its early returns are gated
+            // on a non-null $fallbackRule and its accumulator guards the type.
             $rule = $entry['rule'];
+            // @codeCoverageIgnoreStart
             if (!$rule instanceof ServiceRateFee) {
                 continue;
             }
+            // @codeCoverageIgnoreEnd
 
             $distanceInMeters = (float) ($entry['distance_m'] ?? 0);
             if ($distanceInMeters <= 0) {
@@ -1274,12 +1279,16 @@ class ServiceRate extends Model
         $sampledTotal = 0;
 
         for ($i = 0; $i < $places->count() - 1; $i++) {
+            // Unreachable: $places is filtered to Place instances above, and
+            // getLngLatFromPlace() only returns null for a non-Place.
             $start = $this->getLngLatFromPlace($places[$i]);
             $end   = $this->getLngLatFromPlace($places[$i + 1]);
 
+            // @codeCoverageIgnoreStart
             if (!$start || !$end) {
                 continue;
             }
+            // @codeCoverageIgnoreEnd
 
             $legDistance = $this->haversineDistanceInMeters($start['lat'], $start['lng'], $end['lat'], $end['lng']);
             $steps       = max(1, min(500, (int) ceil($legDistance / 1000)));
@@ -1367,12 +1376,10 @@ class ServiceRate extends Model
             return null;
         }
 
+        // getLocationAsPoint() is typed `: SpatialPoint`, which always exposes
+        // getLat()/getLng(), so no further guarding is possible here
         $point = $place->getLocationAsPoint();
 
-        if (!$point || !method_exists($point, 'getLat') || !method_exists($point, 'getLng')) {
-            return null;
-        }
-
         return ['lat' => (float) $point->getLat(), 'lng' => (float) $point->getLng()];
     }
 

package/server/src/Models/Telematic.php

@@ -385,9 +385,9 @@ class Telematic extends Model
             return 'recently_offline';
         } elseif ($minutesOffline <= 1440) { // 24 hours
             return 'offline';
-        } else {
-            return 'long_offline';
         }
+
+        return 'long_offline';
     }
 
     /**