@fleetbase/fleetops-engine 0.6.47 → 0.6.49

package/server/config/telematics.php

@@ -106,6 +106,116 @@ return [
                 'pagination' => 'cursor',
             ],
         ],
+
+        [
+            'key' => 'afaqy',
+            'label' => 'AFAQY',
+            'type' => 'native',
+            'driver_class' => \Fleetbase\FleetOps\Support\Telematics\Providers\AfaqyProvider::class,
+            'icon' => 'https://api.afaqy.sa/docs/img/favicon.ico',
+            'description' => 'AFAQY AVL REST integration for unit discovery, live position, speed, heading, odometer, fuel, and signal data.',
+            'docs_url' => 'https://api.afaqy.sa/docs/',
+            'required_fields' => [
+                [
+                    'name' => 'base_url',
+                    'label' => 'Base URL',
+                    'type' => 'text',
+                    'placeholder' => 'https://api.afaqy.sa',
+                    'required' => false,
+                    'validation' => 'nullable|url',
+                ],
+                [
+                    'name' => 'username',
+                    'label' => 'Username',
+                    'type' => 'text',
+                    'placeholder' => 'Enter your AFAQY username',
+                    'required' => false,
+                    'validation' => 'required_without:token|string',
+                ],
+                [
+                    'name' => 'password',
+                    'label' => 'Password',
+                    'type' => 'password',
+                    'placeholder' => 'Enter your AFAQY password',
+                    'required' => false,
+                    'validation' => 'required_without:token|string',
+                ],
+                [
+                    'name' => 'token',
+                    'label' => 'Token',
+                    'type' => 'password',
+                    'placeholder' => 'Use an existing AFAQY token',
+                    'required' => false,
+                    'validation' => 'required_without:username|string',
+                ],
+            ],
+            'supports_webhooks' => false,
+            'supports_discovery' => true,
+            'metadata' => [
+                'rate_limit' => 60,
+                'pagination' => 'offset',
+                'capabilities' => ['tracking', 'speed', 'heading', 'odometer', 'fuel_level', 'ignition'],
+            ],
+        ],
+
+        [
+            'key' => 'safee',
+            'label' => 'Safee Tracking',
+            'type' => 'native',
+            'driver_class' => \Fleetbase\FleetOps\Support\Telematics\Providers\SafeeProvider::class,
+            'description' => 'Safee Tracking REST integration for vehicle discovery, last state, live positions, odometer, fuel, and sensor data.',
+            'required_fields' => [
+                [
+                    'name' => 'server_uri',
+                    'label' => 'Server URI',
+                    'type' => 'text',
+                    'placeholder' => 'https://tracking.example.com',
+                    'required' => true,
+                    'validation' => 'required|url',
+                ],
+                [
+                    'name' => 'realm_id',
+                    'label' => 'Realm ID',
+                    'type' => 'text',
+                    'placeholder' => 'Enter Safee realm ID',
+                    'required' => true,
+                ],
+                [
+                    'name' => 'client_id',
+                    'label' => 'Client ID',
+                    'type' => 'text',
+                    'placeholder' => 'Enter Safee client ID',
+                    'required' => true,
+                ],
+                [
+                    'name' => 'client_secret',
+                    'label' => 'Client Secret',
+                    'type' => 'password',
+                    'placeholder' => 'Enter Safee client secret',
+                    'required' => true,
+                ],
+                [
+                    'name' => 'username',
+                    'label' => 'Username',
+                    'type' => 'text',
+                    'placeholder' => 'Enter Safee username',
+                    'required' => true,
+                ],
+                [
+                    'name' => 'password',
+                    'label' => 'Password',
+                    'type' => 'password',
+                    'placeholder' => 'Enter Safee password',
+                    'required' => true,
+                ],
+            ],
+            'supports_webhooks' => false,
+            'supports_discovery' => true,
+            'metadata' => [
+                'rate_limit' => 3000,
+                'pagination' => 'none',
+                'capabilities' => ['tracking', 'speed', 'heading', 'odometer', 'fuel_level', 'ignition'],
+            ],
+        ],
     ]
 ];
-

package/server/migrations/2026_05_13_000001_repair_customer_contact_user_types.php

