@fleetbase/fleetops-engine 0.6.53 → 0.6.55

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

@@ -0,0 +1,89 @@
+<?php
+
+namespace Fleetbase\FleetOps\Console\Commands;
+
+use Fleetbase\FleetOps\Jobs\SyncTelematicDevicesJob;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Support\Telematics\TelematicProviderRegistry;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Cache;
+
+class SyncTelematics extends Command
+{
+    protected $signature = 'fleetops:sync-telematics
+        {--provider=* : Limit polling to one or more provider keys}
+        {--limit=500 : Maximum provider units to fetch per page}
+        {--exclude-webhook-providers : Skip providers that support webhooks}
+        {--no-lock : Skip process locking}';
+
+    protected $description = 'Poll active telematics providers for device snapshots and positional telemetry.';
+
+    public function handle(TelematicProviderRegistry $registry): int
+    {
+        $useLock = !$this->option('no-lock');
+        $lock    = null;
+
+        if ($useLock) {
+            $lock = Cache::lock('fleetops:sync-telematics', 600);
+            if (!$lock->get()) {
+                $this->warn('Another telematics sync run appears to be in progress.');
+
+                return self::SUCCESS;
+            }
+        }
+
+        try {
+            $providerKeys = $this->pollableProviderKeys($registry);
+            if (empty($providerKeys)) {
+                $this->info('No pollable telematics providers found.');
+
+                return self::SUCCESS;
+            }
+
+            $query = Telematic::withoutGlobalScopes()
+                ->whereIn('provider', $providerKeys)
+                ->whereIn('status', ['active', 'connected'])
+                ->whereNotNull('company_uuid');
+
+            $queued = 0;
+            $query->orderBy('id')->chunkById(100, function ($telematics) use (&$queued) {
+                foreach ($telematics as $telematic) {
+                    SyncTelematicDevicesJob::dispatch($telematic, [
+                        'limit' => (int) $this->option('limit'),
+                    ]);
+                    $queued++;
+                }
+            });
+
+            $this->info("Queued {$queued} telematics sync job(s).");
+
+            return self::SUCCESS;
+        } finally {
+            if ($lock) {
+                $lock->release();
+            }
+        }
+    }
+
+    protected function pollableProviderKeys(TelematicProviderRegistry $registry): array
+    {
+        $requestedProviders      = array_filter((array) $this->option('provider'));
+        $excludeWebhookProviders = (bool) $this->option('exclude-webhook-providers');
+
+        return $registry->all()
+            ->filter(function ($descriptor) use ($requestedProviders, $excludeWebhookProviders) {
+                if (!empty($requestedProviders) && !in_array($descriptor->key, $requestedProviders, true)) {
+                    return false;
+                }
+
+                if (!$descriptor->supportsDiscovery) {
+                    return false;
+                }
+
+                return !$excludeWebhookProviders || !$descriptor->supportsWebhooks;
+            })
+            ->keys()
+            ->values()
+            ->all();
+    }
+}

package/server/src/Exceptions/TelematicProviderException.php

@@ -2,8 +2,6 @@
 
 namespace Fleetbase\FleetOps\Exceptions;
 
-use Exception;
-
 /**
  * Class TelematicProviderException.
  *
@@ -11,4 +9,17 @@ use Exception;
  */
 class TelematicProviderException extends \Exception
 {
+    protected array $context;
+
+    public function __construct(string $message = '', array $context = [], int $code = 0, ?\Throwable $previous = null)
+    {
+        parent::__construct($message, $code, $previous);
+
+        $this->context = $context;
+    }
+
+    public function context(): array
+    {
+        return $this->context;
+    }
 }

package/server/src/Http/Controllers/Api/v1/OrderController.php

@@ -3,7 +3,6 @@
 namespace Fleetbase\FleetOps\Http\Controllers\Api\v1;
 
 use Fleetbase\FleetOps\Events\OrderDispatchFailed;
