@fleetbase/fleetops-engine 0.6.65 → 0.6.66

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

@@ -0,0 +1,84 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Resources\v1;
+
+use Fleetbase\FleetOps\Support\InspectionLinkPin;
+use Fleetbase\Http\Resources\FleetbaseResource;
+use Fleetbase\Support\Http;
+
+/**
+ * A public inspection link, as the console lists it.
+ *
+ * `state` is the computed one — active, expired, used or revoked — not the
+ * stored `status`, because a link that has run out of time still says
+ * `active` in the column. `url` is the link itself, present only for links
+ * minted since the token has been kept.
+ */
+class InspectionLink extends FleetbaseResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @param \Illuminate\Http\Request $request
+     *
+     * @return array
+     */
+    public function toArray($request)
+    {
+        $internal = Http::isInternalRequest();
+
+        return [
+            // Always the public id: it is what identifies a link back to the
+            // revoke endpoint. `$this->id` is the table's auto-increment
+            // column, which no lookup here resolves — a list built from it
+            // could show links but never revoke one.
+            'id'             => $this->public_id,
+            'uuid'           => $this->when($internal, $this->uuid),
+            'public_id'      => $this->when($internal, $this->public_id),
+            'path'           => $this->path,
+            'state'          => $this->state,
+            'status'         => $this->status,
+            'single_use'     => (bool) $this->single_use,
+            'has_pin'        => $this->hasPin(),
+            // Shown in the console, like the link, so a dispatcher can read it
+            // out or send it again. Never on a public request.
+            'pin'            => $this->when($internal, fn () => $this->pin),
+            'pin_sent_via'   => $this->pin_sent_via,
+            'pin_sent_at'    => $this->pin_sent_at,
+            'pin_attempts'   => $this->when($internal, fn () => (int) $this->pin_attempts),
+            'recipient'      => $this->when($internal, function () {
+                $recipient = InspectionLinkPin::recipientFor($this->resource);
+
+                return $recipient ? ['name' => $recipient->name] : null;
+            }),
+            'can_send_pin'   => $this->when($internal, function () {
+                $recipient = InspectionLinkPin::recipientFor($this->resource);
+
+                return [
+                    'email' => InspectionLinkPin::unavailableReason($recipient, 'email') === null,
+                    'sms'   => InspectionLinkPin::unavailableReason($recipient, 'sms') === null,
+                ];
+            }),
+            'assignee'       => $this->assignee ? [
+                'id'   => $this->assignee->public_id,
+                'name' => $this->assignee->name,
+            ] : null,
+            'driver'         => $this->driver ? [
+                'id'   => $this->driver->public_id,
+                'name' => $this->driver->name,
+            ] : null,
+            'vehicle'        => $this->vehicle ? [
+                'id'   => $this->vehicle->public_id,
+                'name' => $this->vehicle->display_name ?? $this->vehicle->name,
+            ] : null,
+            'created_by'     => $this->createdBy ? [
+                'id'   => $this->createdBy->public_id,
+                'name' => $this->createdBy->name,
+            ] : null,
+            'expires_at'     => $this->expires_at,
+            'last_viewed_at' => $this->last_viewed_at,
+            'used_at'        => $this->used_at,
+            'created_at'     => $this->created_at,
+        ];
+    }
+}

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

