@fleetbase/fleetops-engine 0.6.65 → 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/WorkOrder.php

@@ -75,6 +75,7 @@ class WorkOrder extends Model
      */
     protected $fillable = [
         'company_uuid',
+        'schedule_uuid',
         'code',
         'subject',
         'category',
@@ -97,6 +98,8 @@ class WorkOrder extends Model
         'cost_center',
         'budget_code',
         'meta',
+        'created_by_uuid',
+        'updated_by_uuid',
     ];
 
     /**

package/server/src/Observers/WorkOrderObserver.php

@@ -61,7 +61,7 @@ class WorkOrderObserver
             'maintainable_type'  => $workOrder->target_type,
             'maintainable_uuid'  => $workOrder->target_uuid,
             'type'               => 'scheduled',
-            'status'             => 'done',
+            'status'             => 'completed',
             'priority'           => $workOrder->priority,
             'scheduled_at'       => $workOrder->opened_at,
             'completed_at'       => $workOrder->closed_at ?? now(),

package/server/src/Providers/FleetOpsServiceProvider.php

@@ -76,6 +76,7 @@ class FleetOpsServiceProvider extends CoreServiceProvider
         \Fleetbase\FleetOps\Console\Commands\SendMaintenanceReminders::class,
         \Fleetbase\FleetOps\Console\Commands\ProcessOperationalAlerts::class,
         \Fleetbase\FleetOps\Console\Commands\SyncTelematics::class,
+        \Fleetbase\FleetOps\Console\Commands\DrainTelematicInbox::class,
     ];
 
     /**
@@ -149,6 +150,7 @@ class FleetOpsServiceProvider extends CoreServiceProvider
             $schedule->command('fleetops:send-maintenance-reminders')->daily()->withoutOverlapping()->storeOutputInDb();
             $schedule->command('fleetops:process-operational-alerts')->everyMinute()->withoutOverlapping()->storeOutputInDb();
             $schedule->command('fleetops:sync-telematics')->everyMinute()->withoutOverlapping()->storeOutputInDb();
+            $schedule->command('fleetops:drain-telematic-inbox')->everyMinute()->withoutOverlapping();
         });
         $this->registerNotifications();
         $this->registerAiCapabilities();
@@ -193,6 +195,8 @@ class FleetOpsServiceProvider extends CoreServiceProvider
         $this->loadViewsFrom(__DIR__ . '/../../resources/views', 'fleetops');
         $this->mergeConfigFrom(__DIR__ . '/../../config/fleetops.php', 'fleetops');
         $this->mergeConfigFrom(__DIR__ . '/../../config/telematics.php', 'telematics');
+        $this->mergeConfigFrom(__DIR__ . '/../../config/afaqy.php', 'telematics.afaqy');
+        $this->mergeConfigFrom(__DIR__ . '/../../config/telemetry.php', 'telematics.telemetry');
         $this->mergeConfigFrom(__DIR__ . '/../../config/fuel-providers.php', 'fuel-providers');
         $this->mergeConfigFrom(__DIR__ . '/../../config/api.php', 'api');
         $this->mergeConfigFrom(__DIR__ . '/../../config/cache.stores.php', 'cache.stores');
@@ -218,6 +222,11 @@ class FleetOpsServiceProvider extends CoreServiceProvider
             '\\Fleetbase\\Models\\Vehicle'  => \Fleetbase\FleetOps\Models\Vehicle::class,
             'fleet-ops:vehicle'             => \Fleetbase\FleetOps\Models\Vehicle::class,
             'fleet-ops:trailer'             => \Fleetbase\FleetOps\Models\Trailer::class,
+            // A photo or signature filed with an inspection is a platform file
+            // whose subject is the submission. The console names that subject
+            // the way Ember names it, so the alias has to resolve here.
+            'fleet-ops:inspection-submission' => \Fleetbase\FleetOps\Models\InspectionSubmission::class,
+            'fleet-ops:inspection-form'       => \Fleetbase\FleetOps\Models\InspectionForm::class,
         ]);
     }
 

package/server/src/Rules/Base64OrUrl.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Fleetbase\FleetOps\Rules;
+
+use Illuminate\Contracts\Validation\Rule;
+
+/**
+ * A photo as the driver app sends it: either a URL to an uploaded file, or the
+ * image bytes base64 encoded — bare, or as a `data:image/...;base64,` URI.
+ *
+ * Deliberately not a regex rule. A DVIR photo is easily a megabyte of base64,
+ * and running a backtracking pattern over that many characters is the kind of
+ * thing that only fails on a real handset. `base64_decode` in strict mode is
+ * linear and rejects anything outside the alphabet.
+ */
+class Base64OrUrl implements Rule
+{
+    /**
+     * Determine if the validation rule passes.
+     *
+     * @param string $attribute
+     */
+    public function passes($attribute, $value): bool
+    {
+        return static::isBase64OrUrl($value);
+    }
+
+    public static function isBase64OrUrl(mixed $value): bool
+    {
+        if (!is_string($value) || trim($value) === '') {
+            return false;
+        }
+
+        if (filter_var($value, FILTER_VALIDATE_URL) !== false) {
+            return true;
+        }
+
+        if (preg_match('#^data:[\w.+-]+/[\w.+-]+;base64,#i', $value, $prefix)) {
+            $value = substr($value, strlen($prefix[0]));
+        }
+
+        $stripped = preg_replace('/\s+/', '', $value);
+
+        return $stripped !== '' && base64_decode($stripped, true) !== false;
+    }
+
+    /**
+     * Get the validation error message.
+     */
+    public function message(): string
+    {
+        return 'The :attribute must be a base64 encoded image or a URL.';
+    }
+}