@fleetbase/fleetops-engine 0.6.55 → 0.6.57

package/server/src/Exports/VehicleExport.php

@@ -2,7 +2,9 @@
 
 namespace Fleetbase\FleetOps\Exports;
 
+use Fleetbase\FleetOps\Models\Order;
 use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\Utils;
 use Maatwebsite\Excel\Concerns\FromCollection;
 use Maatwebsite\Excel\Concerns\ShouldAutoSize;
 use Maatwebsite\Excel\Concerns\WithColumnFormatting;
@@ -14,6 +16,14 @@ class VehicleExport implements FromCollection, WithHeadings, WithMapping, WithCo
 {
     protected array $selections = [];
 
+    protected array $dateHeadings = [
+        'Purchased At',
+        'Lease Expires At',
+        'Loan First Payment',
+        'Created At',
+        'Updated At',
+    ];
+
     public function __construct(array $selections = [])
     {
         $this->selections = $selections;
@@ -21,15 +31,103 @@ class VehicleExport implements FromCollection, WithHeadings, WithMapping, WithCo
 
     public function map($vehicle): array
     {
+        $currency = $vehicle->currency ?: 'USD';
+
         return [
             $vehicle->public_id,
             $vehicle->internal_id,
             $vehicle->display_name,
-            $vehicle->driver_name,
+            $vehicle->description,
+            $vehicle->plate_number,
+            $vehicle->vin,
             $vehicle->make,
             $vehicle->model,
             $vehicle->year,
+            $vehicle->trim,
+            $vehicle->color,
+            $vehicle->serial_number,
+            $vehicle->fuel_card_number,
+            $vehicle->class,
+            $vehicle->type,
+            $vehicle->driver_name,
+            $vehicle->vendor_name,
+            $vehicle->status,
+            $this->yesNo($vehicle->online),
+            $vehicle->call_sign,
+            $this->locationPart($vehicle->location, 'lat'),
+            $this->locationPart($vehicle->location, 'lng'),
+            $vehicle->heading,
+            $vehicle->altitude,
+            $vehicle->speed,
+            $vehicle->measurement_system,
+            $vehicle->fuel_volume_unit,
+            $vehicle->odometer,
+            $vehicle->odometer_unit,
+            $vehicle->odometer_at_purchase,
+            $vehicle->body_type,
+            $vehicle->body_sub_type,
+            $vehicle->usage_type,
+            $vehicle->ownership_type,
+            $vehicle->fuel_type,
+            $vehicle->transmission,
+            $vehicle->engine_number,
+            $vehicle->engine_make,
+            $vehicle->engine_model,
+            $vehicle->engine_family,
+            $vehicle->engine_configuration,
+            $vehicle->cylinder_arrangement,
+            $vehicle->number_of_cylinders,
+            $vehicle->engine_size,
+            $vehicle->engine_displacement,
+            $vehicle->horsepower,
+            $vehicle->horsepower_rpm,
+            $vehicle->torque,
+            $vehicle->torque_rpm,
+            $vehicle->fuel_capacity,
+            $vehicle->payload_capacity,
+            $vehicle->towing_capacity,
+            $vehicle->seating_capacity,
+            $vehicle->weight,
+            $vehicle->length,
+            $vehicle->width,
+            $vehicle->height,
+            $vehicle->cargo_volume,
+            $vehicle->payload_capacity_volume,
+            $vehicle->payload_capacity_pallets,
+            $vehicle->payload_capacity_parcels,
+            $vehicle->passenger_volume,
+            $vehicle->interior_volume,
+            $vehicle->ground_clearance,
+            $vehicle->bed_length,
+            $vehicle->emission_standard,
+            $this->yesNo($vehicle->dpf_equipped),
+            $this->yesNo($vehicle->scr_equipped),
+            $vehicle->gvwr,
+            $vehicle->gcwr,
+            $vehicle->currency,
+            $this->money($vehicle->acquisition_cost, $currency),
+            $this->money($vehicle->current_value, $currency),
+            $this->money($vehicle->insurance_value, $currency),
+            $vehicle->depreciation_rate,
+            $vehicle->estimated_service_life_distance,
+            $vehicle->estimated_service_life_distance_unit,
+            $vehicle->estimated_service_life_months,
+            $vehicle->purchased_at,
+            $vehicle->lease_expires_at,
+            $vehicle->financing_status,
+            $this->money($vehicle->loan_amount, $currency),
+            $vehicle->loan_number_of_payments,
+            $vehicle->loan_first_payment,
+            $this->joinSkills($vehicle->skills),
+            $vehicle->time_window_start,
+            $vehicle->time_window_end,
+            $vehicle->max_tasks,
+            $this->yesNo($vehicle->return_to_depot),
+            $this->assignedOrdersCount($vehicle),
+            $this->currentOrderReference($vehicle),
+            $vehicle->notes,
             $vehicle->created_at,
+            $vehicle->updated_at,
         ];
     }
 
@@ -39,19 +137,111 @@ class VehicleExport implements FromCollection, WithHeadings, WithMapping, WithCo
             'ID',
             'Internal ID',
             'Name',
-            'Driver Assigned',
+            'Description',
+            'Plate Number',
+            'VIN',
             'Make',
             'Model',
             'Year',
-            'Date Created',
+            'Trim',
+            'Color',
+            'Serial Number',
+            'Fuel Card Number',
+            'Class',
+            'Type',
+            'Driver',
+            'Vendor',
+            'Status',
+            'Online',
+            'Call Sign',
+            'Latitude',
+            'Longitude',
+            'Heading',
+            'Altitude',
+            'Speed',
+            'Measurement System',
+            'Fuel Volume Unit',
+            'Odometer',
+            'Odometer Unit',
+            'Odometer At Purchase',
+            'Body Type',
+            'Body Sub Type',
+            'Usage Type',
+            'Ownership Type',
+            'Fuel Type',
+            'Transmission',
+            'Engine Number',
+            'Engine Make',
+            'Engine Model',
+            'Engine Family',
+            'Engine Configuration',
+            'Cylinder Arrangement',
+            'Number Of Cylinders',
+            'Engine Size (L)',
+            'Engine Displacement (cc)',
+            'Horsepower (hp)',
+            'Horsepower RPM',
+            'Torque (Nm)',
+            'Torque RPM',
+            'Fuel Capacity (L)',
+            'Payload Capacity (kg)',
+            'Towing Capacity (kg)',
+            'Seating Capacity',
+            'Weight (kg)',
+            'Length (cm)',
+            'Width (cm)',
+            'Height (cm)',
+            'Cargo Volume (L)',
+            'Payload Volume (m3)',
+            'Payload Pallets',
+            'Payload Parcels',
+            'Passenger Volume (L)',
+            'Interior Volume (L)',
+            'Ground Clearance (cm)',
+            'Bed Length (cm)',
+            'Emission Standard',
+            'DPF Equipped',
+            'SCR Equipped',
+            'GVWR (kg)',
+            'GCWR (kg)',
+            'Currency',
+            'Acquisition Cost',
+            'Current Value',
+            'Insurance Value',
+            'Depreciation Rate',
+            'Estimated Service Life Distance',
+            'Estimated Service Life Distance Unit',
+            'Estimated Service Life Months',
+            'Purchased At',
+            'Lease Expires At',
+            'Financing Status',
+            'Loan Amount',
+            'Loan Number Of Payments',
+            'Loan First Payment',
+            'Vehicle Skills',
+            'Time Window Start',
+            'Time Window End',
+            'Max Tasks',
+            'Return To Depot',
+            'Assigned Order Count',
+            'Current Order Reference',
+            'Notes',
+            'Created At',
+            'Updated At',
         ];
     }
 
     public function columnFormats(): array
     {
-        return [
-            'H' => NumberFormat::FORMAT_DATE_DDMMYYYY,
-        ];
+        return collect($this->headings())
+            ->mapWithKeys(function ($heading, $index) {
+                if (!in_array($heading, $this->dateHeadings, true)) {
+                    return [];
+                }
+
+                return [$this->columnLetter($index + 1) => NumberFormat::FORMAT_DATE_DDMMYYYY];
+            })
+            ->all();
     }
 
     /**
@@ -59,10 +249,86 @@ class VehicleExport implements FromCollection, WithHeadings, WithMapping, WithCo
      */
     public function collection()
     {
+        $query = Vehicle::where('company_uuid', session('company'))->with(['driver.currentOrder', 'vendor']);
+
         if ($this->selections) {
-            return Vehicle::where('company_uuid', session('company'))->whereIn('uuid', $this->selections)->with(['driver'])->get();
+            $query->whereIn('uuid', $this->selections);
+        }
+
+        return $query->get();
+    }
+
+    protected function yesNo($value): ?string
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        return filter_var($value, FILTER_VALIDATE_BOOLEAN) ? 'Yes' : 'No';
+    }
+
+    protected function joinSkills($skills): ?string
+    {
+        if (empty($skills)) {
+            return null;
+        }
+
+        if (is_string($skills)) {
+            return $skills;
+        }
+
+        return collect($skills)->filter()->values()->join(', ');
+    }
+
+    protected function locationPart($location, string $part)
+    {
+        $location = Utils::castPoint($location);
+
+        if (!$location) {
+            return null;
+        }
+
+        if ($part === 'lat') {
+            return method_exists($location, 'getLat') ? $location->getLat() : data_get($location, 'latitude', data_get($location, 'lat'));
+        }
+
+        return method_exists($location, 'getLng') ? $location->getLng() : data_get($location, 'longitude', data_get($location, 'lng'));
+    }
+
+    protected function money($amount, ?string $currency = 'USD'): ?string
+    {
+        if ($amount === null || $amount === '') {
+            return null;
+        }
+
+        return Utils::moneyFormat($amount, $currency ?: 'USD');
+    }
+
+    protected function assignedOrdersCount(Vehicle $vehicle): int
+    {
+        return Order::where('vehicle_assigned_uuid', $vehicle->uuid)->count();
+    }
+
+    protected function currentOrderReference(Vehicle $vehicle): ?string
+    {
+        $order = data_get($vehicle, 'driver.currentOrder') ?? Order::where('vehicle_assigned_uuid', $vehicle->uuid)
+            ->whereNotIn('status', ['completed', 'canceled', 'cancelled'])
+            ->latest()
+            ->first();
+
+        return data_get($order, 'tracking') ?? data_get($order, 'public_id');
+    }
+
+    protected function columnLetter(int $index): string
+    {
+        $letter = '';
+
+        while ($index > 0) {
+            $index--;
+            $letter = chr(65 + ($index % 26)) . $letter;
+            $index  = intdiv($index, 26);
         }
 
-        return Vehicle::where('company_uuid', session('company'))->with(['driver'])->get();
+        return $letter;
     }
 }

package/server/src/Exports/VendorExport.php

@@ -25,10 +25,16 @@ class VendorExport implements FromCollection, WithHeadings, WithMapping, WithCol
             $vendor->public_id,
             $vendor->internal_id,
             $vendor->name,
+            $vendor->business_id,
             $vendor->address,
             $vendor->email,
+            $vendor->website_url,
             $vendor->phone,
+            $vendor->type,
+            $vendor->country,
+            $vendor->status,
             $vendor->created_at,
+            $vendor->updated_at,
         ];
     }
 
@@ -38,18 +44,25 @@ class VendorExport implements FromCollection, WithHeadings, WithMapping, WithCol
             'ID',
             'Internal ID',
             'Name',
+            'Business ID',
             'Address',
             'Email',
+            'Website URL',
             'Phone',
+            'Type',
+            'Country',
+            'Status',
             'Date Created',
+            'Date Updated',
         ];
     }
 
     public function columnFormats(): array
     {
         return [
-            'F' => '+#',
-            'G' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+            'H' => '+#',
+            'L' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+            'M' => NumberFormat::FORMAT_DATE_DDMMYYYY,
         ];
     }
 

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