@fleetbase/fleetops-engine 0.6.50 → 0.6.52

package/addon/controllers/connectivity/fuel-providers/details.js

@@ -0,0 +1,69 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { task } from 'ember-concurrency';
+
+export default class ConnectivityFuelProvidersIndexDetailsController extends Controller {
+    @service hostRouter;
+    @service fetch;
+    @service notifications;
+
+    get tabs() {
+        return [
+            { route: 'connectivity.fuel-providers.details.index', label: 'Overview' },
+            { route: 'connectivity.fuel-providers.details.sync', label: 'Sync' },
+            { route: 'connectivity.fuel-providers.details.matching', label: 'Matching' },
+            { route: 'connectivity.fuel-providers.details.transactions', label: 'Transactions' },
+            { route: 'connectivity.fuel-providers.details.settings', label: 'Settings' },
+        ].map((tab) => ({
+            ...tab,
+            active: this.hostRouter.currentRouteName?.endsWith(tab.route),
+        }));
+    }
+
+    get statusLabel() {
+        switch (this.model?.status) {
+            case 'draft':
+                return 'Draft';
+            case 'configured':
+                return 'Configured';
+            case 'connected':
+                return 'Connected';
+            case 'active':
+                return 'Active';
+            case 'error':
+                return 'Needs attention';
+            case 'disabled':
+                return 'Disabled';
+            default:
+                return 'Unknown';
+        }
+    }
+
+    get healthStatus() {
+        return ['connected', 'active'].includes(this.model?.status) ? 'success' : this.model?.status === 'error' ? 'warning' : 'default';
+    }
+
+    get lastSummary() {
+        return this.model?.last_sync_state?.summary ?? {};
+    }
+
+    @task *testConnection() {
+        try {
+            const result = yield this.fetch.post(`fuel-provider-connections/${this.model.id}/test-connection`);
+            this.notifications.success(result.message ?? 'Fuel integration connection tested.');
+            yield this.hostRouter.refresh();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    @task *syncTransactions(options = {}) {
+        try {
+            yield this.fetch.post(`fuel-provider-connections/${this.model.id}/sync`, { async: true, ...options });
+            this.notifications.success('Fuel transaction sync queued.');
+            yield this.hostRouter.refresh();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+}

package/addon/controllers/connectivity/fuel-providers/edit.js

@@ -0,0 +1,24 @@
+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 ConnectivityFuelProvidersIndexEditController extends Controller {
+    @service hostRouter;
+    @service notifications;
+
+    @task *save(connection) {
+        try {
+            yield connection.save();
+            yield this.hostRouter.refresh();
+            yield this.hostRouter.transitionTo('console.fleet-ops.connectivity.fuel-providers.details', connection);
+            this.notifications.success('Fuel integration settings saved.');
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    @action cancel() {
+        return this.hostRouter.transitionTo('console.fleet-ops.connectivity.fuel-providers.details', this.model);
+    }
+}

package/addon/controllers/connectivity/fuel-providers/index.js

@@ -0,0 +1,177 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { action } from '@ember/object';
+import { task } from 'ember-concurrency';
+
+export default class ConnectivityFuelProvidersIndexController extends Controller {
+    @service fetch;
+    @service notifications;
+    @service tableContext;
+    @service fuelIntegrationActions;
+    @service intl;
+
+    @tracked queryParams = ['page', 'limit', 'sort', 'query', 'provider', 'status', 'environment'];
+    @tracked page = 1;
+    @tracked limit;
+    @tracked sort = '-updated_at';
+    @tracked query;
+    @tracked provider;
+    @tracked status;
+    @tracked environment;
+    @tracked table;
+    @tracked providers = [];
+
+    constructor() {
+        super(...arguments);
+        this.loadProviders.perform();
+    }
+
+    get actionButtons() {
+        return [
+            {
+                icon: 'refresh',
+                onClick: this.refresh,
+                helpText: this.intl.t('common.reload'),
+            },
+            {
+                icon: 'plus',
+                text: 'Connect Integration',
+                type: 'primary',
+                onClick: () => this.fuelIntegrationActions.transition.create(),
+            },
+        ];
+    }
+
+    get bulkActions() {
+        const selected = this.tableContext.getSelectedRows();
+
+        return [
+            {
+                label: `Sync ${selected.length} selected`,
+                fn: () => selected.forEach((connection) => this.syncConnection(connection)),
+            },
+        ];
+    }
+
+    get columns() {
+        return [
+            {
+                sticky: true,
+                label: 'Integration',
+                valuePath: 'name',
+                cellComponent: 'click-to-copy',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterParam: 'query',
+                filterComponent: 'filter/string',
+            },
+            {
+                label: 'Provider Key',
+                valuePath: 'provider',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterComponent: 'filter/string',
+            },
+            {
+                label: 'Status',
+                valuePath: 'status',
+                cellComponent: 'table/cell/status',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterComponent: 'filter/multi-option',
+                filterOptions: ['configured', 'connected', 'active', 'error', 'disabled'],
+            },
+            {
+                label: 'Last Sync',
+                valuePath: 'last_synced_at',
+                resizable: true,
+                sortable: true,
+            },
+            {
+                label: 'Imported',
+                valuePath: 'last_sync_state.summary.imported',
+                resizable: true,
+                sortable: false,
+            },
+            {
+                label: 'Unmatched',
+                valuePath: 'last_sync_state.summary.unmatched',
+                resizable: true,
+                sortable: false,
+            },
+            {
+                label: 'Last Error',
+                valuePath: 'last_error',
+                resizable: true,
+                hidden: true,
+            },
+            {
+                label: '',
+                cellComponent: 'table/cell/dropdown',
+                ddButtonText: false,
+                ddButtonIcon: 'ellipsis-h',
+                ddButtonIconPrefix: 'fas',
+                ddMenuLabel: 'Fuel Integration Actions',
+                cellClassNames: 'overflow-visible',
+                wrapperClass: 'flex items-center justify-end mx-2',
+                sticky: 'right',
+                width: 60,
+                actions: [
+                    { label: 'Open Integration', fn: this.openConnection },
+                    { label: 'Edit Settings', fn: this.editConnection },
+                    { separator: true },
+                    { label: 'Test Connection', fn: this.testConnection },
+                    { label: 'Sync Transactions', fn: this.syncConnection },
+                ],
+                sortable: false,
+                filterable: false,
+                resizable: false,
+                searchable: false,
+            },
+        ];
+    }
+
+    @task *loadProviders() {
+        try {
+            this.providers = yield this.fetch.get('fuel-provider-connections/providers');
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    @action refresh() {
+        this.target.send('refresh');
+    }
+
+    @action openConnection(connection) {
+        return this.fuelIntegrationActions.transition.view(connection);
+    }
+
+    @action editConnection(connection) {
+        return this.fuelIntegrationActions.transition.edit(connection);
+    }
+
+    @action async testConnection(connection) {
+        try {
+            await this.fetch.post(`fuel-provider-connections/${connection.id}/test-connection`);
+            this.notifications.success('Fuel integration connection tested.');
+            this.refresh();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    @action async syncConnection(connection) {
+        try {
+            await this.fetch.post(`fuel-provider-connections/${connection.id}/sync`, { async: true });
+            this.notifications.success('Fuel transaction sync queued.');
+            this.refresh();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+}

package/addon/controllers/connectivity/fuel-providers/new.js

@@ -0,0 +1,37 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+import { task } from 'ember-concurrency';
+
+export default class ConnectivityFuelProvidersIndexNewController extends Controller {
+    @service fuelIntegrationActions;
+    @service hostRouter;
+    @service notifications;
+    @service events;
+
+    queryParams = ['setupProvider'];
+    @tracked setupProvider;
+    @tracked connection = this.fuelIntegrationActions.createNewInstance();
+
+    @task *save(connection) {
+        try {
+            yield connection.save();
+            this.events.trackResourceCreated(connection);
+            yield this.hostRouter.refresh();
+            yield this.hostRouter.transitionTo('console.fleet-ops.connectivity.fuel-providers.details', connection);
+            this.notifications.success('Fuel integration connected.');
+            this.resetForm();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    @action resetForm() {
+        this.connection = this.fuelIntegrationActions.createNewInstance();
+    }
+
+    @action cancel() {
+        return this.hostRouter.transitionTo('console.fleet-ops.connectivity.fuel-providers.index');
+    }
+}

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();
+                }
+            },
+        });
+    }
+}