@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/src/Jobs/NotifyBulkAssignedDriver.php

@@ -23,25 +23,38 @@ class NotifyBulkAssignedDriver implements ShouldQueue
 
     public function handle(): void
     {
-        $driver = Driver::where('uuid', $this->driverUuid)->first();
+        $driver = $this->findDriver();
         if (!$driver) {
             return;
         }
 
-        Order::whereIn('uuid', $this->orderUuids)
-            ->cursor()
-            ->each(function (Order $order) use ($driver): void {
-                $order->setRelation('driverAssigned', $driver);
-                $order->driver_assigned_uuid = $driver->uuid;
-
-                try {
-                    $order->notifyDriverAssigned();
-                } catch (\Throwable $e) {
-                    logger()->warning(
-                        'Failed notifying driver on order ' . $order->uuid,
-                        ['error' => $e->getMessage()]
-                    );
-                }
-            });
+        foreach ($this->ordersForNotification() as $order) {
+            $order->setRelation('driverAssigned', $driver);
+            $order->driver_assigned_uuid = $driver->uuid;
+
+            try {
+                $order->notifyDriverAssigned();
+            } catch (\Throwable $e) {
+                $this->logNotificationFailure($order, $e);
+            }
+        }
+    }
+
+    protected function findDriver(): ?Driver
+    {
+        return Driver::where('uuid', $this->driverUuid)->first();
+    }
+
+    protected function ordersForNotification(): iterable
+    {
+        return Order::whereIn('uuid', $this->orderUuids)->cursor();
+    }
+
+    protected function logNotificationFailure(Order $order, \Throwable $e): void
+    {
+        logger()->warning(
+            'Failed notifying driver on order ' . $order->uuid,
+            ['error' => $e->getMessage()]
+        );
     }
 }

package/server/src/Jobs/ProcessAllocationJob.php

