@fleetbase/fleetops-engine 0.6.54 → 0.6.56

package/addon/controllers/connectivity/telematics/details/devices.js

@@ -3,24 +3,36 @@ import { action } from '@ember/object';
 import { inject as service } from '@ember/service';
 import { tracked } from '@glimmer/tracking';
 import { task } from 'ember-concurrency';
-
-const connectionStatusOptions = [
-    { label: 'Online', value: 'online' },
-    { label: 'Recently Offline', value: 'recently_offline' },
-    { label: 'Offline', value: 'offline' },
-    { label: 'Long Offline', value: 'long_offline' },
-    { label: 'Never Connected', value: 'never_connected' },
-];
+import buildDeviceTableColumns from '../../../../utils/device-table-columns';
+import fleetOpsOptions from '../../../../utils/fleet-ops-options';
 
 export default class ConnectivityTelematicsDetailsDevicesController extends Controller {
     @service deviceActions;
     @service fetch;
     @service hostRouter;
     @service intl;
+    @service mapManager;
     @service modalsManager;
     @service notifications;
-
-    @tracked queryParams = ['page', 'limit', 'sort', 'query', 'status', 'provider', 'attachment_state', 'vehicle', 'connection_status', 'device_id', 'last_online_at', 'updated_at'];
+    @service store;
+    @service vehicleActions;
+
+    @tracked queryParams = [
+        'page',
+        'limit',
+        'sort',
+        'query',
+        'status',
+        'provider',
+        'attachment_state',
+        'vehicle',
+        'connection_status',
+        'device_id',
+        'type',
+        'serial_number',
+        'last_online_at',
+        'updated_at',
+    ];
     @tracked telematic;
     @tracked page = 1;
     @tracked limit;
@@ -32,6 +44,8 @@ export default class ConnectivityTelematicsDetailsDevicesController extends Cont
     @tracked vehicle;
     @tracked connection_status;
     @tracked device_id;
+    @tracked type;
+    @tracked serial_number;
     @tracked last_online_at;
     @tracked updated_at;
 
@@ -57,7 +71,17 @@ export default class ConnectivityTelematicsDetailsDevicesController extends Cont
 
     get hasActiveFilters() {
         return Boolean(
-            this.query || this.status || this.provider || this.attachment_state || this.vehicle || this.connection_status || this.device_id || this.last_online_at || this.updated_at
+            this.query ||
+            this.status ||
+            this.provider ||
+            this.attachment_state ||
+            this.vehicle ||
+            this.connection_status ||
+            this.device_id ||
+            this.type ||
+            this.serial_number ||
+            this.last_online_at ||
+            this.updated_at
         );
     }
 
@@ -194,130 +218,16 @@ export default class ConnectivityTelematicsDetailsDevicesController extends Cont
 
     @tracked bulkActions = [];
 
+    get deviceTypeOptions() {
+        return fleetOpsOptions('deviceTypes');
+    }
+
+    get deviceStatusOptions() {
+        return fleetOpsOptions('deviceStatuses');
+    }
+
     get columns() {
-        return [
-            {
-                sticky: true,
-                label: this.intl.t('column.name'),
-                valuePath: 'displayName',
-                cellComponent: 'table/cell/anchor',
-                action: this.deviceActions.transition.view,
-                permission: 'fleet-ops view device',
-                resizable: true,
-                sortable: true,
-                filterable: true,
-                filterParam: 'query',
-                filterComponent: 'filter/string',
-            },
-            {
-                label: 'Provider ID',
-                valuePath: 'device_id',
-                resizable: true,
-                sortable: true,
-                filterable: true,
-                filterParam: 'device_id',
-                filterComponent: 'filter/string',
-            },
-            {
-                label: 'Vehicle',
-                valuePath: 'attached_to_name',
-                resizable: true,
-                sortable: true,
-                filterable: true,
-                filterParam: 'vehicle',
-                filterComponent: 'filter/model',
-                filterComponentPlaceholder: 'Select vehicle',
-                model: 'vehicle',
-                modelNamePath: 'displayName',
-            },
-            {
-                label: 'Connection',
-                valuePath: 'connection_status',
-                cellComponent: 'table/cell/status',
-                resizable: true,
-                sortable: true,
-                filterable: true,
-                filterParam: 'connection_status',
-                filterComponent: 'filter/multi-option',
-                filterOptions: connectionStatusOptions,
-                filterOptionLabel: 'label',
-                filterOptionValue: 'value',
-            },
-            {
-                label: 'Last Seen',
-                valuePath: 'lastOnlineAt',
-                sortParam: 'last_online_at',
-                resizable: true,
-                sortable: true,
-                filterable: true,
-                filterParam: 'last_online_at',
-                filterComponent: 'filter/date',
-            },
-            {
-                label: 'Attachment',
-                valuePath: 'attachable_uuid',
-                hidden: true,
-                resizable: true,
-                sortable: false,
-                filterable: true,
-                filterParam: 'attachment_state',
-                filterComponent: 'filter/select',
-                filterOptions: [
-                    { label: 'Attached', value: 'attached' },
-                    { label: 'Unattached', value: 'unattached' },
-                ],
-                filterOptionLabel: 'label',
-                filterOptionValue: 'value',
-            },
-            {
-                label: this.intl.t('column.updated-at'),
-                valuePath: 'updatedAt',
-                sortParam: 'updated_at',
-                resizable: true,
-                sortable: true,
-                hidden: true,
-                filterable: true,
-                filterComponent: 'filter/date',
-            },
-            {
-                label: '',
-                cellComponent: 'table/cell/dropdown',
-                ddButtonText: false,
-                ddButtonIcon: 'ellipsis-h',
-                ddButtonIconPrefix: 'fas',
-                ddMenuLabel: this.intl.t('common.resource-actions', { resource: this.intl.t('resource.device') }),
-                cellClassNames: 'overflow-visible align-middle',
-                wrapperClass: 'flex items-center justify-end mx-2',
-                sticky: 'right',
-                width: 60,
-                actions: [
-                    {
-                        label: this.intl.t('common.view-resource', { resource: this.intl.t('resource.device') }),
-                        fn: this.deviceActions.transition.view,
-                        permission: 'fleet-ops view device',
-                    },
-                    {
-                        label: this.intl.t('common.edit-resource', { resource: this.intl.t('resource.device') }),
-                        fn: this.deviceActions.transition.edit,
-                        permission: 'fleet-ops update device',
-                    },
-                    {
-                        label: 'Attach or change vehicle',
-                        fn: this.openAttachDeviceModal,
-                        permission: 'fleet-ops update device',
-                    },
-                    {
-                        label: 'Review recent events',
-                        fn: this.openDeviceEvents,
-                        permission: 'fleet-ops view device-event',
-                    },
-                ],
-                sortable: false,
-                filterable: false,
-                resizable: false,
-                searchable: false,
-            },
-        ];
+        return buildDeviceTableColumns(this, { showProvider: false, deviceActionMode: 'panel', showDeviceStatus: false });
     }
 
     @action refresh() {
@@ -336,6 +246,8 @@ export default class ConnectivityTelematicsDetailsDevicesController extends Cont
         this.vehicle = null;
         this.connection_status = null;
         this.device_id = null;
+        this.type = null;
+        this.serial_number = null;
         this.last_online_at = null;
         this.updated_at = null;
         this.page = 1;
@@ -358,6 +270,86 @@ export default class ConnectivityTelematicsDetailsDevicesController extends Cont
         });
     }
 
