@fleetbase/fleetops-engine 0.6.64 → 0.6.65

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

@@ -57,32 +57,33 @@ export default class ConnectivityTelematicsDetailsAttachmentsController extends
         return this.syncedDevices.filter((device) => !device.attachable_uuid).length;
     }
 
-    get mappedVehiclesCount() {
+    get mappedAssetsCount() {
         const vehicleIds = new Set(this.syncedDevices.filter((device) => device.attachable_uuid).map((device) => device.attachable_uuid));
 
         return vehicleIds.size;
     }
 
-    get vehicleGroups() {
+    get assetGroups() {
         const groups = new Map();
 
         for (const device of this.attachedDevices) {
-            this.addDeviceToVehicleGroup(groups, device);
+            this.addDeviceToAssetGroup(groups, device);
         }
 
-        return this.sortVehicleGroups(groups);
+        return this.sortAssetGroups(groups);
     }
 
-    addDeviceToVehicleGroup(groups, device) {
+    addDeviceToAssetGroup(groups, device) {
         const key = device.attachable_uuid;
 
         if (!groups.has(key)) {
-            const vehicle = device.attachable;
+            const asset = device.attachable;
 
             groups.set(key, {
                 id: key,
-                name: this.getDeviceVehicleName(device),
-                vehicle,
+                name: this.getDeviceAssetName(device),
+                asset,
+                attachableType: device.attachable_type,
                 devices: [],
             });
         }
@@ -90,7 +91,7 @@ export default class ConnectivityTelematicsDetailsAttachmentsController extends
         groups.get(key).devices.push(device);
     }
 
-    sortVehicleGroups(groups) {
+    sortAssetGroups(groups) {
         return Array.from(groups.values()).sort((a, b) => String(a.name).localeCompare(String(b.name)));
     }
 
@@ -146,11 +147,11 @@ export default class ConnectivityTelematicsDetailsAttachmentsController extends
     }
 
     get hasOnlyUnattachedDevices() {
-        return this.unattachedDevices.length > 0 && this.vehicleGroups.length === 0 && !this.hasActiveFilters;
+        return this.unattachedDevices.length > 0 && this.assetGroups.length === 0 && !this.hasActiveFilters;
     }
 
     get allMapped() {
-        return this.hasSyncedDevices && this.unattachedDevices.length === 0 && this.vehicleGroups.length > 0 && !this.hasActiveFilters;
+        return this.hasSyncedDevices && this.unattachedDevices.length === 0 && this.assetGroups.length > 0 && !this.hasActiveFilters;
     }
 
     get emptyStateVariant() {
@@ -234,7 +235,7 @@ export default class ConnectivityTelematicsDetailsAttachmentsController extends
     get metrics() {
         return [
             { label: 'Synced devices', value: this.totalSyncedDevices, icon: 'microchip', accentClass: 'fleetops-connectivity-kpi-accent-blue' },
-            { label: 'Vehicles mapped', value: this.mappedVehiclesCount, icon: 'truck', accentClass: 'fleetops-connectivity-kpi-accent-blue' },
+            { label: 'Assets mapped', value: this.mappedAssetsCount, icon: 'truck', accentClass: 'fleetops-connectivity-kpi-accent-blue' },
             { label: 'Attached devices', value: this.attachedDevicesCount, icon: 'link', accentClass: 'fleetops-connectivity-kpi-accent-green' },
             { label: 'Unattached devices', value: this.unattachedDevicesCount, icon: 'link-slash', accentClass: 'fleetops-connectivity-kpi-accent-amber' },
             { label: 'Online devices', value: this.onlineDevicesCount, icon: 'signal', accentClass: 'fleetops-connectivity-kpi-accent-green' },
@@ -320,40 +321,20 @@ export default class ConnectivityTelematicsDetailsAttachmentsController extends
             return;
         }
 
-        return this.attachDeviceToVehicle(this.selectedDevice, group.vehicle ?? { id: group.id, name: group.name });
+        return this.attachDeviceToAsset(this.selectedDevice, group.asset ?? { id: group.id, name: group.name }, group.attachableType);
     }
 
     @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;
-                }
-
-                modal.startLoading();
-
-                try {
-                    await this.attachDeviceToVehicle(device, selectedVehicle);
-                    modal.done();
-                } catch (error) {
-                    this.notifications.serverError(error);
-                    modal.stopLoading();
-                }
-            },
-        });
+        return this.deviceActions.attachToAsset(device, { callback: this.refresh });
     }
 
