@fleetbase/fleetops-engine 0.6.64 → 0.6.66

package/server/src/Models/InspectionSubmission.php

@@ -0,0 +1,440 @@
+<?php
+
+namespace Fleetbase\FleetOps\Models;
+
+use Fleetbase\Casts\Json;
+use Fleetbase\FleetOps\Support\InspectionFileStore;
+use Fleetbase\Models\Category;
+use Fleetbase\Models\CustomField;
+use Fleetbase\Models\CustomFieldValue;
+use Fleetbase\Models\File;
+use Fleetbase\Models\Model;
+use Fleetbase\Models\User;
+use Fleetbase\Traits\HasApiModelBehavior;
+use Fleetbase\Traits\HasCustomFields;
+use Fleetbase\Traits\HasMetaAttributes;
+use Fleetbase\Traits\HasPublicId;
+use Fleetbase\Traits\HasUuid;
+use Fleetbase\Traits\Searchable;
+use Fleetbase\Traits\TracksApiCredential;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Support\Str;
+use Spatie\Activitylog\LogOptions;
+use Spatie\Activitylog\Traits\LogsActivity;
+
+class InspectionSubmission extends Model
+{
+    use HasUuid;
+    use HasPublicId;
+    use TracksApiCredential;
+    use HasApiModelBehavior;
+    use LogsActivity;
+    use HasMetaAttributes;
+    use Searchable;
+    use HasCustomFields;
+
+    protected $table             = 'inspection_submissions';
+    protected $publicIdType      = 'inspection_submission';
+    protected $searchableColumns = ['public_id', 'type', 'status', 'result', 'vehicle.name', 'driver.name'];
+    protected $filterParams      = ['status', 'result', 'type', 'source', 'vehicle', 'driver', 'inspection_form_uuid'];
+
+    protected $fillable = [
+        'company_uuid',
+        'inspection_form_uuid',
+        'vehicle_uuid',
+        'driver_uuid',
+        'submitted_by_uuid',
+        'issue_uuid',
+        'work_order_uuid',
+        'type',
+        'status',
+        'result',
+        'source',
+        'odometer',
+        'engine_hours',
+        'total_items',
+        'failed_items',
+        'started_at',
+        'submitted_at',
+        'resolved_at',
+        'location',
+        'signature',
+        'attachments',
+        'meta',
+        'created_by_uuid',
+        'updated_by_uuid',
+    ];
+
+    protected $casts = [
+        'started_at'   => 'datetime',
+        'submitted_at' => 'datetime',
+        'resolved_at'  => 'datetime',
+        'location'     => Json::class,
+        'signature'    => Json::class,
+        'attachments'  => Json::class,
+        'meta'         => Json::class,
+        'odometer'     => 'integer',
+        'engine_hours' => 'integer',
+        'total_items'  => 'integer',
+        'failed_items' => 'integer',
+    ];
+
+    /**
+     * The column defaults, restored when a client sends null for them.
+     *
+     * An explicit null in an insert overrides the column's default rather than
+     * falling back to it, and these columns are NOT NULL. The console's model
+     * serialises every attribute, so it sent `total_items: null` and the insert
+     * was refused before the counts could be worked out from the answers.
+     */
+    public const COLUMN_DEFAULTS = [
+        'type'         => 'dvir',
+        'status'       => 'draft',
+        'total_items'  => 0,
+        'failed_items' => 0,
+    ];
+
+    protected static function booted(): void
+    {
+        static::saving(function (InspectionSubmission $submission) {
+            foreach (static::COLUMN_DEFAULTS as $column => $default) {
+                if ($submission->getAttribute($column) === null) {
+                    $submission->setAttribute($column, $default);
+                }
+            }
+        });
+    }
+
+    protected $appends = ['form_name', 'vehicle_name', 'driver_name', 'has_failures'];
+    protected $with    = ['form', 'vehicle', 'driver'];
+
+    protected static $logName         = 'inspection_submission';
+    protected static $logAttributes   = '*';
+    protected static $submitEmptyLogs = false;
+
+    public function getActivitylogOptions(): LogOptions
+    {
+        return LogOptions::defaults()->logAll()->logOnlyDirty();
+    }
+
+    public function form(): BelongsTo
+    {
+        return $this->belongsTo(InspectionForm::class, 'inspection_form_uuid', 'uuid');
+    }
+
+    public function vehicle(): BelongsTo
+    {
+        return $this->belongsTo(Vehicle::class, 'vehicle_uuid', 'uuid');
+    }
+
+    public function driver(): BelongsTo
+    {
+        return $this->belongsTo(Driver::class, 'driver_uuid', 'uuid');
+    }
+
+    public function submittedBy(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'submitted_by_uuid', 'uuid');
+    }
+
+    public function issue(): BelongsTo
+    {
+        return $this->belongsTo(Issue::class, 'issue_uuid', 'uuid');
+    }
+
+    public function workOrder(): BelongsTo
+    {
+        return $this->belongsTo(WorkOrder::class, 'work_order_uuid', 'uuid');
+    }
+
+    public function itemResults(): HasMany
+    {
+        return $this->hasMany(InspectionItemResult::class, 'inspection_submission_uuid', 'uuid');
+    }
+
+    public function failedItemResults(): HasMany
+    {
+        return $this->itemResults()->where('passed', false);
+    }
+
+    /**
+     * The photos and signatures filed with the inspection: platform files
+     * whose subject is the submission, however they arrived — inside the
+     * driver's submit body, or dropped on the console's Photos panel.
+     */
+    public function files(): HasMany
+    {
+        return $this->hasMany(File::class, 'subject_uuid', 'uuid')->orderBy('created_at');
+    }
+
+    /**
+     * Every `pass-fail` answer, as the row the rest of the platform reads.
+     *
+     * Issues, work orders and the history are all built from
+     * `inspection_item_results`; a form built from fields answers through
+     * custom-field values instead, so each pass-fail value is mirrored into
+     * a result row keyed the way the app keys it — the field's name, or its
+     * uuid when it has none. Rows for pass-fail fields the submission no
+     * longer answers are dropped; rows written any other way (a legacy
+     * checklist, the console's results editor) are left alone.
+     *
+     * @return int the number of result rows derived
+     */
+    public function syncItemResultsFromCustomFieldValues(): int
+    {
+        $this->unsetRelation('customFieldValues');
+        $this->load('customFieldValues.customField');
+
+        $answered = $this->customFieldValues->filter(fn (CustomFieldValue $value) => $value->customField?->type === 'pass-fail');
+        $groups   = Category::query()->whereIn('uuid', $answered->map(fn (CustomFieldValue $value) => $value->customField->category_uuid)->filter()->unique()->values())->pluck('name', 'uuid');
+        $unsafe   = false;
+        $kept     = [];
+
+        foreach ($answered as $value) {
+            /** @var CustomField $field */
+            $field         = $value->customField;
+            $answer        = is_array($value->value) ? $value->value : [];
+            $notApplicable = filter_var($answer['not_applicable'] ?? false, FILTER_VALIDATE_BOOLEAN);
+            $passed        = $notApplicable || filter_var($answer['passed'] ?? true, FILTER_VALIDATE_BOOLEAN);
+            $failed        = !$passed;
+            $isUnsafe      = $failed && filter_var($answer['unsafe'] ?? data_get($field->meta, 'unsafe_on_fail', false), FILTER_VALIDATE_BOOLEAN);
+            $unsafe        = $unsafe || $isUnsafe;
+            $itemKey       = static::itemKeyFor($field);
+
+            InspectionItemResult::updateOrCreate([
+                'inspection_submission_uuid' => $this->uuid,
+                'item_key'                   => $itemKey,
+            ], [
+                'company_uuid' => $this->company_uuid,
+                'label'        => $field->label ?? $field->name,
+                'category'     => $groups->get($field->category_uuid) ?? data_get($field->meta, 'category'),
+                'status'       => $notApplicable ? 'not_applicable' : ($passed ? 'passed' : 'failed'),
+                'severity'     => $failed ? ($answer['severity'] ?? data_get($field->meta, 'severity')) : null,
+                'passed'       => $passed,
+                'comments'     => $answer['comments'] ?? null,
+                'photos'       => array_values(array_filter((array) ($answer['photos'] ?? []), 'is_string')),
+                'meta'         => [
+                    'custom_field_uuid' => $field->uuid,
+                    'not_applicable'    => $notApplicable,
+                    'unsafe'            => $isUnsafe,
+                ],
+            ]);
+
+            $kept[] = $itemKey;
+        }
+
+        $stale = CustomField::query()
+            ->where('subject_uuid', $this->inspection_form_uuid)
+            ->where('for', InspectionForm::FIELD_FOR)
+            ->where('type', 'pass-fail')
+            ->get()
+            ->map(fn (CustomField $field) => static::itemKeyFor($field))
+            ->diff($kept)
+            ->values();
+        if ($stale->isNotEmpty()) {
+            $this->itemResults()->whereIn('item_key', $stale)->delete();
+        }
+
+        $meta = $this->meta ?? [];
+        if (($meta['unsafe'] ?? null) !== $unsafe) {
+            $this->update(['meta' => array_merge($meta, ['unsafe' => $unsafe])]);
+        }
+
+        InspectionFileStore::attachReferenced($this, $this->referencedFileUuids());
+        $this->unsetRelation('itemResults');
+
+        return count($kept);
+    }
+
+    /**
+     * The key a pass-fail field's result row is filed under. The app derives
+     * the same key (`field.name ?? field.id`), so a result the app built and
+     * one the server derived name the same item.
+     */
+    public static function itemKeyFor(CustomField $field): string
+    {
+        return $field->name ?: $field->uuid;
+    }
+
+    /**
+     * Every `file:<uuid>` the submission's values point at: file and
+     * signature values, and the photos inside a failed pass-fail answer.
+     *
+     * @return string[]
+     */
+    public function referencedFileUuids(): array
+    {
+        $uuids = [];
+        foreach ($this->customFieldValues as $value) {
+            $raw        = $value->getRawOriginal('value');
+            $candidates = is_array($value->value) ? (array) ($value->value['photos'] ?? []) : [$raw];
+            foreach ($candidates as $candidate) {
+                $uuid = InspectionFileStore::referencedUuid($candidate);
+                if ($uuid) {
+                    $uuids[] = $uuid;
+                }
+            }
+        }
+
+        return array_values(array_unique($uuids));
+    }
+
+    public function getFormNameAttribute(): ?string
+    {
+        return $this->form?->name;
+    }
+
+    public function getVehicleNameAttribute(): ?string
+    {
+        return $this->vehicle?->display_name ?? $this->vehicle?->name;
+    }
+
+    public function getDriverNameAttribute(): ?string
+    {
+        return $this->driver?->name;
+    }
+
+    public function getHasFailuresAttribute(): bool
+    {
+        return (int) $this->failed_items > 0 || $this->result === 'failed';
+    }
+
+    public function syncResultCounts(): bool
+    {
+        $total  = $this->itemResults()->count();
+        $failed = $this->failedItemResults()->count();
+
+        return $this->update([
+            'total_items'  => $total,
+            'failed_items' => $failed,
+            'result'       => $failed > 0 ? 'failed' : 'passed',
+            'status'       => $this->status === 'draft' ? 'submitted' : $this->status,
+            'submitted_at' => $this->submitted_at ?? now(),
+        ]);
+    }
+
+    public function createIssueFromFailures(): ?Issue
+    {
+        if (!$this->has_failures || $this->issue_uuid) {
+            return $this->issue;
+        }
+
+        $failedLabels = $this->failedItemResults()->limit(6)->pluck('label')->filter()->values()->all();
+        $issue        = Issue::create([
+            'company_uuid'      => $this->company_uuid,
+            'reported_by_uuid'  => $this->submitted_by_uuid,
+            'vehicle_uuid'      => $this->vehicle_uuid,
+            'driver_uuid'       => $this->driver_uuid,
+            'type'              => 'inspection',
+            'category'          => 'inspection_failed',
+            'location'          => $this->failureLocation(),
+            'title'             => 'Failed inspection: ' . ($this->vehicle_name ?? $this->public_id),
+            'report'            => empty($failedLabels) ? 'Inspection failed.' : 'Failed items: ' . implode(', ', $failedLabels),
+            'priority'          => $this->highestFailureSeverity(),
+            'status'            => 'pending',
+            'meta'              => [
+                'inspection_submission_uuid' => $this->uuid,
+                'inspection_submission_id'   => $this->public_id,
+                'inspection_form_uuid'       => $this->inspection_form_uuid,
+                'failed_items'               => $failedLabels,
+            ],
+        ]);
+
+        $this->update(['issue_uuid' => $issue->uuid]);
+
+        return $issue;
+    }
+
+    /**
+     * Where the failure was reported, for the issue it raises.
+     *
+     * `issues.location` is a spatial column with no default, so an insert that
+     * leaves it out is refused outright — MySQL 1364, which reached a driver
+     * filing a failed inspection as a 500. The submission's own coordinates
+     * come first, then the vehicle's last known position, then the driver's,
+     * and an empty point when nothing is known.
+     */
+    public function failureLocation(): Point
+    {
+        // Read here rather than through Utils::getPointFromMixed(), which
+        // throws when it cannot resolve a point: every source below is
+        // routinely empty, and an inspection must not fail for want of one.
+        foreach ([$this->location, $this->vehicle?->location, $this->driver?->location] as $candidate) {
+            if ($candidate instanceof Point) {
+                return $candidate;
+            }
+
+            $latitude  = data_get($candidate, 'latitude', data_get($candidate, 'lat'));
+            $longitude = data_get($candidate, 'longitude', data_get($candidate, 'lng'));
+
+            if (is_numeric($latitude) && is_numeric($longitude)) {
+                return new Point((float) $latitude, (float) $longitude);
+            }
+        }
+
+        return new Point(0, 0);
+    }
+
+    public function createWorkOrderFromFailures(): ?WorkOrder
+    {
+        if (!$this->has_failures || $this->work_order_uuid) {
+            return $this->workOrder;
+        }
+
+        $failedItems = $this->failedItemResults()->get();
+        $checklist   = $failedItems->map(fn (InspectionItemResult $item) => [
+            'title'      => $item->label,
+            'required'   => true,
+            'completed'  => false,
+            'source'     => 'inspection',
+            'item_key'   => $item->item_key,
+            'severity'   => $item->severity,
+            'created_at' => now(),
+        ])->values()->all();
+
+        $workOrder = WorkOrder::create([
+            'company_uuid'    => $this->company_uuid,
+            'subject'         => 'Inspection repair: ' . ($this->vehicle_name ?? $this->public_id),
+            'status'          => 'open',
+            'priority'        => $this->highestFailureSeverity(),
+            'target_type'     => $this->vehicle_uuid ? Vehicle::class : null,
+            'target_uuid'     => $this->vehicle_uuid,
+            'opened_at'       => now(),
+            'due_at'          => now()->addDays($this->highestFailureSeverity() === 'critical' ? 1 : 7),
+            'instructions'    => 'Resolve failed inspection items and record completion details.',
+            'checklist'       => $checklist,
+            'currency'        => $this->vehicle?->currency,
+            'created_by_uuid' => $this->submitted_by_uuid,
+            'meta'            => [
+                'source'                     => 'inspection',
+                'inspection_submission_uuid' => $this->uuid,
+                'inspection_submission_id'   => $this->public_id,
+                'issue_uuid'                 => $this->issue_uuid,
+            ],
+        ]);
+
+        $this->update(['work_order_uuid' => $workOrder->uuid]);
+        $this->failedItemResults()->update(['work_order_uuid' => $workOrder->uuid]);
+
+        return $workOrder;
+    }
+
+    public function highestFailureSeverity(): string
+    {
+        $severity = $this->failedItemResults()
+            ->pluck('severity')
+            ->map(fn ($value) => Str::slug((string) $value))
+            ->filter()
+            ->all();
+
+        foreach (['critical', 'high', 'medium', 'low'] as $candidate) {
+            if (in_array($candidate, $severity, true)) {
+                return $candidate;
+            }
+        }
+
+        return $this->has_failures ? 'high' : 'low';
+    }
+}

