@fleetbase/fleetops-engine 0.6.51 → 0.6.52

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

@@ -0,0 +1,247 @@
+import Controller from '@ember/controller';
+import { action } from '@ember/object';
+import { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+
+export default class ConnectivityTelematicsDetailsAttachmentsController extends Controller {
+    @service deviceActions;
+    @service hostRouter;
+    @service intl;
+    @service modalsManager;
+    @service notifications;
+
+    @tracked queryParams = ['query', 'status', 'attachment_state', 'vehicle', 'sort'];
+    @tracked telematic;
+    @tracked query;
+    @tracked status;
+    @tracked attachment_state;
+    @tracked vehicle;
+    @tracked sort = '-updated_at';
+
+    get syncedDevices() {
+        return Array.from(this.model ?? []);
+    }
+
+    get devices() {
+        const query = String(this.query ?? '')
+            .trim()
+            .toLowerCase();
+
+        return this.syncedDevices.filter((device) => {
+            const matchesQuery =
+                !query ||
+                [device.displayName, device.name, device.device_id, device.serial_number, device.imei, device.attached_to_name, device.status, device.connection_status]
+                    .filter(Boolean)
+                    .some((value) => String(value).toLowerCase().includes(query));
+
+            const matchesStatus = !this.status || device.status === this.status || device.connection_status === this.status;
+            const matchesAttachmentState =
+                !this.attachment_state || (this.attachment_state === 'attached' && device.attachable_uuid) || (this.attachment_state === 'unattached' && !device.attachable_uuid);
+            const matchesVehicle = !this.vehicle || device.attachable_uuid === this.vehicle;
+
+            return matchesQuery && matchesStatus && matchesAttachmentState && matchesVehicle;
+        });
+    }
+
+    get unattachedDevices() {
+        return this.devices.filter((device) => !device.attachable_uuid);
+    }
+
+    get attachedDevices() {
+        return this.devices.filter((device) => device.attachable_uuid);
+    }
+
+    get onlineDevicesCount() {
+        return this.devices.filter((device) => device.is_online || device.connection_status === 'online' || device.status === 'online' || device.status === 'active').length;
+    }
+
+    get vehicleGroups() {
+        const groups = new Map();
+
+        for (const device of this.attachedDevices) {
+            const key = device.attachable_uuid;
+
+            if (!groups.has(key)) {
+                groups.set(key, {
+                    id: key,
+                    name: device.attached_to_name ?? 'Unknown vehicle',
+                    devices: [],
+                });
+            }
+
+            groups.get(key).devices.push(device);
+        }
+
+        return Array.from(groups.values()).sort((a, b) => String(a.name).localeCompare(String(b.name)));
+    }
+
+    get hasActiveFilters() {
+        return Boolean(this.query || this.status || this.attachment_state || this.vehicle);
+    }
+
+    get hasSyncedDevices() {
+        return this.syncedDevices.length > 0;
+    }
+
+    get hasVisibleDevices() {
+        return this.devices.length > 0;
+    }
+
+    get hasOnlyUnattachedDevices() {
+        return this.unattachedDevices.length > 0 && this.vehicleGroups.length === 0 && !this.hasActiveFilters;
+    }
+
+    get allMapped() {
+        return this.hasSyncedDevices && this.unattachedDevices.length === 0 && this.vehicleGroups.length > 0 && !this.hasActiveFilters;
+    }
+
+    get emptyStateVariant() {
+        if (!this.hasSyncedDevices) {
+            return 'not_synced';
+        }
+
+        if (this.hasActiveFilters && !this.hasVisibleDevices) {
+            return 'filtered_empty';
+        }
+
+        if (this.allMapped) {
+            return 'empty';
+        }
+
+        if (this.hasOnlyUnattachedDevices) {
+            return 'unattached_only';
+        }
+
+        return null;
+    }
+
+    get emptyStateContent() {
+        switch (this.emptyStateVariant) {
+            case 'not_synced':
+                return {
+                    tone: 'warning',
+                    icon: 'satellite-dish',
+                    title: 'Sync devices before mapping vehicles',
+                    message: 'Vehicle attachment starts after provider devices are synced into this connection.',
+                    primaryText: 'Go to Devices',
+                    primaryIcon: 'microchip',
+                    primaryAction: this.goToDevices,
+                };
+            case 'filtered_empty':
+                return {
+                    tone: 'info',
+                    icon: 'filter',
+                    title: 'No mappings match these filters',
+                    message: 'Clear the search and filters to return to all synced devices and vehicle mappings.',
+                    primaryText: 'Clear filters',
+                    primaryIcon: 'filter',
+                    primaryAction: this.clearFilters,
+                };
+            case 'empty':
+                return {
+                    tone: 'success',
+                    icon: 'check',
+                    title: 'All synced devices are mapped',
+                    message: 'Every synced provider device in this connection is currently attached to a vehicle.',
+                };
+            case 'unattached_only':
+                return {
+                    tone: 'warning',
+                    icon: 'link-slash',
+                    title: 'Attach synced devices to vehicles',
+                    message: 'Use the unattached devices section below to map each device deliberately. Bulk auto-attachment is intentionally not available here.',
+                };
+            default:
+                return null;
+        }
+    }
+
+    get metrics() {
+        return [
+            { label: 'Vehicles mapped', value: this.vehicleGroups.length, icon: 'truck', accentClass: 'fleetops-connectivity-kpi-accent-blue' },
+            { label: 'Attached devices', value: this.attachedDevices.length, icon: 'link', accentClass: 'fleetops-connectivity-kpi-accent-green' },
+            { label: 'Unattached devices', value: this.unattachedDevices.length, icon: 'link-slash', accentClass: 'fleetops-connectivity-kpi-accent-amber' },
+            { label: 'Online devices', value: this.onlineDevicesCount, icon: 'signal', accentClass: 'fleetops-connectivity-kpi-accent-green' },
+        ];
+    }
+
+    @action updateQuery(event) {
+        this.query = event.target.value;
+    }
+
+    @action updateAttachmentState(event) {
+        this.attachment_state = event.target.value || null;
+    }
+
+    @action updateStatus(event) {
+        this.status = event.target.value || null;
+    }
+
+    @action clearFilters() {
+        this.query = null;
+        this.status = null;
+        this.attachment_state = null;
+        this.vehicle = null;
+    }
+
+    @action goToDevices() {
+        return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.details.devices', this.telematic);
+    }
+
+    @action openAttachDeviceModal(device) {
+        this.modalsManager.show('modals/attach-telematic-device', {
+            title: this.intl.t('device.prompts.attach-device-to-vehicle-title', { deviceName: device.displayName ?? device.name ?? device.device_id ?? this.intl.t('resource.device') }),
+            acceptButtonText: this.intl.t('device.actions.attach-to-vehicle'),
+            device,
+            selectedVehicle: null,
+            confirm: async (modal) => {
+                const selectedVehicle = modal.getOption('selectedVehicle');
+                if (!selectedVehicle) {
+                    return;
+                }
+
+                device.setProperties({
+                    attachable_uuid: selectedVehicle.id,
+                    attachable_type: 'fleet-ops:vehicle',
+                });
+
+                modal.startLoading();
+
+                try {
+                    await device.save();
+                    this.notifications.success(this.intl.t('device.prompts.attach-to-vehicle-success'));
+                    await this.hostRouter.refresh();
+                    modal.done();
+                } catch (error) {
+                    device.rollbackAttributes();
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+        });
+    }
+
+    @action detachDevice(device) {
+        const deviceName = device.displayName ?? device.name ?? device.device_id ?? this.intl.t('resource.device');
+
+        this.modalsManager.confirm({
+            title: this.intl.t('device.prompts.detach-telematic-device-title', { deviceName }),
+            body: this.intl.t('device.prompts.detach-telematic-device-body', { deviceName }),
+            confirm: async (modal) => {
+                modal.startLoading();
+                device.setProperties({ attachable_uuid: null, attachable_type: null });
+
+                try {
+                    await device.save();
+                    this.notifications.success(this.intl.t('device.prompts.detach-from-vehicle-success'));
+                    await this.hostRouter.refresh();
+                    modal.done();
+                } catch (error) {
+                    device.rollbackAttributes();
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+        });
+    }
+}

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

@@ -0,0 +1,368 @@
+import Controller from '@ember/controller';
+import { action } from '@ember/object';
+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 ConnectivityTelematicsDetailsDevicesController extends Controller {
+    @service deviceActions;
+    @service fetch;
+    @service hostRouter;
+    @service intl;
+    @service modalsManager;
+    @service notifications;
+
+    @tracked queryParams = ['page', 'limit', 'sort', 'query', 'status', 'provider', 'attachment_state', 'device_id'];
+    @tracked telematic;
+    @tracked page = 1;
+    @tracked limit;
+    @tracked sort = '-updated_at';
+    @tracked query;
+    @tracked status;
+    @tracked provider;
+    @tracked attachment_state;
+    @tracked device_id;
+
+    get devices() {
+        return Array.from(this.model ?? []);
+    }
+
+    get totalDevices() {
+        return this.model?.meta?.total ?? this.devices.length;
+    }
+
+    get onlineDevicesCount() {
+        return this.devices.filter((device) => device.is_online || device.connection_status === 'online' || device.status === 'online' || device.status === 'active').length;
+    }
+
+    get unattachedDevicesCount() {
+        return this.devices.filter((device) => !device.attachable_uuid).length;
+    }
+
+    get offlineDevicesCount() {
+        return Math.max(this.devices.length - this.onlineDevicesCount, 0);
+    }
+
+    get hasActiveFilters() {
+        return Boolean(this.query || this.status || this.provider || this.attachment_state || this.device_id);
+    }
+
+    get hasDevices() {
+        return this.devices.length > 0;
+    }
+
+    get isSyncing() {
+        return this.telematic?.status === 'synchronizing' || this.telematic?.meta?.last_sync_result === 'queued';
+    }
+
+    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.hasDevices) {
+            return null;
+        }
+
+        if (this.hasActiveFilters) {
+            return 'filtered_empty';
+        }
+
+        if (this.isSyncing) {
+            return 'syncing';
+        }
+
+        if (!this.hasSyncRun) {
+            return 'not_synced';
+        }
+
+        return 'empty';
+    }
+
+    get emptyStateContent() {
+        switch (this.emptyStateVariant) {
+            case 'filtered_empty':
+                return {
+                    tone: 'info',
+                    icon: 'filter',
+                    title: 'No devices match these filters',
+                    message: 'Clear the current search and filters to return to the synced device inventory.',
+                    primaryText: 'Clear filters',
+                    primaryIcon: 'filter',
+                    primaryAction: this.clearFilters,
+                };
+            case 'syncing':
+                return {
+                    tone: 'info',
+                    icon: 'rotate',
+                    title: 'Device sync is running',
+                    message: 'Devices are being fetched from the provider. Refresh this tab when the sync job finishes.',
+                    primaryText: 'Refresh',
+                    primaryIcon: 'refresh',
+                    primaryAction: this.refresh,
+                };
+            case 'not_synced':
+                return {
+                    tone: 'warning',
+                    icon: 'satellite-dish',
+                    title: 'No device sync has run yet',
+                    message: 'Sync devices from this provider connection to build the inventory and start vehicle attachment.',
+                    primaryText: 'Sync Devices',
+                    primaryIcon: 'satellite-dish',
+                    primaryAction: this.startDeviceSync,
+                    secondaryText: 'Test Connection',
+                    secondaryIcon: 'plug',
+                    secondaryAction: this.openConnectionTestDialog,
+                };
+            case 'empty':
+                return {
+                    tone: 'info',
+                    icon: 'microchip',
+                    title: 'Provider returned no devices',
+                    message: 'The connection synced successfully, but the provider did not return device inventory for these credentials.',
+                    primaryText: 'Sync Again',
+                    primaryIcon: 'refresh',
+                    primaryAction: this.startDeviceSync,
+                    secondaryText: 'Test Connection',
+                    secondaryIcon: 'plug',
+                    secondaryAction: this.openConnectionTestDialog,
+                    note: 'Check provider permissions and account scope if devices exist in the provider dashboard.',
+                };
+            default:
+                return null;
+        }
+    }
+
+    get metrics() {
+        return [
+            { label: 'Synced devices', value: this.totalDevices, icon: 'microchip', accentClass: 'fleetops-connectivity-kpi-accent-blue' },
+            { label: 'Online', value: this.onlineDevicesCount, icon: 'signal', accentClass: 'fleetops-connectivity-kpi-accent-green' },
+            { label: 'Unattached', value: this.unattachedDevicesCount, icon: 'link-slash', accentClass: 'fleetops-connectivity-kpi-accent-amber' },
+            { label: 'Offline / unknown', value: this.offlineDevicesCount, icon: 'power-off', accentClass: 'fleetops-connectivity-kpi-accent-rose' },
+        ];
+    }
+
+    @tracked actionButtons = [
+        {
+            icon: 'refresh',
+            size: 'xs',
+            onClick: this.refresh,
+            helpText: this.intl.t('common.refresh'),
+            wrapperClass: 'fleetops-telematics-action-button',
+        },
+        {
+            icon: 'ellipsis-h',
+            prefix: 'fas',
+            text: 'Actions',
+            type: 'primary',
+            size: 'xs',
+            triggerClass: 'fleetops-telematics-action-button',
+            items: [
+                {
+                    icon: 'satellite-dish',
+                    text: 'Sync Devices',
+                    onClick: this.startDeviceSync,
+                },
+                {
+                    icon: 'link',
+                    text: 'Attach Unassigned',
+                    onClick: this.openAttachmentsForUnassigned,
+                },
+            ],
+        },
+    ];
+
+    @tracked bulkActions = [];
+
+    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: 'attachment_state',
+                filterComponent: 'filter/multi-option',
+                filterOptions: [
+                    { label: 'Attached', value: 'attached' },
+                    { label: 'Unattached', value: 'unattached' },
+                ],
+            },
+            {
+                label: 'Connection',
+                valuePath: 'connection_status',
+                cellComponent: 'table/cell/status',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterParam: 'status',
+                filterComponent: 'filter/multi-option',
+                filterOptions: fleetOpsOptions('deviceStatuses'),
+            },
+            {
+                label: 'Last Seen',
+                valuePath: 'lastOnlineAt',
+                sortParam: 'last_online_at',
+                resizable: true,
+                sortable: true,
+            },
+            {
+                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,
+            },
+        ];
+    }
+
+    @action refresh() {
+        return this.hostRouter.refresh();
+    }
+
+    @action clearFilters() {
+        this.query = null;
+        this.status = null;
+        this.provider = null;
+        this.attachment_state = null;
+        this.device_id = null;
+        this.page = 1;
+    }
+
+    @action openConnectionTestDialog() {
+        this.modalsManager.show('modals/telematic-connection-diagnostics', {
+            title: 'Test Connection',
+            acceptButtonText: 'Run Test',
+            acceptButtonIcon: 'plug',
+            declineButtonText: 'Close',
+            telematic: this.telematic,
+            onTested: () => this.hostRouter.refresh(),
+        });
+    }
+
+    @action openAttachmentsForUnassigned() {
+        return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.details.attachments', this.telematic, {
+            queryParams: { attachment_state: 'unattached' },
+        });
+    }
+
+    @action openDeviceEvents(device) {
+        return this.hostRouter.transitionTo('console.fleet-ops.connectivity.telematics.details.events', this.telematic, {
+            queryParams: { device_uuid: device.id },
+        });
+    }
+
+    @action openAttachDeviceModal(device) {
+        this.modalsManager.show('modals/attach-telematic-device', {
+            title: this.intl.t('device.prompts.attach-device-to-vehicle-title', { deviceName: device.displayName ?? device.name ?? device.device_id ?? this.intl.t('resource.device') }),
+            acceptButtonText: this.intl.t('device.actions.attach-to-vehicle'),
+            device,
+            selectedVehicle: null,
+            confirm: async (modal) => {
+                const selectedVehicle = modal.getOption('selectedVehicle');
+                if (!selectedVehicle) {
+                    return;
+                }
+
+                device.setProperties({
+                    attachable_uuid: selectedVehicle.id,
+                    attachable_type: 'fleet-ops:vehicle',
+                });
+
+                modal.startLoading();
+
+                try {
+                    await device.save();
+                    this.notifications.success(this.intl.t('device.prompts.attach-to-vehicle-success'));
+                    await this.hostRouter.refresh();
+                    modal.done();
+                } catch (error) {
+                    device.rollbackAttributes();
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+        });
+    }
+
+    @action startDeviceSync() {
+        return this.syncDevices.perform();
+    }
+
+    @task *syncDevices() {
+        try {
+            yield this.fetch.post(`telematics/${this.telematic.id}/discover`);
+            this.notifications.success('Device sync queued.');
+            yield this.hostRouter.refresh();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+}