@fleetbase/fleetops-engine 0.6.58 → 0.6.60

package/server/src/Listeners/HandleOrderDispatchFailed.php

@@ -25,11 +25,21 @@ class HandleOrderDispatchFailed implements ShouldQueue
         $order = $event->getModelRecord();
 
         /** @var User */
-        $createdBy = User::where('uuid', $order->created_by_uuid)->first();
+        $createdBy = $this->findUser($order->created_by_uuid);
 
         // notify driver assigned order was canceled
         if ($createdBy) {
-            $createdBy->notify(new OrderDispatchFailedNotification($order, $event));
+            $this->notifyUser($createdBy, $order, $event);
         }
     }
+
+    protected function findUser(?string $uuid): ?User
+    {
+        return User::where('uuid', $uuid)->first();
+    }
+
+    protected function notifyUser(User $user, $order, OrderDispatchFailed $event): void
+    {
+        $user->notify(new OrderDispatchFailedNotification($order, $event));
+    }
 }

package/server/src/Listeners/HandleOrderDispatched.php

@@ -36,16 +36,16 @@ class HandleOrderDispatched implements ShouldQueue
 
         /* make sure driver is assigned if not trigger failed dispatch */
         if (!$order->hasDriverAssigned && !$order->adhoc) {
-            return event(new OrderDispatchFailed($order, 'No driver assigned for order to dispatch to.'));
+            return $this->dispatchFailed($order, 'No driver assigned for order to dispatch to.');
         }
 
         /**
          * Check if dispatch activity already exists, if not -
          * Check for dispatch code in activity options, if there is the correct dispatch code update activity.
          **/
-        $doesntHaveDispatchActivity = TrackingStatus::where(['code' => 'DISPATCHED', 'tracking_number_uuid' => $order->tracking_number_uuid])->doesntExist();
+        $doesntHaveDispatchActivity = $this->doesntHaveDispatchActivity($order);
         if ($doesntHaveDispatchActivity) {
-            $activity = $order->config()->getDispatchActivity();
+            $activity = $this->getDispatchActivity($order);
             if ($activity) {
                 /** update order activity */
                 $location = $order->getLastLocation();
@@ -69,29 +69,11 @@ class HandleOrderDispatched implements ShouldQueue
                 return;
             }
 
-            $drivers = Driver::where(['status' => 'available', 'online' => 1])
-                ->whereHas('company', function ($q) {
-                    $q->whereHas('users', function ($q) {
-                        $q->whereHas('driver', function ($q) {
-                            $q->where(['status' => 'available', 'online' => 1]);
-                            $q->whereNull('deleted_at');
-                        });
-                    });
-                })
-                ->whereNull('deleted_at')
-                ->whereNotNull('location')->whereRaw('
-                ST_Y(location) BETWEEN -90 AND 90
-                AND ST_X(location) BETWEEN -180 AND 180
-                AND NOT (ST_X(location) = 0 AND ST_Y(location) = 0)
-            ')
-                ->distanceSphere('location', $pickup, $distance)
-                ->distanceSphereValue('location', $pickup)
-                ->withoutGlobalScopes()
-                ->get();
+            $drivers = $this->nearbyAvailableDrivers($pickup, $distance);
 
             return $drivers->each(function ($driver) use ($order) {
                 try {
-                    $driver->notify(new OrderPing($order, $driver->distance));
+                    $this->notifyAdhocDriver($driver, $order);
                 } catch (\Exception $exception) {
                     // failed to notify driver for order dispatch for reason uknown -- exit silently
                 }
@@ -99,17 +81,70 @@ class HandleOrderDispatched implements ShouldQueue
         }
 
         /** @var \Fleetbase\Models\Driver */
-        $driver = Driver::where('uuid', $order->driver_assigned_uuid)->withoutGlobalScopes()->first();
+        $driver = $this->findAssignedDriver($order);
 
         /* notify driver order has dispatched */
         if (!$driver) {
-            return event(new OrderDispatchFailed($order, 'Order was dispatched, but driver was unable to be notified.'));
+            return $this->dispatchFailed($order, 'Order was dispatched, but driver was unable to be notified.');
         }
 
         try {
-            $driver->notify(new OrderDispatchedNotification($order));
+            $this->notifyAssignedDriver($driver, $order);
         } catch (\Exception $exception) {
             // silently fail notifying driver for now
         }
     }
+
+    protected function dispatchFailed($order, string $reason): mixed
+    {
+        return event(new OrderDispatchFailed($order, $reason));
+    }
+
+    protected function doesntHaveDispatchActivity($order): bool
+    {
+        return TrackingStatus::where(['code' => 'DISPATCHED', 'tracking_number_uuid' => $order->tracking_number_uuid])->doesntExist();
+    }
+
+    protected function getDispatchActivity($order): mixed
+    {
+        return $order->config()?->getDispatchActivity();
+    }
+
+    protected function nearbyAvailableDrivers($pickup, int|float $distance)
+    {
+        return Driver::where(['status' => 'available', 'online' => 1])
+            ->whereHas('company', function ($q) {
+                $q->whereHas('users', function ($q) {
+                    $q->whereHas('driver', function ($q) {
+                        $q->where(['status' => 'available', 'online' => 1]);
+                        $q->whereNull('deleted_at');
+                    });
+                });
+            })
+            ->whereNull('deleted_at')
+            ->whereNotNull('location')->whereRaw('
+                ST_Y(location) BETWEEN -90 AND 90
+                AND ST_X(location) BETWEEN -180 AND 180
+                AND NOT (ST_X(location) = 0 AND ST_Y(location) = 0)
+            ')
+            ->distanceSphere('location', $pickup, $distance)
+            ->distanceSphereValue('location', $pickup)
+            ->withoutGlobalScopes()
+            ->get();
+    }
+
+    protected function notifyAdhocDriver(Driver $driver, $order): void
+    {
+        $driver->notify(new OrderPing($order, $driver->distance));
+    }
+
+    protected function findAssignedDriver($order): ?Driver
+    {
+        return Driver::where('uuid', $order->driver_assigned_uuid)->withoutGlobalScopes()->first();
+    }
+
+    protected function notifyAssignedDriver(Driver $driver, $order): void
+    {
+        $driver->notify(new OrderDispatchedNotification($order));
+    }
 }

package/server/src/Listeners/HandleOrderDriverAssigned.php

@@ -31,12 +31,22 @@ class HandleOrderDriverAssigned implements ShouldQueue
         }
 
         /** @var Driver */
-        $driver = Driver::where('uuid', $order->driver_assigned_uuid)->withoutGlobalScopes()->first();
+        $driver = $this->findAssignedDriver($order);
         $order->setRelation('driverAssigned', $driver);
 
         // notify driver order has been assigned - only if order is not adhoc
         if ($driver && $order->adhoc === false) {
-            $driver->notify(new OrderAssigned($order));
+            $this->notifyAssignedDriver($driver, $order);
         }
     }