-use Fleetbase\FleetOps\Events\OrderReady;
 use Fleetbase\FleetOps\Events\OrderStarted;
 use Fleetbase\FleetOps\Exceptions\CustomerUserConflictException;
 use Fleetbase\FleetOps\Exceptions\UserAlreadyExistsException;
@@ -14,6 +13,7 @@ use Fleetbase\FleetOps\Http\Requests\UpdateOrderRequest;
 use Fleetbase\FleetOps\Http\Resources\v1\DeletedResource;
 use Fleetbase\FleetOps\Http\Resources\v1\Order as OrderResource;
 use Fleetbase\FleetOps\Http\Resources\v1\Proof as ProofResource;
+use Fleetbase\FleetOps\Jobs\FinalizeApiOrderCreation;
 use Fleetbase\FleetOps\Models\Contact;
 use Fleetbase\FleetOps\Models\Driver;
 use Fleetbase\FleetOps\Models\Entity;
@@ -335,26 +335,11 @@ class OrderController extends Controller
         // Determine if order should be dispatched on creation
         $shouldDispatch = $request->boolean('dispatch') && $integratedVendorOrder === null;
 
-        // Run background processes on queue
-        dispatch(function () use ($order, $serviceQuote, $shouldDispatch): void {
-            // notify driver if assigned
-            $order->notifyDriverAssigned();
-
-            // set driving distance and time
-            $order->setPreliminaryDistanceAndTime();
-
-            // if service quote attached purchase
-            $order->purchaseServiceQuote($serviceQuote);
-
-            // dispatch if flagged true
-            if ($shouldDispatch) {
-                $order->dispatchWithActivity();
-            }
-
-            // Trigger order created event
-            event(new OrderReady($order));
-        })
-        ->afterCommit();
+        FinalizeApiOrderCreation::dispatch(
+            $order->uuid,
+            $serviceQuote instanceof ServiceQuote ? $serviceQuote->uuid : null,
+            $shouldDispatch
+        )->afterCommit();
 
         // response the driver resource
         return new OrderResource($order);

package/server/src/Http/Controllers/Internal/v1/DeviceController.php

@@ -5,6 +5,7 @@ namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
 use Fleetbase\FleetOps\Http\Controllers\FleetOpsController;
 use Fleetbase\FleetOps\Models\Device;
 use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\Utils;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Log;
