@fleetbase/fleetops-engine 0.6.65 → 0.6.67

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/Jobs/SyncTelematicDevicesJob.php

@@ -40,6 +40,7 @@ class SyncTelematicDevicesJob implements ShouldQueue
         $this->telematic = $telematic;
         $this->options   = $options;
         $this->jobId     = $jobId ?? \Illuminate\Support\Str::uuid()->toString();
+        $this->onQueue(\Fleetbase\FleetOps\Support\Telematics\Telemetry\Configuration::pollQueue());
     }
 
     /**
@@ -47,6 +48,24 @@ class SyncTelematicDevicesJob implements ShouldQueue
      */
     public function handle(TelematicProviderRegistry $registry, TelematicService $service): void
     {
+        // Jobs queued before a provider opts into batching must use the same bounded
+        // path as new manual requests, without acquiring the legacy hour-long lock.
+        $provider = $registry->resolve($this->telematic->provider);
+        if ($provider instanceof \Fleetbase\FleetOps\Contracts\TelemetryProviderInterface
+            && (\Fleetbase\FleetOps\Support\Telematics\Telemetry\Configuration::options($provider)['manual_batch_sync'] ?? false)) {
+            $this->telematic->refresh();
+            if (\Fleetbase\FleetOps\Support\Telematics\Telemetry\Inbox::enabled($this->telematic)) {
+                try {
+                    $service->queueTelemetrySync($this->telematic, $this->options, $this->jobId);
+                } catch (\Illuminate\Validation\ValidationException) {
+                    // Paused or already queued/running. Failing here would mark the connection
+                    // as errored and detach the active request's progress tracking.
+                    Log::info('Skipped legacy telematics sync redirect.', ['telematic_uuid' => $this->telematic->uuid]);
+                }
+            }
+
+            return;
+        }
         $correlationId = \Illuminate\Support\Str::uuid()->toString();
         $lockKey       = 'fleetops:sync-telematic-devices:' . $this->telematic->uuid;
         $lock          = Cache::lock($lockKey, $this->timeout + 60);
@@ -96,12 +115,54 @@ class SyncTelematicDevicesJob implements ShouldQueue
             $totalEnrichment            = 0;
             $totalEnrichmentCompleted   = 0;
             $totalEnrichmentFailures    = 0;
+            $itemsSinceCheckpoint       = 0;
+            $lastCheckpointAt           = now();
+
+            $checkpoint = function (string $phase, bool $force = false) use (
+                &$itemsSinceCheckpoint, &$lastCheckpointAt, &$providerSyncMeta, &$totalFetched,
+                &$totalLinked, &$totalLinkAttempts, &$totalEvents, &$totalSensors, &$totalSkipped,
+                &$pageCount, &$lastProviderAllCount, &$lastProviderFiltersCount,
+                &$inventoryFetched, &$inventoryLinked, &$inventorySkipped,
+                &$totalEnrichment, &$totalEnrichmentCompleted, &$totalEnrichmentFailures
+            ): void {
+                if (!$force && $itemsSinceCheckpoint < 25 && $lastCheckpointAt->diffInSeconds(now(), true) < 5) {
+                    return;
+                }
+                $this->telematic->status = 'synchronizing';
+                $this->telematic->meta   = array_merge($this->telematic->meta ?? [], $providerSyncMeta, [
+                    'last_sync_job_id'                  => $this->jobId,
+                    'last_sync_result'                  => 'running',
+                    'last_sync_phase'                   => $phase,
+                    'last_sync_progress_at'             => now()->toDateTimeString(),
+                    'last_sync_fetched_total'           => $totalFetched,
+                    'last_sync_linked_total'            => $totalLinked,
+                    'last_sync_link_attempts_total'     => $totalLinkAttempts,
+                    'last_sync_events_total'            => $totalEvents,
+                    'last_sync_sensors_total'           => $totalSensors,
+                    'last_sync_skipped_total'           => $totalSkipped,
+                    'last_sync_page_count'              => $pageCount,
+                    'last_sync_provider_total'          => $lastProviderFiltersCount ?? $lastProviderAllCount,
+                    'last_sync_provider_all_count'      => $lastProviderAllCount,
+                    'last_sync_provider_filters_count'  => $lastProviderFiltersCount,
+                    'last_sync_inventory_total'         => $inventoryFetched,
+                    'last_sync_inventory_linked_total'  => $inventoryLinked,
+                    'last_sync_inventory_skipped_total' => $inventorySkipped,
+                    'last_sync_enrichment_total'        => $totalEnrichment,
+                    'last_sync_enrichment_completed'    => $totalEnrichmentCompleted,
+                    'last_sync_enrichment_failures'     => $totalEnrichmentFailures,
+                ]);
+                $this->telematic->save();
+                $itemsSinceCheckpoint = 0;
+                $lastCheckpointAt     = now();
+            };
 
             try {
+                $checkpoint('connecting', true);
                 $provider = $registry->resolve($this->telematic->provider);
                 $provider->connect($this->telematic);
 
                 do {
+                    $checkpoint('fetching_inventory', true);
                     $response = $provider->fetchDevices([
                         'limit'   => $this->options['limit'] ?? null,
                         'cursor'  => $cursor,
@@ -137,6 +198,9 @@ class SyncTelematicDevicesJob implements ShouldQueue
                         'has_more'       => $response['has_more'] ?? false,
                     ]);
 
+                    // Persist retrieval before any potentially slow per-device database work.
+                    $inventoryFetched = $totalFetched;
+                    $checkpoint('ingesting_inventory', true);
                     foreach ($devices as $devicePayload) {
                         $normalizedDevice = $provider->normalizeDevice($devicePayload);
                         try {
@@ -162,7 +226,12 @@ class SyncTelematicDevicesJob implements ShouldQueue
                                 'imei'             => $devicePayload['imei'] ?? null,
                             ]);
                         }
+                        $inventoryLinked  = $totalLinked;
+                        $inventorySkipped = $totalSkipped;
+                        $itemsSinceCheckpoint++;
+                        $checkpoint('ingesting_inventory');
                     }
+                    $checkpoint('ingesting_inventory', true);
 
                     $cursor = $response['next_cursor'] ?? null;
 
@@ -221,6 +290,7 @@ class SyncTelematicDevicesJob implements ShouldQueue
                         'device_count'   => count($inventoryPayloads),
                     ]);
 
