@fleetbase/fleetops-engine 0.6.64 → 0.6.66

package/server/src/Jobs/ProcessTelematicDelivery.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace Fleetbase\FleetOps\Jobs;
+
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Support\Telematics\TelematicService;
+use Fleetbase\FleetOps\Support\Telematics\Telemetry\Configuration;
+use Fleetbase\FleetOps\Support\Telematics\Telemetry\Inbox;
+use Fleetbase\FleetOps\Support\Telematics\Telemetry\Ingestor;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldBeUnique;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Crypt;
+use Illuminate\Support\Facades\DB;
+
+class ProcessTelematicDelivery implements ShouldQueue, ShouldBeUnique
+{
+    use Dispatchable;
+    use InteractsWithQueue;
+    use Queueable;
+
+    public int $uniqueFor = 300;
+
+    public function uniqueId(): string
+    {
+        return $this->deliveryUuid;
+    }
+
+    public int $tries   = 1;
+    public int $timeout = 60;
+
+    public function __construct(public string $deliveryUuid)
+    {
+    }
+
+    public function handle(Ingestor $ingestor, TelematicService $service): void
+    {
+        $lock = Cache::lock('telemetry:delivery:' . $this->deliveryUuid, 90);
+        if (!$lock->get()) {
+            return;
+        }
+        try {
+            $row = DB::table('telematic_deliveries')->where('uuid', $this->deliveryUuid)->first();
+            if (!$row || !in_array($row->status, ['pending', 'retry', 'processing'], true) || ($row->available_at && now()->lt($row->available_at))) {
+                return;
+            }
+            if ($row->attempts >= 5) {
+                $this->update(['status' => 'quarantined', 'failed' => max(1, $row->failed), 'error' => 'Worker retry budget exhausted; inspect and replay.']);
+                Inbox::finishRun($row->run_uuid);
+
+                return;
+            }
+            $telematic = Telematic::withoutGlobalScopes()->where('uuid', $row->telematic_uuid)->first();
+            if (!$telematic || !Inbox::enabled($telematic)) {
+                $this->update(['status' => 'quarantined', 'error' => 'Connection disabled or removed.', 'failed' => 1]);
+                Inbox::finishRun($row->run_uuid);
+
+                return;
+            }
+            $provider = Configuration::provider($telematic);
+            $options  = Configuration::options($provider);
+            if ($row->source === 'webhook' && !($options['webhooks_enabled'] ?? false)) {
+                return;
+            }
+            $this->update(['status' => 'processing', 'attempts' => $row->attempts + 1, 'available_at' => now()->addSeconds(120)]);
+            try {
+                $units = $provider->telemetryUnits(json_decode(Crypt::decryptString($row->retry_payload ?? $row->payload), true, 512, JSON_THROW_ON_ERROR));
+            } catch (\Throwable) {
+                $this->update(['status' => 'quarantined', 'failed' => 1, 'error' => 'Unsupported or unreadable position payload; inspect and replay after adapter correction.']);
+                Inbox::finishRun($row->run_uuid);
+
+                return;
+            }
+            $failed       = [];
+            $failureTypes = [];
+            $applied      = 0;
+            $invalid      = (int) $row->invalid_count;
+            $sourceDelay  = null;
+            $queueDelay   = max(0, now()->timestamp - \Illuminate\Support\Carbon::parse($row->received_at, 'UTC')->timestamp);
+            foreach ($units as $unit) {
+                try {
+                    $result      = $ingestor->ingest($telematic, $provider, $unit, $service, $row->received_at, $row->source);
+                    $sourceDelay = max($sourceDelay ?? 0, data_get($result['device']->meta, 'telemetry.source_delay_seconds', 0));
+                    if ($result['invalid_position']) {
+                        $invalid++;
+                    } else {
+                        $applied++;
+                    }
+                } catch (\Throwable $e) {
+                    $failed[]       = $unit;
+                    $failureTypes[] = class_basename($e);
+                }
+            }
+            $this->update(['queue_delay_seconds' => $queueDelay, 'source_delay_seconds' => $sourceDelay]);
+            if ($failed && $row->attempts < 4) {
+                $this->update([
+                    'status'  => 'retry', 'retry_payload' => Crypt::encryptString(json_encode($failed, JSON_THROW_ON_ERROR)),
+                    'applied' => $row->applied + $applied, 'failed' => count($failed) + $invalid, 'invalid_count' => $invalid,
+                    'error'   => 'Some units failed ingestion; retry scheduled. ' . implode(', ', array_unique($failureTypes)), 'available_at' => now()->addSeconds(15 * (2 ** $row->attempts)),
+                ]);
+            } else {
+                $this->update([
+                    'status'       => ($failed || $invalid) ? 'quarantined' : 'processed',
+                    'applied'      => $row->applied + $applied, 'failed' => count($failed) + $invalid, 'invalid_count' => $invalid,
+                    'error'        => ($failed || $invalid) ? 'Invalid positions or exhausted ingestion retries; inspect and replay.' : null,
+                    'processed_at' => now(),
+                ]);
+            }
+            Inbox::finishRun($row->run_uuid);
+        } finally {
+            $lock->release();
+        }
+    }
+
+    private function update(array $attributes): void
+    {
+        DB::table('telematic_deliveries')->where('uuid', $this->deliveryUuid)->update(array_merge($attributes, ['updated_at' => now()]));
+    }
+}

package/server/src/Jobs/SyncFuelProviderTransactionsJob.php