@@ -27,6 +28,7 @@ class DeviceController extends FleetOpsController
     public static function onQueryRecord($query, $request): void
     {
         $query->with(['telematic', 'warranty', 'attachable']);
+        $query->withCount('sensors');
 
         if ($request->filled('attachment_state')) {
             match ($request->input('attachment_state')) {
@@ -37,12 +39,41 @@ class DeviceController extends FleetOpsController
         }
 
         if ($request->filled('vehicle')) {
-            $query->where('attachable_uuid', $request->input('vehicle'));
+            static::applyVehicleFilter($query, $request->input('vehicle'));
         }
 
         if ($request->filled('device_id')) {
             $query->where('device_id', 'like', '%' . $request->input('device_id') . '%');
         }
+
+        if ($request->filled('serial_number')) {
+            $query->where('serial_number', 'like', '%' . $request->input('serial_number') . '%');
+        }
+
+        if ($request->filled('connection_status')) {
+            $statuses = Utils::arrayFrom($request->input('connection_status'));
+
+            $query->where(function ($statusQuery) use ($statuses) {
+                foreach ($statuses as $status) {
+                    match ($status) {
+                        'online'           => $statusQuery->orWhere('last_online_at', '>=', now()->subMinutes(10)),
+                        'recently_offline' => $statusQuery->orWhereBetween('last_online_at', [now()->subMinutes(60), now()->subMinutes(10)]),
+                        'offline'          => $statusQuery->orWhereBetween('last_online_at', [now()->subDay(), now()->subMinutes(60)]),
+                        'long_offline'     => $statusQuery->orWhere('last_online_at', '<', now()->subDay()),
+                        'never_connected'  => $statusQuery->orWhereNull('last_online_at'),
+                        default            => null,
+                    };
+                }
+            });
+        }
+
+        if ($request->filled('last_online_at')) {
+            static::applyDateFilter($query, 'last_online_at', $request->input('last_online_at'));
+        }
+
+        if ($request->filled('updated_at')) {
+            static::applyDateFilter($query, 'updated_at', $request->input('updated_at'));
+        }
     }
 
     /**
@@ -54,6 +85,7 @@ class DeviceController extends FleetOpsController
     public static function onFindRecord($query, $request): void
     {
         $query->with(['telematic', 'warranty', 'attachable']);
+        $query->withCount('sensors');
     }
 
     /**
@@ -146,6 +178,28 @@ class DeviceController extends FleetOpsController
             ->first();
     }
 
+    protected static function applyDateFilter($query, string $column, string|array $value): void
+    {
+        $dates = Utils::dateRange($value);
+
+        if (is_array($dates)) {
+            $query->whereBetween($column, $dates);
+        } else {
+            $query->whereDate($column, $dates);
+        }
+    }
+
+    protected static function applyVehicleFilter($query, string $vehicle): void
+    {
+        $query->where(function ($vehicleQuery) use ($vehicle) {
+            $vehicleQuery->where('attachable_uuid', $vehicle)
+                ->orWhereIn('attachable_uuid', Vehicle::query()
+                    ->where('company_uuid', session('company'))
+                    ->where('public_id', $vehicle)
+                    ->pluck('uuid'));
+        });
+    }
+
     protected function logDeviceAttachmentLookupFailure(string $action, string $missingResource, string $deviceId, ?string $vehicleId): void
     {
         Log::warning('Device attachment lookup failed', [

package/server/src/Http/Controllers/Internal/v1/DeviceEventController.php

@@ -4,6 +4,7 @@ namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
 
 use Fleetbase\FleetOps\Http\Controllers\FleetOpsController;
 use Fleetbase\FleetOps\Models\DeviceEvent;
+use Fleetbase\FleetOps\Support\Utils;
 use Illuminate\Http\JsonResponse;
 
 class DeviceEventController extends FleetOpsController
@@ -23,7 +24,7 @@ class DeviceEventController extends FleetOpsController
      */
     public static function onQueryRecord($query, $request): void
     {
-        $query->with(['device']);
+        $query->with(['device.telematic']);
 
         if ($request->filled('telematic')) {
             $query->whereHas('device', function ($deviceQuery) use ($request) {
@@ -32,11 +33,21 @@ class DeviceEventController extends FleetOpsController
         }
 
         if ($request->filled('processed')) {
-            match ($request->input('processed')) {
-                'processed'   => $query->whereNotNull('processed_at'),
-                'unprocessed' => $query->whereNull('processed_at'),
-                default       => null,
-            };
+            $states = Utils::arrayFrom($request->input('processed'));
+
+            if (!$states) {
+                return;
+            }
+
+            $query->where(function ($query) use ($states) {
+                foreach ($states as $state) {
+                    match ($state) {
+                        'processed'   => $query->orWhereNotNull('processed_at'),
+                        'unprocessed' => $query->orWhereNull('processed_at'),
+                        default       => null,
+                    };
+                }
+            });
         }
     }
 

package/server/src/Http/Controllers/Internal/v1/FleetController.php

@@ -11,6 +11,7 @@ use Fleetbase\FleetOps\Models\Fleet;
 use Fleetbase\FleetOps\Models\FleetDriver;
 use Fleetbase\FleetOps\Models\FleetVehicle;
 use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\LiveCacheService;
 use Fleetbase\Http\Requests\ExportRequest;
 use Fleetbase\Http\Requests\ImportRequest;
 use Illuminate\Http\Request;
@@ -121,6 +122,8 @@ class FleetController extends FleetOpsController
             'driver_uuid' => $driver->uuid,
         ])->delete();
 
+        LiveCacheService::invalidate('operations-monitor');
+
         return response()->json([
             'status'  => 'ok',
             'deleted' => $deleted,
@@ -153,6 +156,8 @@ class FleetController extends FleetOpsController
             ]);
         }
 