@@ -0,0 +1,86 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\Models\CompanyUser;
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     *
+     * @return void
+     */
+    public function up()
+    {
+        Contact::withoutGlobalScopes()
+            ->where('type', 'customer')
+            ->whereNull('deleted_at')
+            ->chunkById(100, function ($contacts) {
+                foreach ($contacts as $contact) {
+                    try {
+                        $contact->repairCustomerTypeInvariant(true);
+                    } catch (Throwable $e) {
+                        // Skip ambiguous or unrecoverable records; runtime invariants handle new writes.
+                    }
+                }
+            });
+
+        if (!$this->canUseCustomerRoleHint()) {
+            return;
+        }
+
+        DB::table('contacts')
+            ->select('contacts.id')
+            ->join('company_users', function ($join) {
+                $join->on('company_users.user_uuid', '=', 'contacts.user_uuid');
+                $join->on('company_users.company_uuid', '=', 'contacts.company_uuid');
+            })
+            ->join('model_has_roles', function ($join) {
+                $join->on('model_has_roles.model_uuid', '=', 'company_users.uuid');
+                $join->where('model_has_roles.model_type', CompanyUser::class);
+            })
+            ->join('roles', 'roles.id', '=', 'model_has_roles.role_id')
+            ->where('roles.name', 'Fleet-Ops Customer')
+            ->whereNull('contacts.deleted_at')
+            ->where(function ($query) {
+                $query->whereNull('contacts.type');
+                $query->orWhere('contacts.type', '!=', 'customer');
+            })
+            ->distinct()
+            ->orderBy('contacts.id')
+            ->chunk(100, function ($rows) {
+                foreach ($rows as $row) {
+                    $contact = Contact::withoutGlobalScopes()->find($row->id);
+                    if (!$contact) {
+                        continue;
+                    }
+
+                    try {
+                        $contact->repairCustomerTypeInvariant(true);
+                    } catch (Throwable $e) {
+                        // Skip ambiguous or unrecoverable records; role is only a recovery hint.
+                    }
+                }
+            });
+    }
+
+    /**
+     * Reverse the migrations.
+     *
+     * @return void
+     */
+    public function down()
+    {
+        // Data repair is intentionally not reversible.
+    }
+
+    private function canUseCustomerRoleHint(): bool
+    {
+        return Schema::hasTable('contacts')
+            && Schema::hasTable('company_users')
+            && Schema::hasTable('model_has_roles')
+            && Schema::hasTable('roles');
+    }
+};

package/server/migrations/2026_05_18_000001_add_license_expiry_to_drivers_table.php

@@ -0,0 +1,25 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    public function up()
+    {
+        Schema::table('drivers', function (Blueprint $table) {
+            if (!Schema::hasColumn('drivers', 'license_expiry')) {
+                $table->date('license_expiry')->nullable()->after('drivers_license_number')->index();
+            }
+        });
+    }
+
+    public function down()
+    {
+        Schema::table('drivers', function (Blueprint $table) {
+            if (Schema::hasColumn('drivers', 'license_expiry')) {
+                $table->dropColumn('license_expiry');
+            }
+        });
+    }
+};

package/server/seeders/Testing/Concerns/SeedsTestingData.php