package/server/src/Models/Part.php

@@ -5,6 +5,7 @@ namespace Fleetbase\FleetOps\Models;
 use Fleetbase\Casts\Json;
 use Fleetbase\Casts\Money;
 use Fleetbase\Casts\PolymorphicType;
+use Fleetbase\FleetOps\Support\Radar\RadarRules;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\FleetOps\Traits\Maintainable;
 use Fleetbase\Models\Alert;
@@ -88,6 +89,8 @@ class Part extends Model
         'barcode',
         'description',
         'quantity_on_hand',
+        'reorder_point',
+        'reorder_quantity',
         'unit_cost',
         'msrp',
         'currency',
@@ -252,8 +255,12 @@ class Part extends Model
      */
     public function getIsLowStockAttribute(): bool
     {
-        $specs             = $this->specs ?? [];
-        $lowStockThreshold = $specs['low_stock_threshold'] ?? 5;
+        // One definition of "low", shared with the Radar low-stock rule: the
+        // reorder point when set, else the spec's threshold, else 5.
+        $lowStockThreshold = RadarRules::lowStockThreshold([
+            'reorder_point' => $this->reorder_point,
+            'specs'         => $this->specs,
+        ]);
 
         return $this->quantity_on_hand <= $lowStockThreshold;
     }