+        LiveCacheService::invalidate('operations-monitor');
+
         return response()->json([
             'status' => 'ok',
             'exists' => $exists,
@@ -178,6 +183,8 @@ class FleetController extends FleetOpsController
             'vehicle_uuid' => $vehicle->uuid,
         ])->delete();
 
+        LiveCacheService::invalidate('operations-monitor');
+
         return response()->json([
             'status'  => 'ok',
             'deleted' => $deleted,
@@ -210,6 +217,8 @@ class FleetController extends FleetOpsController
             ]);
         }
 
+        LiveCacheService::invalidate('operations-monitor');
+
         return response()->json([
             'status' => 'ok',
             'exists' => $exists,

package/server/src/Http/Controllers/Internal/v1/LiveController.php

@@ -8,12 +8,16 @@ use Fleetbase\FleetOps\Http\Resources\v1\Index\Order as OrderIndexResource;
 use Fleetbase\FleetOps\Http\Resources\v1\Index\Place as PlaceIndexResource;
 use Fleetbase\FleetOps\Http\Resources\v1\Index\Vehicle as VehicleIndexResource;
 use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Fleet;
+use Fleetbase\FleetOps\Models\FleetDriver;
+use Fleetbase\FleetOps\Models\FleetVehicle;
 use Fleetbase\FleetOps\Models\Order;
 use Fleetbase\FleetOps\Models\Place;
 use Fleetbase\FleetOps\Models\Route;
 use Fleetbase\FleetOps\Models\Vehicle;
 use Fleetbase\FleetOps\Support\LiveCacheService;
 use Fleetbase\FleetOps\Support\LiveOrderQuery;
+use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\Http\Controllers\Controller;
 use Illuminate\Http\Request;
 
@@ -144,7 +148,7 @@ class LiveController extends Controller
 
         return LiveCacheService::remember('drivers', $cacheParams, function () use ($bounds, $limit) {
             $query = Driver::where(['company_uuid' => session('company')])
-                ->with(['user', 'vehicle'])
+                ->with(['user', 'vehicle.devices'])
                 ->applyDirectivesForPermissions('fleet-ops list driver');
 
             $this->applyLiveLocationGuards($query);
@@ -186,6 +190,179 @@ class LiveController extends Controller
         });
     }
 
+    /**
+     * Get the complete resource snapshot used by the operations sidebar monitor.
+     *
+     * @return array
+     */
+    public function operationsMonitor()
+    {
+        return LiveCacheService::remember('operations-monitor', [], function () {
+            $drivers = Driver::where(['company_uuid' => session('company')])
+                ->with(['user', 'vehicle'])
+                ->applyDirectivesForPermissions('fleet-ops list driver')
+                ->orderBy('id')
+                ->get();
+
+            $vehicles = Vehicle::where(['company_uuid' => session('company')])
+                ->with(['driver'])
+                ->applyDirectivesForPermissions('fleet-ops list vehicle')
+                ->orderBy('id')
+                ->get();
+
+            $fleets = Fleet::where(['company_uuid' => session('company')])
+                ->applyDirectivesForPermissions('fleet-ops list fleet')
+                ->orderBy('name')
+                ->orderBy('id')
+                ->get();
+
+            $driverIdsByUuid    = $drivers->pluck('uuid', 'uuid');
+            $vehicleIdsByUuid   = $vehicles->pluck('uuid', 'uuid');
+            $onlineDriverUuids  = $drivers->where('online', true)->pluck('uuid')->flip();
+            $onlineVehicleUuids = $vehicles->where('online', true)->pluck('uuid')->flip();
+            $fleetUuids         = $fleets->pluck('uuid');
+
+            $driverMemberships = FleetDriver::whereIn('fleet_uuid', $fleetUuids)
+                ->whereIn('driver_uuid', $driverIdsByUuid->keys())
+                ->get()
+                ->groupBy('fleet_uuid');
+
+            $vehicleMemberships = FleetVehicle::whereIn('fleet_uuid', $fleetUuids)
+                ->whereIn('vehicle_uuid', $vehicleIdsByUuid->keys())
+                ->get()
+                ->groupBy('fleet_uuid');
+
+            $fleetNodes = $fleets->mapWithKeys(function (Fleet $fleet) use ($driverMemberships, $vehicleMemberships, $driverIdsByUuid, $vehicleIdsByUuid, $onlineDriverUuids, $onlineVehicleUuids) {
+                $fleetDriverUuids  = $driverMemberships->get($fleet->uuid, collect())->pluck('driver_uuid')->unique()->values();
+                $fleetVehicleUuids = $vehicleMemberships->get($fleet->uuid, collect())->pluck('vehicle_uuid')->unique()->values();
+                $driverIds         = $fleetDriverUuids->map(fn ($uuid) => $driverIdsByUuid->get($uuid))->filter()->values();
+                $vehicleIds        = $fleetVehicleUuids->map(fn ($uuid) => $vehicleIdsByUuid->get($uuid))->filter()->values();
+
+                return [
+                    $fleet->uuid => [
+                        'id'                    => $fleet->uuid,
+                        'uuid'                  => $fleet->uuid,
+                        'public_id'             => $fleet->public_id,
+                        'name'                  => $fleet->name,
+                        'task'                  => $fleet->task,
+                        'status'                => $fleet->status,
+                        'slug'                  => $fleet->slug,
+                        'parent_fleet_uuid'     => $fleet->parent_fleet_uuid,
+                        'drivers_count'         => $driverIds->count(),
+                        'drivers_online_count'  => $fleetDriverUuids->filter(fn ($uuid) => $onlineDriverUuids->has($uuid))->count(),
+                        'vehicles_count'        => $vehicleIds->count(),
+                        'vehicles_online_count' => $fleetVehicleUuids->filter(fn ($uuid) => $onlineVehicleUuids->has($uuid))->count(),
+                        'driver_ids'            => $driverIds->all(),
+                        'vehicle_ids'           => $vehicleIds->all(),
+                        'subfleets'             => [],
+                        'updated_at'            => $fleet->updated_at,
+                        'created_at'            => $fleet->created_at,
+                    ],
+                ];
+            });
+
+            return [
+                'drivers'  => $drivers->map(fn (Driver $driver) => $this->serializeMonitorDriver($driver))->values()->all(),
+                'vehicles' => $vehicles->map(fn (Vehicle $vehicle) => $this->serializeMonitorVehicle($vehicle))->values()->all(),
+                'fleets'   => $this->buildOperationsMonitorFleetTree($fleetNodes),
+                'meta'     => [
+                    'generated_at'   => now()->toISOString(),
+                    'ttl'            => LiveCacheService::DEFAULT_TTL,
+                    'drivers_count'  => $drivers->count(),
+                    'vehicles_count' => $vehicles->count(),
+                    'fleets_count'   => $fleets->count(),
+                ],
+            ];
+        });
+    }
+
+    protected function serializeMonitorDriver(Driver $driver): array
+    {
+        return [
+            'id'                    => $driver->uuid,
+            'uuid'                  => $driver->uuid,
+            'public_id'             => $driver->public_id,
+            'company_uuid'          => $driver->company_uuid,
+            'user_uuid'             => $driver->user_uuid,
+            'vehicle_uuid'          => $driver->vehicle_uuid,
+            'vendor_uuid'           => $driver->vendor_uuid,
+            'current_job_uuid'      => $driver->current_job_uuid,
+            'name'                  => $driver->name,
+            'email'                 => $driver->email,
+            'phone'                 => $driver->phone,
+            'photo_url'             => $driver->photo_url,
+            'avatar_url'            => $driver->photo_url,
+            'vehicle_name'          => $driver->vehicle_name,
+            'status'                => $driver->status,
+            'location'              => Utils::castPoint($driver->location),
+            'heading'               => (int) data_get($driver, 'heading', 0),
+            'altitude'              => (int) data_get($driver, 'altitude', 0),
+            'speed'                 => (int) data_get($driver, 'speed', 0),
+            'online'                => (bool) data_get($driver, 'online', false),
+            'assigned_orders_count' => null,
+            'meta'                  => [
+                '_index_resource' => true,
+            ],
+            'updated_at'            => $driver->updated_at,
+            'created_at'            => $driver->created_at,
+        ];
+    }
+
+    protected function serializeMonitorVehicle(Vehicle $vehicle): array
+    {
+        return [
+            'id'                    => $vehicle->uuid,
+            'uuid'                  => $vehicle->uuid,
+            'public_id'             => $vehicle->public_id,
+            'company_uuid'          => $vehicle->company_uuid,
+            'vendor_uuid'           => $vehicle->vendor_uuid,
+            'photo_uuid'            => $vehicle->photo_uuid,
+            'internal_id'           => $vehicle->internal_id,
+            'name'                  => $vehicle->name,
+            'display_name'          => $vehicle->display_name,
+            'driver_name'           => $vehicle->driver_name,
+            'plate_number'          => $vehicle->plate_number,
+            'serial_number'         => $vehicle->serial_number,
+            'fuel_card_number'      => $vehicle->fuel_card_number,
+            'vin'                   => $vehicle->vin,
+            'make'                  => $vehicle->make,
+            'model'                 => $vehicle->model,
+            'year'                  => $vehicle->year,
+            'photo_url'             => $vehicle->photo_url,
+            'avatar_url'            => $vehicle->avatar_url,
+            'status'                => $vehicle->status,
+            'location'              => Utils::castPoint($vehicle->location),
+            'heading'               => (int) data_get($vehicle, 'heading', 0),
+            'altitude'              => (int) data_get($vehicle, 'altitude', 0),
+            'speed'                 => (int) data_get($vehicle, 'speed', 0),
+            'online'                => (bool) data_get($vehicle, 'online', false),
+            'assigned_orders_count' => null,
+            'meta'                  => [
+                '_index_resource' => true,
+            ],
+            'updated_at'            => $vehicle->updated_at,
+            'created_at'            => $vehicle->created_at,
+        ];
+    }
+
+    protected function buildOperationsMonitorFleetTree($fleetNodes): array
+    {
+        $nodes = $fleetNodes->map(fn ($node) => $node)->all();
+
+        foreach ($nodes as $uuid => $node) {
+            $parentUuid = data_get($node, 'parent_fleet_uuid');
+
+            if ($parentUuid && isset($nodes[$parentUuid])) {
+                $nodes[$parentUuid]['subfleets'][] = &$nodes[$uuid];
+            }
+        }
+
+        return collect($nodes)
+            ->filter(fn ($node) => empty(data_get($node, 'parent_fleet_uuid')) || !isset($nodes[data_get($node, 'parent_fleet_uuid')]))
+            ->values()
+            ->all();
+    }
+
     /**
      * Get places based on filters for the current company.
      *

package/server/src/Http/Controllers/Internal/v1/MaintenanceScheduleController.php

@@ -102,6 +102,7 @@ class MaintenanceScheduleController extends FleetOpsController
             'company_uuid'    => $schedule->company_uuid,
             'schedule_uuid'   => $schedule->uuid,
             'subject'         => $schedule->name,
+            'category'        => 'preventive_maintenance',
             'status'          => 'open',
             'priority'        => $schedule->default_priority ?? 'normal',
             'target_type'     => $schedule->subject_type,

package/server/src/Http/Controllers/Internal/v1/OrderController.php

@@ -6,7 +6,6 @@ use Fleetbase\Exceptions\FleetbaseRequestValidationException;
 use Fleetbase\FleetOps\Events\EntityActivityChanged;
 use Fleetbase\FleetOps\Events\EntityCompleted;
 use Fleetbase\FleetOps\Events\OrderDispatchFailed;
-use Fleetbase\FleetOps\Events\OrderReady;
 use Fleetbase\FleetOps\Events\OrderStarted;
 use Fleetbase\FleetOps\Events\WaypointActivityChanged;
 use Fleetbase\FleetOps\Events\WaypointCompleted;
@@ -20,6 +19,8 @@ use Fleetbase\FleetOps\Http\Resources\v1\Index\Order as OrderIndexResource;
 use Fleetbase\FleetOps\Http\Resources\v1\Order as OrderResource;
 use Fleetbase\FleetOps\Http\Resources\v1\Proof as ProofResource;
 use Fleetbase\FleetOps\Imports\OrdersImport;
+use Fleetbase\FleetOps\Jobs\FinalizeInternalOrderCreation;
+use Fleetbase\FleetOps\Jobs\NotifyBulkAssignedDriver;
 use Fleetbase\FleetOps\Models\Driver;
 use Fleetbase\FleetOps\Models\Entity;
 use Fleetbase\FleetOps\Models\Order;
@@ -210,14 +211,7 @@ class OrderController extends FleetOpsController
                     // if service quote attached purchase
                     $order->purchaseServiceQuote($serviceQuote);
 
-                    // Run background processes on queue
-                    dispatch(function () use ($order): void {
-                        // notify driver if assigned
-                        $order->notifyDriverAssigned();
-
-                        // Trigger order created event
-                        event(new OrderReady($order));
-                    })->afterCommit();
+                    FinalizeInternalOrderCreation::dispatch($order->uuid)->afterCommit();
                 }
             );
 
@@ -527,29 +521,7 @@ class OrderController extends FleetOpsController
 
         // Queue Per‑Order Notifications
         if (!$request->boolean('silent')) {
-            dispatch(function () use ($orderUuids, $driver): void {
-                // Re‑hydrate Driver To Avoid Serializing The Full Model
-                $driver = Driver::whereUuid($driver->uuid)->first();
-
-                // Stream Orders To Keep Memory Footprint Low
-                Order::whereIn('uuid', $orderUuids)
-                    ->cursor()
-                    ->each(function (Order $order) use ($driver): void {
-                        // Synchronize In‑Memory Model
-                        $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()]
-                            );
-                        }
-                    });
-            })
-            ->afterCommit();
+            NotifyBulkAssignedDriver::dispatch($orderUuids->all(), $driver->uuid)->afterCommit();
         }
 
         return response()->json([

package/server/src/Http/Controllers/Internal/v1/SearchController.php

@@ -332,9 +332,9 @@ class SearchController extends Controller
 
     private function searchWorkOrders(string $query, int $limit): Collection
     {
-        return $this->searchGeneric(WorkOrder::class, ['code', 'subject', 'instructions', 'status', 'priority', 'public_id', 'uuid'], $query, $limit, fn (WorkOrder $workOrder) => [
+        return $this->searchGeneric(WorkOrder::class, ['code', 'subject', 'category', 'instructions', 'status', 'priority', 'public_id', 'uuid'], $query, $limit, fn (WorkOrder $workOrder) => [
             'label'       => $workOrder->code ?: $workOrder->subject,
-            'description' => $this->description($workOrder->status, $workOrder->priority, $workOrder->subject),
+            'description' => $this->description($workOrder->status, $workOrder->priority, $workOrder->category ?: $workOrder->subject),
             'icon'        => 'clipboard-list',
             'type'        => 'Work Order',
             'route'       => 'console.fleet-ops.maintenance.work-orders.index.details',