@fleetbase/fleetops-engine 0.6.54 → 0.6.56

package/server/src/Exports/WorkOrderExport.php

@@ -0,0 +1,92 @@
+<?php
+
+namespace Fleetbase\FleetOps\Exports;
+
+use Fleetbase\FleetOps\Models\WorkOrder;
+use Maatwebsite\Excel\Concerns\FromCollection;
+use Maatwebsite\Excel\Concerns\ShouldAutoSize;
+use Maatwebsite\Excel\Concerns\WithColumnFormatting;
+use Maatwebsite\Excel\Concerns\WithHeadings;
+use Maatwebsite\Excel\Concerns\WithMapping;
+use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
+
+class WorkOrderExport implements FromCollection, WithHeadings, WithMapping, WithColumnFormatting, ShouldAutoSize
+{
+    protected array $selections = [];
+
+    public function __construct(array $selections = [])
+    {
+        $this->selections = $selections;
+    }
+
+    public function map($workOrder): array
+    {
+        return [
+            $workOrder->public_id,
+            $workOrder->code,
+            $workOrder->subject,
+            $workOrder->category,
+            $workOrder->status,
+            $workOrder->priority,
+            $workOrder->target_name,
+            $workOrder->assignee_name,
+            $workOrder->opened_at,
+            $workOrder->due_at,
+            $workOrder->closed_at,
+            $workOrder->completion_percentage,
+            $this->yesNo($workOrder->is_overdue),
+            $workOrder->days_until_due,
+            $workOrder->created_at,
+            $workOrder->updated_at,
+        ];
+    }
+
+    public function headings(): array
+    {
+        return [
+            'ID',
+            'Code',
+            'Subject',
+            'Category',
+            'Status',
+            'Priority',
+            'Target',
+            'Assignee',
+            'Opened At',
+            'Due At',
+            'Closed At',
+            'Completion Percentage',
+            'Overdue',
+            'Days Until Due',
+            'Date Created',
+            'Date Updated',
+        ];
+    }
+
+    public function columnFormats(): array
+    {
+        return [
+            'I' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+            'J' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+            'K' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+            'O' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+            'P' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+        ];
+    }
+
+    public function collection()
+    {
+        $query = WorkOrder::where('company_uuid', session('company'))->with(['target', 'assignee']);
+
+        if ($this->selections) {
+            $query->whereIn('uuid', $this->selections);
+        }
+
+        return $query->get();
+    }
+
+    protected function yesNo($value): string
+    {
+        return $value ? 'Yes' : 'No';
+    }
+}

package/server/src/Http/Controllers/Api/v1/Concerns/ResolvesFleetOpsApiResources.php