package/server/src/Models/Trailer.php

@@ -0,0 +1,181 @@
+<?php
+
+namespace Fleetbase\FleetOps\Models;
+
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Fleetbase\Models\Model;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasOne;
+
+class Trailer extends Asset
+{
+    public const ASSET_CLASS = 'trailer';
+
+    /**
+     * Lifecycle statuses. Attachment and connectivity are derived separately.
+     */
+    public const STATUSES = ['available', 'in_use', 'maintenance', 'out_of_service', 'retired'];
+
+    /**
+     * Stable trailer classification values shared by validation, import and the console.
+     */
+    public const TYPES = ['dry_van', 'reefer', 'flatbed', 'step_deck', 'lowboy', 'tanker', 'bulk', 'dump', 'chassis', 'curtain_side', 'car_carrier', 'livestock', 'logging', 'dolly', 'specialty', 'other'];
+
+    /**
+     * Ownership arrangements accepted for a trailer.
+     */
+    public const OWNERSHIP_TYPES = ['owned', 'leased', 'financed', 'rented'];
+
+    /**
+     * Keep the API payload identity independent from the shared assets table.
+     */
+    protected string $payloadKey = 'trailer';
+
+    protected $publicIdType = 'trailer';
+
+    protected $appends = ['category_name', 'vendor_name', 'warranty_name', 'current_location', 'photo_url', 'display_name', 'is_online', 'last_maintenance', 'next_maintenance_due', 'attachment_state', 'connectivity_status'];
+
+    protected $fillable = [
+        'company_uuid', 'category_uuid', 'vendor_uuid', 'warranty_uuid', 'telematic_uuid', 'current_place_uuid', 'photo_uuid',
+        'name', 'description', 'code', 'type', 'body_type', 'location', 'speed', 'heading', 'altitude', 'status', 'online', 'last_online_at',
+        'usage_type', 'vin', 'plate_number', 'make', 'model', 'year', 'color', 'serial_number', 'measurement_system', 'odometer', 'odometer_unit',
+        'ownership_type', 'engine_hours', 'length', 'width', 'height', 'tare_weight', 'gvwr', 'payload_capacity', 'cargo_volume', 'axle_count',
+        'tire_count', 'door_count', 'coupling_type', 'brake_type', 'abs_equipped', 'ebs_equipped', 'refrigerated', 'temperature_min',
+        'temperature_max', 'reefer_engine_hours', 'acquisition_cost', 'current_value', 'depreciation_rate', 'insurance_value', 'currency',
+        'financing_status', 'purchased_at', 'lease_expires_at', 'capacity', 'specs', 'attributes', 'telematics', 'notes', 'slug',
+    ];
+
+    protected $casts = [
+        'year'           => 'integer', 'odometer' => 'integer', 'engine_hours' => 'integer', 'axle_count' => 'integer', 'tire_count' => 'integer',
+        'door_count'     => 'integer', 'online' => 'boolean', 'abs_equipped' => 'boolean', 'ebs_equipped' => 'boolean', 'refrigerated' => 'boolean',
+        'last_online_at' => 'datetime', 'purchased_at' => 'date', 'lease_expires_at' => 'date', 'location' => \Fleetbase\FleetOps\Casts\Point::class,
+        'capacity'       => \Fleetbase\Casts\Json::class, 'specs' => \Fleetbase\Casts\Json::class, 'attributes' => \Fleetbase\Casts\Json::class,
+        'telematics'     => \Fleetbase\Casts\Json::class,
+    ];
+
+    protected static function booted(): void
+    {
+        static::addGlobalScope('trailer', fn (Builder $query) => $query->where($query->qualifyColumn('asset_class'), static::ASSET_CLASS));
+        static::creating(function (Trailer $trailer) {
+            $trailer->asset_class = static::ASSET_CLASS;
+            $trailer->status ??= 'available';
+        });
+        static::saving(fn (Trailer $trailer) => $trailer->asset_class = static::ASSET_CLASS);
+    }
+
+    /**
+     * Bulk removal never deletes a trailer that is still coupled to a vehicle: the
+     * active towing connection would be orphaned. Attached trailers are skipped, and
+     * the operation is refused outright when every selected trailer is attached.
+     */
+    public function bulkRemove($ids = [])
+    {
+        $ids      = array_values(array_filter(array_map('strval', (array) $ids), 'strlen'));
+        $selected = static::where('company_uuid', session('company'))
+            ->where(fn ($query) => $query->whereIn('uuid', $ids)->orWhereIn('public_id', $ids))
+            ->get(['uuid', 'public_id']);
+        $attachedUuids = AssetConnection::where('company_uuid', session('company'))
+            ->whereIn('active_connected_uuid', $selected->pluck('uuid'))
+            ->pluck('active_connected_uuid')
+            ->all();
+        $blocked = $selected
+            ->filter(fn (Trailer $trailer) => in_array($trailer->uuid, $attachedUuids, true))
+            ->flatMap(fn (Trailer $trailer) => [$trailer->uuid, $trailer->public_id])
+            ->all();
+        $deletable = array_values(array_filter($ids, fn ($id) => !in_array($id, $blocked, true)));
+
+        if (empty($deletable)) {
+            throw new \RuntimeException('Detach the selected trailers from their vehicles before deleting them.');
+        }
+
+        return parent::bulkRemove($deletable);
+    }
+
+    public function currentConnection(): HasOne
+    {
+        return $this->hasOne(AssetConnection::class, 'connected_uuid', 'uuid')
+            ->where('connected_type', static::class)->whereNotNull('active_connected_uuid')->whereNull('disconnected_at');
+    }
+
+    public function devices(): HasMany
+    {
+        return $this->hasMany(Device::class, 'attachable_uuid', 'uuid')->where('attachable_type', static::class);
+    }
+
+    public function equipments(): HasMany
+    {
+        return $this->hasMany(Equipment::class, 'equipable_uuid', 'uuid')->where('equipable_type', static::class);
+    }
+
+    public function positions(): HasMany
+    {
+        return $this->hasMany(Position::class, 'subject_uuid', 'uuid')->where('subject_type', static::class);
+    }
+
+    public function maintenances(): HasMany
+    {
+        return $this->hasMany(Maintenance::class, 'maintainable_uuid', 'uuid')->where('maintainable_type', static::class);
+    }
+
+    public function maintenanceSchedules(): HasMany
+    {
+        return $this->hasMany(MaintenanceSchedule::class, 'subject_uuid', 'uuid')->where('subject_type', static::class);
+    }
+
+    public function workOrders(): HasMany
+    {
+        return $this->hasMany(WorkOrder::class, 'target_uuid', 'uuid')->where('target_type', static::class);
+    }
+
+    public function connections(): HasMany
+    {
+        return $this->hasMany(AssetConnection::class, 'connected_uuid', 'uuid')->where('connected_type', static::class)->latest('connected_at');
+    }
+
+    public function createPosition(array $attributes = [], Model|string|null $destination = null): ?Position
+    {
+        $latitude  = $attributes['latitude'] ?? null;
+        $longitude = $attributes['longitude'] ?? null;
+        if ($latitude === null || $longitude === null) {
+            return null;
+        }
+
+        return Position::create([
+            'company_uuid'     => $this->company_uuid,
+            'subject_uuid'     => $this->uuid,
+            'subject_type'     => static::class,
+            'destination_uuid' => $destination instanceof Model ? $destination->uuid : $destination,
+            'coordinates'      => new Point((float) $latitude, (float) $longitude),
+            'heading'          => $attributes['heading'] ?? null,
+            'bearing'          => $attributes['bearing'] ?? null,
+            'speed'            => $attributes['speed'] ?? null,
+            'altitude'         => $attributes['altitude'] ?? null,
+        ]);
+    }
+
+    public function getCurrentVehicleAttribute(): ?Vehicle
+    {
+        return $this->currentConnection?->vehicle;
+    }
+
+    public function getAttachmentStateAttribute(): string
+    {
+        return $this->currentConnection ? 'attached' : 'detached';
+    }
+
+    public function getConnectivityStatusAttribute(): string
+    {
+        if (!$this->last_online_at) {
+            return 'never_connected';
+        }
+        if ($this->last_online_at->gte(now()->subMinutes(10))) {
+            return 'online';
+        }
+        if ($this->last_online_at->gte(now()->subDay())) {
+            return 'recently_offline';
+        }
+
+        return 'offline';
+    }
+}

package/server/src/Models/Vehicle.php

@@ -375,6 +375,19 @@ class Vehicle extends Model
         return $this->hasMany(Equipment::class, 'equipable_uuid', 'uuid')->where('equipable_type', static::class);
     }
 
+    public function trailerConnections(): HasMany
+    {
+        return $this->hasMany(AssetConnection::class, 'connector_uuid', 'uuid')->where('connector_type', static::class)->latest('connected_at');
+    }
+
+    public function currentTrailers(): HasManyThrough
+    {
+        return $this->hasManyThrough(Trailer::class, AssetConnection::class, 'connector_uuid', 'uuid', 'uuid', 'connected_uuid')
+            ->where('asset_connections.connector_type', static::class)
+            ->where('asset_connections.connected_type', Trailer::class)
+            ->whereNull('asset_connections.disconnected_at');
+    }
+
     public function maintenances(): HasMany
     {
         return $this->hasMany(Maintenance::class, 'maintainable_uuid', 'uuid')->where('maintainable_type', static::class);