@fleetbase/fleetops-engine 0.6.52 → 0.6.53

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

@@ -0,0 +1,506 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
+
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\DeviceEvent;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\Fleet;
+use Fleetbase\FleetOps\Models\FuelProviderConnection;
+use Fleetbase\FleetOps\Models\FuelProviderTransaction;
+use Fleetbase\FleetOps\Models\FuelReport;
+use Fleetbase\FleetOps\Models\Issue;
+use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\MaintenanceSchedule;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\OrderConfig;
+use Fleetbase\FleetOps\Models\Part;
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\FleetOps\Models\Sensor;
+use Fleetbase\FleetOps\Models\ServiceRate;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Vendor;
+use Fleetbase\FleetOps\Models\WorkOrder;
+use Fleetbase\Http\Controllers\Controller;
+use Fleetbase\Support\Auth;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Str;
+
+class SearchController extends Controller
+{
+    private const SEARCH_TYPES = [
+        'orders',
+        'drivers',
+        'vehicles',
+        'fleets',
+        'vendors',
+        'contacts',
+        'places',
+        'issues',
+        'fuel_reports',
+        'fuel_transactions',
+        'maintenance_schedules',
+        'work_orders',
+        'maintenances',
+        'equipment',
+        'parts',
+        'fuel_providers',
+        'telematics',
+        'devices',
+        'sensors',
+        'events',
+        'service_rates',
+        'order_configs',
+    ];
+
+    public function search(Request $request): JsonResponse
+    {
+        $query = trim((string) ($request->input('query') ?: $request->input('q')));
+        $limit = max(1, min((int) $request->input('limit', 12), 24));
+
+        if ($query === '') {
+            return response()->json(['results' => []]);
+        }
+
+        $types        = $this->requestedTypes($request);
+        $perTypeLimit = max(1, (int) ceil($limit / max(count($types), 1)));
+        $results      = collect();
+
+        foreach ($types as $type) {
+            if (!$this->canSearchType($type)) {
+                continue;
+            }
+
+            $results = $results->merge($this->searchType($type, $query, $perTypeLimit));
+        }
+
+        return response()->json([
+            'results' => $results->take($limit)->values(),
+        ]);
+    }
+
+    private function requestedTypes(Request $request): array
+    {
+        $types = $request->input('types', self::SEARCH_TYPES);
+
+        if (is_string($types)) {
+            $types = array_filter(array_map('trim', explode(',', $types)));
+        }
+
+        if (!is_array($types)) {
+            return self::SEARCH_TYPES;
+        }
+
+        $types = array_values(array_intersect($types, self::SEARCH_TYPES));
+
+        return empty($types) ? self::SEARCH_TYPES : $types;
+    }
+
+    private function canSearchType(string $type): bool
+    {
+        $permissions = [
+            'orders'                => 'fleet-ops see order',
+            'drivers'               => 'fleet-ops see driver',
+            'vehicles'              => 'fleet-ops see vehicle',
+            'fleets'                => 'fleet-ops see fleet',
+            'vendors'               => 'fleet-ops see vendor',
+            'contacts'              => 'fleet-ops see contact',
+            'places'                => 'fleet-ops see place',
+            'issues'                => 'fleet-ops see issue',
+            'fuel_reports'          => 'fleet-ops see fuel-report',
+            'fuel_transactions'     => 'fleet-ops see fuel-report',
+            'maintenance_schedules' => 'fleet-ops see maintenance-schedule',
+            'work_orders'           => 'fleet-ops see work-order',
+            'maintenances'          => 'fleet-ops see maintenance',
+            'equipment'             => 'fleet-ops see equipment',
+            'parts'                 => 'fleet-ops see part',
+            'fuel_providers'        => 'fleet-ops see fuel-report',
+            'telematics'            => 'fleet-ops see telematic',
+            'devices'               => 'fleet-ops see device',
+            'sensors'               => 'fleet-ops see sensor',
+            'events'                => 'fleet-ops see device-event',
+            'service_rates'         => 'fleet-ops see service-rate',
+            'order_configs'         => 'fleet-ops see order-config',
+        ];
+
+        $user = Auth::getUserFromSession();
+
+        if ($user?->isAdmin()) {
+            return true;
+        }
+
+        return Auth::can($permissions[$type]);
+    }
+
+    private function searchType(string $type, string $query, int $limit): Collection
+    {
+        return match ($type) {
+            'orders'                => $this->searchOrders($query, $limit),
+            'drivers'               => $this->searchDrivers($query, $limit),
+            'vehicles'              => $this->searchVehicles($query, $limit),
+            'fleets'                => $this->searchFleets($query, $limit),
+            'vendors'               => $this->searchVendors($query, $limit),
+            'contacts'              => $this->searchContacts($query, $limit),
+            'places'                => $this->searchPlaces($query, $limit),
+            'issues'                => $this->searchIssues($query, $limit),
+            'fuel_reports'          => $this->searchFuelReports($query, $limit),
+            'fuel_transactions'     => $this->searchFuelTransactions($query, $limit),
+            'maintenance_schedules' => $this->searchMaintenanceSchedules($query, $limit),
+            'work_orders'           => $this->searchWorkOrders($query, $limit),
+            'maintenances'          => $this->searchMaintenances($query, $limit),
+            'equipment'             => $this->searchEquipment($query, $limit),
+            'parts'                 => $this->searchParts($query, $limit),
+            'fuel_providers'        => $this->searchFuelProviders($query, $limit),
+            'telematics'            => $this->searchTelematics($query, $limit),
+            'devices'               => $this->searchDevices($query, $limit),
+            'sensors'               => $this->searchSensors($query, $limit),
+            'events'                => $this->searchEvents($query, $limit),
+            'service_rates'         => $this->searchServiceRates($query, $limit),
+            'order_configs'         => $this->searchOrderConfigs($query, $limit),
+            default                 => collect(),
+        };
+    }
+
+    private function searchOrders(string $query, int $limit): Collection
+    {
+        return Order::with('trackingNumber')
+            ->where('company_uuid', session('company'))
+            ->where(function (Builder $builder) use ($query) {
+                $this->whereLike($builder, ['public_id', 'internal_id', 'uuid', 'status', 'type'], $query);
+                $builder->orWhereHas('trackingNumber', function (Builder $trackingNumberBuilder) use ($query) {
+                    $this->whereLike($trackingNumberBuilder, ['tracking_number', 'barcode'], $query);
+                });
+            })
+            ->limit($limit)
+            ->get()
+            ->map(fn (Order $order) => [
+                'label'       => $order->tracking ?: $order->public_id ?: $order->internal_id,
+                'description' => $this->description($order->status, $order->type, $order->public_id, $order->internal_id),
+                'icon'        => 'map-location-dot',
+                'type'        => 'Order',
+                'route'       => 'console.fleet-ops.operations.orders.index.details',
+                'models'      => [$this->routeModel($order)],
+                'breadcrumb'  => 'Fleet-Ops > Operations > Orders',
+            ]);
+    }
+
+    private function searchDrivers(string $query, int $limit): Collection
+    {
+        return Driver::with('user')
+            ->where('company_uuid', session('company'))
+            ->where(function (Builder $builder) use ($query) {
+                $this->whereLike($builder, ['public_id', 'uuid', 'drivers_license_number', 'status'], $query);
+                $builder->orWhereHas('user', function (Builder $userBuilder) use ($query) {
+                    $this->whereLike($userBuilder, ['name', 'email', 'phone'], $query);
+                });
+            })
+            ->limit($limit)
+            ->get()
+            ->map(fn (Driver $driver) => [
+                'label'       => data_get($driver, 'user.name') ?: $driver->public_id,
+                'description' => $this->description(data_get($driver, 'user.email'), data_get($driver, 'user.phone'), $driver->drivers_license_number),
+                'icon'        => 'id-card',
+                'type'        => 'Driver',
+                'route'       => 'console.fleet-ops.management.drivers.index.details',
+                'models'      => [$this->routeModel($driver)],
+                'breadcrumb'  => 'Fleet-Ops > Resources > Drivers',
+            ]);
+    }
+
+    private function searchVehicles(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Vehicle::class, ['name', 'description', 'make', 'model', 'year', 'internal_id', 'plate_number', 'vin', 'serial_number', 'call_sign', 'public_id', 'uuid'], $query, $limit, fn (Vehicle $vehicle) => [
+            'label'       => $vehicle->display_name ?: $vehicle->name ?: $vehicle->public_id,
+            'description' => $this->description($vehicle->plate_number, $vehicle->vin, $vehicle->status),
+            'icon'        => 'truck',
+            'type'        => 'Vehicle',
+            'route'       => 'console.fleet-ops.management.vehicles.index.details',
+            'models'      => [$this->routeModel($vehicle)],
+            'breadcrumb'  => 'Fleet-Ops > Resources > Vehicles',
+        ]);
+    }
+
+    private function searchFleets(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Fleet::class, ['name', 'public_id', 'uuid'], $query, $limit, fn (Fleet $fleet) => [
+            'label'       => $fleet->name ?: $fleet->public_id,
+            'description' => $this->description($fleet->public_id),
+            'icon'        => 'user-group',
+            'type'        => 'Fleet',
+            'route'       => 'console.fleet-ops.management.fleets.index.details',
+            'models'      => [$this->routeModel($fleet)],
+            'breadcrumb'  => 'Fleet-Ops > Resources > Fleets',
+        ]);
+    }
+
+    private function searchVendors(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Vendor::class, ['name', 'email', 'phone', 'business_id', 'public_id', 'uuid'], $query, $limit, fn (Vendor $vendor) => [
+            'label'       => $vendor->name ?: $vendor->public_id,
+            'description' => $this->description($vendor->email, $vendor->phone, $vendor->business_id),
+            'icon'        => 'warehouse',
+            'type'        => 'Vendor',
+            'route'       => 'console.fleet-ops.management.vendors.index.details',
+            'models'      => [$this->routeModel($vendor)],
+            'breadcrumb'  => 'Fleet-Ops > Resources > Vendors',
+        ]);
+    }
+
+    private function searchContacts(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Contact::class, ['name', 'email', 'phone', 'public_id', 'uuid'], $query, $limit, fn (Contact $contact) => [
+            'label'       => $contact->name ?: $contact->public_id,
+            'description' => $this->description($contact->email, $contact->phone, $contact->type),
+            'icon'        => 'address-book',
+            'type'        => 'Contact',
+            'route'       => 'console.fleet-ops.management.contacts.index.details',
+            'models'      => [$this->routeModel($contact)],
+            'breadcrumb'  => 'Fleet-Ops > Resources > Contacts',
+        ]);
+    }
+
+    private function searchPlaces(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Place::class, ['name', 'street1', 'street2', 'country', 'province', 'district', 'city', 'postal_code', 'phone', 'public_id', 'uuid'], $query, $limit, fn (Place $place) => [
+            'label'       => $place->name ?: $place->public_id,
+            'description' => $this->description($place->street1, $place->city, $place->country),
+            'icon'        => 'location-dot',
+            'type'        => 'Place',
+            'route'       => 'console.fleet-ops.management.places.index.details',
+            'models'      => [$this->routeModel($place)],
+            'breadcrumb'  => 'Fleet-Ops > Resources > Places',
+        ]);
+    }
+
+    private function searchIssues(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Issue::class, ['public_id', 'uuid', 'issue_id', 'category', 'type', 'report', 'title', 'priority', 'status'], $query, $limit, fn (Issue $issue) => [
+            'label'       => $issue->title ?: $issue->public_id,
+            'description' => $this->description($issue->status, $issue->priority, $issue->type),
+            'icon'        => 'triangle-exclamation',
+            'type'        => 'Issue',
+            'route'       => 'console.fleet-ops.management.issues.index.details',
+            'models'      => [$this->routeModel($issue)],
+            'breadcrumb'  => 'Fleet-Ops > Resources > Issues',
+        ]);
+    }
+
+    private function searchFuelReports(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(FuelReport::class, ['public_id', 'uuid', 'report', 'status', 'currency'], $query, $limit, fn (FuelReport $report) => [
+            'label'       => $report->public_id ?: $report->report,
+            'description' => $this->description($report->status, $report->currency, $report->report),
+            'icon'        => 'gas-pump',
+            'type'        => 'Fuel Report',
+            'route'       => 'console.fleet-ops.management.fuel-reports.index.details',
+            'models'      => [$this->routeModel($report)],
+            'breadcrumb'  => 'Fleet-Ops > Resources > Fuel Reports',
+        ]);
+    }
+
+    private function searchFuelTransactions(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(FuelProviderTransaction::class, ['public_id', 'provider', 'provider_transaction_id', 'vehicle_card_id', 'internal_number', 'plate_number', 'vin', 'serial_number', 'call_sign', 'station_name', 'trip_number', 'sync_status'], $query, $limit, fn (FuelProviderTransaction $transaction) => [
+            'label'       => $transaction->public_id ?: $transaction->provider_transaction_id,
+            'description' => $this->description($transaction->provider, $transaction->station_name, $transaction->sync_status),
+            'icon'        => 'credit-card',
+            'type'        => 'Fuel Transaction',
+            'route'       => 'console.fleet-ops.management.fuel-transactions.index.details',
+            'models'      => [$this->routeModel($transaction)],
+            'breadcrumb'  => 'Fleet-Ops > Resources > Fuel Transactions',
+        ]);
+    }
+
+    private function searchMaintenanceSchedules(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(MaintenanceSchedule::class, ['name', 'type', 'status', 'public_id', 'uuid'], $query, $limit, fn (MaintenanceSchedule $schedule) => [
+            'label'       => $schedule->name ?: $schedule->public_id,
+            'description' => $this->description($schedule->type, $schedule->status),
+            'icon'        => 'calendar-alt',
+            'type'        => 'Maintenance Schedule',
+            'route'       => 'console.fleet-ops.maintenance.schedules.index.details',
+            'models'      => [$this->routeModel($schedule)],
+            'breadcrumb'  => 'Fleet-Ops > Maintenance > Schedules',
+        ]);
+    }
+
+    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) => [
+            'label'       => $workOrder->code ?: $workOrder->subject,
+            'description' => $this->description($workOrder->status, $workOrder->priority, $workOrder->subject),
+            'icon'        => 'clipboard-list',
+            'type'        => 'Work Order',
+            'route'       => 'console.fleet-ops.maintenance.work-orders.index.details',
+            'models'      => [$this->routeModel($workOrder)],
+            'breadcrumb'  => 'Fleet-Ops > Maintenance > Work Orders',
+        ]);
+    }
+
+    private function searchMaintenances(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Maintenance::class, ['summary', 'notes', 'type', 'status', 'priority', 'public_id', 'uuid'], $query, $limit, fn (Maintenance $maintenance) => [
+            'label'       => $maintenance->summary ?: $maintenance->public_id,
+            'description' => $this->description($maintenance->status, $maintenance->priority, $maintenance->type),
+            'icon'        => 'history',
+            'type'        => 'Maintenance',
+            'route'       => 'console.fleet-ops.maintenance.maintenances.index.details',
+            'models'      => [$this->routeModel($maintenance)],
+            'breadcrumb'  => 'Fleet-Ops > Maintenance > Maintenances',
+        ]);
+    }
+
+    private function searchEquipment(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Equipment::class, ['name', 'code', 'type', 'serial_number', 'manufacturer', 'model', 'public_id', 'uuid'], $query, $limit, fn (Equipment $equipment) => [
+            'label'       => $equipment->name ?: $equipment->code,
+            'description' => $this->description($equipment->type, $equipment->manufacturer, $equipment->model),
+            'icon'        => 'trailer',
+            'type'        => 'Equipment',
+            'route'       => 'console.fleet-ops.maintenance.equipment.index.details',
+            'models'      => [$this->routeModel($equipment)],
+            'breadcrumb'  => 'Fleet-Ops > Maintenance > Equipment',
+        ]);
+    }
+
+    private function searchParts(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Part::class, ['sku', 'name', 'manufacturer', 'model', 'serial_number', 'barcode', 'public_id', 'uuid'], $query, $limit, fn (Part $part) => [
+            'label'       => $part->name ?: $part->sku,
+            'description' => $this->description($part->sku, $part->manufacturer, $part->model),
+            'icon'        => 'cog',
+            'type'        => 'Part',
+            'route'       => 'console.fleet-ops.maintenance.parts.index.details',
+            'models'      => [$this->routeModel($part)],
+            'breadcrumb'  => 'Fleet-Ops > Maintenance > Parts',
+        ]);
+    }
+
+    private function searchFuelProviders(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(FuelProviderConnection::class, ['public_id', 'name', 'provider', 'status', 'environment', 'uuid'], $query, $limit, fn (FuelProviderConnection $connection) => [
+            'label'       => $connection->name ?: $connection->provider,
+            'description' => $this->description($connection->provider, $connection->status, $connection->environment),
+            'icon'        => 'gas-pump',
+            'type'        => 'Fuel Integration',
+            'route'       => 'console.fleet-ops.connectivity.fuel-providers.details',
+            'models'      => [$this->routeModel($connection)],
+            'breadcrumb'  => 'Fleet-Ops > Connectivity > Fuel Integrations',
+        ]);
+    }
+
+    private function searchTelematics(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Telematic::class, ['name', 'provider', 'model', 'serial_number', 'imei', 'public_id', 'uuid'], $query, $limit, fn (Telematic $telematic) => [
+            'label'       => $telematic->name ?: $telematic->provider,
+            'description' => $this->description($telematic->provider, $telematic->model, $telematic->serial_number),
+            'icon'        => 'satellite-dish',
+            'type'        => 'Telematic Provider',
+            'route'       => 'console.fleet-ops.connectivity.telematics.details',
+            'models'      => [$this->routeModel($telematic)],
+            'breadcrumb'  => 'Fleet-Ops > Connectivity > Telematics',
+        ]);
+    }
+
+    private function searchDevices(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Device::class, ['name', 'model', 'serial_number', 'manufacturer', 'device_id', 'internal_id', 'imei', 'public_id', 'uuid'], $query, $limit, fn (Device $device) => [
+            'label'       => $device->name ?: $device->device_id,
+            'description' => $this->description($device->manufacturer, $device->model, $device->serial_number),
+            'icon'        => 'hard-drive',
+            'type'        => 'Device',
+            'route'       => 'console.fleet-ops.connectivity.devices.index.details',
+            'models'      => [$this->routeModel($device)],
+            'breadcrumb'  => 'Fleet-Ops > Connectivity > Devices',
+        ]);
+    }
+
+    private function searchSensors(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Sensor::class, ['name', 'type', 'internal_id', 'unit', 'public_id', 'uuid'], $query, $limit, fn (Sensor $sensor) => [
+            'label'       => $sensor->name ?: $sensor->internal_id,
+            'description' => $this->description($sensor->type, $sensor->unit),
+            'icon'        => 'temperature-full',
+            'type'        => 'Sensor',
+            'route'       => 'console.fleet-ops.connectivity.sensors.index.details',
+            'models'      => [$this->routeModel($sensor)],
+            'breadcrumb'  => 'Fleet-Ops > Connectivity > Sensors',
+        ]);
+    }
+
+    private function searchEvents(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(DeviceEvent::class, ['event_type', 'message', 'ident', 'code', 'provider', 'severity', 'public_id', 'uuid'], $query, $limit, fn (DeviceEvent $event) => [
+            'label'       => $event->event_type ?: $event->public_id,
+            'description' => $this->description($event->severity, $event->provider, $event->message),
+            'icon'        => 'stream',
+            'type'        => 'Device Event',
+            'route'       => 'console.fleet-ops.connectivity.events.details',
+            'models'      => [$this->routeModel($event)],
+            'breadcrumb'  => 'Fleet-Ops > Connectivity > Events',
+        ]);
+    }
+
+    private function searchServiceRates(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(ServiceRate::class, ['public_id', 'uuid', 'service_name', 'service_type', 'currency', 'algorithm', 'rate_calculation_method'], $query, $limit, fn (ServiceRate $serviceRate) => [
+            'label'       => $serviceRate->service_name ?: $serviceRate->public_id,
+            'description' => $this->description($serviceRate->service_type, $serviceRate->currency, $serviceRate->rate_calculation_method),
+            'icon'        => 'file-invoice-dollar',
+            'type'        => 'Service Rate',
+            'route'       => 'console.fleet-ops.operations.service-rates.index.details',
+            'models'      => [$this->routeModel($serviceRate)],
+            'breadcrumb'  => 'Fleet-Ops > Operations > Service Rates',
+        ]);
+    }
+
+    private function searchOrderConfigs(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(OrderConfig::class, ['name', 'description', 'key', 'namespace', 'status', 'public_id', 'uuid'], $query, $limit, fn (OrderConfig $orderConfig) => [
+            'label'       => $orderConfig->name ?: $orderConfig->public_id,
+            'description' => $this->description($orderConfig->status, $orderConfig->description, $orderConfig->namespace),
+            'icon'        => 'diagram-project',
+            'type'        => 'Order Config',
+            'route'       => 'console.fleet-ops.operations.order-config',
+            'queryParams' => ['query' => $query],
+            'breadcrumb'  => 'Fleet-Ops > Operations > Order Config',
+        ]);
+    }
+
+    private function searchGeneric(string $modelClass, array $columns, string $query, int $limit, callable $mapper): Collection
+    {
+        return $modelClass::where('company_uuid', session('company'))
+            ->where(function (Builder $builder) use ($columns, $query) {
+                $this->whereLike($builder, $columns, $query);
+            })
+            ->limit($limit)
+            ->get()
+            ->map($mapper);
+    }
+
+    private function whereLike(Builder $builder, array $columns, string $query): void
+    {
+        $like = '%' . Str::replace(['%', '_'], ['\\%', '\\_'], $query) . '%';
+
+        foreach ($columns as $index => $column) {
+            $method = $index === 0 ? 'where' : 'orWhere';
+            $builder->{$method}($column, 'like', $like);
+        }
+    }
+
+    private function routeModel($model): ?string
+    {
+        return $model->public_id ?: $model->uuid;
+    }
+
+    private function description(...$parts): string
+    {
+        return trim(implode(' ', array_filter(array_map(fn ($part) => is_scalar($part) ? (string) $part : null, $parts))));
+    }
+}

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