+
+    protected function findAssignedDriver(Order $order): ?Driver
+    {
+        return Driver::where('uuid', $order->driver_assigned_uuid)->withoutGlobalScopes()->first();
+    }
+
+    protected function notifyAssignedDriver(Driver $driver, Order $order): void
+    {
+        $driver->notify(new OrderAssigned($order));
+    }
 }

package/server/src/Listeners/HandleUserRemovedFromCompany.php

@@ -21,11 +21,24 @@ class HandleUserRemovedFromCompany implements ShouldQueue
     public function handle(UserRemovedFromCompany $event)
     {
         // If user has driver record assosciated to the company, remove it
-        Driver::where(
-            [
-                'company_uuid' => $event->company->uuid,
-                'user_uuid'    => $event->user->uuid,
-            ]
-        )->delete();
+        $this->deleteDriversForCompanyUser($event->company->uuid, $event->user->uuid);
+    }
+
+    protected function deleteDriversForCompanyUser(string $companyUuid, string $userUuid): void
+    {
+        $this->driverQueryForCompanyUser($companyUuid, $userUuid)->delete();
+    }
+
+    protected function driverQueryForCompanyUser(string $companyUuid, string $userUuid): mixed
+    {
+        return $this->driverQuery([
+            'company_uuid' => $companyUuid,
+            'user_uuid'    => $userUuid,
+        ]);
+    }
+
+    protected function driverQuery(array $criteria): mixed
+    {
+        return Driver::where($criteria);
     }
 }

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

@@ -6,6 +6,7 @@ use Fleetbase\Casts\Json;
 use Fleetbase\FleetOps\Casts\Point;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\LaravelMysqlSpatial\Eloquent\SpatialTrait;
+use Fleetbase\LaravelMysqlSpatial\Types\Point as SpatialPoint;
 use Fleetbase\Models\Model;
 use Fleetbase\Models\User;
 use Fleetbase\Traits\HasApiModelBehavior;
@@ -149,6 +150,26 @@ class FuelReport extends Model
         return $this->belongsTo(User::class, 'reported_by_uuid');
     }
 
+    /**
+     * Bootstrap the model.
+     *
+     * `location` is declared nullable in CreateFuelReportRequest but the column is
+     * POINT NOT NULL, so a report created without one failed outright with
+     * SQLSTATE[HY000] 1364 "Field 'location' doesn't have a default value" — a 500 for
+     * a request the validator had just accepted. Mirrors Device and Sensor, which
+     * default their spatial columns the same way.
+     */
+    protected static function boot()
+    {
+        parent::boot();
+
+        static::creating(function (self $fuelReport) {
+            if (empty($fuelReport->location)) {
+                $fuelReport->location = new SpatialPoint(0, 0);
+            }
+        });
+    }
+
     /**
      * Get the driver's name assigned to vehicle.
      *
@@ -213,10 +234,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) {