+                    $checkpoint('fetching_enrichment', true);
                     $enrichmentResponse = $provider->fetchDeviceTelemetrySnapshots($inventoryPayloads, [
                         'limit'   => $this->options['limit'] ?? null,
                         'filters' => $this->options['filters'] ?? [],
@@ -229,6 +299,7 @@ class SyncTelematicDevicesJob implements ShouldQueue
                     $enrichedDevices  = $enrichmentResponse['devices'] ?? [];
                     $totalEnrichment += count($enrichedDevices);
 
+                    $checkpoint('ingesting_enrichment', true);
                     foreach ($enrichedDevices as $devicePayload) {
                         $normalizedDevice = $provider->normalizeDevice($devicePayload);
                         try {
@@ -256,7 +327,10 @@ class SyncTelematicDevicesJob implements ShouldQueue
                                 'imei'             => $devicePayload['imei'] ?? null,
                             ]);
                         }
+                        $itemsSinceCheckpoint++;
+                        $checkpoint('ingesting_enrichment');
                     }
+                    $checkpoint('ingesting_enrichment', true);
 
                     Log::info($this->telematic->provider === 'safee' ? 'Safee telemetry enrichment completed' : 'Telematics telemetry enrichment completed', [
                         'correlation_id' => $correlationId,
@@ -289,6 +363,8 @@ class SyncTelematicDevicesJob implements ShouldQueue
                     'last_sync_job_id'                  => $this->jobId,
                     'last_sync_completed_at'            => now()->toDateTimeString(),
                     'last_sync_result'                  => 'success',
+                    'last_sync_phase'                   => 'completed',
+                    'last_sync_progress_at'             => now()->toDateTimeString(),
                     'last_sync_total'                   => $totalLinked,
                     'last_sync_fetched_total'           => $totalFetched,
                     'last_sync_linked_total'            => $totalLinked,
@@ -310,7 +386,7 @@ class SyncTelematicDevicesJob implements ShouldQueue
                     'last_sync_error_context'           => null,
                 ]);
                 $this->telematic->save();
