@fleetbase/fleetops-engine 0.6.64 → 0.6.66

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/connectivity/telematics/details/events.js

@@ -1,5 +1,7 @@
 import Controller from '@ember/controller';
 import { action } from '@ember/object';
+import { buildIdentityStub } from '../../../../utils/identity-cell-resource';
+import relationValue from '../../../../utils/relation-value';
 import { inject as service } from '@ember/service';
 import { tracked } from '@glimmer/tracking';
 import { task } from 'ember-concurrency';
@@ -13,6 +15,7 @@ const severityOptions = [
 ];
 
 export default class ConnectivityTelematicsDetailsEventsController extends Controller {
+    @service store;
     @service deviceEventActions;
     @service hostRouter;
     @service intl;
@@ -142,6 +145,11 @@ export default class ConnectivityTelematicsDetailsEventsController extends Contr
             {
                 label: 'Device',
                 valuePath: 'device_name',
+                cellComponent: 'cell/device-identity',
+                permission: 'fleet-ops view device',
+                resourcePath: (event) =>
+                    relationValue(event, 'device') ??
+                    buildIdentityStub(event, { type: 'device', load: () => (event.device_uuid ? this.store.findRecord('device', event.device_uuid) : null) }),
                 resizable: true,
                 sortable: true,
                 filterable: true,

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

@@ -1,5 +1,6 @@
 import Controller from '@ember/controller';
 import { action } from '@ember/object';
+import relationValue from '../../../../utils/relation-value';
 import { inject as service } from '@ember/service';
 import { tracked } from '@glimmer/tracking';
 import { task } from 'ember-concurrency';
@@ -177,8 +178,8 @@ export default class ConnectivityTelematicsDetailsSensorsController extends Cont
             {
                 label: 'Device',
                 valuePath: 'device.displayName',
-                cellComponent: 'table/cell/anchor',
-                action: this.deviceActions.transition.view,
+                cellComponent: 'cell/device-identity',
+                resourcePath: (sensor) => relationValue(sensor, 'device'),
                 permission: 'fleet-ops view device',
                 resizable: true,
                 sortable: true,

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

@@ -69,7 +69,7 @@ export default class ConnectivityTelematicsIndexController extends Controller {
             sticky: true,
             label: 'Provider',
             valuePath: 'name',
-            cellComponent: 'cell/telematic-provider',
+            cellComponent: 'cell/telematic-identity',
             action: this.telematicActions.transition.view,
             permission: 'fleet-ops view telematic',
             width: 460,
@@ -89,6 +89,8 @@ export default class ConnectivityTelematicsIndexController extends Controller {
             filterable: true,
             filterComponent: 'filter/multi-option',
             filterOptions: fleetOpsOptions('telematicStatuses'),
+            filterOptionLabel: 'label',
+            filterOptionValue: 'value',
         },
         {
             label: this.intl.t('column.created-at'),

package/addon/controllers/maintenance/inspection-forms/index/details.js

@@ -0,0 +1,29 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+
+export default class MaintenanceInspectionFormsIndexDetailsController extends Controller {
+    @service inspectionFormActions;
+    @service hostRouter;
+    @service intl;
+    @tracked overlay;
+
+    get tabs() {
+        return [
+            { id: 'index', route: 'maintenance.inspection-forms.index.details.index', label: this.intl.t('inspection.form.overview') },
+            { id: 'submissions', route: 'maintenance.inspection-forms.index.details.submissions', label: this.intl.t('inspection.form.submissions') },
+        ];
+    }
+
+    /**
+     * Publish disappears once the form is published — leaving it there invites
+     * an author to press a button that can only tell them it is already done.
+     * The public link needs a published form, so it appears at the same moment.
+     */
+    get actionButtons() {
+        return this.inspectionFormActions.headerActionButtons(this.model, {
+            onEdit: () => this.hostRouter.transitionTo('console.fleet-ops.maintenance.inspection-forms.index.edit', this.model),
+            onDeleted: () => this.hostRouter.transitionTo('console.fleet-ops.maintenance.inspection-forms.index'),
+        });
+    }
+}

package/addon/controllers/maintenance/inspection-forms/index/edit.js

@@ -0,0 +1,39 @@
+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 MaintenanceInspectionFormsIndexEditController extends Controller {
+    @service inspectionFormActions;
+    @service hostRouter;
+    @service notifications;
+    @service intl;
+
+    @tracked overlay;
+
+    /** The builder's draft, set only once the author has changed something. */
+    @tracked structure = null;
+
+    @task *save(inspectionForm) {
+        try {
+            yield inspectionForm.save();
+            yield this.inspectionFormActions.saveStructure(inspectionForm, this.structure);
+
+            this.overlay?.close();
+            yield this.hostRouter.refresh();
+            yield this.hostRouter.transitionTo('console.fleet-ops.maintenance.inspection-forms.index.details', inspectionForm);
+            this.notifications.success(this.intl.t('inspection.form.updated'));
+        } catch (err) {
+            this.notifications.serverError(err);
+        }
+    }
+
+    @action setStructure(groups) {
+        this.structure = groups;
+    }
+
+    @action cancel() {
+        return this.hostRouter.transitionTo('console.fleet-ops.maintenance.inspection-forms.index.details', this.model);
+    }
+}

package/addon/controllers/maintenance/inspection-forms/index/new.js

@@ -0,0 +1,48 @@
+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 MaintenanceInspectionFormsIndexNewController extends Controller {
+    @service inspectionFormActions;
+    @service hostRouter;
+    @service notifications;
+    @service intl;
+    @service events;
+
+    @tracked overlay;
+    @tracked inspectionForm = this.inspectionFormActions.createNewInstance();
+
+    /** The builder's draft, laid out before the form record exists. */
+    @tracked structure = null;
+
+    @task *save(inspectionForm) {
+        try {
+            yield inspectionForm.save();
+
+            // The structure is posted separately, under the key the server
+            // reads it from — Ember Data cannot carry it, because the
+            // `inspection-form` model declares no attribute for it.
+            yield this.inspectionFormActions.saveStructure(inspectionForm, this.structure);
+
+            this.events.trackResourceCreated(inspectionForm);
+            this.overlay?.close();
+            yield this.hostRouter.refresh();
+            yield this.hostRouter.transitionTo('console.fleet-ops.maintenance.inspection-forms.index.details', inspectionForm);
+            this.notifications.success(this.intl.t('inspection.form.created'));
+            this.resetForm();
+        } catch (err) {
+            this.notifications.serverError(err);
+        }
+    }
+
+    @action setStructure(groups) {
+        this.structure = groups;
+    }
+
+    @action resetForm() {
+        this.structure = null;
+        this.inspectionForm = this.inspectionFormActions.createNewInstance();
+    }
+}

package/addon/controllers/maintenance/inspection-forms/index.js

@@ -0,0 +1,90 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+
+export default class MaintenanceInspectionFormsIndexController extends Controller {
+    @service inspectionFormActions;
+    @service intl;
+
+    @tracked queryParams = ['status', 'type', 'page', 'limit', 'sort', 'query', 'public_id', 'created_at', 'updated_at'];
+    @tracked page = 1;
+    @tracked limit;
+    @tracked sort = '-created_at';
+    @tracked public_id;
+    @tracked status;
+    @tracked type;
+
+    get actionButtons() {
+        return [
+            { icon: 'refresh', onClick: this.inspectionFormActions.refresh, helpText: this.intl.t('common.refresh') },
+            { text: this.intl.t('common.new'), type: 'primary', icon: 'plus', onClick: this.inspectionFormActions.transition.create },
+        ];
+    }
+
+    get bulkActions() {
+        return [{ label: 'Delete selected...', class: 'text-red-500', fn: this.inspectionFormActions.bulkDelete }];
+    }
+
+    get columns() {
+        return [
+            {
+                label: 'Name',
+                valuePath: 'name',
+                cellComponent: 'table/cell/anchor',
+                action: this.inspectionFormActions.transition.view,
+                permission: 'fleet-ops view inspection-form',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterParam: 'name',
+                filterComponent: 'filter/string',
+            },
+            {
+                label: 'Type',
+                valuePath: 'type',
+                cellComponent: 'table/cell/fleet-ops-option',
+                optionsKey: 'inspectionFormTypes',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterParam: 'type',
+                filterComponent: 'filter/string',
+            },
+            {
+                label: 'Status',
+                valuePath: 'status',
+                cellComponent: 'table/cell/status',
+                resizable: true,
+                sortable: true,
+                filterable: true,
+                filterParam: 'status',
+                filterComponent: 'filter/string',
+            },
+            { label: 'Items', valuePath: 'item_count', resizable: true, sortable: false },
+            { label: this.intl.t('column.created-at'), valuePath: 'createdAt', sortParam: 'created_at', resizable: true, sortable: true, filterable: true, filterComponent: 'filter/date' },
+            {
+                label: '',
+                cellComponent: 'table/cell/dropdown',
+                ddButtonText: false,
+                ddButtonIcon: 'ellipsis-h',
+                ddButtonIconPrefix: 'fas',
+                cellClassNames: 'overflow-visible',
+                wrapperClass: 'flex items-center justify-end mx-2',
+                actions: [
+                    { label: 'View form', fn: this.inspectionFormActions.transition.view, permission: 'fleet-ops view inspection-form' },
+                    { label: 'Edit form', fn: this.inspectionFormActions.transition.edit, permission: 'fleet-ops update inspection-form' },
+                    { separator: true },
+                    { label: 'Publish', fn: this.inspectionFormActions.publish, permission: 'fleet-ops publish inspection-form' },
+                    { label: 'Archive', fn: this.inspectionFormActions.archive, permission: 'fleet-ops archive inspection-form' },
+                    { label: 'Generate inspection link', fn: this.inspectionFormActions.generateLink, permission: 'fleet-ops view inspection-form' },
+                    { separator: true },
+                    { label: 'Delete form', fn: this.inspectionFormActions.delete, class: 'text-red-500', permission: 'fleet-ops delete inspection-form' },
+                ],
+                sortable: false,
+                filterable: false,
+                resizable: false,
+                searchable: false,
+            },
+        ];
+    }
+}

package/addon/controllers/maintenance/inspection-submissions/index/details.js

@@ -0,0 +1,53 @@
+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 MaintenanceInspectionSubmissionsIndexDetailsController extends Controller {
+    @service inspectionSubmissionActions;
+    @service hostRouter;
+    @service intl;
+    @tracked overlay;
+
+    get tabs() {
+        return [
+            { route: 'maintenance.inspection-submissions.index.details.index', label: this.intl.t('inspection.record.overview') },
+            { route: 'maintenance.inspection-submissions.index.details.photos', label: this.intl.t('inspection.record.photos') },
+            { route: 'maintenance.inspection-submissions.index.details.audit', label: this.intl.t('inspection.record.audit') },
+        ];
+    }
+
+    /**
+     * Editing is the one action worth a button of its own; the rest sit behind
+     * the ellipsis, which is what the vehicle panel does. Five buttons
+     * overflowed the overlay header and pushed the title out of sight.
+     */
+    get actionButtons() {
+        return [
+            { icon: 'edit', fn: this.edit, permission: 'fleet-ops update inspection-submission' },
+            {
+                icon: 'ellipsis-h',
+                iconPrefix: 'fas',
+                renderInPlace: true,
+                items: this.followUpItems,
+            },
+        ];
+    }
+
+    /**
+     * A submission raises one issue and one work order, and the server enforces
+     * that — `createIssueFromFailures()` hands back what already exists. The
+     * console kept offering both anyway, so the same click reported success
+     * over and over while creating nothing. What is already raised is linked
+     * from the Follow Up panel instead of offered again here.
+     */
+    get followUpItems() {
+        return this.inspectionSubmissionActions.followUpItems(this.model, {
+            onDeleted: () => this.hostRouter.transitionTo('console.fleet-ops.maintenance.inspection-submissions.index'),
+        });
+    }
+
+    @action edit() {
+        return this.hostRouter.transitionTo('console.fleet-ops.maintenance.inspection-submissions.index.edit', this.model);
+    }
+}

package/addon/controllers/maintenance/inspection-submissions/index/edit.js

@@ -0,0 +1,39 @@
+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 MaintenanceInspectionSubmissionsIndexEditController extends Controller {
+    @service inspectionSubmissionActions;
+    @service hostRouter;
+    @service notifications;
+    @service intl;
+
+    @tracked overlay;
+
+    /** The answers, as the server accepts them. */
+    @tracked answers = null;
+
+    @task *save(inspectionSubmission) {
+        try {
+            yield inspectionSubmission.save();
+            yield this.inspectionSubmissionActions.saveAnswers(inspectionSubmission, this.answers);
+
+            this.overlay?.close();
+            yield this.hostRouter.refresh();
+            yield this.hostRouter.transitionTo('console.fleet-ops.maintenance.inspection-submissions.index.details', inspectionSubmission);
+            this.notifications.success(this.intl.t('inspection.record.updated'));
+        } catch (err) {
+            this.notifications.serverError(err);
+        }
+    }
+
+    @action setAnswers(rows) {
+        this.answers = rows;
+    }
+
+    @action cancel() {
+        return this.hostRouter.transitionTo('console.fleet-ops.maintenance.inspection-submissions.index.details', this.model);
+    }
+}

package/addon/controllers/maintenance/inspection-submissions/index/new.js

@@ -0,0 +1,48 @@
+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 MaintenanceInspectionSubmissionsIndexNewController extends Controller {
+    @service inspectionSubmissionActions;
+    @service hostRouter;
+    @service notifications;
+    @service intl;
+    @service events;
+
+    @tracked overlay;
+    @tracked inspectionSubmission = this.inspectionSubmissionActions.createNewInstance();
+
+    /** The answers, as the server accepts them. */
+    @tracked answers = null;
+
+    @task *save(inspectionSubmission) {
+        try {
+            yield inspectionSubmission.save();
+
+            // The answers are posted separately, under the key the server
+            // reads them from — the `inspection-submission` model declares no
+            // `custom_field_values` relationship, so Ember Data drops them.
+            yield this.inspectionSubmissionActions.saveAnswers(inspectionSubmission, this.answers);
+
+            this.events.trackResourceCreated(inspectionSubmission);
+            this.overlay?.close();
+            yield this.hostRouter.refresh();
+            yield this.hostRouter.transitionTo('console.fleet-ops.maintenance.inspection-submissions.index.details', inspectionSubmission);
+            this.notifications.success(this.intl.t('inspection.record.saved'));
+            this.resetForm();
+        } catch (err) {
+            this.notifications.serverError(err);
+        }
+    }
+
+    @action setAnswers(rows) {
+        this.answers = rows;
+    }
+
+    @action resetForm() {
+        this.answers = null;
+        this.inspectionSubmission = this.inspectionSubmissionActions.createNewInstance();
+    }
+}