@fleetbase/fleetops-engine 0.6.63 → 0.6.65

package/server/src/Http/Resources/v1/Trailer.php

@@ -0,0 +1,199 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Resources\v1;
+
+use Fleetbase\FleetOps\Http\Resources\v1\Concerns\ResolvesPublicRelationFields;
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Http\Resources\FleetbaseResource;
+use Fleetbase\Support\Http;
+use Fleetbase\Support\Resolve;
+
+/**
+ * First-class Trailer representation.
+ *
+ * Internal (console) responses expose the record with its UUID identity and fully
+ * embedded relations so Ember Data can hydrate the store. Public API responses use
+ * the `trailer_` public identifier, additive `*_id` relation identifiers, and only
+ * expand relation objects that were requested through `with`.
+ */
+class Trailer extends FleetbaseResource
+{
+    use ResolvesPublicRelationFields;
+
+    /**
+     * Transform the resource into an array.
+     *
+     * @param \Illuminate\Http\Request $request
+     */
+    public function toArray($request): array
+    {
+        $internal = Http::isInternalRequest();
+        $with     = $this->requestedRelations($request);
+
+        return $this->withCustomFields([
+            // Identity
+            'id'                   => $this->when($internal, $this->id, $this->public_id),
+            'uuid'                 => $this->when(Http::isInternalRequest(), $this->uuid),
+            'public_id'            => $this->when($internal, $this->public_id),
+            'company_uuid'         => $this->when(Http::isInternalRequest(), $this->company_uuid),
+            'category_uuid'        => $this->when(Http::isInternalRequest(), $this->category_uuid),
+            'vendor_uuid'          => $this->when(Http::isInternalRequest(), $this->vendor_uuid),
+            'warranty_uuid'        => $this->when(Http::isInternalRequest(), $this->warranty_uuid),
+            'photo_uuid'           => $this->when(Http::isInternalRequest(), $this->photo_uuid),
+            'asset_class'          => 'trailer',
+            'name'                 => $this->name,
+            'display_name'         => $this->display_name,
+            'code'                 => $this->code,
+            'description'          => $this->description,
+            'slug'                 => $this->when($internal, $this->slug),
+            // Classification & lifecycle
+            'type'                 => $this->type,
+            'body_type'            => $this->body_type,
+            'usage_type'           => $this->usage_type,
+            'status'               => $this->status,
+            'attachment_state'     => $this->attachment_state,
+            'connectivity_status'  => $this->connectivity_status,
+            'online'               => $this->online,
+            // Registration
+            'vin'                  => $this->vin,
+            'plate_number'         => $this->plate_number,
+            'serial_number'        => $this->serial_number,
+            'make'                 => $this->make,
+            'model'                => $this->model,
+            'year'                 => $this->year,
+            'color'                => $this->color,
+            // Media
+            'photo_url'            => $this->photo_url,
+            // Relationships. Identifiers are additive and always present so a write
+            // can be read back; relation objects follow the public `with` contract.
+            'category_id'          => $this->publicIdForRelation('category', 'category_uuid'),
+            'vendor_id'            => $this->publicIdForRelation('vendor', 'vendor_uuid'),
+            'warranty_id'          => $this->publicIdForRelation('warranty', 'warranty_uuid'),
+            'photo_id'             => $this->publicIdForRelation('photo', 'photo_uuid'),
+            'category_name'        => $this->when($internal, $this->category_name),
+            'vendor_name'          => $this->when($internal, $this->vendor_name),
+            'warranty_name'        => $this->when($internal, $this->warranty_name),
+            'category'             => $this->publicRelationObject('category', $with, fn () => Resolve::httpResourceForModel($this->category)),
+            'vendor'               => $this->publicRelationObject('vendor', $with, fn () => new Vendor($this->vendor)),
+            'warranty'             => $this->publicRelationObject('warranty', $with, fn () => Resolve::httpResourceForModel($this->warranty)),
+            'photo'                => $this->publicRelationObject('photo', $with, fn () => Resolve::httpResourceForModel($this->photo)),
+            // Towing connection
+            'vehicle_id'           => $this->whenLoaded('currentConnection', fn () => $this->currentConnection?->vehicle?->public_id),
+            'current_vehicle_name' => $this->whenLoaded('currentConnection', fn () => $this->currentConnection?->vehicle?->display_name),
+            'attached_at'          => $this->whenLoaded('currentConnection', fn () => $this->currentConnection?->connected_at),
+            'current_vehicle'      => $this->whenLoaded('currentConnection', fn () => $this->currentVehicleRepresentation($internal)),
+            'current_connection'   => $this->whenLoaded('currentConnection', fn () => $this->currentConnection ? new AssetConnection($this->currentConnection) : null),
+            // Ember Data embeds these collections, so the console always receives an array;
+            // the public API only includes them when they were loaded.
+            'connections'          => $this->embeddedCollection('connections', AssetConnection::class, $internal),
+            'devices'              => $this->embeddedCollection('devices', Device::class, $internal),
+            // Ember Data embeds the `equipments` relationship; the public contract reads `equipment`.
+            'equipment'            => $this->when(!$internal, fn () => $this->whenLoaded('equipments', fn () => Equipment::collection($this->equipments))),
+            'equipments'           => $this->when($internal, fn () => $this->embeddedCollection('equipments', Equipment::class, true)),
+            'devices_count'        => $this->whenCounted('devices'),
+            'equipment_count'      => $this->whenCounted('equipments'),
+            // Dimensions & capacity
+            'measurement_system'   => $this->measurement_system,
+            'length'               => $this->length,
+            'width'                => $this->width,
+            'height'               => $this->height,
+            'tare_weight'          => $this->tare_weight,
+            'gvwr'                 => $this->gvwr,
+            'payload_capacity'     => $this->payload_capacity,
+            'cargo_volume'         => $this->cargo_volume,
+            'capacity'             => data_get($this, 'capacity', Utils::createObject()),
+            // Running gear
+            'axle_count'           => $this->axle_count,
+            'tire_count'           => $this->tire_count,
+            'door_count'           => $this->door_count,
+            'coupling_type'        => $this->coupling_type,
+            'brake_type'           => $this->brake_type,
+            'abs_equipped'         => $this->abs_equipped,
+            'ebs_equipped'         => $this->ebs_equipped,
+            // Refrigeration
+            'refrigerated'         => $this->refrigerated,
+            'temperature_min'      => $this->temperature_min,
+            'temperature_max'      => $this->temperature_max,
+            'reefer_engine_hours'  => $this->reefer_engine_hours,
+            // Usage
+            'odometer'             => $this->odometer,
+            'odometer_unit'        => $this->odometer_unit,
+            'engine_hours'         => $this->engine_hours,
+            // Ownership & finance
+            'ownership_type'       => $this->ownership_type,
+            'financing_status'     => $this->financing_status,
+            'currency'             => $this->currency,
+            'acquisition_cost'     => $this->acquisition_cost,
+            'current_value'        => $this->current_value,
+            'insurance_value'      => $this->insurance_value,
+            'depreciation_rate'    => $this->depreciation_rate,
+            'purchased_at'         => $this->purchased_at,
+            'lease_expires_at'     => $this->lease_expires_at,
+            // Location & telematics
+            'location'             => Utils::castPoint($this->location),
+            'speed'                => $this->speed,
+            'heading'              => $this->heading,
+            'altitude'             => $this->altitude,
+            'last_online_at'       => $this->last_online_at,
+            'telematics'           => $this->telematicsRepresentation($internal),
+            'positions'            => $this->whenLoaded('positions', fn () => Position::collection($this->positions)),
+            // Blobs, notes & timestamps
+            'specs'                => data_get($this, 'specs', Utils::createObject()),
+            'attributes'           => $this->resource->getAttribute('attributes') ?? Utils::createObject(),
+            'notes'                => $this->notes,
+            'created_at'           => $this->created_at,
+            'updated_at'           => $this->updated_at,
+        ]);
+    }
+
+    /**
+     * A loaded relation serializes through its resource; an unloaded one is omitted for the
+     * public API and an empty array for the console, which embeds the relationship.
+     */
+    protected function embeddedCollection(string $relation, string $resourceClass, bool $internal): mixed
+    {
+        if ($this->resource->relationLoaded($relation)) {
+            return $resourceClass::collection($this->{$relation});
+        }
+
+        return $internal ? [] : new \Illuminate\Http\Resources\MissingValue();
+    }
+
+    /**
+     * The console receives the full Vehicle record so Ember Data can hydrate it; the
+     * public API receives a compact public identity.
+     */
+    protected function currentVehicleRepresentation(bool $internal): mixed
+    {
+        $vehicle = $this->currentConnection?->vehicle;
+
+        if (!$vehicle) {
+            return null;
+        }
+
+        if ($internal) {
+            return Resolve::httpResourceForModel($vehicle);
+        }
+
+        return [
+            'id'           => $vehicle->public_id,
+            'name'         => $vehicle->display_name,
+            'plate_number' => $vehicle->plate_number,
+        ];
+    }
+
+    /**
+     * Telemetry provenance references devices and events by UUID for the console;
+     * the public API must never expose internal identifiers.
+     */
+    protected function telematicsRepresentation(bool $internal): mixed
+    {
+        $telematics = $this->telematics;
+
+        if ($internal || !is_array($telematics)) {
+            return $telematics;
+        }
+
+        return array_filter($telematics, fn ($key) => !preg_match('/(^uuid$|_uuid$)/', (string) $key), ARRAY_FILTER_USE_KEY);
+    }
+}