@@ -110,7 +110,7 @@ class TelematicController extends FleetOpsController
         $telematic = $this->findTelematic($id);
 
         $jobId = $this->telematicService->discoverDevices($telematic, [
-            'limit'   => $request->input('limit', 100),
+            'limit'   => $request->input('limit'),
             'filters' => $request->input('filters', []),
         ]);
 

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

@@ -16,6 +16,7 @@ use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
 use Illuminate\Support\Str;
 use Maatwebsite\Excel\Facades\Excel;
 
@@ -179,12 +180,31 @@ class VehicleController extends FleetOpsController
     {
         $request->validate(['device' => 'required|string']);
 
-        $vehicle = $this->findVehicle($id);
-        $device  = $this->findDevice($request->input('device'));
+        $deviceId = $request->input('device');
+        $vehicle  = $this->resolveVehicle($id);
+        $device   = $this->resolveDevice($deviceId);
 
-        $device->attachTo($vehicle);
-        $device->load(['telematic', 'warranty', 'attachable']);
-        $vehicle->load(['driver', 'devices']);
+        if (!$vehicle) {
+            $this->logDeviceAttachmentLookupFailure('attach-device', 'vehicle', $id, $deviceId);
+
+            return response()->error('Vehicle not found or not available for this organization.', 404);
+        }
+
+        if (!$device) {
+            $this->logDeviceAttachmentLookupFailure('attach-device', 'device', $id, $deviceId);
+
+            return response()->error('Device not found or not available for this organization.', 404);
+        }
+
+        try {
+            $device->attachTo($vehicle);
+            $device->load(['telematic', 'warranty', 'attachable']);
+            $vehicle->load(['driver', 'devices']);
+        } catch (\Throwable $e) {
+            $this->logDeviceAttachmentFailure('attach-device', $vehicle, $device, $e);
+
+            return response()->error('Unable to attach device to vehicle. Please try again or contact support.', 500);
+        }
 
         return response()->json([
             'status'  => 'ok',
@@ -198,16 +218,35 @@ class VehicleController extends FleetOpsController
     {
         $request->validate(['device' => 'required|string']);
 
-        $vehicle = $this->findVehicle($id);
-        $device  = $this->findDevice($request->input('device'));
+        $deviceId = $request->input('device');
+        $vehicle  = $this->resolveVehicle($id);
+        $device   = $this->resolveDevice($deviceId);
+
+        if (!$vehicle) {
+            $this->logDeviceAttachmentLookupFailure('detach-device', 'vehicle', $id, $deviceId);
+
+            return response()->error('Vehicle not found or not available for this organization.', 404);
+        }
+
+        if (!$device) {
+            $this->logDeviceAttachmentLookupFailure('detach-device', 'device', $id, $deviceId);
+
+            return response()->error('Device not found or not available for this organization.', 404);
+        }
 
         if ($device->attachable_uuid !== $vehicle->uuid) {
             return response()->error('This device is not attached to the selected vehicle.');
         }
 
-        $device->detach();
-        $device->load(['telematic', 'warranty', 'attachable']);
-        $vehicle->load(['driver', 'devices']);
+        try {
+            $device->detach();
+            $device->load(['telematic', 'warranty', 'attachable']);
+            $vehicle->load(['driver', 'devices']);
+        } catch (\Throwable $e) {
+            $this->logDeviceAttachmentFailure('detach-device', $vehicle, $device, $e);
+
+            return response()->error('Unable to detach device from vehicle. Please try again or contact support.', 500);
+        }
 
         return response()->json([
             'status'  => 'ok',
@@ -226,6 +265,15 @@ class VehicleController extends FleetOpsController
             ->firstOrFail();
     }
 
+    protected function resolveVehicle(string $id): ?Vehicle
+    {
+        return Vehicle::where(function ($query) use ($id) {
+            $query->where('uuid', $id)->orWhere('public_id', $id);
+        })
+            ->where('company_uuid', session('company'))
+            ->first();
+    }
+
     protected function findDriver(string $id): Driver
     {
         return Driver::where(function ($query) use ($id) {
@@ -235,6 +283,42 @@ class VehicleController extends FleetOpsController
             ->firstOrFail();
     }
 
+    protected function resolveDevice(string $id): ?Device
+    {
+        return Device::where(function ($query) use ($id) {
+            $query->where('uuid', $id)->orWhere('public_id', $id);
+        })
+            ->where('company_uuid', session('company'))
+            ->first();
+    }
+
+    protected function logDeviceAttachmentLookupFailure(string $action, string $missingResource, string $vehicleId, ?string $deviceId): void
+    {
+        Log::warning('Vehicle device attachment lookup failed', [
+            'action'           => $action,
+            'missing_resource' => $missingResource,
+            'vehicle_id'       => $vehicleId,
+            'device_id'        => $deviceId,
+            'company_uuid'     => session('company'),
+            'request_id'       => request()->headers->get('X-Request-ID') ?? request()->headers->get('X-Correlation-ID'),
+        ]);
+    }
+
+    protected function logDeviceAttachmentFailure(string $action, Vehicle $vehicle, Device $device, \Throwable $exception): void
+    {
+        Log::error('Vehicle device attachment failed', [
+            'action'          => $action,
+            'vehicle_uuid'    => $vehicle->uuid,
+            'vehicle_id'      => $vehicle->public_id,
+            'device_uuid'     => $device->uuid,
+            'device_id'       => $device->public_id,
+            'company_uuid'    => session('company'),
+            'request_id'      => request()->headers->get('X-Request-ID') ?? request()->headers->get('X-Correlation-ID'),
+            'exception_class' => get_class($exception),
+            'exception'       => $exception->getMessage(),
+        ]);
+    }
+
     protected function activeOrderUuid(Vehicle $vehicle): ?string
     {
         $vehicle->loadMissing('driver.currentOrder');