@fleetbase/fleetops-engine 0.6.51 → 0.6.52

package/addon/components/widget/fuel-providers.js

@@ -0,0 +1,27 @@
+import Component from '@glimmer/component';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { task } from 'ember-concurrency';
+
+export default class WidgetFuelProvidersComponent extends Component {
+    static widgetId = 'fleet-ops-fuel-providers-widget';
+
+    @service fetch;
+
+    @tracked data = null;
+    @tracked error = null;
+
+    constructor() {
+        super(...arguments);
+        this.load.perform();
+    }
+
+    @task *load() {
+        try {
+            this.data = yield this.fetch.get('fleet-ops/analytics/fuel-providers', { period: '30d' });
+            this.error = null;
+        } catch (error) {
+            this.error = error?.message ?? 'Failed to load fuel integration data';
+        }
+    }
+}

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

@@ -4,14 +4,16 @@ import { isArray } from '@ember/array';
 
 export default class ConnectivityDevicesIndexDetailsController extends Controller {
     @service('universe/menu-service') menuService;
+    @service deviceActions;
     @service hostRouter;
+    @service intl;
 
     get tabs() {
         const registeredTabs = this.menuService.getMenuItems('fleet-ops:component:device:details');
         return [
             {
                 route: 'connectivity.devices.index.details.index',
-                label: 'Overview',
+                label: this.intl.t('common.overview'),
             },
             ...(isArray(registeredTabs) ? registeredTabs : []),
         ];
@@ -22,6 +24,30 @@ export default class ConnectivityDevicesIndexDetailsController extends Controlle
             {
                 icon: 'pencil',
                 fn: () => this.hostRouter.transitionTo('console.fleet-ops.connectivity.devices.index.edit', this.model),
+                permission: 'fleet-ops update device',
+            },
+            {
+                icon: 'ellipsis-h',
+                iconPrefix: 'fas',
+                renderInPlace: true,
+                items: [
+                    {
+                        text: this.intl.t('device.actions.attach-to-vehicle'),
+                        icon: 'link',
+                        fn: () => this.deviceActions.attachToVehicle(this.model),
+                        permission: 'fleet-ops update device',
+                    },
+                    ...(this.model.attachable_uuid || this.model.attached_to_name || this.model.attachable
+                        ? [
+                              {
+                                  text: this.intl.t('device.actions.detach-from-vehicle'),
+                                  icon: 'unlink',
+                                  fn: () => this.deviceActions.detachFromVehicle(this.model),
+                                  permission: 'fleet-ops update device',
+                              },
+                          ]
+                        : []),
+                ],
             },
         ];
     }

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

@@ -156,6 +156,20 @@ export default class ConnectivityDevicesIndexController extends Controller {
                 {
                     separator: true,
                 },
+                {
+                    label: this.intl.t('device.actions.attach-to-vehicle'),
+                    fn: this.deviceActions.attachToVehicle,
+                    permission: 'fleet-ops update device',
+                },
+                {
+                    label: this.intl.t('device.actions.detach-from-vehicle'),
+                    fn: this.deviceActions.detachFromVehicle,
+                    permission: 'fleet-ops update device',
+                    isVisible: (device) => Boolean(device.attachable_uuid || device.attached_to_name || device.attachable),
+                },
+                {
+                    separator: true,
+                },
                 {
                     label: this.intl.t('common.delete-resource', { resource: this.intl.t('resource.device') }),
                     fn: this.deviceActions.delete,

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

@@ -0,0 +1,18 @@
+import Controller from '@ember/controller';
+import { inject as controller } from '@ember/controller';
+
+export default class ConnectivityFuelProvidersIndexDetailsSyncController extends Controller {
+    @controller('connectivity.fuel-providers.details') details;
+
+    get syncTransactions() {
+        return this.details.syncTransactions;
+    }
+
+    get lastSyncStateJson() {
+        return JSON.stringify(this.model?.connection?.last_sync_state ?? {}, null, 2);
+    }
+
+    get syncRuns() {
+        return Array.from(this.model?.syncRuns ?? []);
+    }
+}

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

@@ -0,0 +1,24 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+
+export default class ConnectivityFuelProvidersIndexDetailsTransactionsController extends Controller {
+    @service hostRouter;
+
+    get columns() {
+        return [
+            { sticky: true, label: 'Transaction', valuePath: 'provider_transaction_id', cellComponent: 'click-to-copy', resizable: true },
+            { label: 'Status', valuePath: 'sync_status', cellComponent: 'table/cell/status', resizable: true },
+            { label: 'Vehicle', valuePath: 'vehicle_name', resizable: true },
+            { label: 'Station', valuePath: 'station_name', resizable: true },
+            { label: 'Liters', valuePath: 'volume', resizable: true },
+            { label: 'Amount', valuePath: 'amount', cellComponent: 'table/cell/currency', resizable: true },
+            { label: 'Fuel Report', valuePath: 'fuel_report_id', cellComponent: 'click-to-copy', resizable: true },
+            { label: 'Date', valuePath: 'transaction_at', resizable: true },
+        ];
+    }
+
+    @action refresh() {
+        return this.hostRouter.refresh();
+    }
+}

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