@@ -0,0 +1,173 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Resources\v1;
+
+use Fleetbase\FleetOps\Support\InspectionFileStore;
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Http\Resources\FleetbaseResource;
+use Fleetbase\Http\Resources\User;
+use Fleetbase\Models\CustomFieldValue;
+use Fleetbase\Models\File;
+use Fleetbase\Support\Http;
+
+class InspectionSubmission extends FleetbaseResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @param \Illuminate\Http\Request $request
+     *
+     * @return array
+     */
+    public function toArray($request)
+    {
+        $data = $this->withCustomFields([
+            'id'                   => $this->when(Http::isInternalRequest(), $this->id, $this->public_id),
+            'uuid'                 => $this->when(Http::isInternalRequest(), $this->uuid),
+            'public_id'            => $this->when(Http::isInternalRequest(), $this->public_id),
+            'company_uuid'         => $this->when(Http::isInternalRequest(), $this->company_uuid),
+            'inspection_form_uuid' => $this->when(Http::isInternalRequest(), $this->inspection_form_uuid),
+            'vehicle_uuid'         => $this->when(Http::isInternalRequest(), $this->vehicle_uuid),
+            'driver_uuid'          => $this->when(Http::isInternalRequest(), $this->driver_uuid),
+            'submitted_by_uuid'    => $this->when(Http::isInternalRequest(), $this->submitted_by_uuid),
+            'issue_uuid'           => $this->when(Http::isInternalRequest(), $this->issue_uuid),
+            'work_order_uuid'      => $this->when(Http::isInternalRequest(), $this->work_order_uuid),
+            'form'                 => $this->whenLoaded('form', fn () => new InspectionForm($this->form)),
+            'vehicle'              => $this->whenLoaded('vehicle', fn () => new Vehicle($this->vehicle)),
+            'driver'               => $this->whenLoaded('driver', fn () => new Driver($this->driver)),
+            'submitted_by'         => $this->whenLoaded('submittedBy', fn () => new User($this->submittedBy)),
+            'issue'                => $this->whenLoaded('issue', fn () => new Issue($this->issue)),
+            'work_order'           => $this->whenLoaded('workOrder', fn () => new WorkOrder($this->workOrder)),
+            'item_results'         => InspectionItemResult::collection($this->whenLoaded('itemResults')),
+            'type'                 => $this->type,
+            'status'               => $this->status,
+            'result'               => $this->result,
+            'source'               => $this->source,
+            'odometer'             => $this->odometer,
+            'engine_hours'         => $this->engine_hours,
+            'total_items'          => $this->total_items,
+            'failed_items'         => $this->failed_items,
+            'location'             => data_get($this, 'location', (object) []),
+            'signature'            => data_get($this, 'signature', (object) []),
+            'attachments'          => data_get($this, 'attachments', []),
+            'meta'                 => data_get($this, 'meta', Utils::createObject()),
+            'form_name'            => $this->form_name,
+            'vehicle_name'         => $this->vehicle_name,
+            'driver_name'          => $this->driver_name,
+            'has_failures'         => $this->has_failures,
+            'started_at'           => $this->started_at,
+            'submitted_at'         => $this->submitted_at,
+            'resolved_at'          => $this->resolved_at,
+            'updated_at'           => $this->updated_at,
+            'created_at'           => $this->created_at,
+        ]);
+
+        // The platform's own `withCustomFields` puts the raw value models
+        // under `custom_field_values` for the console. What both consoles and
+        // the app want is the field's identity beside its answer, with file
+        // references resolved, so that projection replaces it.
+        //
+        // A form has `fields`; a submission has `answers` to them. The stored
+        // shape is the platform's custom-field values, but that is how it is
+        // built rather than what it is, and an integrator reading a DVIR
+        // should not have to know the difference.
+        $answers = $this->projectCustomFieldValues();
+        if (Http::isInternalRequest()) {
+            $data['custom_field_values'] = $answers;
+        }
+        $data['answers'] = $answers;
+        $data['files']   = $this->projectFiles();
+
+        return $data;
+    }
+
+    /**
+     * The answers, as the app and the console read them: which field, what it
+     * is called, its type, and the value with every `file:<uuid>` resolved to
+     * something fetchable.
+     */
+    protected function projectCustomFieldValues(): array
+    {
+        // `withCustomFields()` has already loaded the values and the fields
+        // they answer, so there is nothing to guard against here.
+        $internal = Http::isInternalRequest();
+
+        return collect($this->resource?->customFieldValues)->map(function (CustomFieldValue $value) use ($internal) {
+            $field = $value->customField;
+            $row   = [
+                // The field's public id, as the form hands it out. `value_type`
+                // describes how the answer is stored, which is the platform's
+                // business and not an integrator's, so it stays internal.
+                'field'      => $internal ? $value->custom_field_uuid : ($field?->public_id ?? $value->custom_field_uuid),
+                'name'       => $field?->name,
+                'label'      => $field?->label ?? $value->custom_field_label,
+                'type'       => $field?->type ?? $value->value_type,
+                'value'      => static::projectValue($value),
+            ];
+
+            if ($internal) {
+                $row['custom_field'] = $value->custom_field_uuid;
+                $row['value_type']   = $value->value_type;
+                $row['uuid']          = $value->uuid;
+                $row['category_uuid'] = $field?->category_uuid;
+                $row['order']         = $field?->order === null ? null : (int) $field->order;
+                $row['meta']          = is_array($field?->meta) && !empty($field->meta) ? $field->meta : (object) [];
+            }
+
+            return $row;
+        })->values()->all();
+    }
+
+    /**
+     * One stored value, with file references resolved. A pass-fail answer
+     * carries its photos inside it, so those are resolved too.
+     */
+    protected static function projectValue(CustomFieldValue $value): mixed
+    {
+        $raw = $value->getRawOriginal('value');
+
+        if (in_array($value->value_type, ['object', 'array'], true)) {
+            $decoded = is_string($raw) ? json_decode($raw, true) : $raw;
+            if (!is_array($decoded)) {
+                return $decoded;
+            }
+
+            if (isset($decoded['photos']) && is_array($decoded['photos'])) {
+                $decoded['photos'] = array_values(array_map(fn ($photo) => InspectionFileStore::project($photo), $decoded['photos']));
+            }
+
+            return $decoded;
+        }
+
+        // A value column is a string, so a meter reading comes back as one.
+        // The app compares and charts these; hand it the number it wrote.
+        if ($value->value_type === 'number') {
+            return is_numeric($raw) ? $raw + 0 : $raw;
+        }
+
+        if ($value->value_type === 'boolean') {
+            return filter_var($raw, FILTER_VALIDATE_BOOLEAN);
+        }
+
+        return InspectionFileStore::project($raw);
+    }
+
+    /** The photos and signatures filed with the inspection. */
+    protected function projectFiles(): array
+    {
+        if (!$this->resource || !$this->resource->relationLoaded('files')) {
+            return [];
+        }
+
+        return $this->resource->files->map(fn (File $file) => [
+            'id'                => $file->public_id ?? $file->uuid,
+            'uuid'              => $file->uuid,
+            'url'               => $file->url,
+            'original_filename' => $file->original_filename,
+            'content_type'      => $file->content_type,
+            'type'              => $file->type,
+            'caption'           => $file->caption,
+            'created_at'        => $file->created_at,
+        ])->values()->all();
+    }
+}