-            } catch (\Exception $e) {
+            } catch (\Throwable $e) {
                 $failureContext = method_exists($e, 'context') ? $e->context() : [];
                 $failureMessage = $this->safeSyncErrorMessage($e);
 

package/server/src/Jobs/TestTelematicConnectionJob.php

@@ -37,6 +37,7 @@ class TestTelematicConnectionJob implements ShouldQueue
     {
         $this->telematic = $telematic;
         $this->jobId     = $jobId ?? Str::uuid()->toString();
+        $this->onQueue(\Fleetbase\FleetOps\Support\Telematics\Telemetry\Configuration::pollQueue());
     }
 
     /**

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

package/server/src/Models/InspectionForm.php

@@ -0,0 +1,240 @@
+<?php
+
+namespace Fleetbase\FleetOps\Models;
+
+use Fleetbase\Casts\Json;
+use Fleetbase\Casts\PolymorphicType;
+use Fleetbase\Models\Category;
+use Fleetbase\Models\CustomField;
+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 Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+use Illuminate\Support\Collection;
+use Spatie\Activitylog\LogOptions;
+use Spatie\Activitylog\Traits\LogsActivity;
+
+class InspectionForm extends Model
+{
+    use HasUuid;
+    use HasPublicId;
+    use TracksApiCredential;
+    use HasApiModelBehavior;
+    use LogsActivity;
+    use HasMetaAttributes;
+    use Searchable;
+    use HasCustomFields;
+
+    /**
+     * What a field built for an inspection form is filed under, so the
+     * platform's custom-field listings can tell an inspection field from a
+     * field added to the form record itself.
+     */
+    public const FIELD_FOR = 'fleetops_inspection_form';
+
+    /** The category kind a form's field groups are stored as. */
+    public const GROUP_FOR = 'custom_field_group';
+
+    /** The field types an inspection form may be built from. */
+    public const FIELD_TYPES = [
+        'pass-fail',
+        'input',
+        'textarea',
+        'number',
+        'select',
+        'radio-button',
+        'boolean',
+        'date-picker',
+        'date-time-input',
+        'file-upload',
+        'signature',
+    ];
+
+    protected $table             = 'inspection_forms';
+    protected $publicIdType      = 'inspection_form';
+    protected $searchableColumns = ['name', 'description', 'type', 'public_id'];
+    protected $filterParams      = ['status', 'type', 'subject_type', 'subject_uuid'];
+
+    protected $fillable = [
+        'company_uuid',
+        'name',
+        'description',
+        'type',
+        'status',
+        'subject_type',
+        'subject_uuid',
+        'items',
+        'settings',
+        'meta',
+        'published_at',
+        'created_by_uuid',
+        'updated_by_uuid',
+    ];
+
+    protected $casts = [
+        'items'        => Json::class,
+        'settings'     => Json::class,
+        'meta'         => Json::class,
+        'published_at' => 'datetime',
+        'subject_type' => PolymorphicType::class,
+    ];
+
+    protected $appends = ['subject_name', 'item_count', 'is_published'];
+    protected $with    = ['subject'];
+
+    protected static $logName         = 'inspection_form';
+    protected static $logAttributes   = '*';
+    protected static $submitEmptyLogs = false;
+
+    public function getActivitylogOptions(): LogOptions
+    {
+        return LogOptions::defaults()->logAll()->logOnlyDirty();
+    }
+
+    public function subject(): MorphTo
+    {
+        return $this->morphTo(__FUNCTION__, 'subject_type', 'subject_uuid');
+    }
+
+    public function submissions(): HasMany
+    {
+        return $this->hasMany(InspectionSubmission::class, 'inspection_form_uuid', 'uuid');
+    }
+
+    public function createdBy(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'created_by_uuid', 'uuid');
+    }
+
+    public function updatedBy(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'updated_by_uuid', 'uuid');
+    }
+
+    /**
+     * The groups the form's fields are laid out in: platform categories owned
+     * by the form, in the order the builder put them.
+     */
+    public function fieldGroups(): HasMany
+    {
+        return $this->hasMany(Category::class, 'owner_uuid', 'uuid')
+            ->where('for', static::GROUP_FOR)
+            ->orderByRaw('COALESCE(`order`, 999999), created_at');
+    }
+
+    /**
+     * The fields a driver fills in: platform custom fields whose subject is
+     * the form, filed under the inspection kind so a field attached to the
+     * form record by the console's generic custom-field panel is not one.
+     */
+    public function fields(): HasMany
+    {
+        return $this->hasMany(CustomField::class, 'subject_uuid', 'uuid')
+            ->where('for', static::FIELD_FOR)
+            ->orderByRaw('COALESCE(`order`, 999999), created_at');
+    }
+
+    /**
+     * The form as the driver sees it: every group with its fields inside,
+     * both sorted by `order` then creation, with the fields that belong to
+     * no group gathered into an "Ungrouped" tail.
+     *
+     * @return Category[]
+     */
+    public function getGroupedFieldsAttribute(): array
+    {
+        $this->loadMissing(['fieldGroups', 'fields']);
+
+        $fieldsByGroup = $this->fields->groupBy(fn (CustomField $field) => $field->category_uuid ?: '_ungrouped');
+
+        $grouped = static::sortByOrder($this->fieldGroups)->map(function (Category $group) use ($fieldsByGroup) {
+            $group->setRelation('fields', static::sortByOrder($fieldsByGroup->get($group->uuid, collect())));
+
+            return $group;
+        });
+
+        if ($fieldsByGroup->has('_ungrouped')) {
+            $ungrouped = new Category([
+                'name'       => 'Ungrouped',
+                'for'        => static::GROUP_FOR,
+                'owner_uuid' => $this->uuid,
+            ]);
+            $ungrouped->exists = false;
+            $ungrouped->setRelation('fields', static::sortByOrder($fieldsByGroup->get('_ungrouped')));
+            $grouped->push($ungrouped);
+        }
+
+        return $grouped->values()->all();
+    }
+
+    /**
+     * Sorts groups or fields the way the builder laid them out: an explicit
+     * `order` first (lowest first), then anything without one in creation order.
+     */
+    public static function sortByOrder(Collection $items): Collection
+    {
+        return $items->sort(function ($a, $b) {
+            $aOrder = $a->order === null ? null : (int) $a->order;
+            $bOrder = $b->order === null ? null : (int) $b->order;
+
+            if ($aOrder !== null && $bOrder !== null && $aOrder !== $bOrder) {
+                return $aOrder <=> $bOrder;
+            }
+
+            if ($aOrder !== null && $bOrder === null) {
+                return -1;
+            }
+
+            if ($aOrder === null && $bOrder !== null) {
+                return 1;
+            }
+
+            return (string) ($a->created_at ?? '') <=> (string) ($b->created_at ?? '');
+        })->values();
+    }
+
+    public function getSubjectNameAttribute(): ?string
+    {
+        return $this->subject?->name ?? $this->subject?->display_name ?? $this->subject?->public_id;
+    }
+
+    /**
+     * How many things a driver answers. Fields once the form has been built
+     * with them; the legacy checklist while it still is one.
+     */
+    public function getItemCountAttribute(): int
+    {
+        $fields = $this->relationLoaded('fields') ? $this->fields->count() : $this->fields()->count();
+        if ($fields > 0) {
+            return $fields;
+        }
+
+        return count($this->items ?? []);
+    }
+
+    public function getIsPublishedAttribute(): bool
+    {
+        return $this->status === 'published' && $this->published_at !== null;
+    }
+
+    public function publish(): bool
+    {
+        return $this->update([
+            'status'       => 'published',
+            'published_at' => $this->published_at ?? now(),
+        ]);
+    }
+
+    public function archive(): bool
+    {
+        return $this->update(['status' => 'archived']);
+    }
+}