@@ -9,6 +9,7 @@ use Illuminate\Bus\Queueable;
 use Illuminate\Contracts\Queue\ShouldQueue;
 use Illuminate\Foundation\Bus\Dispatchable;
 use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\Middleware\WithoutOverlapping;
 use Illuminate\Queue\SerializesModels;
 use Illuminate\Support\Carbon;
 
@@ -23,6 +24,11 @@ class SyncFuelProviderTransactionsJob implements ShouldQueue
     {
     }
 
+    public function middleware(): array
+    {
+        return [(new WithoutOverlapping('fuel-provider:' . $this->connectionUuid))->releaseAfter(30)->expireAfter(1800)];
+    }
+
     public function handle(FuelProviderService $fuelProviderService): void
     {
         $connection = $this->findConnection();
@@ -45,16 +51,27 @@ class SyncFuelProviderTransactionsJob implements ShouldQueue
             $connection->update([
                 'status'          => 'error',
                 'last_error'      => $e->getMessage(),
-                'last_sync_state' => [
-                    'failed_at' => now()->toIso8601String(),
-                    'message'   => $e->getMessage(),
-                ],
             ]);
 
             throw $e;
         }
     }
 
+    public function failed(\Throwable $error): void
+    {
+        // Laravel calls this for terminal failures, including worker timeouts
+        // that never reach the catch block in handle().
+        $this->findSyncRun()?->update([
+            'status'      => 'error',
+            'finished_at' => now(),
+            'error'       => 'The background import stopped before completing. Retry this date range.',
+        ]);
+        FuelProviderConnection::where('uuid', $this->connectionUuid)->update([
+            'status'     => 'error',
+            'last_error' => 'The background import stopped before completing. Retry this date range.',
+        ]);
+    }
+
     protected function findConnection(): FuelProviderConnection
     {
         return FuelProviderConnection::where('uuid', $this->connectionUuid)->firstOrFail();

package/server/src/Mail/InspectionLinkPinMail.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Fleetbase\FleetOps\Mail;
+
+use Fleetbase\FleetOps\Models\InspectionLink;
+use Fleetbase\Models\User;
+use Illuminate\Bus\Queueable;
+use Illuminate\Mail\Mailable;
+use Illuminate\Mail\Mailables\Content;
+use Illuminate\Mail\Mailables\Envelope;
+use Illuminate\Queue\SerializesModels;
+
+/**
+ * An inspection link and its PIN, with a button that opens the inspection.
+ * Sent synchronously, so the PIN never sits in a queue's payload.
+ */
+class InspectionLinkPinMail extends Mailable
+{
+    use Queueable;
+    use SerializesModels;
+
+    public InspectionLink $link;
+    public string $pin;
+    public ?User $recipient;
+    public ?string $url;
+
+    public function __construct(InspectionLink $link, string $pin, ?User $recipient = null, ?string $url = null)
+    {
+        $this->link      = $link;
+        $this->pin       = $pin;
+        $this->recipient = $recipient;
+        $this->url       = $url;
+    }
+
+    /** The PIN is kept out of the subject, which a locked phone shows. */
+    public function envelope(): Envelope
+    {
+        return new Envelope(subject: 'Complete the ' . ($this->link->form?->name ?? 'inspection') . ' inspection');
+    }
+
+    public function content(): Content
+    {
+        return new Content(
+            markdown: 'fleetops::mail.inspection-link-pin',
+            with: [
+                'pin'         => $this->pin,
+                'url'         => $this->url,
+                'recipient'   => $this->recipient,
+                'form'        => $this->link->form,
+                'vehicle'     => $this->link->vehicle,
+                'sender'      => $this->link->createdBy,
+                'expiresAt'   => $this->link->expires_at,
+                'maxAttempts' => InspectionLink::MAX_PIN_ATTEMPTS,
+            ]
+        );
+    }
+}

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/Driver.php

@@ -57,6 +57,12 @@ class Driver extends Model
     use LogsActivity;
     use CausesActivity;
     use HasCustomFields;
+    /**
+     * Schedule item statuses in which a driver is expected on shift. The
+     * `schedule_items.status` enum has no `active`; a shift a driver is
+     * working is `in_progress`.
+     */
+    public const LIVE_SHIFT_STATUSES = ['pending', 'scheduled', 'confirmed', 'in_progress'];
 
     /**
      * The database table used by the model.
@@ -375,7 +381,7 @@ class Driver extends Model
     public function currentShift(): MorphOne
     {
         return $this->morphOne(ScheduleItem::class, 'assignee', 'assignee_type', 'assignee_uuid')
-            ->whereIn('status', ['scheduled', 'active'])
+            ->whereIn('status', static::LIVE_SHIFT_STATUSES)
             ->where('start_at', '<=', now())
             ->where('end_at', '>=', now())
             ->latest('start_at');
@@ -391,7 +397,7 @@ class Driver extends Model
 
         return $this->scheduleItems()
             ->whereDate('start_at', $date)
-            ->whereIn('status', ['pending', 'active'])
+            ->whereIn('status', static::LIVE_SHIFT_STATUSES)
             ->orderBy('start_at')
             ->first();
     }

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,
         };
     }

package/server/src/Models/FuelProviderTransaction.php

@@ -17,6 +17,7 @@ class FuelProviderTransaction extends Model
     use HasPublicId;
     use HasApiModelBehavior;
     use Searchable;
+    public bool $createdFuelReport = false;
 
     protected $table             = 'fuel_provider_transactions';
     protected $publicIdType      = 'fuel_provider_transaction';