@fleetbase/fleetops-engine 0.6.50 → 0.6.52

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

@@ -0,0 +1,270 @@
+import Controller from '@ember/controller';
+import { action } from '@ember/object';
+import { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import fleetOpsOptions from '../../../../utils/fleet-ops-options';
+
+export default class ConnectivityTelematicsDetailsSensorsController extends Controller {
+    @service sensorActions;
+    @service deviceActions;
+    @service hostRouter;
+    @service intl;
+
+    @tracked queryParams = ['page', 'limit', 'sort', 'query', 'status', 'type', 'device_uuid'];
+    @tracked telematic;
+    @tracked page = 1;
+    @tracked limit;
+    @tracked sort = '-updated_at';
+    @tracked query;
+    @tracked status;
+    @tracked type;
+    @tracked device_uuid;
+
+    get sensors() {
+        return Array.from(this.model ?? []);
+    }
+
+    get activeSensorsCount() {
+        return this.sensors.filter((sensor) => sensor.is_active || sensor.status === 'active' || sensor.status === 'online').length;
+    }
+
+    get sensorsWithReadingsCount() {
+        return this.sensors.filter((sensor) => sensor.last_value || sensor.last_reading_at).length;
+    }
+
+    get deviceCount() {
+        return new Set(this.sensors.map((sensor) => sensor.device_uuid).filter(Boolean)).size;
+    }
+
+    get hasActiveFilters() {
+        return Boolean(this.query || this.status || this.type || this.device_uuid);
+    }
+
+    get hasSensors() {
+        return this.sensors.length > 0;
+    }
+
+    get hasSyncedDevices() {
+        const meta = this.telematic?.meta ?? {};
+
+        return Number(meta.last_sync_total ?? meta.device_count ?? 0) > 0;
+    }
+
+    get hasSyncRun() {
+        const meta = this.telematic?.meta ?? {};
+
+        return Boolean(meta.last_sync_started_at || meta.last_sync_completed_at || meta.last_sync_job_id || meta.last_sync_result || meta.last_sync_total);
+    }
+
+    get emptyStateVariant() {
+        if (this.hasSensors) {
+            return null;
+        }
+
+        if (this.hasActiveFilters) {
+            return 'filtered_empty';
+        }
+
+        if (!this.hasSyncedDevices && !this.hasSyncRun) {
+            return 'not_synced';
+        }
+
+        return 'empty';
+    }
+
+    get emptyStateContent() {
+        switch (this.emptyStateVariant) {
+            case 'filtered_empty':
+                return {
+                    tone: 'info',
+                    icon: 'filter',
+                    title: 'No sensors match these filters',
+                    message: 'Clear the current search and filters to return to the full sensor inventory.',
+                    primaryText: 'Clear filters',
+                    primaryIcon: 'filter',
+                    primaryAction: this.clearFilters,
+                };
+            case 'not_synced':
+                return {
+                    tone: 'warning',
+                    icon: 'satellite-dish',
+                    title: 'Sync devices before reviewing sensors',
+                    message: 'Sensor inventory depends on synced devices and provider telemetry ingestion.',
+                    primaryText: 'Go to Devices',
+                    primaryIcon: 'microchip',
+                    primaryAction: this.goToDevices,
+                };
+            case 'empty':
+                return {
+                    tone: 'info',
+                    icon: 'gauge-high',
+                    title: 'No sensors reported yet',
+                    message: 'Devices are synced, but this provider has not reported sensor inventory or webhook sensor data yet.',
+                    primaryText: 'Refresh',
+                    primaryIcon: 'refresh',
+                    primaryAction: this.refresh,
+                    secondaryText: 'View Devices',
+                    secondaryIcon: 'microchip',
+                    secondaryAction: this.goToDevices,
+                    note: 'Some providers expose sensors only after live telemetry, fuel, or diagnostic events are ingested.',
+                };
+            default:
+                return null;
+        }
+    }
+
+    get metrics() {
+        return [
+            { label: 'Sensors', value: this.model?.meta?.total ?? this.sensors.length, icon: 'gauge-high', accentClass: 'fleetops-connectivity-kpi-accent-blue' },
+            { label: 'Active', value: this.activeSensorsCount, icon: 'signal', accentClass: 'fleetops-connectivity-kpi-accent-green' },
+            { label: 'Reporting values', value: this.sensorsWithReadingsCount, icon: 'chart-line', accentClass: 'fleetops-connectivity-kpi-accent-amber' },
+            { label: 'Parent devices', value: this.deviceCount, icon: 'microchip', accentClass: 'fleetops-connectivity-kpi-accent-blue' },
+        ];
+    }
+
+    @tracked actionButtons = [
+        {
+            icon: 'refresh',
+            size: 'xs',
+            onClick: this.refresh,
+            helpText: this.intl.t('common.refresh'),
+            wrapperClass: 'fleetops-telematics-action-button',
+        },
+        {
+            icon: 'microchip',
+            text: 'View Devices',
+            size: 'xs',
+            onClick: this.goToDevices,
+            wrapperClass: 'fleetops-telematics-action-button',
+        },
+    ];
+
+    @tracked bulkActions = [];
+
+    get columns() {
+        return [
+            {
+                sticky: true,
+                label: this.intl.t('column.name'),
+                valuePath: 'name',
+                cellComponent: 'table/cell/anchor',
+                action: this.sensorActions.transition.view,
+                permission: 'fleet-ops view sensor',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterParam: 'query',
+                filterComponent: 'filter/string',
+            },
+            {
+                label: 'Type',
+                valuePath: 'type',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterParam: 'type',
+                filterComponent: 'filter/multi-option',
+                filterOptions: fleetOpsOptions('sensorTypes'),
+            },
+            {
+                label: 'Device',
+                valuePath: 'device.displayName',
+                cellComponent: 'table/cell/anchor',
+                action: this.deviceActions.transition.view,
+                permission: 'fleet-ops view device',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterComponent: 'filter/model',
+                filterComponentPlaceholder: 'Select device',
+                filterParam: 'device_uuid',
+                model: 'device',
+            },
+            {
+                label: 'Value',
+                valuePath: 'last_value',
+                resizable: true,
+                sortable: true,
+            },
+            {
+                label: 'Unit',
+                valuePath: 'unit',
+                resizable: true,
+                sortable: true,
+            },
+            {
+                label: this.intl.t('column.status'),
+                valuePath: 'status',
+                cellComponent: 'table/cell/status',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterComponent: 'filter/multi-option',
+                filterOptions: fleetOpsOptions('sensorStatuses'),
+            },
+            {
+                label: 'Last Reading',
+                valuePath: 'lastReadingAt',
+                sortParam: 'last_reading_at',
+                resizable: true,
+                sortable: true,
+            },
+            {
+                label: '',
+                cellComponent: 'table/cell/dropdown',
+                ddButtonText: false,
+                ddButtonIcon: 'ellipsis-h',
+                ddButtonIconPrefix: 'fas',
+                ddMenuLabel: this.intl.t('common.resource-actions', { resource: this.intl.t('resource.sensor') }),
+                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.sensor') }),
+                        fn: this.sensorActions.transition.view,
+                        permission: 'fleet-ops view sensor',
+                    },
+                    {
+                        label: 'Open parent device',
+                        fn: this.openParentDevice,
+                        permission: 'fleet-ops view device',
+                    },
+                ],
+                sortable: false,
+                filterable: false,
+                resizable: false,
+                searchable: false,
+            },
+        ];
+    }
+
+    @action refresh() {
+        return this.hostRouter.refresh();
+    }
+
+    @action clearFilters() {
+        this.query = null;
+        this.status = null;
+        this.type = null;
+        this.device_uuid = null;
+        this.page = 1;
+    }
+
+    @action goToDevices() {
+        return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.details.devices', this.telematic);
+    }
+
+    @action openParentDevice(sensor) {
+        const device = sensor.device;
+
+        if (device?.id) {
+            return this.deviceActions.transition.view(device);
+        }
+
+        return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.details.devices', this.telematic, {
+            queryParams: { device_id: sensor.device_uuid },
+        });
+    }
+}

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