@@ -0,0 +1,176 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Api\v1\Concerns;
+
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\FuelProviderConnection;
+use Fleetbase\FleetOps\Models\FuelReport;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Part;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Vendor;
+use Fleetbase\FleetOps\Models\Warranty;
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Models\File;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\ModelNotFoundException;
+use Illuminate\Http\Request;
+use Illuminate\Validation\ValidationException;
+
+trait ResolvesFleetOpsApiResources
+{
+    protected function resolveUuid(string $modelClass, ?string $id): ?string
+    {
+        if (empty($id)) {
+            return null;
+        }
+
+        return $this->resolveModel($modelClass, $id)->uuid;
+    }
+
+    protected function resolveModel(string $modelClass, string $id): Model
+    {
+        $instance = new $modelClass();
+        $query    = $modelClass::query()->where(function ($query) use ($id, $instance) {
+            $query->whereRaw('0 = 1');
+
+            if (in_array('public_id', $instance->getFillable()) || method_exists($instance, 'getPublicIdType')) {
+                $query->orWhere('public_id', $id);
+            }
+
+            if (in_array('internal_id', $instance->getFillable())) {
+                $query->orWhere('internal_id', $id);
+            }
+        });
+
+        if (session('company') && $this->modelHasColumn($instance, 'company_uuid')) {
+            $query->where($instance->qualifyColumn('company_uuid'), session('company'));
+        }
+
+        $model = $query->first();
+        if ($model) {
+            return $model;
+        }
+
+        throw (new ModelNotFoundException())->setModel($modelClass, $id);
+    }
+
+    protected function resolveMorph(?string $type, ?string $id): array
+    {
+        if (empty($type) || empty($id)) {
+            return [null, null];
+        }
+
+        $modelClass = Utils::getMutationType($type);
+        $model      = $this->resolveModel($modelClass, $id);
+
+        return [$modelClass, $model->uuid];
+    }
+
+    protected function rejectUuidIdentifiers(Request $request): void
+    {
+        $invalidKeys = array_unique(array_merge(
+            $this->collectUuidIdentifierKeys($request->query->all()),
+            $this->collectUuidIdentifierKeys($request->request->all())
+        ));
+
+        if (empty($invalidKeys)) {
+            return;
+        }
+
+        $messages = [];
+        foreach ($invalidKeys as $key) {
+            $messages[$key] = ['UUID identifiers are not accepted by the public API. Use public_id or internal_id values instead.'];
+        }
+
+        throw ValidationException::withMessages($messages);
+    }
+
+    protected function collectUuidIdentifierKeys(array $input, string $prefix = ''): array
+    {
+        $keys = [];
+
+        foreach ($input as $key => $value) {
+            $path = $prefix ? $prefix . '.' . $key : (string) $key;
+
+            if ($this->isUuidIdentifierKey((string) $key)) {
+                $keys[] = $path;
+            }
+
+            if (is_array($value)) {
+                $keys = array_merge($keys, $this->collectUuidIdentifierKeys($value, $path));
+            }
+        }
+
+        return $keys;
+    }
+
+    protected function isUuidIdentifierKey(string $key): bool
+    {
+        return preg_match('/(^uuid$|_uuid$|Uuid$|UUID$)/', $key) === 1;
+    }
+
+    protected function applyPublicIdRelation(array &$input, string $requestKey, string $column, string $modelClass, $request): void
+    {
+        if (!$request->exists($requestKey)) {
+            return;
+        }
+
+        $input[$column] = filled($request->input($requestKey))
+            ? $this->resolveUuid($modelClass, $request->input($requestKey))
+            : null;
+    }
+
+    protected function allowedMorphTypes(): array
+    {
+        return [
+            'fleet-ops:vehicle'                  => Vehicle::class,
+            'vehicle'                            => Vehicle::class,
+            Vehicle::class                       => Vehicle::class,
+            'fleet-ops:driver'                   => Driver::class,
+            'driver'                             => Driver::class,
+            Driver::class                        => Driver::class,
+            'fleet-ops:equipment'                => Equipment::class,
+            'equipment'                          => Equipment::class,
+            Equipment::class                     => Equipment::class,
+            'fleet-ops:part'                     => Part::class,
+            'part'                               => Part::class,
+            Part::class                          => Part::class,
+            'fleet-ops:vendor'                   => Vendor::class,
+            'vendor'                             => Vendor::class,
+            Vendor::class                        => Vendor::class,
+            'fleet-ops:contact'                  => Contact::class,
+            'contact'                            => Contact::class,
+            Contact::class                       => Contact::class,
+            'fleet-ops:device'                   => Device::class,
+            'device'                             => Device::class,
+            Device::class                        => Device::class,
+            'fleet-ops:telematic'                => Telematic::class,
+            'telematic'                          => Telematic::class,
+            Telematic::class                     => Telematic::class,
+            'fleet-ops:warranty'                 => Warranty::class,
+            'warranty'                           => Warranty::class,
+            Warranty::class                      => Warranty::class,
+            'fleet-ops:fuel-report'              => FuelReport::class,
+            'fuel-report'                        => FuelReport::class,
+            FuelReport::class                    => FuelReport::class,
+            'fleet-ops:fuel-provider-connection' => FuelProviderConnection::class,
+            'fuel-provider-connection'           => FuelProviderConnection::class,
+            FuelProviderConnection::class        => FuelProviderConnection::class,
+            'fleet-ops:order'                    => Order::class,
+            'order'                              => Order::class,
+            Order::class                         => Order::class,
+            'file'                               => File::class,
+            File::class                          => File::class,
+        ];
+    }
+
+    protected function modelHasColumn(Model $model, string $column): bool
+    {
+        return in_array($column, $model->getFillable()) || $column === $model->getKeyName();
+    }
+}

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