-    async attachDeviceToVehicle(device, selectedVehicle) {
-        const response = await this.fetch.post(`devices/${device.id}/attach`, { vehicle: selectedVehicle.id });
+    async attachDeviceToAsset(device, selectedAsset, attachableType) {
+        const normalizedType = `${attachableType ?? ''}`.toLowerCase().includes('trailer') ? 'fleet-ops:trailer' : 'fleet-ops:vehicle';
+        const response = await this.fetch.post(`devices/${device.id}/attach`, { attachable_type: normalizedType, attachable: selectedAsset.id });
 
-        this.applyDeviceAttachment(device, selectedVehicle, response?.device);
+        this.applyDeviceAttachment(device, selectedAsset, response?.device, normalizedType);
         this.selectedDevice = null;
-        this.notifications.success(this.intl.t('device.prompts.attach-to-vehicle-success'));
+        this.notifications.success(this.intl.t('device.prompts.attach-to-asset-success'));
     }
 
     @action detachDevice(device) {
@@ -369,7 +350,7 @@ export default class ConnectivityTelematicsDetailsAttachmentsController extends
                     const response = await this.fetch.post(`devices/${device.id}/detach`);
 
                     this.applyDeviceDetachment(device, response?.device);
-                    this.notifications.success(this.intl.t('device.prompts.detach-from-vehicle-success'));
+                    this.notifications.success(this.intl.t('device.prompts.detach-from-asset-success'));
                     modal.done();
                 } catch (error) {
                     this.notifications.serverError(error);
@@ -379,16 +360,16 @@ export default class ConnectivityTelematicsDetailsAttachmentsController extends
         });
     }
 