@@ -0,0 +1,149 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+import { task } from 'ember-concurrency';
+
+export default class ConnectivityTelematicsDetailsController extends Controller {
+    @service hostRouter;
+    @service fetch;
+    @service modalsManager;
+    @service notifications;
+
+    get tabs() {
+        return [
+            {
+                route: 'connectivity.telematics.details.index',
+                label: 'Overview',
+            },
+            {
+                route: 'connectivity.telematics.details.devices',
+                label: 'Devices',
+            },
+            {
+                route: 'connectivity.telematics.details.attachments',
+                label: 'Vehicle Attachments',
+            },
+            {
+                route: 'connectivity.telematics.details.sensors',
+                label: 'Sensors',
+            },
+            {
+                route: 'connectivity.telematics.details.events',
+                label: 'Events',
+            },
+            {
+                route: 'connectivity.telematics.details.logs',
+                label: 'Logs',
+            },
+        ].map((tab) => ({
+            ...tab,
+            active: this.isTabActive(tab.route),
+        }));
+    }
+
+    get actionButtons() {
+        return [
+            {
+                icon: 'plug',
+                text: 'Test',
+                onClick: () => this.openConnectionTestDialog(),
+            },
+            {
+                icon: 'satellite-dish',
+                text: 'Discover',
+                onClick: () => this.discoverDevices.perform(),
+                isLoading: this.discoverDevices.isRunning,
+            },
+            {
+                icon: 'cog',
+                fn: () => this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.edit', this.model),
+            },
+        ];
+    }
+
+    get telematicId() {
+        return this.model?.id;
+    }
+
+    isTabActive(routeName) {
+        return this.hostRouter.currentRouteName?.endsWith(routeName);
+    }
+
+    get healthStatus() {
+        switch (this.model?.status) {
+            case 'active':
+            case 'connected':
+                return 'success';
+            case 'synchronizing':
+                return 'info';
+            case 'error':
+            case 'degraded':
+            case 'disconnected':
+                return 'warning';
+            case 'initialized':
+                return 'default';
+            default:
+                return 'default';
+        }
+    }
+
+    get statusLabel() {
+        switch (this.model?.status) {
+            case 'initialized':
+                return 'Not tested';
+            case 'connected':
+                return 'Connected';
+            case 'synchronizing':
+                return 'Syncing';
+            case 'active':
+                return 'Connected';
+            case 'error':
+                return 'Needs attention';
+            case null:
+            case undefined:
+                return 'Unknown';
+            default:
+                return 'Unknown';
+        }
+    }
+
+    get connectionTestLabel() {
+        switch (this.model?.meta?.last_test_result) {
+            case 'success':
+                return 'Verified';
+            case 'failed':
+                return 'Failed';
+            default:
+                return 'Not tested';
+        }
+    }
+
+    get lastSyncAt() {
+        if (this.model?.status === 'synchronizing') {
+            return this.model?.meta?.last_sync_started_at;
+        }
+
+        return this.model?.meta?.last_sync_completed_at;
+    }
+
+    @action openConnectionTestDialog() {
+        this.modalsManager.show('modals/telematic-connection-diagnostics', {
+            title: 'Test Connection',
+            acceptButtonText: 'Run Test',
+            acceptButtonIcon: 'plug',
+            declineButtonText: 'Close',
+            telematic: this.model,
+            onTested: () => this.hostRouter.refresh(),
+        });
+    }
+
+    @task *discoverDevices() {
+        try {
+            const result = yield this.fetch.post(`telematics/${this.telematicId}/discover`);
+            this.notifications.success(result.message ?? 'Device discovery initiated.');
+            yield this.hostRouter.refresh();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+}

package/addon/controllers/connectivity/telematics/{index/edit.js → edit.js}

@@ -4,7 +4,7 @@ import { inject as service } from '@ember/service';
 import { action } from '@ember/object';
 import { task } from 'ember-concurrency';
 
-export default class ConnectivityTelematicsIndexEditController extends Controller {
+export default class ConnectivityTelematicsEditController extends Controller {
     @service hostRouter;
     @service intl;
     @service notifications;
@@ -27,7 +27,7 @@ export default class ConnectivityTelematicsIndexEditController extends Controlle
             this.events.trackResourceUpdated(telematic);
             this.overlay?.close();
 
-            yield this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.index.details', telematic);
+            yield this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.details', telematic);
             this.notifications.success(
                 this.intl.t('common.resource-updated-success', {
                     resource: this.intl.t('resource.telematic'),
@@ -52,7 +52,18 @@ export default class ConnectivityTelematicsIndexEditController extends Controlle
             return this.#confirmContinueWithUnsavedChanges(this.model);
         }
 
-        return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.index.details', this.model);
+        return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.details', this.model);
+    }
+
+    @action openConnectionTestDialog() {
+        this.modalsManager.show('modals/telematic-connection-diagnostics', {
+            title: 'Test Connection',
+            acceptButtonText: 'Run Test',
+            acceptButtonIcon: 'plug',
+            declineButtonText: 'Close',
+            telematic: this.model,
+            onTested: () => this.hostRouter.refresh(),
+        });
     }
 
     #confirmContinueWithUnsavedChanges(telematic, options = {}) {
@@ -62,7 +73,7 @@ export default class ConnectivityTelematicsIndexEditController extends Controlle
             acceptButtonText: this.intl.t('common.continue'),
             confirm: async () => {
                 telematic.rollbackAttributes();
-                await this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.index.details', telematic);
+                await this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.details', telematic);
             },
             ...options,
         });

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

@@ -1,11 +1,15 @@
 import Controller from '@ember/controller';
 import { inject as service } from '@ember/service';
 import { tracked } from '@glimmer/tracking';
+import { task } from 'ember-concurrency';
 import fleetOpsOptions from '../../../utils/fleet-ops-options';
 
 export default class ConnectivityTelematicsIndexController extends Controller {
     @service telematicActions;
+    @service fetch;
     @service intl;
+    @service notifications;
+    @tracked providers = [];
 
     /** query params */
     @tracked queryParams = ['name', 'provider', 'status', 'page', 'limit', 'sort', 'query', 'public_id', 'created_at', 'updated_at'];
@@ -17,6 +21,11 @@ export default class ConnectivityTelematicsIndexController extends Controller {
     @tracked provider;
     @tracked status;
 
+    constructor() {
+        super(...arguments);
+        this.loadProviders.perform();
+    }
+
     /** action buttons */
     @tracked actionButtons = [
         {
@@ -59,11 +68,11 @@ export default class ConnectivityTelematicsIndexController extends Controller {
         {
             sticky: true,
             label: 'Provider',
-            valuePath: 'provider',
-            cellComponent: 'table/cell/anchor',
-            cellClassNames: 'uppercase',
+            valuePath: 'name',
+            cellComponent: 'cell/telematic-provider',
             action: this.telematicActions.transition.view,
             permission: 'fleet-ops view telematic',
+            width: 460,
             resizable: true,
             sortable: true,
             filterable: true,
@@ -73,7 +82,8 @@ export default class ConnectivityTelematicsIndexController extends Controller {
         {
             label: this.intl.t('column.status'),
             valuePath: 'status',
-            cellComponent: 'table/cell/status',
+            cellComponent: 'cell/telematic-status',
+            cellClassNames: 'fleetops-provider-connections-cell-middle',
             resizable: true,
             sortable: true,
             filterable: true,
@@ -84,6 +94,7 @@ export default class ConnectivityTelematicsIndexController extends Controller {
             label: this.intl.t('column.created-at'),
             valuePath: 'createdAt',
             sortParam: 'created_at',
+            cellClassNames: 'fleetops-provider-connections-cell-middle',
             resizable: true,
             sortable: true,
             filterable: true,
@@ -93,6 +104,7 @@ export default class ConnectivityTelematicsIndexController extends Controller {
             label: this.intl.t('column.updated-at'),
             valuePath: 'updatedAt',
             sortParam: 'updated_at',
+            cellClassNames: 'fleetops-provider-connections-cell-middle',
             resizable: true,
             sortable: true,
             hidden: true,
@@ -107,7 +119,7 @@ export default class ConnectivityTelematicsIndexController extends Controller {
             ddButtonIcon: 'ellipsis-h',
             ddButtonIconPrefix: 'fas',
             ddMenuLabel: this.intl.t('common.resource-actions', { resource: this.intl.t('resource.telematic') }),
-            cellClassNames: 'overflow-visible',
+            cellClassNames: 'fleetops-provider-connections-cell-middle overflow-visible',
             wrapperClass: 'flex items-center justify-end mx-2',
             sticky: 'right',
             width: 60,
@@ -137,4 +149,12 @@ export default class ConnectivityTelematicsIndexController extends Controller {
             searchable: false,
         },
     ];
+
+    @task *loadProviders() {
+        try {
+            this.providers = yield this.fetch.get('telematics/providers');
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
 }

package/addon/controllers/connectivity/telematics/{index/new.js → new.js}

@@ -4,7 +4,7 @@ import { inject as service } from '@ember/service';
 import { action } from '@ember/object';
 import { task } from 'ember-concurrency';
 
-export default class ConnectivityTelematicsIndexNewController extends Controller {
+export default class ConnectivityTelematicsNewController extends Controller {
     @service telematicActions;
     @service hostRouter;
     @service intl;
@@ -12,6 +12,8 @@ export default class ConnectivityTelematicsIndexNewController extends Controller
     @service events;
     @tracked overlay;
     @tracked telematic = this.telematicActions.createNewInstance();
+    queryParams = ['setupProvider'];
+    @tracked setupProvider;
 
     @task *save(telematic) {
         try {
@@ -20,7 +22,7 @@ export default class ConnectivityTelematicsIndexNewController extends Controller
             this.overlay?.close();
 
             yield this.hostRouter.refresh();
-            yield this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.index.details', telematic);
+            yield this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.details', telematic);
             this.notifications.success('Telematic created successfully.');
             this.resetForm();
         } catch (err) {
@@ -31,4 +33,8 @@ export default class ConnectivityTelematicsIndexNewController extends Controller
     @action resetForm() {
         this.telematic = this.telematicActions.createNewInstance();
     }
+
+    @action cancel() {
+        return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.index');
+    }
 }

package/addon/controllers/management/contacts/customers/details.js

@@ -1,19 +1,37 @@
 import Controller from '@ember/controller';
-import { tracked } from '@glimmer/tracking';
 import { inject as service } from '@ember/service';
+import { isArray } from '@ember/array';
 
 export default class ManagementContactsCustomersDetailsController extends Controller {
+    @service('universe/menu-service') menuService;
+    @service customerActions;
     @service hostRouter;
-    @tracked tabs = [
-        {
-            route: 'management.contacts.customers.details.index',
-            label: 'Overview',
-        },
-    ];
-    @tracked actionButtons = [
-        {
-            icon: 'pencil',
-            fn: () => this.hostRouter.transitionTo('console.fleet-ops.management.contacts.customers.edit', this.model),
-        },
-    ];
+    @service intl;
+
+    get tabs() {
+        const registeredTabs = this.menuService.getMenuItems('fleet-ops:component:customer:details');
+        return [
+            {
+                route: 'management.contacts.index.details.index',
+                label: 'Overview',
+            },
+            ...(isArray(registeredTabs) ? registeredTabs : []),
+        ];
+    }
+
+    get actionButtons() {
+        const buttons = [
+            {
+                icon: 'pencil',
+                fn: () => this.hostRouter.transitionTo('console.fleet-ops.management.contacts.customers.edit', this.model),
+            },
+        ];
+
+        const accountActionButton = this.customerActions.accountActionButton(this.model);
+        if (accountActionButton) {
+            buttons.push(accountActionButton);
+        }
+
+        return buttons;
+    }
 }