@fleetbase/fleetops-engine 0.6.42 → 0.6.44

package/addon/services/geofence-event-bus.js

@@ -0,0 +1,223 @@
+import Service from '@ember/service';
+import { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { action } from '@ember/object';
+import { debug } from '@ember/debug';
+
+/**
+ * GeofenceEventBus
+ *
+ * A singleton service that subscribes to the company-level geofence WebSocket
+ * channel and maintains a live feed of geofence events (entered, exited, dwelled).
+ *
+ * Other components (e.g. the live map, the geofence events panel) inject this
+ * service and observe `this.events` to react to incoming events.
+ *
+ * Usage:
+ *   @service geofenceEventBus;
+ *
+ *   // In a template: {{#each this.geofenceEventBus.events as |event|}} ...
+ *   // In JS: this.geofenceEventBus.on('geofence.entered', this.handleEntry);
+ */
+export default class GeofenceEventBusService extends Service {
+    @service socket;
+    @service currentUser;
+    @service universe;
+
+    /**
+     * Live event feed — most recent events at the front.
+     * Capped at MAX_EVENTS to prevent unbounded memory growth.
+     *
+     * @type {Array}
+     */
+    @tracked events = [];
+
+    /**
+     * Whether the service has successfully subscribed to the socket channel.
+     *
+     * @type {boolean}
+     */
+    @tracked isSubscribed = false;
+
+    /**
+     * Maximum number of events to retain in the live feed.
+     */
+    MAX_EVENTS = 100;
+
+    /**
+     * The geofence event types to listen for.
+     */
+    GEOFENCE_EVENTS = ['geofence.entered', 'geofence.exited', 'geofence.dwelled'];
+
+    /**
+     * Internal map of event type → array of handler functions.
+     * Supports the simple pub/sub API.
+     *
+     * @type {Map}
+     */
+    #handlers = new Map();
+
+    /**
+     * The active socket channel subscription.
+     */
+    #channel = null;
+
+    /**
+     * Subscribe to the company geofence channel.
+     * Should be called once after the user session is established.
+     *
+     * @param {string} companyUuid - The company UUID to subscribe to
+     */
+    @action
+    async subscribe(companyUuid) {
+        if (this.isSubscribed || !companyUuid) {
+            return;
+        }
+
+        try {
+            const socketInstance = this.socket.instance();
+            const channelId = `company.${companyUuid}`;
+
+            this.#channel = socketInstance.subscribe(channelId);
+            if (this.#channel.state !== 'subscribed') {
+                await this.#channel.subscribe();
+            }
+
+            this.isSubscribed = true;
+            debug(`[GeofenceEventBus] Subscribed to channel: ${channelId}`);
+
+            // Start consuming events from the channel
+            (async () => {
+                for await (const output of this.#channel) {
+                    const { event, data } = output;
+
+                    if (this.GEOFENCE_EVENTS.includes(event)) {
+                        this.#handleIncomingEvent(event, data);
+                    }
+                }
+            })();
+        } catch (error) {
+            debug(`[GeofenceEventBus] Failed to subscribe: ${error.message}`);
+        }
+    }
+
+    /**
+     * Unsubscribe from the geofence channel and clear state.
+     * Called on user logout or session end.
+     */
+    @action
+    unsubscribe() {
+        if (this.#channel) {
+            this.#channel.close();
+            this.#channel = null;
+        }
+        this.isSubscribed = false;
+        this.events = [];
+        this.#handlers.clear();
+        debug('[GeofenceEventBus] Unsubscribed.');
+    }
+
+    /**
+     * Register a handler function for a specific geofence event type.
+     *
+     * @param {string}   eventType - 'geofence.entered' | 'geofence.exited' | 'geofence.dwelled'
+     * @param {Function} handler   - Called with the normalised event object
+     */
+    on(eventType, handler) {
+        if (!this.#handlers.has(eventType)) {
+            this.#handlers.set(eventType, []);
+        }
+        this.#handlers.get(eventType).push(handler);
+    }
+
+    /**
+     * Unregister a previously registered handler.
+     *
+     * @param {string}   eventType
+     * @param {Function} handler
+     */
+    off(eventType, handler) {
+        if (!this.#handlers.has(eventType)) {
+            return;
+        }
+        const handlers = this.#handlers.get(eventType).filter((h) => h !== handler);
+        this.#handlers.set(eventType, handlers);
+    }
+
+    /**
+     * Clear the live event feed.
+     */
+    @action
+    clearFeed() {
+        this.events = [];
+    }
+
+    @action
+    seedEvents(events = []) {
+        this.events = Array.isArray(events) ? events.slice(0, this.MAX_EVENTS).map((event) => ({ ...event, isNew: false })) : [];
+    }
+
+    /**
+     * Process an incoming geofence event from the WebSocket channel.
+     *
+     * @param {string} eventType
+     * @param {Object} data
+     */
+    #handleIncomingEvent(eventType, data) {
+        const normalised = this.normalizeEvent(eventType, data);
+
+        // Prepend and cap
+        this.events = [normalised, ...this.events].slice(0, this.MAX_EVENTS);
+
+        setTimeout(() => {
+            this.events = this.events.map((event) => (event.id === normalised.id ? { ...event, isNew: false } : event));
+        }, 3000);
+
+        debug(`[GeofenceEventBus] ${eventType} — driver: ${normalised.driverName}, geofence: ${normalised.geofenceName}`);
+
+        // Notify registered handlers
+        const handlers = this.#handlers.get(eventType) ?? [];
+        handlers.forEach((handler) => {
+            try {
+                handler(normalised);
+            } catch (e) {
+                debug(`[GeofenceEventBus] Handler error for ${eventType}: ${e.message}`);
+            }
+        });
+
+        // Also emit on the universe bus so any component can react
+        this.universe.trigger(`fleet-ops.geofence.${eventType.replace('geofence.', '')}`, normalised);
+    }
+
+    /**
+     * Normalise a raw WebSocket payload into a consistent display object.
+     *
+     * @param {string} eventType
+     * @param {Object} raw
+     * @returns {Object}
+     */
+    normalizeEvent(eventType, raw) {
+        const subject = raw.subject ?? null;
+        const subjectType = subject?.type ?? (raw.vehicle && !raw.driver ? 'vehicle' : 'driver');
+        const subjectName = subject?.name ?? raw.driver?.name ?? raw.vehicle?.name ?? raw.vehicle?.plate ?? 'Unknown Subject';
+        return {
+            id: raw.id ?? raw.uuid ?? `${Date.now()}-${Math.random()}`,
+            eventType,
+            occurredAt: raw.occurred_at ?? new Date().toISOString(),
+            subjectType,
+            subjectName,
+            driverName: raw.driver?.name ?? null,
+            driverUuid: raw.driver?.uuid ?? null,
+            vehicleName: raw.vehicle?.name ?? null,
+            vehiclePlate: raw.vehicle?.plate ?? null,
+            geofenceName: raw.geofence?.name ?? 'Unknown Geofence',
+            geofenceUuid: raw.geofence?.uuid ?? null,
+            geofenceType: raw.geofence?.type ?? 'zone',
+            orderPublicId: raw.order?.id ?? null,
+            latitude: raw.location?.latitude ?? null,
+            longitude: raw.location?.longitude ?? null,
+            dwellMinutes: raw.dwell_duration_minutes ?? null,
+            isNew: true,
+        };
+    }
+}