package/server/src/Http/Resources/v1/Vehicle.php

@@ -68,6 +68,8 @@ class Vehicle extends FleetbaseResource
             'warranty'               => $this->publicRelationObject('warranty', $with, fn () => Resolve::httpResourceForModel($this->warranty)),
             'photo'                  => $this->publicRelationObject('photo', $with, fn () => Resolve::httpResourceForModel($this->photo)),
             'devices'                => $this->whenLoaded('devices', fn () => $this->devices),
+            // Trailers currently coupled to this vehicle (`with=trailers` on the public API).
+            'trailers'               => $this->publicRelationObject('currentTrailers', $with, fn () => Trailer::collection($this->currentTrailers)),
             // Vehicle identification
             'make'                   => $this->make,
             'model'                  => $this->model,

package/server/src/Http/Resources/v1/VehicleWithoutDriver.php

@@ -2,6 +2,7 @@
 
 namespace Fleetbase\FleetOps\Http\Resources\v1;
 
+use Fleetbase\FleetOps\Support\TrailerSummary;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\Http\Resources\FleetbaseResource;
 use Fleetbase\Support\Http;
@@ -41,6 +42,8 @@ class VehicleWithoutDriver extends FleetbaseResource
             'vendor_name'            => $this->when(Http::isInternalRequest(), $this->vendor_name),
             // Relationships
             'devices'                => $this->whenLoaded('devices', fn () => $this->devices),
