@fleetbase/fleetops-engine 0.6.20 → 0.6.21

package/addon/controllers/connectivity/telematics/index.js

@@ -1,18 +1,21 @@
 import Controller from '@ember/controller';
 import { inject as service } from '@ember/service';
 import { tracked } from '@glimmer/tracking';
+import fleetOpsOptions from '../../../utils/fleet-ops-options';
 
 export default class ConnectivityTelematicsIndexController extends Controller {
     @service telematicActions;
     @service intl;
 
     /** query params */
-    @tracked queryParams = ['name', 'page', 'limit', 'sort', 'query', 'public_id', 'created_at', 'updated_at'];
+    @tracked queryParams = ['name', 'provider', 'status', 'page', 'limit', 'sort', 'query', 'public_id', 'created_at', 'updated_at'];
     @tracked page = 1;
     @tracked limit;
     @tracked sort = '-created_at';
     @tracked public_id;
     @tracked name;
+    @tracked provider;
+    @tracked status;
 
     /** action buttons */
     @tracked actionButtons = [
@@ -54,25 +57,32 @@ export default class ConnectivityTelematicsIndexController extends Controller {
     /** columns */
     @tracked columns = [
         {
-            label: this.intl.t('column.name'),
-            valuePath: 'name',
-            width: '180px',
+            label: 'Provider',
+            valuePath: 'provider',
             cellComponent: 'table/cell/anchor',
             cellClassNames: 'uppercase',
             action: this.telematicActions.transition.view,
             permission: 'fleet-ops view telematic',
-            hidden: true,
             resizable: true,
             sortable: true,
             filterable: true,
             filterParam: 'name',
             filterComponent: 'filter/string',
         },
+        {
+            label: this.intl.t('column.status'),
+            valuePath: 'status',
+            cellComponent: 'table/cell/status',
+            resizable: true,
+            sortable: true,
+            filterable: true,
+            filterComponent: 'filter/multi-option',
+            filterOptions: fleetOpsOptions('telematicStatuses'),
+        },
         {
             label: this.intl.t('column.created-at'),
             valuePath: 'createdAt',
             sortParam: 'created_at',
-            width: '10%',
             resizable: true,
             sortable: true,
             filterable: true,
@@ -82,7 +92,6 @@ export default class ConnectivityTelematicsIndexController extends Controller {
             label: this.intl.t('column.updated-at'),
             valuePath: 'updatedAt',
             sortParam: 'updated_at',
-            width: '10%',
             resizable: true,
             sortable: true,
             hidden: true,
@@ -96,18 +105,18 @@ export default class ConnectivityTelematicsIndexController extends Controller {
             ddButtonText: false,
             ddButtonIcon: 'ellipsis-h',
             ddButtonIconPrefix: 'fas',
-            ddMenuLabel: this.intl.t('common.resource-actions', { resource: this.intl.t('resource.Telematic') }),
+            ddMenuLabel: this.intl.t('common.resource-actions', { resource: this.intl.t('resource.telematic') }),
             cellClassNames: 'overflow-visible',
             wrapperClass: 'flex items-center justify-end mx-2',
             width: '10%',
             actions: [
                 {
-                    label: this.intl.t('column.view-details'),
+                    label: this.intl.t('common.view-resource', { resource: this.intl.t('resource.telematic') }),
                     fn: this.telematicActions.transition.view,
                     permission: 'fleet-ops view telematic',
                 },
                 {
-                    label: this.intl.t('column.edit-place'),
+                    label: this.intl.t('common.edit-resource', { resource: this.intl.t('resource.telematic') }),
                     fn: this.telematicActions.transition.edit,
                     permission: 'fleet-ops update telematic',
                 },
@@ -115,7 +124,7 @@ export default class ConnectivityTelematicsIndexController extends Controller {
                     separator: true,
                 },
                 {
-                    label: this.intl.t('column.delete'),
+                    label: this.intl.t('common.delete-resource', { resource: this.intl.t('resource.telematic') }),
                     fn: this.telematicActions.delete,
                     permission: 'fleet-ops delete telematic',
                 },

package/addon/controllers/management/fleets/index/details.js

@@ -1,27 +1,32 @@
 import Controller from '@ember/controller';
-import { tracked } from '@glimmer/tracking';
 import { inject as service } from '@ember/service';
 
 export default class ManagementFleetsIndexDetailsController extends Controller {
     @service hostRouter;
-    @tracked tabs = [
-        {
-            route: 'management.fleets.index.details.index',
-            label: 'Overview',
-        },
-        {
-            route: 'management.fleets.index.details.vehicles',
-            label: 'Vehicles',
-        },
-        {
-            route: 'management.fleets.index.details.drivers',
-            label: 'Drivers',
-        },
-    ];
-    @tracked actionButtons = [
-        {
-            icon: 'pencil',
-            fn: () => this.hostRouter.transitionTo('console.fleet-ops.management.fleets.index.edit', this.model),
-        },
-    ];
+
+    get tabs() {
+        return [
+            {
+                route: 'management.fleets.index.details.index',
+                label: 'Overview',
+            },
+            {
+                route: 'management.fleets.index.details.vehicles',
+                label: 'Vehicles',
+            },
+            {
+                route: 'management.fleets.index.details.drivers',
+                label: 'Drivers',
+            },
+        ];
+    }
+
+    get actionButtons() {
+        return [
+            {
+                icon: 'pencil',
+                fn: () => this.hostRouter.transitionTo('console.fleet-ops.management.fleets.index.edit', this.model),
+            },
+        ];
+    }
 }

package/addon/controllers/management/fleets/index/edit.js

@@ -10,12 +10,15 @@ export default class ManagementFleetsIndexEditController extends Controller {
     @service notifications;
     @service modalsManager;
     @tracked overlay;
-    @tracked actionButtons = [
-        {
-            icon: 'eye',
-            fn: this.view,
-        },
-    ];
+
+    get actionButtons() {
+        return [
+            {
+                icon: 'eye',
+                fn: this.view,
+            },
+        ];
+    }
 
     @task *save(fleet) {
         try {

package/addon/controllers/management/vehicles/index/details.js

@@ -1,19 +1,27 @@
 import Controller from '@ember/controller';
-import { tracked } from '@glimmer/tracking';
 import { inject as service } from '@ember/service';
 
 export default class ManagementVehiclesIndexDetailsController extends Controller {
     @service hostRouter;
-    @tracked tabs = [
-        {
-            route: 'management.vehicles.index.details.index',
-            label: 'Overview',
-        },
-    ];
-    @tracked actionButtons = [
-        {
-            icon: 'pencil',
-            fn: () => this.hostRouter.transitionTo('console.fleet-ops.management.vehicles.index.edit', this.model),
-        },
-    ];
+
+    get tabs() {
+        return [
+            {
+                route: 'management.vehicles.index.details.index',
+                label: 'Overview',
+            },
+            {
+                route: 'management.vehicles.index.details.positions',
+                label: 'Positions',
+            },
+        ];
+    }
+    get actionButtons() {
+        return [
+            {
+                icon: 'pencil',
+                fn: () => this.hostRouter.transitionTo('console.fleet-ops.management.vehicles.index.edit', this.model),
+            },
+        ];
+    }
 }

package/addon/controllers/settings/custom-fields.js

@@ -33,6 +33,12 @@ export default class SettingsCustomFieldsController extends Controller {
                 label: 'Place',
                 groups: [],
             },
+            {
+                model: 'entity',
+                type: 'fleet-ops:entity',
+                label: 'Entity',
+                groups: [],
+            },
             {
                 model: 'fleet',
                 type: 'fleet-ops:fleet',

package/addon/helpers/get-fleet-ops-option-label.js

@@ -0,0 +1,11 @@
+import { helper } from '@ember/component/helper';
+import fleetOpsOptions from '../utils/fleet-ops-options';
+
+export function getFleetOpsOptionLabel(optionsKey, value) {
+    const allOptions = fleetOpsOptions(optionsKey);
+    return allOptions.find((opt) => opt.value === value)?.label ?? null;
+}
+
+export default helper(function getFleetOpsOptionLabelHelper([optionsKey, value]) {
+    return getFleetOpsOptionLabel(optionsKey, value);
+});

package/addon/routes/connectivity/devices/index/details.js

@@ -1,3 +1,29 @@
 import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
 
-export default class ConnectivityDevicesIndexDetailsRoute extends Route {}
+export default class ConnectivityDevicesIndexDetailsRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.devices.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops view device')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.devices.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('device', public_id);
+    }
+}

package/addon/routes/connectivity/devices/index/edit.js

@@ -1,3 +1,29 @@
 import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
 
-export default class ConnectivityDevicesIndexEditRoute extends Route {}
+export default class ConnectivityDevicesIndexEditRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.devices.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops update device')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.devices.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('device', public_id);
+    }
+}

package/addon/routes/connectivity/sensors/index/details.js

@@ -1,3 +1,29 @@
 import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
 
-export default class ConnectivitySensorsIndexDetailsRoute extends Route {}
+export default class ConnectivitySensorsIndexDetailsRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.sensors.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops view sensor')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.sensors.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('sensor', public_id);
+    }
+}

package/addon/routes/connectivity/sensors/index/edit.js

@@ -1,3 +1,29 @@
 import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
 
-export default class ConnectivitySensorsIndexEditRoute extends Route {}
+export default class ConnectivitySensorsIndexEditRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.sensors.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops update sensor')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.sensors.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('sensor', public_id);
+    }
+}

package/addon/routes/connectivity/telematics/index/details.js

@@ -1,3 +1,29 @@
 import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
 
-export default class ConnectivityTelematicsIndexDetailsRoute extends Route {}
+export default class ConnectivityTelematicsIndexDetailsRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops view telematic')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('telematic', public_id);
+    }
+}

package/addon/routes/connectivity/telematics/index/edit.js

@@ -1,3 +1,29 @@
 import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
 
-export default class ConnectivityTelematicsIndexEditRoute extends Route {}
+export default class ConnectivityTelematicsIndexEditRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops update telematic')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('telematic', public_id);
+    }
+}