-    getDeviceVehicleName(device) {
-        return device.attached_to_name ?? device.attachable?.display_name ?? device.attachable?.name ?? 'Unknown vehicle';
+    getDeviceAssetName(device) {
+        return device.attached_to_name ?? device.attachable?.display_name ?? device.attachable?.name ?? this.intl.t('device.attachment.unknown');
     }
 
-    applyDeviceAttachment(device, selectedVehicle, serverDevice = {}) {
+    applyDeviceAttachment(device, selectedAsset, serverDevice = {}, attachableType = 'fleet-ops:vehicle') {
         this.updateDevice(device, {
-            attachable_uuid: serverDevice.attachable_uuid ?? selectedVehicle.id,
-            attachable_type: serverDevice.attachable_type ?? 'fleet-ops:vehicle',
-            attached_to_name: serverDevice.attached_to_name ?? selectedVehicle.displayName ?? selectedVehicle.display_name ?? selectedVehicle.name,
-            attachable: serverDevice.attachable ?? selectedVehicle,
+            attachable_uuid: serverDevice.attachable_uuid ?? selectedAsset.id,
+            attachable_type: serverDevice.attachable_type ?? attachableType,
+            attached_to_name: serverDevice.attached_to_name ?? selectedAsset.displayName ?? selectedAsset.display_name ?? selectedAsset.name,
+            attachable: serverDevice.attachable ?? selectedAsset,
         });
     }
 

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

@@ -16,6 +16,7 @@ export default class ConnectivityTelematicsDetailsDevicesController extends Cont
     @service notifications;
     @service store;
     @service vehicleActions;
+    @service trailerActions;
 
     @tracked queryParams = [
         'page',

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

@@ -8,6 +8,10 @@ export default class ManagementContactsCustomersController extends ManagementCon
         return this.contactActions;
     }
 
+    get layoutCacheKey() {
+        return 'fleetops:customers:layout';
+    }
+
     /** columns */
     get columns() {
         return [

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

@@ -1,11 +1,13 @@
 import Controller from '@ember/controller';
 import { inject as service } from '@ember/service';
 import { tracked } from '@glimmer/tracking';
+import { action } from '@ember/object';
 
 export default class ManagementContactsIndexController extends Controller {
     @service contactActions;
     @service tableContext;
     @service intl;
+    @service appCache;
 
     /** query params */
     @tracked queryParams = ['page', 'limit', 'sort', 'query', 'public_id', 'internal_id', 'created_by', 'updated_by', 'status', 'title', 'email', 'phone'];
@@ -19,10 +21,35 @@ export default class ManagementContactsIndexController extends Controller {
     @tracked phone;
     @tracked status;
     @tracked table;
+    @tracked layout = this.appCache.get(this.layoutCacheKey, 'table');
+
+    /** cache key that remembers the chosen layout per listing */
+    get layoutCacheKey() {
+        return 'fleetops:contacts:layout';
+    }
 
     /** action buttons */
     get actionButtons() {
         return [
+            {
+                component: 'dropdown-button',
+                icon: 'display',
+                size: 'xs',
+                items: [
+                    {
+                        label: this.intl.t('common.table-view'),
+                        icon: 'table-list',
+                        onClick: () => this.setLayout('table'),
+                    },
+                    {
+                        label: this.intl.t('common.grid-view'),
+                        icon: 'grip',
+                        onClick: () => this.setLayout('grid'),
+                    },
+                ],
+                renderInPlace: true,
+                helpText: this.intl.t('common.change-layout'),
+            },
             {
                 icon: 'refresh',
                 onClick: this.contactActions.refresh,
@@ -199,4 +226,9 @@ export default class ManagementContactsIndexController extends Controller {
             },
         ];
     }
+
+    @action setLayout(layout) {
+        this.layout = layout;
+        this.appCache.set(this.layoutCacheKey, layout);
+    }
 }

package/addon/controllers/management/trailers/index/details.js

@@ -0,0 +1,119 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { isArray } from '@ember/array';
+
+export default class ManagementTrailersIndexDetailsController extends Controller {
+    @service trailerActions;
+    @service('universe/menu-service') menuService;
+    @service hostRouter;
+    @service intl;
+
+    get tabs() {
+        const registeredTabs = this.menuService.getMenuItems('fleet-ops:component:trailer:details');
+
+        return [
+            { id: 'index', route: 'management.trailers.index.details.index', label: this.intl.t('trailer.tabs.overview') },
+            { id: 'positions', route: 'management.trailers.index.details.positions', label: this.intl.t('trailer.tabs.positions') },
+            { id: 'devices', route: 'management.trailers.index.details.devices', label: this.intl.t('trailer.tabs.devices') },
+            { id: 'equipment', route: 'management.trailers.index.details.equipment', label: this.intl.t('trailer.tabs.equipment') },
+            { id: 'connections', route: 'management.trailers.index.details.connections', label: this.intl.t('trailer.tabs.connections') },
+            { id: 'schedules', route: 'management.trailers.index.details.schedules', label: this.intl.t('trailer.tabs.schedules') },
+            { id: 'work-orders', route: 'management.trailers.index.details.work-orders', label: this.intl.t('trailer.tabs.work-orders') },
+            { id: 'maintenance-history', route: 'management.trailers.index.details.maintenance-history', label: this.intl.t('trailer.tabs.maintenance') },
+            ...(isArray(registeredTabs) ? registeredTabs : []),
+        ];
+    }
+
+    get isAttached() {
+        return this.model?.isAttached ?? this.model?.attachment_state === 'attached';
+    }
+
+    get actionButtons() {
+        return [
+            {
+                icon: 'pencil',
+                fn: () => this.hostRouter.transitionTo('console.fleet-ops.management.trailers.index.edit', this.model),
+                permission: 'fleet-ops update trailer',
+            },
+            {
+                // Actions dropdown — mirrors the row-level actions from the trailers index table
+                icon: 'ellipsis-h',
+                iconPrefix: 'fas',
+                renderInPlace: true,
+                items: [
+                    {
+                        text: this.intl.t('trailer.actions.locate'),
+                        icon: 'location-dot',
+                        fn: () => this.trailerActions.locate(this.model),
+                        permission: 'fleet-ops view trailer',
+                    },
+                    ...(this.isAttached
+                        ? [
+                              {
+                                  text: this.intl.t('trailer.actions.detach-vehicle'),
+                                  icon: 'unlink',
+                                  fn: () => this.trailerActions.detachVehicle(this.model),
+                                  permission: 'fleet-ops detach-vehicle-for trailer',
+                              },
+                          ]
+                        : [
+                              {
+                                  text: this.intl.t('trailer.actions.attach-vehicle'),
+                                  icon: 'link',
+                                  fn: () => this.trailerActions.attachVehicle(this.model),
+                                  permission: 'fleet-ops attach-vehicle-for trailer',
+                              },
+                          ]),
+                    {
+                        text: this.intl.t('trailer.actions.attach-device'),
+                        icon: 'microchip',
+                        fn: () => this.trailerActions.attachDevice(this.model),
+                        permission: 'fleet-ops attach-device-for trailer',
+                    },
+                    {
+                        text: this.intl.t('trailer.actions.attach-equipment'),
+                        icon: 'toolbox',
+                        fn: () => this.trailerActions.attachEquipment(this.model),
+                        permission: 'fleet-ops attach-equipment-for trailer',
+                    },
+                    {
+                        separator: true,
+                    },
+                    {
+                        text: this.intl.t('trailer.actions.schedule-maintenance'),
+                        icon: 'calendar-check',
+                        fn: () => this.trailerActions.scheduleMaintenance(this.model),
+                        permission: 'fleet-ops create maintenance-schedule',
+                    },
+                    {
+                        text: this.intl.t('trailer.actions.create-work-order'),
+                        icon: 'clipboard-list',
+                        fn: () => this.trailerActions.createWorkOrder(this.model),
+                        permission: 'fleet-ops create work-order',
+                    },
+                    {
+                        text: this.intl.t('trailer.actions.log-maintenance'),
+                        icon: 'wrench',
+                        fn: () => this.trailerActions.logMaintenance(this.model),
+                        permission: 'fleet-ops create maintenance',
+                    },
+                    {
+                        separator: true,
+                    },
+                    {
+                        text: this.intl.t('common.delete-resource', { resource: this.intl.t('resource.trailer') }),
+                        icon: 'trash',
+                        fn: () =>
+                            this.trailerActions.delete(this.model, {
+                                onConfirm: () => {
+                                    this.hostRouter.transitionTo('console.fleet-ops.management.trailers.index');
+                                },
+                            }),
+                        permission: 'fleet-ops delete trailer',
+                        class: 'text-red-500 hover:text-red-600',
+                    },
+                ],
+            },
+        ];
+    }
+}

package/addon/controllers/management/trailers/index/edit.js

@@ -0,0 +1,67 @@
+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 ManagementTrailersIndexEditController extends Controller {
+    @service hostRouter;
+    @service intl;
+    @service notifications;
+    @service modalsManager;
+    @service events;
+    @tracked overlay;
+    @tracked actionButtons = [
+        {
+            icon: 'eye',
+            fn: this.view,
+        },
+    ];
+
+    @task *save(trailer) {
+        try {
+            yield trailer.save();
+            this.events.trackResourceUpdated(trailer);
+            this.overlay?.close();
+
+            yield this.hostRouter.transitionTo('console.fleet-ops.management.trailers.index.details', trailer);
+            this.notifications.success(
+                this.intl.t('common.resource-updated-success', {
+                    resource: this.intl.t('resource.trailer'),
+                    resourceName: trailer.displayName,
+                })
+            );
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    @action cancel() {
+        if (this.model.hasDirtyAttributes) {
+            return this.#confirmContinueWithUnsavedChanges(this.model);
+        }
+
+        return this.hostRouter.transitionTo('console.fleet-ops.management.trailers.index');
+    }
+
+    @action view() {
+        if (this.model.hasDirtyAttributes) {
+            return this.#confirmContinueWithUnsavedChanges(this.model);
+        }
+
+        return this.hostRouter.transitionTo('console.fleet-ops.management.trailers.index.details', this.model);
+    }
+
+    #confirmContinueWithUnsavedChanges(trailer, options = {}) {
+        return this.modalsManager.confirm({
+            title: this.intl.t('common.continue-without-saving'),
+            body: this.intl.t('common.continue-without-saving-prompt', { resource: this.intl.t('resource.trailer') }),
+            acceptButtonText: this.intl.t('common.continue'),
+            confirm: async () => {
+                trailer.rollbackAttributes();
+                await this.hostRouter.transitionTo('console.fleet-ops.management.trailers.index.details', trailer);
+            },
+            ...options,
+        });
+    }
+}

package/addon/controllers/management/trailers/index/new.js

@@ -0,0 +1,43 @@
+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';
+
+const DEFAULT_PROPERTIES = { status: 'available', asset_class: 'trailer', measurement_system: 'metric' };
+
+export default class ManagementTrailersIndexNewController extends Controller {
+    @service store;
+    @service hostRouter;
+    @service intl;
+    @service notifications;
+    @service events;
+    @tracked overlay;
+    @tracked trailer = this.store.createRecord('trailer', DEFAULT_PROPERTIES);
+
+    @task *save(trailer) {
+        try {
+            yield trailer.save();
+            this.events.trackResourceCreated(trailer);
+            this.overlay?.close();
+
+            // Transition with the record so the details route renders immediately from the
+            // create response; refreshing afterwards reloads the index behind the panel.
+            yield this.hostRouter.transitionTo('console.fleet-ops.management.trailers.index.details', trailer);
+            yield this.hostRouter.refresh();
+            this.notifications.success(
+                this.intl.t('common.resource-created-success-name', {
+                    resource: this.intl.t('resource.trailer'),
+                    resourceName: trailer.displayName,
+                })
+            );
+            this.resetForm();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    @action resetForm() {
+        this.trailer = this.store.createRecord('trailer', DEFAULT_PROPERTIES);
+    }
+}