@@ -53,45 +53,29 @@ class ProcessAllocationJob implements ShouldQueue
 
     public function handle(OrchestrationEngineRegistry $registry): void
     {
-        $ordersQuery = Order::where('company_uuid', $this->companyUuid)
-            ->whereNull('driver_assigned_uuid')
-            ->whereNotIn('status', ['completed', 'cancelled'])
-            ->with(['payload.dropoff', 'payload.waypoints']);
-
-        if (!empty($this->orderIds)) {
-            $ordersQuery->whereIn('public_id', $this->orderIds);
-        }
-
-        $orders = $ordersQuery->get();
+        $orders = $this->unassignedOrders();
 
         if ($orders->isEmpty()) {
-            Log::info("[ProcessAllocationJob] No unassigned orders for company {$this->companyUuid}.");
+            $this->logInfo("[ProcessAllocationJob] No unassigned orders for company {$this->companyUuid}.");
 
             return;
         }
 
-        $vehicles = Vehicle::where('company_uuid', $this->companyUuid)
-            ->with(['driver' => fn ($q) => $q->where('online', true)])
-            ->get()
-            ->filter(fn ($v) => $v->driver !== null);
+        $vehicles = $this->availableVehicles();
 
         if ($vehicles->isEmpty()) {
-            Log::info("[ProcessAllocationJob] No available vehicles for company {$this->companyUuid}.");
+            $this->logInfo("[ProcessAllocationJob] No available vehicles for company {$this->companyUuid}.");
 
             return;
         }
 
-        $engineId = Setting::lookup('fleetops.orchestrator_engine', 'greedy');
-        $engine   = $registry->resolve($engineId);
+        $engine = $registry->resolve($this->engineId());
 
-        $result = $engine->allocate($orders, $vehicles, [
-            'max_travel_time'  => Setting::lookup('fleetops.allocation_max_travel_time', 3600),
-            'balance_workload' => Setting::lookup('fleetops.allocation_balance_workload', false),
-        ]);
+        $result = $engine->allocate($orders, $vehicles, $this->allocationOptions());
 
         foreach ($result['assignments'] as $assignment) {
-            $order  = Order::where('public_id', $assignment['order_id'])->first();
-            $driver = Driver::where('public_id', $assignment['driver_id'])->first();
+            $order  = $this->findOrderByPublicId($assignment['order_id']);
+            $driver = $this->findDriverByPublicId($assignment['driver_id']);
 
             if (!$order || !$driver) {
                 continue;
@@ -107,7 +91,7 @@ class ProcessAllocationJob implements ShouldQueue
             $order->firstDispatchWithActivity();
         }
 
-        Log::info(
+        $this->logInfo(
             sprintf(
                 '[ProcessAllocationJob] Committed %d assignments, %d unassigned for company %s.',
                 count($result['assignments']),
@@ -116,4 +100,54 @@ class ProcessAllocationJob implements ShouldQueue
             )
         );
     }
+
+    protected function unassignedOrders()
+    {
+        $ordersQuery = Order::where('company_uuid', $this->companyUuid)
+            ->whereNull('driver_assigned_uuid')
+            ->whereNotIn('status', ['completed', 'cancelled'])
+            ->with(['payload.dropoff', 'payload.waypoints']);
+
+        if (!empty($this->orderIds)) {
+            $ordersQuery->whereIn('public_id', $this->orderIds);
+        }
+
+        return $ordersQuery->get();
+    }
+
+    protected function availableVehicles()
+    {
+        return Vehicle::where('company_uuid', $this->companyUuid)
+            ->with(['driver' => fn ($q) => $q->where('online', true)])
+            ->get()
+            ->filter(fn ($v) => $v->driver !== null);
+    }
+
+    protected function engineId(): string
+    {
+        return Setting::lookup('fleetops.orchestrator_engine', 'greedy');
+    }
+
+    protected function allocationOptions(): array
+    {
+        return [
+            'max_travel_time'  => Setting::lookup('fleetops.allocation_max_travel_time', 3600),
+            'balance_workload' => Setting::lookup('fleetops.allocation_balance_workload', false),
+        ];
+    }
+
+    protected function findOrderByPublicId(string $publicId): ?Order
+    {
+        return Order::where('public_id', $publicId)->first();
+    }
+
+    protected function findDriverByPublicId(string $publicId): ?Driver
+    {
+        return Driver::where('public_id', $publicId)->first();
+    }
+
+    protected function logInfo(string $message): void
+    {
+        Log::info($message);
+    }
 }

package/server/src/Jobs/ReplayPositions.php

@@ -4,7 +4,6 @@ namespace Fleetbase\FleetOps\Jobs;
 
 use Carbon\Carbon;
 use Fleetbase\FleetOps\Models\Position;
-use Fleetbase\Support\SocketCluster\SocketClusterService;
 use Illuminate\Bus\Queueable;
 use Illuminate\Contracts\Queue\ShouldQueue;
 use Illuminate\Foundation\Bus\Dispatchable;
@@ -41,8 +40,6 @@ class ReplayPositions implements ShouldQueue
 
     public function handle(): void
     {
-        $socket = new SocketClusterService();
-
         // Base timestamp to compute relative offsets
         $baseTime = Carbon::parse($this->positions->first()->created_at);
 
@@ -51,14 +48,24 @@ class ReplayPositions implements ShouldQueue
             $offset      = $baseTime->diffInSeconds($currentTime, false) / $this->speed;
 
             // Schedule a small job for each event with its own delay
-            SendPositionReplay::dispatch(
-                $this->channelId,
-                $position,
-                $index,
-                $this->subjectUuid
-            )->delay(now()->addSeconds(max(0, $offset)));
+            $this->dispatchReplayPosition($position, $index, max(0, $offset));
         }
 
-        Log::info("Replay scheduled for {$this->positions->count()} positions on channel {$this->channelId}");
+        $this->logInfo("Replay scheduled for {$this->positions->count()} positions on channel {$this->channelId}");
+    }
+
+    protected function dispatchReplayPosition(Position $position, int|string $index, float $offset)
+    {
+        return SendPositionReplay::dispatch(
+            $this->channelId,
+            $position,
+            $index,
+            $this->subjectUuid
+        )->delay(now()->addSeconds($offset));
+    }
+
+    protected function logInfo(string $message): void
+    {
+        Log::info($message);
     }
 }

package/server/src/Jobs/SendPositionReplay.php

