@fleetbase/fleetops-engine 0.6.64 → 0.6.66

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

@@ -21,6 +21,7 @@ use Fleetbase\FleetOps\Models\Place;
 use Fleetbase\FleetOps\Models\Sensor;
 use Fleetbase\FleetOps\Models\ServiceRate;
 use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Trailer;
 use Fleetbase\FleetOps\Models\Vehicle;
 use Fleetbase\FleetOps\Models\Vendor;
 use Fleetbase\FleetOps\Models\WorkOrder;
@@ -38,6 +39,7 @@ class SearchController extends Controller
         'orders',
         'drivers',
         'vehicles',
+        'trailers',
         'fleets',
         'vendors',
         'contacts',
@@ -108,6 +110,7 @@ class SearchController extends Controller
             'orders'                => 'fleet-ops see order',
             'drivers'               => 'fleet-ops see driver',
             'vehicles'              => 'fleet-ops see vehicle',
+            'trailers'              => 'fleet-ops see trailer',
             'fleets'                => 'fleet-ops see fleet',
             'vendors'               => 'fleet-ops see vendor',
             'contacts'              => 'fleet-ops see contact',
@@ -144,6 +147,7 @@ class SearchController extends Controller
             'orders'                => $this->searchOrders($query, $limit),
             'drivers'               => $this->searchDrivers($query, $limit),
             'vehicles'              => $this->searchVehicles($query, $limit),
+            'trailers'              => $this->searchTrailers($query, $limit),
             'fleets'                => $this->searchFleets($query, $limit),
             'vendors'               => $this->searchVendors($query, $limit),
             'contacts'              => $this->searchContacts($query, $limit),
@@ -226,6 +230,18 @@ class SearchController extends Controller
         ]);
     }
 
+    private function searchTrailers(string $query, int $limit): Collection
+    {
+        return $this->searchGeneric(Trailer::class, ['name', 'description', 'code', 'make', 'model', 'year', 'plate_number', 'vin', 'serial_number', 'public_id', 'uuid'], $query, $limit, fn (Trailer $trailer) => [
+            'label'       => $trailer->display_name ?: $trailer->name ?: $trailer->public_id,
+            'description' => $this->description($trailer->type, $trailer->plate_number, $trailer->status),
+            'icon'        => 'trailer', 'type' => 'Trailer',
+            'route'       => 'console.fleet-ops.management.trailers.index.details',
+            'models'      => [$this->routeModel($trailer)],
+            'breadcrumb'  => 'Fleet-Ops > Resources > Trailers',
+        ]);
+    }
+
     private function searchFleets(string $query, int $limit): Collection
     {
         return $this->searchGeneric(Fleet::class, ['name', 'public_id', 'uuid'], $query, $limit, fn (Fleet $fleet) => [

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

@@ -199,6 +199,73 @@ class TelematicController extends FleetOpsController
         ], 201);
     }
 