package/server/src/Models/InspectionItemResult.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace Fleetbase\FleetOps\Models;
+
+use Fleetbase\Casts\Json;
+use Fleetbase\Models\Model;
+use Fleetbase\Models\User;
+use Fleetbase\Traits\HasApiModelBehavior;
+use Fleetbase\Traits\HasMetaAttributes;
+use Fleetbase\Traits\HasUuid;
+use Fleetbase\Traits\Searchable;
+use Fleetbase\Traits\TracksApiCredential;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Spatie\Activitylog\LogOptions;
+use Spatie\Activitylog\Traits\LogsActivity;
+
+class InspectionItemResult extends Model
+{
+    use HasUuid;
+    use TracksApiCredential;
+    use HasApiModelBehavior;
+    use LogsActivity;
+    use HasMetaAttributes;
+    use Searchable;
+
+    protected $table             = 'inspection_item_results';
+    protected $searchableColumns = ['label', 'category', 'comments'];
+    protected $filterParams      = ['status', 'severity', 'passed', 'inspection_submission_uuid', 'issue_uuid', 'work_order_uuid'];
+
+    protected $fillable = [
+        'company_uuid',
+        'inspection_submission_uuid',
+        'issue_uuid',
+        'work_order_uuid',
+        'item_key',
+        'label',
+        'category',
+        'status',
+        'severity',
+        'passed',
+        'comments',
+        'photos',
+        'meta',
+        'created_by_uuid',
+        'updated_by_uuid',
+    ];
+
+    protected $casts = [
+        'passed' => 'boolean',
+        'photos' => Json::class,
+        'meta'   => Json::class,
+    ];
+
+    protected $appends = ['submission_id'];
+    protected $with    = [];
+
+    protected static $logName         = 'inspection_item_result';
+    protected static $logAttributes   = '*';
+    protected static $submitEmptyLogs = false;
+
+    public function getActivitylogOptions(): LogOptions
+    {
+        return LogOptions::defaults()->logAll()->logOnlyDirty();
+    }
+
+    public function submission(): BelongsTo
+    {
+        return $this->belongsTo(InspectionSubmission::class, 'inspection_submission_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 createdBy(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'created_by_uuid', 'uuid');
+    }
+
+    public function getSubmissionIdAttribute(): ?string
+    {
+        return $this->submission?->public_id;
+    }
+}