+            // Current towing connections, compact; the console vehicle cards list them.
+            'trailers'               => $this->whenLoaded('currentTrailers', fn () => TrailerSummary::collection($this->currentTrailers)),
             // Vehicle identification
             'make'                   => $this->make,
             'model'                  => $this->model,

package/server/src/Imports/TrailerImport.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Fleetbase\FleetOps\Imports;
+
+use Fleetbase\FleetOps\Models\Trailer;
+use Illuminate\Support\Collection;
+use Illuminate\Validation\ValidationException;
+use Maatwebsite\Excel\Concerns\ToCollection;
+use Maatwebsite\Excel\Concerns\WithHeadingRow;
+
+class TrailerImport implements ToCollection, WithHeadingRow
+{
+    public int $imported = 0;
+
+    public function collection(Collection $rows)
+    {
+        foreach ($rows as $index => $row) {
+            $data = $row instanceof Collection ? array_filter($row->toArray(), fn ($v) => $v !== null && $v !== '') : $row;
+            if (!$data) {
+                continue;
+            }
+            if (empty($data['name'])) {
+                throw ValidationException::withMessages(["row.$index.name" => ['Name is required.']]);
+            }
+            if (!empty($data['type']) && !in_array($data['type'], Trailer::TYPES, true)) {
+                throw ValidationException::withMessages(["row.$index.type" => ['Invalid trailer type.']]);
+            }
+            $allowed = ['name', 'code', 'description', 'type', 'status', 'vin', 'plate_number', 'serial_number', 'make', 'model', 'year', 'length', 'width', 'height', 'tare_weight', 'gvwr', 'payload_capacity', 'cargo_volume', 'axle_count', 'tire_count', 'coupling_type', 'brake_type', 'refrigerated', 'measurement_system', 'odometer', 'odometer_unit', 'ownership_type', 'purchased_at', 'lease_expires_at', 'notes'];
+            Trailer::create(array_merge(array_intersect_key($data, array_flip($allowed)), ['company_uuid' => session('company')]));
+            $this->imported++;
+        }
+    }
+}