@@ -0,0 +1,183 @@
+<?php
+
+namespace Fleetbase\FleetOps\Seeders\Testing\Concerns;
+
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\FleetOps\Models\Zone;
+use Fleetbase\LaravelMysqlSpatial\Types\LineString;
+use Fleetbase\LaravelMysqlSpatial\Types\MultiPolygon;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Fleetbase\LaravelMysqlSpatial\Types\Polygon;
+use Fleetbase\Models\Company;
+use Fleetbase\Seeders\Concerns\ResolvesSeedCompany;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\SoftDeletes;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\Schema;
+use Illuminate\Support\Str;
+
+trait SeedsTestingData
+{
+    use ResolvesSeedCompany;
+
+    protected const SEED_NAME = 'fleetops-testing';
+
+    protected function resolveCompany(): ?Company
+    {
+        return $this->resolveSeedCompany();
+    }
+
+    protected function prepareCompany(): ?Company
+    {
+        $company = $this->resolveCompany();
+        if (!$company) {
+            $this->command?->error('No company found. Create a Fleetbase company before running FleetOps testing seeders.');
+
+            return null;
+        }
+
+        session(['company' => $company->uuid]);
+
+        return $company;
+    }
+
+    protected function fixtureKey(string $seedId): string
+    {
+        return static::SEED_NAME . ':' . $seedId;
+    }
+
+    protected function meta(string $seedId, array $extra = []): array
+    {
+        return array_merge([
+            'seed'    => static::SEED_NAME,
+            'seed_id' => $seedId,
+        ], $extra);
+    }
+
+    protected function timestamp(int $hoursOffset = 0): Carbon
+    {
+        return Carbon::parse('2026-01-15 08:00:00', 'Asia/Singapore')->addHours($hoursOffset);
+    }
+
+    protected function point(float $lat, float $lng): Point
+    {
+        return new Point($lat, $lng);
+    }
+
+    protected function polygon(array $coordinates): Polygon
+    {
+        $points = array_map(fn (array $coordinate) => $this->point($coordinate[0], $coordinate[1]), $coordinates);
+        if ($points[0]->getLat() !== end($points)->getLat() || $points[0]->getLng() !== end($points)->getLng()) {
+            $points[] = $points[0];
+        }
+
+        return new Polygon([new LineString($points)]);
+    }
+
+    protected function multiPolygon(array $coordinates): MultiPolygon
+    {
+        return new MultiPolygon([$this->polygon($coordinates)]);
+    }
+
+    protected function createRecord(string $modelClass, array $attributes, bool $withoutEvents = false): Model
+    {
+        /** @var Model $model */
+        $model      = new $modelClass();
+        $attributes = $this->filterColumns($model, array_merge([
+            'uuid'       => (string) Str::uuid(),
+            'created_at' => $this->timestamp(),
+            'updated_at' => $this->timestamp(),
+        ], $attributes));
+
+        $model->forceFill($attributes);
+
+        if ($withoutEvents) {
+            $modelClass::withoutEvents(fn () => $model->save());
+        } else {
+            $model->save();
+        }
+
+        return $model;
+    }
+
+    protected function filterColumns(Model $model, array $attributes): array
+    {
+        $table = $model->getTable();
+
+        if (!Schema::hasTable($table)) {
+            return $attributes;
+        }
+
+        return array_filter(
+            $attributes,
+            fn (string $column) => Schema::hasColumn($table, $column),
+            ARRAY_FILTER_USE_KEY
+        );
+    }
+
+    protected function seededQuery(string $modelClass)
+    {
+        /** @var Model $model */
+        $model = new $modelClass();
+        $table = $model->getTable();
+        $query = $modelClass::query();
+
+        if (Schema::hasColumn($table, 'meta')) {
+            return $query->where('meta->seed', static::SEED_NAME);
+        }
+
+        if (Schema::hasColumn($table, '_key')) {
+            return $query->where('_key', 'like', static::SEED_NAME . ':%');
+        }
+
+        return $query->whereRaw('1 = 0');
+    }
+
+    protected function purgeModel(string $modelClass): void
+    {
+        /** @var Model $model */
+        $model = new $modelClass();
+        $query = $this->seededQuery($modelClass);
+
+        if (in_array(SoftDeletes::class, class_uses_recursive($modelClass), true)) {
+            $query->forceDelete();
+
+            return;
+        }
+
+        $query->delete();
+    }
+
+    protected function seededModel(string $modelClass, string $seedId): ?Model
+    {
+        /** @var Model $model */
+        $model = new $modelClass();
+        $table = $model->getTable();
+
+        if (Schema::hasColumn($table, 'meta')) {
+            return $modelClass::where('meta->seed', static::SEED_NAME)->where('meta->seed_id', $seedId)->first();
+        }
+
+        if (Schema::hasColumn($table, '_key')) {
+            return $modelClass::where('_key', $this->fixtureKey($seedId))->first();
+        }
+
+        return null;
+    }
+
+    protected function seededServiceArea(string $seedId): ?ServiceArea
+    {
+        /** @var ServiceArea|null $serviceArea */
+        $serviceArea = $this->seededModel(ServiceArea::class, $seedId);
+
+        return $serviceArea;
+    }
+
+    protected function seededZone(string $seedId): ?Zone
+    {
+        /** @var Zone|null $zone */
+        $zone = $this->seededModel(Zone::class, $seedId);
+
+        return $zone;
+    }
+}

package/server/seeders/Testing/ConnectivitySeeder.php