@@ -0,0 +1,225 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Api\v1;
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\Concerns\ResolvesFleetOpsApiResources;
+use Fleetbase\FleetOps\Http\Requests\CreateDeviceRequest;
+use Fleetbase\FleetOps\Http\Requests\UpdateDeviceRequest;
+use Fleetbase\FleetOps\Http\Resources\v1\DeletedResource;
+use Fleetbase\FleetOps\Http\Resources\v1\Device as DeviceResource;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Warranty;
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Http\Controllers\Controller;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Fleetbase\Models\File;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Log;
+
+class DeviceController extends Controller
+{
+    use ResolvesFleetOpsApiResources;
+
+    public function create(CreateDeviceRequest $request)
+    {
+        $this->rejectUuidIdentifiers($request);
+
+        $input                 = $this->input($request);
+        $input['company_uuid'] = session('company');
+
+        $device = Device::create($input)->load(['telematic', 'warranty', 'attachable', 'photo'])->loadCount('sensors');
+
+        return new DeviceResource($device);
+    }
+
+    public function update(string $id, UpdateDeviceRequest $request)
+    {
+        $this->rejectUuidIdentifiers($request);
+
+        try {
+            $device = $this->resolveModel(Device::class, $id);
+        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+            return response()->json(['error' => 'Device resource not found.'], 404);
+        }
+
+        $device->update($this->input($request));
+
+        return new DeviceResource($device->refresh()->load(['telematic', 'warranty', 'attachable', 'photo'])->loadCount('sensors'));
+    }
+
+    public function query(Request $request)
+    {
+        $this->rejectUuidIdentifiers($request);
+
+        $results = Device::queryWithRequest($request, function (&$query) {
+            $query->with(['telematic', 'warranty', 'attachable', 'photo'])->withCount('sensors');
+        });
+
+        return DeviceResource::collection($results);
+    }
+
+    public function find(string $id)
+    {
+        try {
+            $device = $this->resolveModel(Device::class, $id)->load(['telematic', 'warranty', 'attachable', 'photo']);
+            $device->loadCount('sensors');
+        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+            return response()->json(['error' => 'Device resource not found.'], 404);
+        }
+
+        return new DeviceResource($device);
+    }
+
+    public function delete(string $id)
+    {
+        try {
+            $device = $this->resolveModel(Device::class, $id);
+        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+            return response()->json(['error' => 'Device resource not found.'], 404);
+        }
+
+        $device->delete();
+
+        return new DeletedResource($device);
+    }
+
+    public function attach(Request $request, string $id): JsonResponse
+    {
+        $this->rejectUuidIdentifiers($request);
+
+        $request->validate([
+            'vehicle' => 'required_without:attachable|string|nullable',
+        ]);
+
+        $deviceId  = $id;
+        $vehicleId = $request->input('vehicle') ?? $request->input('attachable');
+
+        try {
+            $device  = $this->resolveModel(Device::class, $deviceId);
+            $vehicle = $this->resolveModel(Vehicle::class, $vehicleId);
+        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+            $this->logDeviceAttachmentLookupFailure('attach', $deviceId, $vehicleId);
+
+            return response()->json(['error' => 'Device or vehicle resource not found.'], 404);
+        }
+
+        try {
+            $device->attachTo($vehicle);
+            $device->load(['telematic', 'warranty', 'attachable', 'photo'])->loadCount('sensors');
+        } catch (\Throwable $e) {
+            $this->logDeviceAttachmentFailure('attach', $device, $vehicle, $e);
+
+            return response()->json(['error' => 'Unable to attach device to vehicle.'], 500);
+        }
+
+        return response()->json([
+            'status' => 'ok',
+            'device' => new DeviceResource($device),
+        ]);
+    }
+
+    public function detach(string $id): JsonResponse
+    {
+        try {
+            $device = $this->resolveModel(Device::class, $id);
+        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+            $this->logDeviceAttachmentLookupFailure('detach', $id, null);
+
+            return response()->json(['error' => 'Device resource not found.'], 404);
+        }
+
+        try {
+            $device->detach();
+            $device->load(['telematic', 'warranty', 'attachable', 'photo'])->loadCount('sensors');
+        } catch (\Throwable $e) {
+            $this->logDeviceAttachmentFailure('detach', $device, null, $e);
+
+            return response()->json(['error' => 'Unable to detach device from vehicle.'], 500);
+        }
+
+        return response()->json([
+            'status' => 'ok',
+            'device' => new DeviceResource($device),
+        ]);
+    }
+
+    protected function input(Request $request): array
+    {
+        $input = $request->only([
+            'type',
+            'device_id',
+            'internal_id',
+            'imei',
+            'imsi',
+            'firmware_version',
+            'provider',
+            'name',
+            'model',
+            'location',
+            'manufacturer',
+            'serial_number',
+            'installation_date',
+            'last_maintenance_date',
+            'meta',
+            'data',
+            'options',
+            'online',
+            'status',
+            'data_frequency',
+            'notes',
+            'last_online_at',
+        ]);
+
+        if ($request->filled(['latitude', 'longitude'])) {
+            $input['last_position'] = new Point($request->input('latitude'), $request->input('longitude'));
+        } elseif ($request->filled('last_position')) {
+            $input['last_position'] = Utils::getPointFromCoordinates($request->input('last_position'));
+        }
+
+        $this->applyPublicIdRelation($input, 'telematic', 'telematic_uuid', Telematic::class, $request);
+        $this->applyPublicIdRelation($input, 'warranty', 'warranty_uuid', Warranty::class, $request);
+        $this->applyPublicIdRelation($input, 'photo', 'photo_uuid', File::class, $request);
+
+        if ($request->exists('attachable')) {
+            if (blank($request->input('attachable'))) {
+                $input['attachable_type'] = null;
+                $input['attachable_uuid'] = null;
+            } else {
+                [$type, $uuid]            = $this->resolveMorph($request->input('attachable_type'), $request->input('attachable'));
+                $input['attachable_type'] = $type;
+                $input['attachable_uuid'] = $uuid;
+            }
+        }
+
+        return $input;
+    }
+
+    protected function logDeviceAttachmentLookupFailure(string $action, string $deviceId, ?string $vehicleId): void
+    {
+        Log::warning('Public API device attachment lookup failed', [
+            'action'       => $action,
+            'device_id'    => $deviceId,
+            'vehicle_id'   => $vehicleId,
+            'company_uuid' => session('company'),
+            'request_id'   => request()->headers->get('X-Request-ID') ?? request()->headers->get('X-Correlation-ID'),
+        ]);
+    }
+
+    protected function logDeviceAttachmentFailure(string $action, Device $device, ?Vehicle $vehicle, \Throwable $exception): void
+    {
+        Log::error('Public API device attachment failed', [
+            'action'          => $action,
+            'device_uuid'     => $device->uuid,
+            'device_id'       => $device->public_id,
+            'vehicle_uuid'    => $vehicle?->uuid,
+            'vehicle_id'      => $vehicle?->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(),
+        ]);
+    }
+}

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