package/server/src/Jobs/PollTelematicTelemetry.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace Fleetbase\FleetOps\Jobs;
+
+use Fleetbase\FleetOps\Contracts\TelemetryProviderInterface;
+use Fleetbase\FleetOps\Exceptions\TelematicRateLimitExceededException;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Support\Telematics\TelematicProviderRegistry;
+use Fleetbase\FleetOps\Support\Telematics\Telemetry\Configuration;
+use Fleetbase\FleetOps\Support\Telematics\Telemetry\Inbox;
+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\DB;
+use Illuminate\Support\Str;
+
+class PollTelematicTelemetry implements ShouldQueue, ShouldBeUnique
+{
+    use Dispatchable;
+    use InteractsWithQueue;
+    use Queueable;
+
+    public int $tries     = 5;
+    public int $timeout   = 120;
+    public int $uniqueFor = 3600;
+
+    public function __construct(public string $telematicUuid)
+    {
+    }
+
+    public function uniqueId(): string
+    {
+        return $this->telematicUuid;
+    }
+
+    public function backoff(): array
+    {
+        return [15, 60, 180, 300];
+    }
+
+    public function handle(TelematicProviderRegistry $registry, Inbox $inbox): void
+    {
+        $telematic = Telematic::withoutGlobalScopes()->where('uuid', $this->telematicUuid)->first();
+        if (!$telematic || !Inbox::enabled($telematic)) {
+            return;
+        }
+        $provider = $registry->resolve($telematic->provider);
+        if (!$provider instanceof TelemetryProviderInterface) {
+            return;
+        }
+        $options = Configuration::options($provider);
+        if (!($options['polling_enabled'] ?? false)) {
+            return;
+        }
+        // Coalesce ticks while a previous sweep is still being ingested.
+        if (DB::table('telematic_deliveries')->where('telematic_uuid', $this->telematicUuid)->where('source', 'poll')->whereIn('status', ['pending', 'retry', 'processing'])->exists()) {
+            return;
+        }
+        $lock = Cache::lock('telemetry:poll:' . $this->telematicUuid, 150);
+        if (!$lock->get()) {
+            return;
+        }
+        $run = (string) Str::uuid();
+        DB::table('telematic_sync_runs')->insert(['uuid' => $run, 'telematic_uuid' => $telematic->uuid, 'status' => 'fetching', 'created_at' => now(), 'updated_at' => now()]);
+        try {
+            $provider->connect($telematic);
+            $cursor  = null;
+            $cursors = [];
+            $seen    = [];
+            $started = microtime(true);
+            for ($page = 0; $page < ($options['max_pages'] ?? 100); $page++) {
+                if (microtime(true) - $started > 90) {
+                    throw new \RuntimeException('Polling time budget exceeded; sweep incomplete.');
+                }
+                $response = $provider->fetchDevices(['limit' => $options['page_size'] ?? 1000, 'cursor' => $cursor, 'timeout' => 20, 'connect_timeout' => 5]);
+                $received = now()->utc();
+                $units    = $response['devices'];
+                $ids      = array_map(fn ($unit) => $provider->normalizeDevice($unit)['device_id'] ?? null, $units);
+                foreach ($ids as $id) {
+                    if (!$id || isset($seen[(string) $id])) {
+                        throw new \RuntimeException('Repeated or unidentified unit; sweep incomplete.');
+                    }
+                    $seen[(string) $id] = true;
+                }
+                foreach (array_chunk($units, max(1, (int) ($options['batch_size'] ?? 100))) as $batch) {
+                    $inbox->accept($telematic, $batch, 'poll', $run, $received->toDateTimeString());
+                }
+                DB::table('telematic_sync_runs')->where('uuid', $run)->update(['pages' => $page + 1, 'units' => count($seen), 'updated_at' => now()]);
+                if (!$response['has_more']) {
+                    DB::table('telematic_sync_runs')->where('uuid', $run)->update(['status' => 'ingesting', 'updated_at' => now()]);
+                    Inbox::finishRun($run);
+
+                    return;
+                }
+                $next = $response['next_cursor'];
+                if ($next === null || isset($cursors[(string) $next]) || (string) $next === (string) $cursor) {
+                    throw new \RuntimeException('Non-advancing pagination; sweep incomplete.');
+                }
+                $cursors[(string) $next] = true;
+                $cursor                  = $next;
+            }
+            throw new \RuntimeException('Maximum page count reached; sweep incomplete.');
+        } catch (\Throwable $e) {
+            DB::table('telematic_sync_runs')->where('uuid', $run)->update(['status' => 'incomplete', 'error' => $e instanceof TelematicRateLimitExceededException ? 'Rate limited; retry scheduled.' : 'Polling failed; retry scheduled. ' . class_basename($e), 'updated_at' => now()]);
+            if ($e instanceof TelematicRateLimitExceededException && $this->job) {
+                $this->release($e->context()['retry_after'] ?? 60);
+
+                return;
+            }
+            throw $e;
+        } finally {
+            $lock->release();
+        }
+    }
+}

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/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/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';