package/server/src/Models/Asset.php

@@ -5,6 +5,7 @@ namespace Fleetbase\FleetOps\Models;
 use Fleetbase\Casts\Json;
 use Fleetbase\Casts\PolymorphicType;
 use Fleetbase\FleetOps\Casts\Point;
+use Fleetbase\LaravelMysqlSpatial\Eloquent\SpatialTrait;
 use Fleetbase\Models\Category;
 use Fleetbase\Models\File;
 use Fleetbase\Models\Model;
@@ -33,6 +34,7 @@ use Spatie\Sluggable\SlugOptions;
  */
 class Asset extends Model
 {
+    use SpatialTrait;
     use HasUuid;
     use HasPublicId;
     use TracksApiCredential;
@@ -117,13 +119,37 @@ class Asset extends Model
         'odometer_unit',
         'transmission',
         'fuel_volume_unit',
-        'fuel_Type',
+        'fuel_type',
         'ownership_type',
         'engine_hours',
         'gvw',
         'capacity',
         'specs',
         'attributes',
+        'asset_class',
+        'online',
+        'last_online_at',
+        'telematics',
+        'purchased_at',
+        'length',
+        'width',
+        'height',
+        'tare_weight',
+        'gvwr',
+        'payload_capacity',
+        'cargo_volume',
+        'axle_count',
+        'tire_count',
+        'door_count',
+        'body_type',
+        'coupling_type',
+        'brake_type',
+        'abs_equipped',
+        'ebs_equipped',
+        'refrigerated',
+        'temperature_min',
+        'temperature_max',
+        'reefer_engine_hours',
         'notes',
         'slug',
     ];