package/app/components/{modals/set-password.js → map/drawer/geofence-event-listing.js}

@@ -1 +1 @@
-export { default } from '@fleetbase/fleetops-engine/components/modals/set-password';
+export { default } from '@fleetbase/fleetops-engine/components/map/drawer/geofence-event-listing';

package/app/services/geofence-event-bus.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/services/geofence-event-bus';

package/composer.json

@@ -1,6 +1,6 @@
 {
     "name": "fleetbase/fleetops-api",
-    "version": "0.6.42",
+    "version": "0.6.44",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "keywords": [
         "fleetbase-extension",

package/extension.json

@@ -1,6 +1,6 @@
 {
     "name": "Fleet-Ops",
-    "version": "0.6.42",
+    "version": "0.6.44",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "repository": "https://github.com/fleetbase/fleetops",
     "license": "AGPL-3.0-or-later",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fleetbase/fleetops-engine",
-    "version": "0.6.42",
+    "version": "0.6.44",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "fleetbase": {
         "route": "fleet-ops"
@@ -44,7 +44,7 @@
         "@babel/core": "^7.23.2",
         "@fleetbase/ember-core": "^0.3.18",
         "@fleetbase/ember-ui": "^0.3.26",
-        "@fleetbase/fleetops-data": "^0.1.28",
+        "@fleetbase/fleetops-data": "^0.1.29",
         "@fleetbase/leaflet-routing-machine": "^3.2.17",
         "@fortawesome/ember-fontawesome": "^2.0.0",
         "@fortawesome/fontawesome-svg-core": "6.4.0",

package/server/migrations/2026_04_05_000001_add_geofence_config_to_zones_table.php

@@ -0,0 +1,48 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     *
+     * Adds geofence trigger configuration columns to the zones table,
+     * enabling each zone to be configured as an active geofence with
+     * entry/exit/dwell event triggers.
+     */
+    public function up(): void
+    {
+        Schema::table('zones', function (Blueprint $table) {
+            // Whether to fire a GeofenceEntered event when a driver enters this zone
+            $table->boolean('trigger_on_entry')->default(true)->after('stroke_color');
+
+            // Whether to fire a GeofenceExited event when a driver exits this zone
+            $table->boolean('trigger_on_exit')->default(true)->after('trigger_on_entry');
+
+            // Minutes a driver must remain inside before a GeofenceDwelled event fires.
+            // NULL disables dwell tracking for this zone.
+            $table->unsignedSmallInteger('dwell_threshold_minutes')->nullable()->after('trigger_on_exit');
+
+            // Optional speed limit (km/h) enforced within this zone.
+            // NULL means no speed limit is configured.
+            $table->unsignedSmallInteger('speed_limit_kmh')->nullable()->after('dwell_threshold_minutes');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('zones', function (Blueprint $table) {
+            $table->dropColumn([
+                'trigger_on_entry',
+                'trigger_on_exit',
+                'dwell_threshold_minutes',
+                'speed_limit_kmh',
+            ]);
+        });
+    }
+};

package/server/migrations/2026_04_05_000002_add_geofence_config_to_service_areas_table.php

@@ -0,0 +1,38 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     *
+     * Adds geofence trigger configuration columns to the service_areas table,
+     * enabling each service area to act as an active geofence boundary.
+     */
+    public function up(): void
+    {
+        Schema::table('service_areas', function (Blueprint $table) {
+            $table->boolean('trigger_on_entry')->default(true)->after('stroke_color');
+            $table->boolean('trigger_on_exit')->default(true)->after('trigger_on_entry');
+            $table->unsignedSmallInteger('dwell_threshold_minutes')->nullable()->after('trigger_on_exit');
+            $table->unsignedSmallInteger('speed_limit_kmh')->nullable()->after('dwell_threshold_minutes');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('service_areas', function (Blueprint $table) {
+            $table->dropColumn([
+                'trigger_on_entry',
+                'trigger_on_exit',
+                'dwell_threshold_minutes',
+                'speed_limit_kmh',
+            ]);
+        });
+    }
+};

package/server/migrations/2026_04_05_000003_create_driver_geofence_states_table.php

@@ -0,0 +1,62 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     *
+     * Creates the driver_geofence_states table which acts as the state machine
+     * store for the geofencing engine. It tracks whether each driver is currently
+     * inside each geofence, enabling the system to detect transitions (entry/exit)
+     * rather than just evaluating current position in isolation.
+     *
+     * One record exists per driver-geofence pair. Records are upserted on each
+     * location update where a crossing is detected.
+     */
+    public function up(): void
+    {
+        Schema::create('driver_geofence_states', function (Blueprint $table) {
+            $table->id();
+            $table->uuid('driver_uuid')->index();
+            $table->uuid('geofence_uuid')->index();
+
+            // Discriminator: 'zone' or 'service_area'
+            $table->string('geofence_type', 50)->default('zone');
+
+            // Whether the driver is currently inside this geofence
+            $table->boolean('is_inside')->default(false)->index();
+
+            // Timestamp of when the driver most recently entered this geofence
+            $table->timestamp('entered_at')->nullable();
+
+            // Timestamp of when the driver most recently exited this geofence
+            $table->timestamp('exited_at')->nullable();
+
+            // Queue job ID of the pending CheckGeofenceDwell job.
+            // Stored so it can be cancelled if the driver exits before the dwell threshold.
+            $table->string('dwell_job_id')->nullable();
+
+            $table->timestamps();
+
+            // Composite unique key: one state record per driver-geofence pair
+            $table->unique(['driver_uuid', 'geofence_uuid'], 'driver_geofence_unique');
+
+            // Cascade delete when the driver is deleted
+            $table->foreign('driver_uuid')
+                ->references('uuid')
+                ->on('drivers')
+                ->onDelete('cascade');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('driver_geofence_states');
+    }
+};

package/server/migrations/2026_04_05_000004_create_geofence_events_log_table.php

@@ -0,0 +1,66 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     *
+     * Creates the geofence_events_log table which provides a persistent,
+     * queryable audit trail of all geofence events (entered, exited, dwelled).
+     * This table powers the reporting dashboard, dwell time analytics, and
+     * geofence activity history views.
+     */
+    public function up(): void
+    {
+        Schema::create('geofence_events_log', function (Blueprint $table) {
+            $table->id();
+            $table->uuid('uuid')->unique()->index();
+            $table->uuid('company_uuid')->index();
+            $table->uuid('driver_uuid')->index();
+            $table->uuid('vehicle_uuid')->nullable()->index();
+            $table->uuid('order_uuid')->nullable()->index();
+            $table->uuid('geofence_uuid')->index();
+
+            // Discriminator: 'zone' or 'service_area'
+            $table->string('geofence_type', 50)->default('zone');
+
+            // Snapshot of the geofence name at the time of the event
+            $table->string('geofence_name')->nullable();
+
+            // The type of geofence event
+            $table->enum('event_type', ['entered', 'exited', 'dwelled'])->index();
+
+            // Driver location at the time of the event
+            $table->decimal('latitude', 10, 7)->nullable();
+            $table->decimal('longitude', 10, 7)->nullable();
+
+            // Driver speed at the time of the event (km/h)
+            $table->decimal('speed_kmh', 8, 2)->nullable();
+
+            // Populated for 'exited' and 'dwelled' events
+            $table->unsignedInteger('dwell_duration_minutes')->nullable();
+
+            // The precise time the event occurred (not the DB insert time)
+            $table->timestamp('occurred_at')->index();
+
+            $table->timestamps();
+
+            // Composite indexes for common query patterns
+            $table->index(['company_uuid', 'occurred_at'], 'gel_company_occurred_idx');
+            $table->index(['geofence_uuid', 'occurred_at'], 'gel_geofence_occurred_idx');
+            $table->index(['driver_uuid', 'occurred_at'], 'gel_driver_occurred_idx');
+            $table->index(['order_uuid', 'event_type'], 'gel_order_event_idx');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('geofence_events_log');
+    }
+};

package/server/migrations/2026_04_08_000001_add_orchestrator_columns_to_vehicles_table.php

@@ -1,7 +1,9 @@
 <?php
+
 use Illuminate\Database\Migrations\Migration;
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
+
 /**
  * Add Orchestrator constraint columns to the vehicles table.
  *
@@ -34,6 +36,7 @@ return new class extends Migration {
             $table->boolean('return_to_depot')->default(true)->after('time_window_end');
         });
     }
+
     public function down(): void
     {
         Schema::table('vehicles', function (Blueprint $table) {

package/server/migrations/2026_04_08_000004_add_orchestrator_columns_to_payloads_table.php

@@ -1,7 +1,9 @@
 <?php
+
 use Illuminate\Database\Migrations\Migration;
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
+
 /**
  * Add Orchestrator capacity columns to the payloads table.
  *
@@ -24,6 +26,7 @@ return new class extends Migration {
             $table->unsignedInteger('capacity_parcels')->nullable()->after('capacity_pallets');
         });
     }
+
     public function down(): void
     {
         Schema::table('payloads', function (Blueprint $table) {

package/server/migrations/2026_04_14_000001_drop_redundant_capacity_columns_from_payloads_table.php

@@ -1,7 +1,9 @@
 <?php
+
 use Illuminate\Database\Migrations\Migration;
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
+
 /**
  * Drop redundant denormalised capacity columns from the payloads table.
  *

package/server/migrations/2026_04_14_000002_rename_capacity_columns_on_vehicles_table.php

@@ -1,7 +1,9 @@
 <?php
+
 use Illuminate\Database\Migrations\Migration;
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
+
 /**
  * Correct orchestrator capacity column names on the vehicles table.
  *

package/server/migrations/2026_04_21_081353_add_internal_id_column_to_vehicles_table.php

@@ -0,0 +1,27 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    public function up(): void
+    {
+        if (!Schema::hasColumn('vehicles', 'internal_id')) {
+            Schema::table('vehicles', function (Blueprint $table) {
+                $table->string('internal_id')
+                    ->nullable()
+                    ->after('public_id');
+            });
+        }
+    }
+
+    public function down(): void
+    {
+        if (Schema::hasColumn('vehicles', 'internal_id')) {
+            Schema::table('vehicles', function (Blueprint $table) {
+                $table->dropColumn('internal_id');
+            });
+        }
+    }
+};

package/server/migrations/2026_04_22_000001_add_vehicle_support_to_geofence_events_log.php

@@ -0,0 +1,31 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('geofence_events_log', function (Blueprint $table) {
+            $table->uuid('subject_uuid')->nullable()->after('order_uuid')->index();
+            $table->string('subject_type', 50)->default('driver')->after('subject_uuid')->index();
+            $table->string('subject_name')->nullable()->after('subject_type');
+            $table->uuid('driver_uuid')->nullable()->change();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('geofence_events_log', function (Blueprint $table) {
+            $table->dropColumn(['subject_uuid', 'subject_type', 'subject_name']);
+            $table->uuid('driver_uuid')->nullable(false)->change();
+        });
+    }
+};

package/server/migrations/2026_04_22_000002_create_vehicle_geofence_states_table.php

@@ -0,0 +1,39 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('vehicle_geofence_states', function (Blueprint $table) {
+            $table->id();
+            $table->uuid('vehicle_uuid')->index();
+            $table->uuid('geofence_uuid')->index();
+            $table->string('geofence_type', 50)->default('zone');
+            $table->boolean('is_inside')->default(false)->index();
+            $table->timestamp('entered_at')->nullable();
+            $table->timestamp('exited_at')->nullable();
+            $table->string('dwell_job_id')->nullable();
+            $table->timestamps();
+
+            $table->unique(['vehicle_uuid', 'geofence_uuid'], 'vehicle_geofence_unique');
+            $table->foreign('vehicle_uuid')
+                ->references('uuid')
+                ->on('vehicles')
+                ->onDelete('cascade');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('vehicle_geofence_states');
+    }
+};