+    public function telemetryWebhook(Request $request, string $id): JsonResponse
+    {
+        $telematic = $this->findTelematic($id);
+        $provider  = $this->registry->resolve($telematic->provider);
+        abort_unless($provider instanceof \Fleetbase\FleetOps\Contracts\TelemetryProviderInterface, 422);
+        abort_unless($provider->supportsWebhooks(), 422);
+        $url = \Fleetbase\Support\Utils::apiUrl('webhooks/telematics/' . $telematic->provider);
+        abort_unless(str_starts_with($url, 'https://'), 422, 'Configure the public API URL with HTTPS before registering the webhook.');
+        $token = \Illuminate\Support\Facades\DB::transaction(function () use ($telematic, $request) {
+            // Serialize first-time provisioning as well as rotation.
+            Telematic::where('uuid', $telematic->uuid)->lockForUpdate()->firstOrFail();
+            $stored = \Illuminate\Support\Facades\DB::table('telematic_webhook_credentials')->where('telematic_uuid', $telematic->uuid)->first();
+            if ($stored && !$request->boolean('rotate')) {
+                return \Illuminate\Support\Facades\Crypt::decryptString($stored->token);
+            }
+            $token = bin2hex(random_bytes(32));
+            \Illuminate\Support\Facades\DB::table('telematic_webhook_credentials')->updateOrInsert(['telematic_uuid' => $telematic->uuid], [
+                'token' => \Illuminate\Support\Facades\Crypt::encryptString($token), 'created_at' => now(), 'updated_at' => now(),
+            ]);
+
+            return $token;
+        });
+
+        return response()->json(['url' => $url . '?' . http_build_query(['telematic' => $telematic->public_id, 'key' => $token])]);
+    }
+
+    public function telemetryDiagnostics(string $id): JsonResponse
+    {
+        $telematic = $this->findTelematic($id);
+        $provider  = $this->registry->resolve($telematic->provider);
+        abort_unless($provider instanceof \Fleetbase\FleetOps\Contracts\TelemetryProviderInterface, 422);
+        $options     = \Fleetbase\FleetOps\Support\Telematics\Telemetry\Configuration::options($provider);
+        $query       = \Illuminate\Support\Facades\DB::table('telematic_deliveries')->where('telematic_uuid', $telematic->uuid);
+        $last        = (clone $query)->where('source', 'webhook')->orderByDesc('received_at')->first(['uuid', 'status', 'received_at', 'processed_at', 'error']);
+        $provisioned = \Illuminate\Support\Facades\DB::table('telematic_webhook_credentials')->where('telematic_uuid', $telematic->uuid)->exists();
+        $state       = !$provisioned ? 'not_configured' : (!$last ? 'awaiting_first_delivery' : ($last->status === 'quarantined' || \Illuminate\Support\Carbon::parse($last->received_at)->lt(now()->subMinutes(10)) ? 'degraded' : 'receiving'));
+
+        return response()->json([
+            'polling_enabled'   => $options['polling_enabled'] ?? false,
+            'webhooks_enabled'  => $options['webhooks_enabled'] ?? false,
+            'webhook_state'     => $state, 'last_webhook' => $last,
+            'last_poll'         => \Illuminate\Support\Facades\DB::table('telematic_sync_runs')->where('telematic_uuid', $telematic->uuid)->orderByDesc('created_at')->first(),
+            'last_ingestion'    => (clone $query)->whereNotNull('processed_at')->orderByDesc('received_at')->first(['queue_delay_seconds', 'source_delay_seconds', 'processed_at']),
+            'delivery_counts'   => (clone $query)->whereIn('status', ['pending', 'retry', 'processing'])->selectRaw('status, count(*) as total')->groupBy('status')->pluck('total', 'status'),
+            'oldest_pending_at' => (clone $query)->whereIn('status', ['pending', 'retry', 'processing'])->min('received_at'),
+            'recent_failures'   => (clone $query)->whereIn('status', ['quarantined', 'retry'])->orderByDesc('received_at')->limit(10)->get(['uuid', 'status', 'source', 'received_at', 'applied', 'failed', 'error']),
+        ]);
+    }
+
+    public function replayTelemetryDelivery(string $id, string $delivery): JsonResponse
+    {
+        $telematic = $this->findTelematic($id);
+        $provider  = $this->registry->resolve($telematic->provider);
+        abort_unless($provider instanceof \Fleetbase\FleetOps\Contracts\TelemetryProviderInterface, 422);
+        $options = \Fleetbase\FleetOps\Support\Telematics\Telemetry\Configuration::options($provider);
+        $updated = \Illuminate\Support\Facades\DB::table('telematic_deliveries')->where('telematic_uuid', $telematic->uuid)->where('uuid', $delivery)->where('status', 'quarantined')
+            ->update(['status' => 'pending', 'attempts' => 0, 'retry_payload' => null, 'invalid_count' => 0, 'failed' => 0, 'applied' => 0, 'error' => null, 'available_at' => now(), 'processed_at' => null, 'updated_at' => now()]);
+        abort_unless($updated, 404);
+        try {
+            \Fleetbase\FleetOps\Support\Telematics\Telemetry\Queue::dispatch((new \Fleetbase\FleetOps\Jobs\ProcessTelematicDelivery($delivery))->onQueue($options['ingestion_queue'] ?? 'default'));
+        } catch (\Throwable) {
+            // The durable replay is recovered by the scheduled inbox drain.
+        }
+
+        return response()->json(['status' => 'queued'], 202);
+    }
+
     protected function findTelematic(string $id): Telematic
     {
         return Telematic::where(function ($query) use ($id) {

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

@@ -0,0 +1,360 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
+
+use Fleetbase\FleetOps\Exceptions\DeviceAlreadyAttachedException;
+use Fleetbase\FleetOps\Exports\TrailerExport;
+use Fleetbase\FleetOps\Http\Controllers\FleetOpsController;
+use Fleetbase\FleetOps\Http\Resources\v1\AssetConnection as AssetConnectionResource;
+use Fleetbase\FleetOps\Http\Resources\v1\Trailer as TrailerResource;
+use Fleetbase\FleetOps\Imports\TrailerImport;
+use Fleetbase\FleetOps\Models\AssetConnection;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\Trailer;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\Http\Requests\ExportRequest;
+use Fleetbase\Http\Requests\ImportRequest;
+use Fleetbase\Support\Resolve;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Str;
+use Maatwebsite\Excel\Facades\Excel;
+
+class TrailerController extends FleetOpsController
+{
+    /**
+     * The resource to query.
+     *
+     * @var string
+     */
+    public $resource = 'trailer';
+
+    /**
+     * Handle post save transactions.
+     */
+    public function afterSave(Request $request, Trailer $trailer): void
+    {
+        $values = $request->array('trailer.custom_field_values');
+
+        if ($values) {
+            $trailer->syncCustomFieldValues($values);
+        }
+    }
+
+    /**
+     * Deleting a trailer that is still coupled to a vehicle would orphan the active
+     * towing connection, so it must be detached first.
+     */
+    public function deleteRecord($id, Request $request)
+    {
+        $trailer = $this->resolveTrailer($id);
+
+        if ($trailer && $this->activeConnectionQuery($trailer)->exists()) {
+            return response()->error('Detach the trailer from its vehicle before deleting it.', 409);
+        }
+
+        return $this->deleteTrailerRecord($id, $request);
+    }
+
+    // @codeCoverageIgnoreStart
+    // Thin seam over the framework delete flow; the guard above is what this controller owns.
+    protected function deleteTrailerRecord($id, Request $request)
+    {
+        return parent::deleteRecord($id, $request);
+    }
+
+    // @codeCoverageIgnoreEnd
+
+    /**
+     * Attach the trailer to a vehicle. Re-attaching to the same vehicle is idempotent.
+     */
+    public function attach(Request $request, string $id)
+    {
+        $request->validate(['vehicle' => ['required', 'string'], 'position' => ['nullable', 'integer', 'min:1']]);
+
+        $trailer = $this->resolveTrailer($id);
+        $vehicle = $this->resolveVehicle($request->input('vehicle'));
+
+        if (!$trailer) {
+            return response()->error('Trailer not found or not available for this organization.', 404);
+        }
+
+        if (!$vehicle) {
+            return response()->error('Vehicle not found or not available for this organization.', 404);
+        }
+
+        $result = DB::transaction(function () use ($trailer, $vehicle, $request) {
+            $active = $this->activeConnectionQuery($trailer)->lockForUpdate()->first();
+
+            if ($active) {
+                if ($active->connector_uuid !== $vehicle->uuid) {
+                    return 'Trailer is already attached to another vehicle. Detach it before moving.';
+                }
+
+                return $active;
+            }
+
+            $position    = $request->integer('position', 1);
+            $positionKey = $vehicle->uuid . ':' . $position;
+
+            if (AssetConnection::where('company_uuid', session('company'))->where('active_connector_position', $positionKey)->lockForUpdate()->exists()) {
+                return 'Another trailer already occupies this towing position.';
+            }
+
+            return AssetConnection::create([
+                'company_uuid'              => session('company'),
+                'connector_type'            => Vehicle::class,
+                'connector_uuid'            => $vehicle->uuid,
+                'connected_type'            => Trailer::class,
+                'connected_uuid'            => $trailer->uuid,
+                'active_connected_uuid'     => $trailer->uuid,
+                'active_connector_position' => $positionKey,
+                'relationship_type'         => 'towing',
+                'position'                  => $position,
+                'connected_at'              => now(),
+                'source'                    => 'manual',
+                'created_by_uuid'           => session('user'),
+                'updated_by_uuid'           => session('user'),
+            ]);
+        }, 3);
+
+        if (is_string($result)) {
+            return response()->error($result, 409);
+        }
+
+        return response()->json([
+            'status'     => 'ok',
+            'message'    => 'Trailer attached to vehicle.',
+            'trailer'    => new TrailerResource($trailer->fresh(['currentConnection.vehicle'])),
+            'connection' => new AssetConnectionResource($result->load(['vehicle', 'trailer'])),
+        ]);
+    }
+
+    /**
+     * End the active towing connection. Detaching an unattached trailer is a no-op.
+     */
+    public function detach(string $id)
+    {
+        $trailer = $this->resolveTrailer($id);
+
+        if (!$trailer) {
+            return response()->error('Trailer not found or not available for this organization.', 404);
+        }
+
+        DB::transaction(fn () => $this->activeConnectionQuery($trailer)->lockForUpdate()->update([
+            'active_connected_uuid'     => null,
+            'active_connector_position' => null,
+            'disconnected_at'           => now(),
+            'updated_by_uuid'           => session('user'),
+            'updated_at'                => now(),
+        ]));
+
+        return response()->json([
+            'status'  => 'ok',
+            'message' => 'Trailer detached from vehicle.',
+            'trailer' => new TrailerResource($trailer->fresh(['currentConnection.vehicle'])),
+        ]);
+    }
+
+    public function attachDevice(Request $request, string $id)
+    {
+        $request->validate(['device' => ['required', 'string']]);
+
+        $trailer = $this->resolveTrailer($id);
+        $device  = $this->resolveDevice($request->input('device'));
+
+        if (!$trailer) {
+            return response()->error('Trailer not found or not available for this organization.', 404);
+        }
+
+        if (!$device) {
+            return response()->error('Device not found or not available for this organization.', 404);
+        }
+
+        try {
+            $device->attachTo($trailer);
+        } catch (DeviceAlreadyAttachedException $e) {
+            return response()->error($e->getMessage(), 409);
+        }
+
+        return response()->json([
+            'status'  => 'ok',
+            'message' => 'Device attached to trailer.',
+            'trailer' => new TrailerResource($trailer->fresh(['devices'])),
+            'device'  => Resolve::httpResourceForModel($device->fresh(['attachable'])),
+        ]);
+    }
+
+    public function detachDevice(Request $request, string $id)
+    {
+        $request->validate(['device' => ['required', 'string']]);
+
+        $trailer = $this->resolveTrailer($id);
+        $device  = $this->resolveDevice($request->input('device'));
+
+        if (!$trailer) {
+            return response()->error('Trailer not found or not available for this organization.', 404);
+        }
+
+        if (!$device) {
+            return response()->error('Device not found or not available for this organization.', 404);
+        }
+
+        if ($device->attachable_uuid !== $trailer->uuid || $device->attachable_type !== Trailer::class) {
+            return response()->error('This device is not attached to the selected trailer.', 422);
+        }
+
+        $device->detach();
+
+        return response()->json([
+            'status'  => 'ok',
+            'message' => 'Device detached from trailer.',
+            'trailer' => new TrailerResource($trailer->fresh(['devices'])),
+            'device'  => Resolve::httpResourceForModel($device->fresh(['attachable'])),
+        ]);
+    }
+
+    public function attachEquipment(Request $request, string $id)
+    {
+        $request->validate(['equipment' => ['required', 'string']]);
+
+        $trailer   = $this->resolveTrailer($id);
+        $equipment = $this->resolveEquipment($request->input('equipment'));
+
+        if (!$trailer) {
+            return response()->error('Trailer not found or not available for this organization.', 404);
+        }
+
+        if (!$equipment) {
+            return response()->error('Equipment not found or not available for this organization.', 404);
+        }
+
+        DB::transaction(function () use ($equipment, $trailer) {
+            Equipment::where('uuid', $equipment->uuid)->lockForUpdate()->firstOrFail()->update(['equipable_type' => Trailer::class, 'equipable_uuid' => $trailer->uuid]);
+        });
+
+        return response()->json([
+            'status'    => 'ok',
+            'message'   => 'Equipment attached to trailer.',
+            'trailer'   => new TrailerResource($trailer->fresh(['equipments'])),
+            'equipment' => Resolve::httpResourceForModel($equipment->fresh(['equipable'])),
+        ]);
+    }
+
+    public function detachEquipment(Request $request, string $id)
+    {
+        $request->validate(['equipment' => ['required', 'string']]);
+
+        $trailer   = $this->resolveTrailer($id);
+        $equipment = $this->resolveEquipment($request->input('equipment'));
+
+        if (!$trailer) {
+            return response()->error('Trailer not found or not available for this organization.', 404);
+        }
+
+        if (!$equipment) {
+            return response()->error('Equipment not found or not available for this organization.', 404);
+        }
+
+        if ($equipment->equipable_uuid !== $trailer->uuid || $equipment->equipable_type !== Trailer::class) {
+            return response()->error('This equipment is not attached to the selected trailer.', 422);
+        }
+
+        DB::transaction(fn () => Equipment::where('uuid', $equipment->uuid)->lockForUpdate()->update(['equipable_type' => null, 'equipable_uuid' => null]));
+
+        return response()->json([
+            'status'    => 'ok',
+            'message'   => 'Equipment detached from trailer.',
+            'trailer'   => new TrailerResource($trailer->fresh(['equipments'])),
+            'equipment' => Resolve::httpResourceForModel($equipment->fresh(['equipable'])),
+        ]);
+    }
+
+    /**
+     * Lifecycle statuses available to trailers, used by the console status filter.
+     */
+    public function statuses()
+    {
+        return response()->json(Trailer::STATUSES);
+    }
+
+    /**
+     * Trailer classification types, used by the console type filter.
+     */
+    public function types()
+    {
+        return response()->json(Trailer::TYPES);
+    }
+
+    public function export(ExportRequest $request)
+    {
+        $format = $request->input('format', 'xlsx');
+
+        return $this->downloadExport(new TrailerExport($request->array('selections')), Str::slug('trailers-' . date('Y-m-d-H:i')) . '.' . $format);
+    }
+
+    public function import(ImportRequest $request)
+    {
+        $count = 0;
+
+        foreach ($request->resolveFilesFromIds() as $file) {
+            $import = $this->createImport();
+            $this->importFile($import, $file->path, $request->input('disk', config('filesystems.default')));
+            $count += $import->imported;
+        }
+
+        return response()->json(['status' => 'ok', 'message' => 'Import completed', 'imported' => $count]);
+    }
+
+    protected function resolveTrailer(string $id): ?Trailer
+    {
+        return Trailer::where('company_uuid', session('company'))
+            ->where(fn ($query) => $query->where('uuid', $id)->orWhere('public_id', $id))
+            ->first();
+    }
+
+    protected function resolveVehicle(string $id): ?Vehicle
+    {
+        return Vehicle::where('company_uuid', session('company'))
+            ->where(fn ($query) => $query->where('uuid', $id)->orWhere('public_id', $id)->orWhere('internal_id', $id))
+            ->first();
+    }
+
+    protected function resolveDevice(string $id): ?Device
+    {
+        return Device::where('company_uuid', session('company'))
+            ->where(fn ($query) => $query->where('uuid', $id)->orWhere('public_id', $id))
+            ->first();
+    }
+
+    protected function resolveEquipment(string $id): ?Equipment
+    {
+        return Equipment::where('company_uuid', session('company'))
+            ->where(fn ($query) => $query->where('uuid', $id)->orWhere('public_id', $id))
+            ->first();
+    }
+
+    protected function activeConnectionQuery(Trailer $trailer)
+    {
+        return AssetConnection::where('company_uuid', session('company'))->where('active_connected_uuid', $trailer->uuid);
+    }
+
+    // @codeCoverageIgnoreStart
+    // Thin spreadsheet adapter seams are exercised through export/import caller behavior.
+    protected function downloadExport(TrailerExport $export, string $fileName)
+    {
+        return Excel::download($export, $fileName);
+    }
+
+    protected function createImport(): TrailerImport
+    {
+        return new TrailerImport();
+    }
+
+    protected function importFile(TrailerImport $import, string $path, string $disk): void
+    {
+        Excel::import($import, $path, $disk);
+    }
+    // @codeCoverageIgnoreEnd
+}

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

@@ -2,16 +2,19 @@
 
 namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
 
+use Fleetbase\FleetOps\Exceptions\DeviceAlreadyAttachedException;
 use Fleetbase\FleetOps\Exports\VehicleExport;
 use Fleetbase\FleetOps\Http\Controllers\FleetOpsController;
 use Fleetbase\FleetOps\Http\Resources\v1\Index\Order as IndexOrderResource;
 use Fleetbase\FleetOps\Imports\VehicleImport;
 use Fleetbase\FleetOps\Models\Device;
 use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Equipment;
 use Fleetbase\FleetOps\Models\Order;
 use Fleetbase\FleetOps\Models\Vehicle;
 use Fleetbase\Http\Requests\ExportRequest;
 use Fleetbase\Http\Requests\ImportRequest;
+use Fleetbase\Support\Resolve;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
 use Illuminate\Support\Arr;
@@ -200,6 +203,8 @@ class VehicleController extends FleetOpsController
             $device->attachTo($vehicle);
             $device->load(['telematic', 'warranty', 'attachable']);
             $vehicle->load(['driver', 'devices']);
+        } catch (DeviceAlreadyAttachedException $e) {
+            return response()->error($e->getMessage(), 409);
         } catch (\Throwable $e) {
             $this->logDeviceAttachmentFailure('attach-device', $vehicle, $device, $e);
 
@@ -256,6 +261,66 @@ class VehicleController extends FleetOpsController
         ]);
     }
 