@@ -36,9 +36,16 @@ class SendPositionReplay implements ShouldQueue
 
     public function handle(): void
     {
-        $socket = new SocketClusterService();
+        try {
+            $this->socket()->send($this->channelId, $this->eventData());
+        } catch (\Throwable $e) {
+            $this->logError("Failed to send replay event [{$this->position->uuid}]: {$e->getMessage()}");
+        }
+    }
 
-        $eventData = [
+    protected function eventData(): array
+    {
+        return [
             'id'          => uniqid('event_'),
             'api_version' => config('api.version'),
             'event'       => 'position.simulated',
@@ -55,11 +62,15 @@ class SendPositionReplay implements ShouldQueue
                 ],
             ],
         ];
+    }
 
-        try {
-            $socket->send($this->channelId, $eventData);
-        } catch (\Throwable $e) {
-            Log::error("Failed to send replay event [{$this->position->uuid}]: {$e->getMessage()}");
-        }
+    protected function socket()
+    {
+        return new SocketClusterService();
+    }
+
+    protected function logError(string $message): void
+    {
+        Log::error($message);
     }
 }

package/server/src/Jobs/SimulateDrivingRoute.php

@@ -69,13 +69,24 @@ class SimulateDrivingRoute implements ShouldQueue
         $firstWaypoint      = reset($this->waypoints);
         $remainingWaypoints = array_slice($this->waypoints, 1, null, true);
 
-        SimulateWaypointReached::withChain(
+        $this->dispatchWaypointChain(
+            $firstWaypoint,
             Arr::map(
                 $remainingWaypoints,
                 function ($waypoint, $index) {
-                    return new SimulateWaypointReached($this->driver, $waypoint, ['index' => $index]);
+                    return $this->makeWaypointReachedJob($waypoint, ['index' => $index]);
                 }
             )
-        )->dispatch($this->driver, $firstWaypoint, ['index' => 0]);
+        );
+    }
+
+    protected function makeWaypointReachedJob($waypoint, array $additionalData): SimulateWaypointReached
+    {
+        return new SimulateWaypointReached($this->driver, $waypoint, $additionalData);
+    }
+
+    protected function dispatchWaypointChain($firstWaypoint, array $chain): void
+    {
+        SimulateWaypointReached::withChain($chain)->dispatch($this->driver, $firstWaypoint, ['index' => 0]);
     }
 }

package/server/src/Jobs/SyncFuelProviderTransactionsJob.php

@@ -25,8 +25,8 @@ class SyncFuelProviderTransactionsJob implements ShouldQueue
 
     public function handle(FuelProviderService $fuelProviderService): void
     {
-        $connection = FuelProviderConnection::where('uuid', $this->connectionUuid)->firstOrFail();
-        $syncRun    = $this->syncRunUuid ? FuelProviderSyncRun::where('uuid', $this->syncRunUuid)->first() : null;
+        $connection = $this->findConnection();
+        $syncRun    = $this->findSyncRun();
 
         try {
             $fuelProviderService->syncTransactions(
@@ -54,4 +54,14 @@ class SyncFuelProviderTransactionsJob implements ShouldQueue
             throw $e;
         }
     }
+
+    protected function findConnection(): FuelProviderConnection
+    {
+        return FuelProviderConnection::where('uuid', $this->connectionUuid)->firstOrFail();
+    }
+
+    protected function findSyncRun(): ?FuelProviderSyncRun
+    {
+        return $this->syncRunUuid ? FuelProviderSyncRun::where('uuid', $this->syncRunUuid)->first() : null;
+    }
 }

package/server/src/Listeners/HandleDeliveryCompletion.php

@@ -36,12 +36,22 @@ class HandleDeliveryCompletion implements ShouldQueue
         $companyUuid = $order->company_uuid;
 
         // Only re-allocate if the setting is enabled for this company
-        if (!Setting::lookup('fleetops.auto_reallocate_on_complete', false)) {
+        if (!$this->autoReallocateOnCompleteEnabled()) {
             return;
         }
 
         // Dispatch the allocation job asynchronously so it does not block
         // the order completion response.
+        $this->dispatchAllocationJob($companyUuid);
+    }
+
+    protected function autoReallocateOnCompleteEnabled(): bool
+    {
+        return Setting::lookup('fleetops.auto_reallocate_on_complete', false);
+    }
+
+    protected function dispatchAllocationJob(?string $companyUuid): void
+    {
         ProcessAllocationJob::dispatch($companyUuid);
     }
 }