package/addon/routes/management/vehicles/index/details/positions.js

@@ -0,0 +1,3 @@
+import Route from '@ember/routing/route';
+
+export default class ManagementVehiclesIndexDetailsPositionsRoute extends Route {}

package/addon/routes.js

@@ -71,6 +71,7 @@ export default buildRoutes(function () {
                 this.route('new');
                 this.route('details', { path: '/:public_id' }, function () {
                     this.route('index', { path: '/' });
+                    this.route('positions');
                 });
                 this.route('edit', { path: '/edit/:public_id' });
             });

package/addon/services/movement-tracker.js

@@ -10,17 +10,19 @@ import LeafletTrackingMarkerComponent from '../components/leaflet-tracking-marke
 export class EventBuffer {
     @tracked events = [];
     @tracked waitTime = 1000 * 3;
+    @tracked callback;
     @tracked intervalId;
     @tracked model;
 
-    constructor(model, waitTime = 1000 * 3) {
+    constructor(model, { callback = null, waitTime = 1000 * 3 }) {
         this.model = model;
+        this.callback = callback;
         this.waitTime = waitTime;
     }
 
     start() {
         this.intervalId = setInterval(() => {
-            const bufferReady = this.process.isIdle && this.events.length;
+            const bufferReady = this.process.isIdle && this.events.length > 0;
             if (bufferReady) {
                 this.process.perform();
             }
@@ -32,11 +34,11 @@ export class EventBuffer {
     }
 
     clear() {
-        this.events.length = 0;
+        this.events = [];
     }
 
     add(event) {
-        this.events.pushObject(event);
+        this.events = [...this.events, event];
     }
 
     removeByIndex(index) {
@@ -44,65 +46,112 @@ export class EventBuffer {
     }
 
     remove(event) {
-        this.events = this.events.removeObject(event);
+        this.events = this.events.filter((e) => e !== event);
     }
 
     @task *process() {
         debug('Processing movement tracker event buffer.');
+
+        // Take a snapshot of events to process and clear buffer immediately
+        // This prevents losing events that arrive during processing
+        const eventsToProcess = [...this.events];
+        this.events = []; // Clear immediately to accept new events
+
         // Sort events by created_at
-        this.events = this.events.sort((a, b) => new Date(a.created_at) - new Date(b.created_at));
+        eventsToProcess.sort((a, b) => new Date(a.created_at) - new Date(b.created_at));
+        debug(`[MovementTracker EventBuffer processing ${eventsToProcess.length} events]`);
 
         // Process sorted events
-        for (const output of this.events) {
+        for (const output of eventsToProcess) {
             const { event, data } = output;
 
+            // get movingObject marker
+            const marker = this.model.leafletLayer || this.model._layer || this.model._marker;
+            if (!marker || !marker._map) {
+                debug('No marker or marker not on map yet');
+                continue;
+            }
+
             // log incoming event
             debug(`${event} - ${data.id} ${data.additionalData?.index ? '#' + data.additionalData?.index : ''} (${output.created_at}) [ ${data.location.coordinates.join(' ')} ]`);
 
-            // get movingObject marker
-            const marker = this.model._layer || this.model._marker;
-            if (marker) {
-                if (typeof marker.setRotationAngle === 'function' && data.heading) {
+            // GeoJSON -> Leaflet [lat, lng]
+            const [lng, lat] = data.location.coordinates;
+            const nextLatLng = [lat, lng];
+
+            // Calc speed
+            const map = marker._map;
+            const prev = marker.getLatLng();
+            const meters = map ? map.distance(prev, nextLatLng) : prev.distanceTo(nextLatLng);
+
+            // Assume payload speed is m/s; if it's km/h, convert: mps = kmh / 3.6
+            let mps = Number.isFinite(data.speed) && data.speed > 0 ? data.speed : null;
+
+            // Reduce animation duration and clamp between 100ms and 500ms
+            // This makes animations faster and prevents long delays
+            const durationMs = mps ? Math.max(100, Math.min((meters / mps) * 1000, 500)) : 500;
+
+            try {
+                // Apply rotation if heading is valid
+                if (typeof marker.setRotationAngle === 'function' && Number.isFinite(data.heading) && data.heading !== -1) {
                     marker.setRotationAngle(data.heading);
                 }
 
+                // Move marker with animation
                 if (typeof marker.slideTo === 'function') {
-                    marker.slideTo(data.location.coordinates);
+                    marker.slideTo(nextLatLng, { duration: durationMs });
                 } else {
-                    marker.setLatLng(data.location.coordinates);
+                    marker.setLatLng(nextLatLng);
                 }
 
-                yield timeout(1000);
+                if (typeof this.callback === 'function') {
+                    this.callback(output, { nextLatLng, duration: durationMs, mps });
+                }
+
+                // Wait for animation to complete
+                yield timeout(durationMs + 50);
+            } catch (err) {
+                debug('MovementTracker EventBuffer error: ' + err.message);
             }
         }
 
-        // Clear the buffer
-        this.clear();
+        // Don't clear here - we already cleared at the start
+        debug(`[MovementTracker EventBuffer finished processing ${eventsToProcess.length} events]`);
     }
 }
 
 export default class MovementTrackerService extends Service {
     @service socket;
     @tracked channels = [];
+    @tracked buffers = new Map();
 
     constructor() {
         super(...arguments);
         this.registerTrackingMarker();
     }
 
-    _getOwner(owner = null) {
+    #getOwner(owner = null) {
         return owner ?? window.Fleetbase ?? getOwner(this);
     }
 
+    #getBuffer(key, model, opts = {}) {
+        let buf = this.buffers.get(key);
+        if (!buf) {
+            buf = new EventBuffer(model, opts);
+            buf.start();
+            this.buffers.set(key, buf);
+        }
+        return buf;
+    }
+
     registerTrackingMarker(_owner = null) {
-        const owner = this._getOwner(_owner);
+        const owner = this.#getOwner(_owner);
         const emberLeafletService = owner.lookup('service:ember-leaflet');
 
         if (emberLeafletService) {
             const alreadyRegistered = emberLeafletService.components.find((registeredComponent) => registeredComponent.name === 'leaflet-tracking-marker');
-            if (alreadyRegistered) {
-                return;
-            }
+            if (alreadyRegistered) return;
+
             // we then invoke the `registerComponent` method
             emberLeafletService.registerComponent('leaflet-tracking-marker', {
                 as: 'tracking-marker',
@@ -123,37 +172,39 @@ export default class MovementTrackerService extends Service {
         });
     }
 
-    async track(model) {
+    async track(model, options = {}) {
         // Create socket instance
         const socket = this.socket.instance();
 
         // Get model type and identifier
         const type = getModelName(model);
         const identifier = model.id;
-        debug(`Tracking movement started for ${type} with id ${identifier}`, model);
+
+        // Location events to listen for
+        const locationEvents = [`${type}.location_changed`, `${type}.simulated_location_changed`, 'position.changed', 'position.simulated'];
 
         // Listen on the specific channel
-        const channelId = `${type}.${identifier}`;
+        const channelId = options?.channelId ?? `${type}.${identifier}`;
         const channel = socket.subscribe(channelId);
 
+        // Debug output
+        debug(`Tracking movement started for ${type} with id ${identifier}${options?.channelId ? ' on channel ' + channelId : ''}`, model);
+
         // Track the channel
-        this.channels.pushObject(channel);
+        this.channels = [...this.channels, channel];
 
         // Listen to the channel for events
         await channel.listener('subscribe').once();
 
         // Create event buffer for tracking model
-        const eventBuffer = new EventBuffer(model);
-
-        // Start tracking with event buffer
-        eventBuffer.start();
+        const eventBuffer = this.#getBuffer(channelId, model, options);
 
         // Get incoming data and console out
         (async () => {
             for await (let output of channel) {
                 const { event } = output;
 
-                if (event === `${type}.location_changed` || event === `${type}.simulated_location_changed`) {
+                if (locationEvents.includes(event)) {
                     eventBuffer.add(output);
                     debug(`Socket Event : ${event} : Added to EventBuffer : ${JSON.stringify(output)}`);
                 }