@@ -158,15 +184,18 @@ class Asset extends Model
      * @var array
      */
     protected $casts = [
-        'year'             => 'integer',
-        'odometer'         => 'integer',
-        'engine_hours'     => 'integer',
-        'gvw'              => 'decimal:2',
-        'capacity'         => Json::class,
-        'specs'            => Json::class,
-        'attributes'       => Json::class,
-        'location'         => Point::class,
-        'assigned_to_type' => PolymorphicType::class,
+        'year'              => 'integer',
+        'odometer'          => 'integer',
+        'engine_hours'      => 'integer',
+        'gvw'               => 'decimal:2',
+        'capacity'          => Json::class,
+        'specs'             => Json::class,
+        'attributes'        => Json::class,
+        'location'          => Point::class,
+        'assigned_to_type'  => PolymorphicType::class,
+        'online'            => 'boolean',
+        'last_online_at'    => 'datetime',
+        'telematics'        => Json::class,
     ];
 
     /**

package/server/src/Models/AssetConnection.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Fleetbase\FleetOps\Models;
+
+use Fleetbase\Casts\Json;
+use Fleetbase\Casts\PolymorphicType;
+use Fleetbase\Models\Model;
+use Fleetbase\Traits\HasPublicId;
+use Fleetbase\Traits\HasUuid;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+use Illuminate\Database\Eloquent\SoftDeletes;
+
+class AssetConnection extends Model
+{
+    use HasUuid;
+    use HasPublicId;
+    use SoftDeletes;
+
+    protected $publicIdType = 'connection';
+    protected $fillable     = ['company_uuid', 'connector_type', 'connector_uuid', 'connected_type', 'connected_uuid', 'active_connected_uuid', 'active_connector_position', 'relationship_type', 'position', 'connected_at', 'disconnected_at', 'source', 'confidence', 'notes', 'meta', 'created_by_uuid', 'updated_by_uuid'];
+    protected $casts        = ['connector_type' => PolymorphicType::class, 'connected_type' => PolymorphicType::class, 'connected_at' => 'datetime', 'disconnected_at' => 'datetime', 'meta' => Json::class];
+
+    public function connector(): MorphTo
+    {
+        return $this->morphTo(__FUNCTION__, 'connector_type', 'connector_uuid');
+    }
+
+    public function connected(): MorphTo
+    {
+        return $this->morphTo(__FUNCTION__, 'connected_type', 'connected_uuid');
+    }
+
+    public function vehicle(): BelongsTo
+    {
+        return $this->belongsTo(Vehicle::class, 'connector_uuid', 'uuid');
+    }
+
+    public function trailer(): BelongsTo
+    {
+        return $this->belongsTo(Trailer::class, 'connected_uuid', 'uuid');
+    }
+}

package/server/src/Models/Device.php

@@ -5,6 +5,7 @@ namespace Fleetbase\FleetOps\Models;
 use Fleetbase\Casts\Json;
 use Fleetbase\Casts\PolymorphicType;
 use Fleetbase\FleetOps\Casts\Point;
+use Fleetbase\FleetOps\Exceptions\DeviceAlreadyAttachedException;
 use Fleetbase\LaravelMysqlSpatial\Eloquent\SpatialTrait;
 use Fleetbase\LaravelMysqlSpatial\Types\Point as SpatialPoint;
 use Fleetbase\Models\File;
@@ -280,6 +281,11 @@ class Device extends Model
         return $this->morphTo(__FUNCTION__, 'attachable_type', 'attachable_uuid');
     }
 
+    public function installations(): HasMany
+    {
+        return $this->hasMany(DeviceInstallation::class, 'device_uuid', 'uuid')->latest('installed_at');
+    }
+
     public function events(): HasMany
     {
         return $this->hasMany(DeviceEvent::class, 'device_uuid', 'uuid');
@@ -420,10 +426,31 @@ class Device extends Model
      */
     public function attachTo(Model $attachable): bool
     {
-        $updated = $this->update([
-            'attachable_type' => get_class($attachable),
-            'attachable_uuid' => $attachable->uuid,
-        ]);
+        if ($attachable->company_uuid && $this->company_uuid && $attachable->company_uuid !== $this->company_uuid) {
+            throw new \DomainException('Devices cannot be attached across companies.');
+        }
+
+        if ($this->attachable_type === get_class($attachable) && $this->attachable_uuid === $attachable->uuid) {
+            return true;
+        }
+
+        // Re-homing an installed device must be an explicit detach first, never a side effect.
+        if ($this->attachable_uuid) {
+            throw DeviceAlreadyAttachedException::for($this->attached_to_name);
+        }
+
+        $historyEnabled = app()->bound('db.schema') && \Illuminate\Support\Facades\Schema::hasTable('device_installations');
+        $updated        = \Illuminate\Support\Facades\DB::transaction(function () use ($attachable, $historyEnabled) {
+            if ($historyEnabled) {
+                DeviceInstallation::where('company_uuid', $this->company_uuid)->where('device_uuid', $this->uuid)->whereNull('removed_at')->lockForUpdate()->update(['removed_at' => now(), 'active_device_uuid' => null]);
+            }
+            $updated = $this->update(['attachable_type' => get_class($attachable), 'attachable_uuid' => $attachable->uuid]);
+            if ($historyEnabled) {
+                DeviceInstallation::create(['company_uuid' => $this->company_uuid, 'device_uuid' => $this->uuid, 'attachable_type' => get_class($attachable), 'attachable_uuid' => $attachable->uuid, 'active_device_uuid' => $this->uuid, 'installed_at' => now(), 'source' => 'manual']);
+            }
+
+            return $updated;
+        });
 
         if ($updated) {
             activity('device_attached')
@@ -447,10 +474,14 @@ class Device extends Model
         $oldAttachableType = $this->attachable_type;
         $oldAttachableUuid = $this->attachable_uuid;
 
-        $updated = $this->update([
-            'attachable_type' => null,
-            'attachable_uuid' => null,
-        ]);
+        $historyEnabled = app()->bound('db.schema') && \Illuminate\Support\Facades\Schema::hasTable('device_installations');
+        $updated        = \Illuminate\Support\Facades\DB::transaction(function () use ($historyEnabled) {
+            if ($historyEnabled) {
+                DeviceInstallation::where('company_uuid', $this->company_uuid)->where('device_uuid', $this->uuid)->whereNull('removed_at')->lockForUpdate()->update(['removed_at' => now(), 'active_device_uuid' => null]);
+            }
+
+            return $this->update(['attachable_type' => null, 'attachable_uuid' => null]);
+        });
 
         if ($updated) {
             activity('device_detached')

package/server/src/Models/DeviceInstallation.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Fleetbase\FleetOps\Models;
+
+use Fleetbase\Casts\Json;
+use Fleetbase\Casts\PolymorphicType;
+use Fleetbase\Models\Model;
+use Fleetbase\Traits\HasUuid;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+
+class DeviceInstallation extends Model
+{
+    use HasUuid;
+    protected $fillable = ['company_uuid', 'device_uuid', 'attachable_type', 'attachable_uuid', 'active_device_uuid', 'installed_at', 'removed_at', 'source', 'metadata'];
+    protected $casts    = ['attachable_type' => PolymorphicType::class, 'installed_at' => 'datetime', 'removed_at' => 'datetime', 'metadata' => Json::class];
+
+    public function device(): BelongsTo
+    {
+        return $this->belongsTo(Device::class, 'device_uuid', 'uuid');
+    }
+
+    public function attachable(): MorphTo
+    {
+        return $this->morphTo(__FUNCTION__, 'attachable_type', 'attachable_uuid');
+    }
+}

package/server/src/Models/Equipment.php

@@ -168,6 +168,7 @@ class Equipment extends Model
         Relation::morphMap([
             'fleet-ops:vehicle' => Vehicle::class,
             'fleet-ops:driver'  => Driver::class,
+            'fleet-ops:trailer' => Trailer::class,
         ]);
     }
 
@@ -243,6 +244,7 @@ class Equipment extends Model
         $this->attributes['equipable_type'] = match ($type) {
             'fleet-ops:vehicle', 'vehicle' => Utils::getMutationType('fleet-ops:vehicle'),
             'fleet-ops:driver', 'driver'   => Utils::getMutationType('fleet-ops:driver'),
+            'fleet-ops:trailer', 'trailer' => Utils::getMutationType('fleet-ops:trailer'),
             default                        => $type,
         };
     }