+    @action hasAttachedVehicle(device) {
+        return Boolean(device?.attachable_uuid && this.isVehicleAttachment(device));
+    }
+
+    @action async viewAttachedVehicle(device) {
+        const vehicle = await this.resolveAttachedVehicle(device);
+
+        if (!vehicle) {
+            return;
+        }
+
+        return this.vehicleActions.panel.view(vehicle);
+    }
+
+    @action async locateAttachedVehicle(device) {
+        const vehicle = await this.resolveAttachedVehicle(device);
+
+        if (!vehicle) {
+            return;
+        }
+
+        await this.transitionToLiveMap();
+        await this.mapManager.waitForMap({ timeoutMs: 8000 });
+
+        this.mapManager.focusResource(vehicle, 16, {
+            paddingBottomRight: [300, 200],
+            moveend: () => {
+                this.vehicleActions.panel.view(vehicle, { closeOnTransition: true });
+            },
+        });
+    }
+
+    async transitionToLiveMap() {
+        try {
+            await this.hostRouter.transitionTo('console.fleet-ops.operations.orders.index', { queryParams: { layout: 'map' } });
+        } catch (_) {
+            // Keep locate actions usable even if the current transition is already in-flight.
+        }
+    }
+
+    isVehicleAttachment(device) {
+        const attachableType = `${device?.attachable_type ?? ''}`.toLowerCase();
+
+        return !attachableType || attachableType.includes('vehicle');
+    }
+
+    async resolveAttachedVehicle(device) {
+        if (!device?.attachable_uuid) {
+            return null;
+        }
+
+        if (!this.isVehicleAttachment(device)) {
+            return null;
+        }
+
+        const attachable = device.attachable;
+
+        if (attachable && typeof attachable.then !== 'function') {
+            return attachable;
+        }
+
+        if (attachable && typeof attachable.then === 'function') {
+            return await attachable;
+        }
+
+        const cachedVehicle = this.store.peekRecord('vehicle', device.attachable_uuid);
+
+        if (cachedVehicle) {
+            return cachedVehicle;
+        }
+
+        try {
+            return await this.store.findRecord('vehicle', device.attachable_uuid);
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+
+        return null;
+    }
+
     @action openDeviceEvents(device) {
         return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.details.events', this.telematic, {
             queryParams: { device_uuid: device.id },

package/addon/controllers/connectivity/telematics/details/events.js

@@ -40,7 +40,7 @@ export default class ConnectivityTelematicsDetailsEventsController extends Contr
     }
 
     get unprocessedEventsCount() {
-        return this.events.filter((event) => !event.processed_at && !event.is_processed).length;
+        return this.events.filter((event) => !event.processed_at).length;
     }
 
     get deviceCount() {

package/addon/controllers/connectivity/telematics/details/sensors.js

@@ -171,6 +171,8 @@ export default class ConnectivityTelematicsDetailsSensorsController extends Cont
                 filterParam: 'type',
                 filterComponent: 'filter/multi-option',
                 filterOptions: fleetOpsOptions('sensorTypes'),
+                filterOptionLabel: 'label',
+                filterOptionValue: 'value',
             },
             {
                 label: 'Device',
@@ -209,6 +211,8 @@ export default class ConnectivityTelematicsDetailsSensorsController extends Cont
                 filterable: true,
                 filterComponent: 'filter/multi-option',
                 filterOptions: fleetOpsOptions('sensorStatuses'),
+                filterOptionLabel: 'label',
+                filterOptionValue: 'value',
             },
             {
                 label: 'Last Reading',

package/addon/controllers/maintenance/equipment/index.js

@@ -61,8 +61,7 @@ export default class MaintenanceEquipmentIndexController extends Controller {
             {
                 label: this.intl.t('column.name'),
                 valuePath: 'name',
-                cellComponent: 'table/cell/anchor',
-                cellClassNames: 'uppercase',
+                cellComponent: 'cell/equipment-identity',
                 action: this.equipmentActions.transition.view,
                 permission: 'fleet-ops view equipment',
                 resizable: true,

package/addon/controllers/maintenance/parts/index.js

@@ -61,8 +61,7 @@ export default class MaintenancePartsIndexController extends Controller {
             {
                 label: this.intl.t('column.name'),
                 valuePath: 'name',
-                cellComponent: 'table/cell/anchor',
-                cellClassNames: 'uppercase',
+                cellComponent: 'cell/part-identity',
                 action: this.partActions.transition.view,
                 permission: 'fleet-ops view part',
                 resizable: true,

package/addon/controllers/management/drivers/index.js

@@ -1,7 +1,7 @@
 import Controller from '@ember/controller';
 import { inject as service } from '@ember/service';
 import { tracked } from '@glimmer/tracking';
-import { action } from '@ember/object';
+import { action, get } from '@ember/object';
 
 export default class ManagementDriversIndexController extends Controller {
     @service driverActions;
@@ -52,6 +52,22 @@ export default class ManagementDriversIndexController extends Controller {
         return Boolean(driver?.vehicle_uuid || driver?.vehicle?.id || driver?.vehicle?.uuid || driver?.vehicle_name);
     }
 
+    async resolveAssignedVehicle(vehicle) {
+        if (!vehicle) {
+            return null;
+        }
+
+        if (typeof vehicle.then === 'function') {
+            return await vehicle;
+        }
+
+        if (typeof vehicle.loadResource === 'function') {
+            return (await vehicle.loadResource()) ?? vehicle;
+        }
+
+        return vehicle;
+    }
+
     /** action buttons */
     get actionButtons() {
         return [
@@ -102,7 +118,8 @@ export default class ManagementDriversIndexController extends Controller {
                 sticky: true,
                 label: this.intl.t('column.name'),
                 valuePath: 'name',
-                cellComponent: 'table/cell/driver-name',
+                cellComponent: 'cell/driver-identity',
+                compact: true,
                 permission: 'fleet-ops view driver',
                 action: this.driverActions.transition.view,
                 resizable: true,
@@ -120,6 +137,69 @@ export default class ManagementDriversIndexController extends Controller {
                 hidden: false,
                 filterComponent: 'filter/string',
             },
+            {
+                label: this.intl.t('column.phone'),
+                valuePath: 'phone',
+                cellComponent: 'table/cell/base',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterParam: 'phone',
+                filterComponent: 'filter/string',
+            },
+            {
+                label: this.intl.t('column.license'),
+                valuePath: 'drivers_license_number',
+                cellComponent: 'table/cell/base',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterComponent: 'filter/string',
+            },
+            {
+                label: this.intl.t('column.vehicle'),
+                cellComponent: 'cell/vehicle-identity',
+                compact: true,
+                permission: 'fleet-ops view vehicle',
+                action: async (vehicle) => {
+                    try {
+                        const resolvedVehicle = await this.resolveAssignedVehicle(vehicle);
+                        if (resolvedVehicle) this.vehicleActions.panel.view(resolvedVehicle);
+                    } catch (err) {
+                        this.notifications.serverError(err);
+                    }
+                },
+                valuePath: 'vehicle.display_name',
+                emptyText: '-',
+                showStatusBadge: true,
+                resourcePath: (driver) => {
+                    const vehicle = get(driver, 'vehicle_assigned') ?? get(driver, 'vehicle');
+
+                    if (vehicle) {
+                        return vehicle;
+                    }
+
+                    const vehicleName = get(driver, 'vehicle_name');
+
+                    if (vehicleName) {
+                        return {
+                            display_name: vehicleName,
+                            name: vehicleName,
+                            status: 'assigned',
+                            loadResource: () => driver.loadVehicle?.(),
+                        };
+                    }
+
+                    return null;
+                },
+                modelNamePath: 'display_name',
+                resizable: true,
+                filterable: true,
+                filterComponent: 'filter/model',
+                filterComponentPlaceholder: 'Select vehicle to filter by',
+                filterParam: 'vehicle',
+                model: 'vehicle',
+            },
             {
                 label: this.intl.t('column.internal-id'),
                 valuePath: 'internal_id',
@@ -150,27 +230,6 @@ export default class ManagementDriversIndexController extends Controller {
                 filterParam: 'vendor',
                 model: 'vendor',
             },
-            {
-                label: this.intl.t('column.vehicle'),
-                cellComponent: 'table/cell/anchor',
-                permission: 'fleet-ops view vehicle',
-                onClick: async (driver) => {
-                    try {
-                        const vehicle = await driver.loadVehicle();
-                        if (vehicle) this.vehicleActions.panel.view(vehicle);
-                    } catch (err) {
-                        this.notifications.serverError(err);
-                    }
-                },
-                valuePath: 'vehicle.display_name',
-                modelNamePath: 'display_name',
-                resizable: true,
-                filterable: true,
-                filterComponent: 'filter/model',
-                filterComponentPlaceholder: 'Select vehicle to filter by',
-                filterParam: 'vehicle',
-                model: 'vehicle',
-            },
             {
                 label: this.intl.t('column.fleet'),
                 cellComponent: 'table/cell/link-list',
@@ -185,25 +244,6 @@ export default class ManagementDriversIndexController extends Controller {
                 filterParam: 'fleet',
                 model: 'fleet',
             },
-            {
-                label: this.intl.t('column.license'),
-                valuePath: 'drivers_license_number',
-                cellComponent: 'table/cell/base',
-                resizable: true,
-                sortable: true,
-                filterable: true,
-                filterComponent: 'filter/string',
-            },
-            {
-                label: this.intl.t('column.phone'),
-                valuePath: 'phone',
-                cellComponent: 'table/cell/base',
-                resizable: true,
-                sortable: true,
-                filterable: true,
-                filterParam: 'phone',
-                filterComponent: 'filter/string',
-            },
             {
                 label: this.intl.t('column.country'),
                 valuePath: 'country',

package/addon/controllers/management/fuel-reports/index.js

@@ -1,4 +1,5 @@
 import Controller from '@ember/controller';
+import { get } from '@ember/object';
 import { inject as service } from '@ember/service';
 import { tracked } from '@glimmer/tracking';
 
@@ -113,9 +114,37 @@ export default class ManagementFuelReportsIndexController extends Controller {
             {
                 label: this.intl.t('column.driver'),
                 valuePath: 'driver_name',
-                cellComponent: 'table/cell/anchor',
+                cellComponent: 'cell/driver-identity',
                 permission: 'fleet-ops view driver',
-                onClick: this.fuelReportActions.viewDriver,
+                action: async (driver) => {
+                    const resolvedDriver = driver?.loadResource ? await driver.loadResource() : driver;
+
+                    if (resolvedDriver) {
+                        this.fuelReportActions.driverActions.panel.view(resolvedDriver);
+                    }
+                },
+                emptyText: '-',
+                showStatusBadge: true,
+                resourcePath: (fuelReport) => {
+                    const driver = get(fuelReport, 'driver');
+
+                    if (driver) {
+                        return driver;
+                    }
+
+                    const driverName = get(fuelReport, 'driver_name');
+
+                    if (driverName) {
+                        return {
+                            id: get(fuelReport, 'driver_uuid'),
+                            name: driverName,
+                            display_name: driverName,
+                            loadResource: () => fuelReport.loadDriver?.(),
+                        };
+                    }
+
+                    return null;
+                },
                 resizable: true,
                 sortable: true,
                 filterable: true,
@@ -127,9 +156,39 @@ export default class ManagementFuelReportsIndexController extends Controller {
             {
                 label: this.intl.t('column.vehicle'),
                 valuePath: 'vehicle_name',
-                cellComponent: 'table/cell/anchor',
+                cellComponent: 'cell/vehicle-identity',
                 permission: 'fleet-ops view vehicle',
-                onClick: this.fuelReportActions.viewVehicle,
+                action: async (vehicle) => {
+                    const resolvedVehicle = vehicle?.loadResource ? await vehicle.loadResource() : vehicle;
+
+                    if (resolvedVehicle) {
+                        this.fuelReportActions.vehicleActions.panel.view(resolvedVehicle);
+                    }
+                },
+                emptyText: '-',
+                showStatusBadge: true,
+                resourcePath: (fuelReport) => {
+                    const vehicle = get(fuelReport, 'vehicle');
+
+                    if (vehicle) {
+                        return vehicle;
+                    }
+
+                    const vehicleName = get(fuelReport, 'vehicle_name');
+
+                    if (vehicleName) {
+                        return {
+                            id: get(fuelReport, 'vehicle_uuid'),
+                            displayName: vehicleName,
+                            display_name: vehicleName,
+                            name: vehicleName,
+                            vehicle_number: get(fuelReport, 'vehicle_uuid'),
+                            loadResource: () => fuelReport.loadVehicle?.(),
+                        };
+                    }
+
+                    return null;
+                },
                 resizable: true,
                 sortable: true,
                 filterable: true,