package/server/src/Listeners/HandleGeofenceDwelled.php

@@ -34,7 +34,7 @@ class HandleGeofenceDwelled implements ShouldQueue
         $order   = $driver?->getCurrentOrder();
         $subject = $event->subjectType === 'vehicle' ? $vehicle : $driver;
 
-        GeofenceEventLog::create([
+        $this->createLog([
             'uuid'                   => Str::uuid()->toString(),
             'company_uuid'           => $event->getCompanyUuid(),
             'driver_uuid'            => $driver?->uuid,
@@ -53,4 +53,9 @@ class HandleGeofenceDwelled implements ShouldQueue
             'occurred_at'            => $event->timestamp,
         ]);
     }
+
+    protected function createLog(array $attributes): GeofenceEventLog
+    {
+        return GeofenceEventLog::create($attributes);
+    }
 }

package/server/src/Listeners/HandleGeofenceEntered.php

@@ -3,6 +3,7 @@
 namespace Fleetbase\FleetOps\Listeners;
 
 use Fleetbase\FleetOps\Events\GeofenceEntered;
+use Fleetbase\FleetOps\Flow\Activity;
 use Fleetbase\FleetOps\Models\GeofenceEventLog;
 use Fleetbase\FleetOps\Models\Order;
 use Fleetbase\FleetOps\Notifications\DriverArrivedAtGeofence;
@@ -140,10 +141,11 @@ class HandleGeofenceEntered implements ShouldQueue
         try {
             $order->setStatus('arrived');
             $order->createActivity(
-                [
+                new Activity([
                     'status'  => 'arrived',
+                    'code'    => 'arrived',
                     'details' => sprintf('Driver entered destination geofence "%s".', $geofence->name),
-                ],
+                ]),
                 $event->location
             );
         } catch (\Throwable $e) {

package/server/src/Listeners/HandleGeofenceExited.php

@@ -34,7 +34,7 @@ class HandleGeofenceExited implements ShouldQueue
         $order   = $driver?->getCurrentOrder();
         $subject = $event->subjectType === 'vehicle' ? $vehicle : $driver;
 
-        GeofenceEventLog::create([
+        $this->createLog([
             'uuid'                   => Str::uuid()->toString(),
             'company_uuid'           => $event->getCompanyUuid(),
             'driver_uuid'            => $driver?->uuid,
@@ -53,4 +53,9 @@ class HandleGeofenceExited implements ShouldQueue
             'occurred_at'            => $event->timestamp,
         ]);
     }
+
+    protected function createLog(array $attributes): GeofenceEventLog
+    {
+        return GeofenceEventLog::create($attributes);
+    }
 }

package/server/src/Listeners/HandleOrderCanceled.php

@@ -24,17 +24,32 @@ class HandleOrderCanceled implements ShouldQueue
         /** @var \Fleetbase\FleetOps\Models\Order $order */
         $order    = $event->getModelRecord();
         if ($order->isIntegratedVendorOrder()) {
-            $order->facilitator->provider()->callback('onCanceled', $order);
+            $this->notifyIntegratedVendorCanceled($order);
         }
 
         // Notify driver assigned order was canceled
         if ($order->hasDriverAssigned) {
             /** @var \Fleetbase\Models\Driver */
-            $driver = Driver::where('uuid', $order->driver_assigned_uuid)->withoutGlobalScopes()->first();
+            $driver = $this->findAssignedDriver($order);
 
             if ($driver) {
-                $driver->notify(new OrderCanceledNotification($order));
+                $this->notifyAssignedDriver($driver, $order);
             }
         }
     }
+
+    protected function notifyIntegratedVendorCanceled($order): void
+    {
+        $order->facilitator->provider()->callback('onCanceled', $order);
+    }
+
+    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 OrderCanceledNotification($order));
+    }
 }

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);
     }
 }