+    /**
+     * Attach equipment to the vehicle. Equipment can only be equipped to one asset at a
+     * time, so attaching moves it from any previous vehicle or trailer.
+     */
+    public function attachEquipment(Request $request, string $id): JsonResponse
+    {
+        $request->validate(['equipment' => 'required|string']);
+
+        $vehicle   = $this->resolveVehicle($id);
+        $equipment = $this->resolveEquipment($request->input('equipment'));
+
+        if (!$vehicle) {
+            return response()->error('Vehicle not found or not available for this organization.', 404);
+        }
+
+        if (!$equipment) {
+            return response()->error('Equipment not found or not available for this organization.', 404);
+        }
+
+        DB::transaction(function () use ($equipment, $vehicle) {
+            Equipment::where('uuid', $equipment->uuid)->lockForUpdate()->firstOrFail()->update(['equipable_type' => Vehicle::class, 'equipable_uuid' => $vehicle->uuid]);
+        });
+
+        return response()->json([
+            'status'    => 'ok',
+            'message'   => 'Equipment attached to vehicle.',
+            'vehicle'   => Resolve::httpResourceForModel($vehicle->fresh(['equipments'])),
+            'equipment' => Resolve::httpResourceForModel($equipment->fresh(['equipable'])),
+        ]);
+    }
+
+    public function detachEquipment(Request $request, string $id): JsonResponse
+    {
+        $request->validate(['equipment' => 'required|string']);
+
+        $vehicle   = $this->resolveVehicle($id);
+        $equipment = $this->resolveEquipment($request->input('equipment'));
+
+        if (!$vehicle) {
+            return response()->error('Vehicle not found or not available for this organization.', 404);
+        }
+
+        if (!$equipment) {
+            return response()->error('Equipment not found or not available for this organization.', 404);
+        }
+
+        if ($equipment->equipable_uuid !== $vehicle->uuid || $equipment->equipable_type !== Vehicle::class) {
+            return response()->error('This equipment is not attached to the selected vehicle.', 422);
+        }
+
+        DB::transaction(fn () => Equipment::where('uuid', $equipment->uuid)->lockForUpdate()->update(['equipable_type' => null, 'equipable_uuid' => null]));
+
+        return response()->json([
+            'status'    => 'ok',
+            'message'   => 'Equipment detached from vehicle.',
+            'vehicle'   => Resolve::httpResourceForModel($vehicle->fresh(['equipments'])),
+            'equipment' => Resolve::httpResourceForModel($equipment->fresh(['equipable'])),
+        ]);
+    }
+
     protected function findVehicle(string $id): Vehicle
     {
         return Vehicle::where(function ($query) use ($id) {
@@ -283,6 +348,15 @@ class VehicleController extends FleetOpsController
             ->firstOrFail();
     }
 
+    protected function resolveEquipment(string $id): ?Equipment
+    {
+        return Equipment::where(function ($query) use ($id) {
+            $query->where('uuid', $id)->orWhere('public_id', $id);
+        })
+            ->where('company_uuid', session('company'))
+            ->first();
+    }
+
     protected function resolveDevice(string $id): ?Device
     {
         return Device::where(function ($query) use ($id) {