@@ -0,0 +1,212 @@
+<?php
+
+namespace Fleetbase\FleetOps\Seeders\Testing;
+
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\DeviceEvent;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\GeofenceEventLog;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Sensor;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Seeders\Testing\Concerns\SeedsTestingData;
+use Fleetbase\Models\Company;
+use Illuminate\Database\Seeder;
+use Illuminate\Support\Facades\DB;
+
+class ConnectivitySeeder extends Seeder
+{
+    use SeedsTestingData;
+
+    public function run(): void
+    {
+        $company = $this->prepareCompany();
+        if (!$company) {
+            return;
+        }
+
+        DB::transaction(function () use ($company) {
+            $this->purgeSeedData();
+            $telematics = $this->seedTelematics($company);
+            $devices    = $this->seedDevices($company, $telematics);
+            $this->seedSensors($company, $devices);
+            $this->seedDeviceEvents($company, $devices);
+            $this->seedGeofenceEvents($company);
+
+            $this->command?->info('Seeded FleetOps testing connectivity fixtures for company: ' . $company->public_id);
+        });
+    }
+
+    public function purgeSeedData(): void
+    {
+        if ($zone = $this->seededZone('cbd_zone')) {
+            GeofenceEventLog::where('geofence_uuid', $zone->uuid)
+                ->whereIn('event_type', ['entered', 'dwelled', 'exited'])
+                ->delete();
+        }
+
+        $this->purgeModel(DeviceEvent::class);
+        $this->purgeModel(Sensor::class);
+        $this->purgeModel(Device::class);
+        $this->purgeModel(Telematic::class);
+    }
+
+    protected function seedTelematics(Company $company): array
+    {
+        $telematics = [
+            'telematic_samsara'    => ['Samsara Sandbox', 'samsara', 'VG34', 'TM-SAM-001', 'active'],
+            'telematic_calculated' => ['Calculated Provider', 'calculated', 'SIM', 'TM-CALC-001', 'connected'],
+        ];
+
+        $models = [];
+        foreach ($telematics as $seedId => [$name, $provider, $model, $serial, $status]) {
+            $models[$seedId] = $this->createRecord(Telematic::class, [
+                '_key'             => $this->fixtureKey($seedId),
+                'company_uuid'     => $company->uuid,
+                'name'             => $name,
+                'provider'         => $provider,
+                'model'            => $model,
+                'serial_number'    => $serial,
+                'firmware_version' => '2026.01',
+                'status'           => $status,
+                'imei'             => '3569380356438' . ($provider === 'samsara' ? '01' : '02'),
+                'last_seen_at'     => $this->timestamp(1),
+                'last_metrics'     => ['signal' => 88, 'battery' => 94],
+                'config'           => ['fixture' => true],
+                'credentials'      => ['token' => 'testing-fixture-redacted'],
+                'meta'             => $this->meta($seedId),
+            ]);
+        }
+
+        return $models;
+    }
+
+    protected function seedDevices(Company $company, array $telematics): array
+    {
+        $vehicleCentral = $this->seededModel(Vehicle::class, 'van_central');
+        $vehicleEast    = $this->seededModel(Vehicle::class, 'van_east');
+        $devices        = [
+            'device_van_central' => ['CEN-01 OBD', 'OBD-II', 'Fleetbase Labs', 'DEV-CEN-001', 'telematic_samsara', $vehicleCentral, 1.2821, 103.8510, true, 'online'],
+            'device_van_east'    => ['EAS-01 Reefer', 'ColdChain-GW', 'Fleetbase Labs', 'DEV-EAST-001', 'telematic_calculated', $vehicleEast, 1.3522, 103.9442, true, 'online'],
+        ];
+
+        $models = [];
+        foreach ($devices as $seedId => [$name, $model, $manufacturer, $serial, $telematicSeedId, $vehicle, $lat, $lng, $online, $status]) {
+            $models[$seedId] = $this->createRecord(Device::class, [
+                '_key'              => $this->fixtureKey($seedId),
+                'company_uuid'      => $company->uuid,
+                'telematic_uuid'    => $telematics[$telematicSeedId]?->uuid,
+                'attachable_uuid'   => $vehicle?->uuid,
+                'attachable_type'   => Vehicle::class,
+                'type'              => 'tracker',
+                'device_id'         => strtoupper($seedId),
+                'internal_id'       => strtoupper($seedId),
+                'name'              => $name,
+                'model'             => $model,
+                'manufacturer'      => $manufacturer,
+                'serial_number'     => $serial,
+                'last_position'     => $this->point($lat, $lng),
+                'installation_date' => $this->timestamp(-720)->toDateString(),
+                'last_online_at'    => $this->timestamp(2),
+                'online'            => $online,
+                'status'            => $status,
+                'data_frequency'    => 60,
+                'notes'             => 'FleetOps testing fixture device.',
+                'data'              => ['speed_kmh' => 28, 'heading' => 92],
+                'options'           => ['fixture' => true],
+                'meta'              => $this->meta($seedId),
+            ]);
+        }
+
+        return $models;
+    }
+
+    protected function seedSensors(Company $company, array $devices): void
+    {
+        $sensors = [
+            'sensor_temperature' => ['device_van_east', 'Cargo Temperature', 'temperature', 'C', -2, 8, '4.2'],
+            'sensor_door'        => ['device_van_central', 'Cargo Door', 'door', 'state', 0, 1, 'closed'],
+        ];
+
+        foreach ($sensors as $seedId => [$deviceSeedId, $name, $sensorType, $unit, $min, $max, $lastValue]) {
+            $device = $devices[$deviceSeedId] ?? null;
+            $this->createRecord(Sensor::class, [
+                '_key'                => $this->fixtureKey($seedId),
+                'company_uuid'        => $company->uuid,
+                'device_uuid'         => $device?->uuid,
+                'name'                => $name,
+                'sensor_type'         => $sensorType,
+                'type'                => $sensorType,
+                'unit'                => $unit,
+                'min_threshold'       => $min,
+                'max_threshold'       => $max,
+                'threshold_inclusive' => true,
+                'last_reading_at'     => $this->timestamp(2),
+                'last_value'          => $lastValue,
+                'sensorable_type'     => Device::class,
+                'sensorable_uuid'     => $device?->uuid,
+                'status'              => 'active',
+                'meta'                => $this->meta($seedId),
+            ]);
+        }
+    }
+
+    protected function seedDeviceEvents(Company $company, array $devices): void
+    {
+        $events = [
+            'event_ignition_on'         => ['device_van_central', 'ignition_on', 'info', 'Vehicle ignition on'],
+            'event_temperature_warning' => ['device_van_east', 'temperature_threshold', 'warning', 'Cargo temperature near threshold'],
+        ];
+
+        foreach ($events as $seedId => [$deviceSeedId, $eventType, $severity, $reason]) {
+            $device = $devices[$deviceSeedId] ?? null;
+            $this->createRecord(DeviceEvent::class, [
+                '_key'         => $this->fixtureKey($seedId),
+                'company_uuid' => $company->uuid,
+                'device_uuid'  => $device?->uuid,
+                'payload'      => ['fixture' => true, 'event' => $eventType],
+                'meta'         => $this->meta($seedId),
+                'event_type'   => $eventType,
+                'severity'     => $severity,
+                'ident'        => strtoupper($seedId),
+                'protocol'     => 'testing',
+                'provider'     => 'fleetops-testing',
+                'state'        => $severity,
+                'code'         => strtoupper($eventType),
+                'reason'       => $reason,
+                'occurred_at'  => $this->timestamp(2),
+            ]);
+        }
+    }
+
+    protected function seedGeofenceEvents(Company $company): void
+    {
+        $driver  = $this->seededModel(Driver::class, 'driver_ava');
+        $vehicle = $this->seededModel(Vehicle::class, 'van_central');
+        $order   = $this->seededModel(Order::class, 'order_dispatched');
+        $zone    = $this->seededZone('cbd_zone');
+
+        if (!$driver || !$zone) {
+            return;
+        }
+
+        foreach (['entered', 'dwelled', 'exited'] as $index => $eventType) {
+            $this->createRecord(GeofenceEventLog::class, [
+                'company_uuid'             => $company->uuid,
+                'driver_uuid'              => $driver->uuid,
+                'vehicle_uuid'             => $vehicle?->uuid,
+                'order_uuid'               => $order?->uuid,
+                'geofence_uuid'            => $zone->uuid,
+                'geofence_type'            => 'zone',
+                'geofence_name'            => 'Marina Bay',
+                'event_type'               => $eventType,
+                'latitude'                 => 1.2821,
+                'longitude'                => 103.8510,
+                'speed_kmh'                => $eventType === 'dwelled' ? 0 : 22,
+                'dwell_duration_minutes'   => $eventType === 'dwelled' ? 18 : null,
+                'occurred_at'              => $this->timestamp($index),
+            ]);
+        }
+    }
+}