@@ -0,0 +1,114 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Api\v1;
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\Concerns\ResolvesFleetOpsApiResources;
+use Fleetbase\FleetOps\Http\Requests\CreateEquipmentRequest;
+use Fleetbase\FleetOps\Http\Requests\UpdateEquipmentRequest;
+use Fleetbase\FleetOps\Http\Resources\v1\DeletedResource;
+use Fleetbase\FleetOps\Http\Resources\v1\Equipment as EquipmentResource;
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\Warranty;
+use Fleetbase\Http\Controllers\Controller;
+use Fleetbase\Models\File;
+use Illuminate\Http\Request;
+
+class EquipmentController extends Controller
+{
+    use ResolvesFleetOpsApiResources;
+
+    public function create(CreateEquipmentRequest $request)
+    {
+        $this->rejectUuidIdentifiers($request);
+
+        $input                 = $this->input($request);
+        $input['company_uuid'] = session('company');
+
+        $equipment = Equipment::create($input)->load(['warranty', 'photo', 'equipable']);
+
+        return new EquipmentResource($equipment);
+    }
+
+    public function update(string $id, UpdateEquipmentRequest $request)
+    {
+        $this->rejectUuidIdentifiers($request);
+
+        try {
+            $equipment = $this->resolveModel(Equipment::class, $id);
+        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+            return response()->json(['error' => 'Equipment resource not found.'], 404);
+        }
+
+        $equipment->update($this->input($request));
+
+        return new EquipmentResource($equipment->refresh()->load(['warranty', 'photo', 'equipable']));
+    }
+
+    public function query(Request $request)
+    {
+        $this->rejectUuidIdentifiers($request);
+
+        $results = Equipment::queryWithRequest($request, function (&$query) {
+            $query->with(['warranty', 'photo', 'equipable']);
+        });
+
+        return EquipmentResource::collection($results);
+    }
+
+    public function find(string $id)
+    {
+        try {
+            $equipment = $this->resolveModel(Equipment::class, $id)->load(['warranty', 'photo', 'equipable']);
+        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+            return response()->json(['error' => 'Equipment resource not found.'], 404);
+        }
+
+        return new EquipmentResource($equipment);
+    }
+
+    public function delete(string $id)
+    {
+        try {
+            $equipment = $this->resolveModel(Equipment::class, $id);
+        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+            return response()->json(['error' => 'Equipment resource not found.'], 404);
+        }
+
+        $equipment->delete();
+
+        return new DeletedResource($equipment);
+    }
+
+    protected function input(Request $request): array
+    {
+        $input = $request->only([
+            'name',
+            'code',
+            'type',
+            'status',
+            'serial_number',
+            'manufacturer',
+            'model',
+            'purchased_at',
+            'purchase_price',
+            'currency',
+            'meta',
+        ]);
+
+        $this->applyPublicIdRelation($input, 'warranty', 'warranty_uuid', Warranty::class, $request);
+        $this->applyPublicIdRelation($input, 'photo', 'photo_uuid', File::class, $request);
+
+        if ($request->exists('equipable')) {
+            if (blank($request->input('equipable'))) {
+                $input['equipable_type'] = null;
+                $input['equipable_uuid'] = null;
+            } else {
+                [$type, $uuid]           = $this->resolveMorph($request->input('equipable_type'), $request->input('equipable'));
+                $input['equipable_type'] = $type;
+                $input['equipable_uuid'] = $uuid;
+            }
+        }
+
+        return $input;
+    }
+}