@fleetbase/fleetops-engine 0.6.65 → 0.6.66

package/addon/services/driver-actions.js

@@ -4,10 +4,12 @@ import config from 'ember-get-config';
 import { action } from '@ember/object';
 import { isArray } from '@ember/array';
 import { dasherize } from '@ember/string';
+import { PANEL_DEFAULTS, closePanelsThen } from '../utils/context-panel';
 
 export default class DriverActionsService extends ResourceActionService {
     @service('universe/menu-service') menuService;
     @service fetch;
+    @service issueActions;
 
     get registeredTabs() {
         const registeredTabs = this.menuService.getMenuItems('fleet-ops:component:driver:details');
@@ -31,7 +33,7 @@ export default class DriverActionsService extends ResourceActionService {
             },
             {
                 key: 'positions',
-                label: 'Positions',
+                label: this.intl.t('common.positions'),
                 component: 'positions-replay',
             },
             {
@@ -39,6 +41,11 @@ export default class DriverActionsService extends ResourceActionService {
                 label: this.intl.t('common.schedule'),
                 component: 'driver/schedule',
             },
+            {
+                key: 'activity',
+                label: this.intl.t('common.activity'),
+                component: 'resource-activity',
+            },
             ...this.registeredTabs,
         ];
     }
@@ -48,6 +55,30 @@ export default class DriverActionsService extends ResourceActionService {
         this.initialize('driver');
     }
 
+    /**
+     * Accepts a driver record, a promise (or proxy) of one, or an identity
+     * stub with loadResource(), and returns the record.
+     */
+    async resolveDriverResource(driver) {
+        if (typeof driver?.then === 'function') {
+            return await driver;
+        }
+
+        if (typeof driver?.loadResource === 'function') {
+            return (await driver.loadResource()) ?? driver;
+        }
+
+        return driver;
+    }
+
+    async reloadIndexResource(driver) {
+        if (driver?.meta?._index_resource) {
+            await driver.reload();
+        }
+
+        return driver;
+    }
+
     transition = {
         view: (driver) => this.transitionTo('management.drivers.index.details', driver),
         edit: (driver) => this.transitionTo('management.drivers.index.edit', driver),
@@ -69,9 +100,7 @@ export default class DriverActionsService extends ResourceActionService {
             });
         },
         edit: async (driver, options = {}) => {
-            if (driver?.meta?._index_resource) {
-                await driver.reload();
-            }
+            driver = await this.reloadIndexResource(await this.resolveDriverResource(driver));
 
             return this.resourceContextPanel.open({
                 content: 'driver/form',
@@ -91,9 +120,8 @@ export default class DriverActionsService extends ResourceActionService {
             });
         },
         view: async (driver, options = {}) => {
-            if (driver?.meta?._index_resource) {
-                await driver.reload();
-            }
+            driver = await this.reloadIndexResource(await this.resolveDriverResource(driver));
+            const service = this;
 
             return this.resourceContextPanel.open({
                 driver,
@@ -101,13 +129,20 @@ export default class DriverActionsService extends ResourceActionService {
                 actionButtons: [
                     {
                         icon: 'pencil',
-                        fn: async () => {
-                            await this.resourceContextPanel.closeAll();
-                            this.panel.edit(driver);
+                        permission: 'fleet-ops update driver',
+                        fn: () => closePanelsThen(this.resourceContextPanel, () => this.panel.edit(driver)),
+                    },
+                    {
+                        icon: 'ellipsis-h',
+                        iconPrefix: 'fas',
+                        renderInPlace: true,
+                        get items() {
+                            return service.detailsMenuItems(driver, { onDeleted: () => service.resourceContextPanel.closeAll() });
                         },
                     },
                 ],
                 tabs: this.panelTabs,
+                ...PANEL_DEFAULTS,
                 ...options,
             });
         },
@@ -126,9 +161,7 @@ export default class DriverActionsService extends ResourceActionService {
             });
         },
         edit: async (driver, options = {}, saveOptions = {}) => {
-            if (driver?.meta?._index_resource) {
-                await driver.reload();
-            }
+            driver = await this.reloadIndexResource(await this.resolveDriverResource(driver));
 
             return this.modalsManager.show('modals/resource', {
                 resource: driver,
@@ -141,9 +174,7 @@ export default class DriverActionsService extends ResourceActionService {
             });
         },
         view: async (driver, options = {}) => {
-            if (driver?.meta?._index_resource) {
-                await driver.reload();
-            }
+            driver = await this.reloadIndexResource(await this.resolveDriverResource(driver));
 
             return this.modalsManager.show('modals/resource', {
                 resource: driver,
@@ -369,4 +400,36 @@ export default class DriverActionsService extends ResourceActionService {
             });
         });
     }
+
+    /**
+     * The actions menu of a driver's header, shared by the details route and
+     * the context panel. Unassign items only show when there is something to
+     * unassign.
+     */
+    detailsMenuItems(driver) {
+        const hasVehicle = Boolean(driver?.vehicle_uuid || driver?.vehicle?.id || driver?.vehicle?.uuid || driver?.vehicle_name);
+
+        return [
+            { text: this.intl.t('driver.actions.assign-order'), icon: 'clipboard-list', fn: () => this.assignOrder(driver), permission: 'fleet-ops assign-order-for driver' },
+            ...(Number(driver?.assigned_orders_count) > 0
+                ? [{ text: this.intl.t('driver.actions.unassign-orders'), icon: 'user-minus', fn: () => this.unassignOrders(driver), permission: 'fleet-ops assign-order-for driver' }]
+                : []),
+            { separator: true },
+            { text: this.intl.t('driver.actions.assign-vehicle'), icon: 'car', fn: () => this.assignVehicle(driver), permission: 'fleet-ops assign-vehicle-for driver' },
+            ...(hasVehicle
+                ? [{ text: this.intl.t('driver.actions.unassign-vehicle'), icon: 'link-slash', fn: () => this.unassignVehicle(driver), permission: 'fleet-ops assign-vehicle-for driver' }]
+                : []),
+            { separator: true },
+            { text: this.intl.t('driver.actions.locate-driver'), icon: 'location-dot', fn: () => this.locate(driver), permission: 'fleet-ops view driver' },
+            { text: this.intl.t('driver.actions.create-issue'), icon: 'triangle-exclamation', fn: () => this.createIssue(driver), permission: 'fleet-ops create issue' },
+        ];
+    }
+
+    @action createIssue(driver) {
+        return this.issueActions.modal.create({
+            driver,
+            driver_uuid: driver.id,
+            title: this.intl.t('driver.prompts.issue-title', { driverName: driver.name }),
+        });
+    }
 }

package/addon/services/equipment-actions.js

@@ -1,6 +1,9 @@
-import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
+import ResourceActionService, { inject as service } from '@fleetbase/ember-core/services/resource-action';
+import { PANEL_DEFAULTS, closePanelsThen, registeredPanelTabs } from '../utils/context-panel';
 
 export default class EquipmentActionsService extends ResourceActionService {
+    @service('universe/menu-service') menuService;
+
     get defaultCurrency() {
         return this.currentUser?.company?.currency || this.currentUser.currency || 'USD';
     }
@@ -42,15 +45,21 @@ export default class EquipmentActionsService extends ResourceActionService {
                 equipment,
             });
         },
-        view: (equipment) => {
+        view: (equipment, options = {}) => {
             return this.resourceContextPanel.open({
                 equipment,
+                title: equipment?.name,
+                header: 'equipment/panel-header',
+                actionButtons: [
+                    { icon: 'edit', permission: 'fleet-ops update equipment', fn: () => closePanelsThen(this.resourceContextPanel, () => this.panel.edit(equipment)) },
+                    { icon: 'trash', type: 'danger', permission: 'fleet-ops delete equipment', fn: () => this.delete(equipment, { onConfirm: () => this.resourceContextPanel.closeAll() }) },
+                ],
                 tabs: [
-                    {
-                        label: this.intl.t('common.overview'),
-                        component: 'equipment/details',
-                    },
+                    { key: 'overview', label: this.intl.t('common.overview'), component: 'equipment/details' },
+                    ...registeredPanelTabs(this.menuService, 'fleet-ops:component:equipment:details'),
                 ],
+                ...PANEL_DEFAULTS,
+                ...options,
             });
         },
     };

package/addon/services/fleet-actions.js

@@ -1,8 +1,10 @@
 import ResourceActionService, { inject as service } from '@fleetbase/ember-core/services/resource-action';
 import { action } from '@ember/object';
+import { PANEL_DEFAULTS, closePanelsThen, registeredPanelTabs } from '../utils/context-panel';
 
 export default class FleetActionsService extends ResourceActionService {
     @service fetch;
+    @service('universe/menu-service') menuService;
 
     constructor() {
         super(...arguments);
@@ -41,12 +43,18 @@ export default class FleetActionsService extends ResourceActionService {
         view: (fleet, options = {}) => {
             return this.resourceContextPanel.open({
                 fleet,
+                title: fleet?.name,
+                actionButtons: [
+                    { icon: 'pencil', permission: 'fleet-ops update fleet', fn: () => closePanelsThen(this.resourceContextPanel, () => this.panel.edit(fleet)) },
+                    { icon: 'ellipsis-h', iconPrefix: 'fas', renderInPlace: true, items: this.detailsMenuItems(fleet) },
+                ],
                 tabs: [
-                    {
-                        label: this.intl.t('common.overview'),
-                        component: 'fleet/details',
-                    },
+                    { key: 'overview', label: this.intl.t('common.overview'), component: 'fleet/details' },
+                    { key: 'vehicles', label: this.intl.t('menu.vehicles'), component: 'fleet/vehicle-listing' },
+                    { key: 'drivers', label: this.intl.t('menu.drivers'), component: 'fleet/driver-listing' },
+                    ...registeredPanelTabs(this.menuService, 'fleet-ops:component:fleet:details'),
                 ],
+                ...PANEL_DEFAULTS,
                 ...options,
             });
         },
@@ -146,4 +154,12 @@ export default class FleetActionsService extends ResourceActionService {
             ...options,
         });
     }
+
+    /** The actions menu of a fleet's header, shared by the details route and the context panel. */
+    detailsMenuItems(fleet) {
+        return [
+            { text: this.intl.t('fleet.actions.assign-driver'), icon: 'user-plus', fn: () => this.assignDriver(fleet), permission: 'fleet-ops assign-driver-for fleet' },
+            { text: this.intl.t('fleet.actions.assign-vehicle'), icon: 'car', fn: () => this.assignVehicle(fleet), permission: 'fleet-ops assign-vehicle-for fleet' },
+        ];
+    }
 }

package/addon/services/fuel-report-actions.js

@@ -1,6 +1,7 @@
 import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
 import { inject as service } from '@ember/service';
 import { action } from '@ember/object';
+import { PANEL_DEFAULTS, closePanelsThen } from '../utils/context-panel';
 
 export default class FuelReportActionsService extends ResourceActionService {
     @service driverActions;
@@ -40,15 +41,14 @@ export default class FuelReportActionsService extends ResourceActionService {
                 fuelReport,
             });
         },
-        view: (fuelReport) => {
+        view: (fuelReport, options = {}) => {
             return this.resourceContextPanel.open({
                 fuelReport,
-                tabs: [
-                    {
-                        label: this.intl.t('common.overview'),
-                        component: 'fuel-report/details',
-                    },
-                ],
+                title: fuelReport?.name ?? `Fuel reported on ${fuelReport?.createdAt ?? ''}`.trim(),
+                actionButtons: [{ icon: 'pencil', permission: 'fleet-ops update fuel-report', fn: () => closePanelsThen(this.resourceContextPanel, () => this.panel.edit(fuelReport)) }],
+                tabs: [{ key: 'overview', label: this.intl.t('common.overview'), component: 'fuel-report/details' }],
+                ...PANEL_DEFAULTS,
+                ...options,
             });
         },
     };

package/addon/services/inspection-form-actions.js

@@ -0,0 +1,236 @@
+import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
+import { action, set } from '@ember/object';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import copyToClipboard from '@fleetbase/ember-core/utils/copy-to-clipboard';
+import { normalizeFieldGroups, serializeFieldGroups } from '../utils/inspection-form-structure';
+import { PANEL_DEFAULTS, closePanelsThen } from '../utils/context-panel';
+
+/** A link's life when nobody chooses; the server applies the same when left blank. */
+const DEFAULT_LINK_TTL_HOURS = 72;
+
+/** A date as a `datetime-local` input reads it: local time, to the minute. */
+export function toDatetimeLocal(date) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+/** The default expiry, filled into the form so the dispatcher can see it. */
+function defaultLinkExpiry() {
+    return toDatetimeLocal(new Date(Date.now() + DEFAULT_LINK_TTL_HOURS * 60 * 60 * 1000));
+}
+
+export default class InspectionFormActionsService extends ResourceActionService {
+    @service fetch;
+    @service notifications;
+    @service intl;
+
+    /**
+     * When a public link was last generated. Every open link list watches
+     * this — the one inside the generate modal and the one on the form's
+     * details panel — so a new link appears in both without a reload.
+     */
+    @tracked linksChangedAt = 0;
+
+    constructor() {
+        super(...arguments);
+        this.initialize('inspection-form', {
+            defaultAttributes: {
+                type: 'dvir',
+                status: 'draft',
+                items: [],
+                settings: {
+                    require_signature: true,
+                    create_issue_on_failure: true,
+                    create_work_order_on_failure: false,
+                },
+            },
+        });
+    }
+
+    transition = {
+        view: (form) => this.transitionTo('maintenance.inspection-forms.index.details', form),
+        edit: (form) => this.transitionTo('maintenance.inspection-forms.index.edit', form),
+        create: () => this.transitionTo('maintenance.inspection-forms.index.new'),
+    };
+
+    panel = {
+        view: (form, options = {}) => {
+            const service = this;
+
+            return this.resourceContextPanel.open({
+                form,
+                title: form?.name,
+                get actionButtons() {
+                    return service.headerActionButtons(form, {
+                        onEdit: () => closePanelsThen(service.resourceContextPanel, () => service.transition.edit(form)),
+                        onDeleted: () => service.resourceContextPanel.closeAll(),
+                    });
+                },
+                tabs: [
+                    { key: 'overview', label: this.intl.t('inspection.form.overview'), component: 'inspection-form/details' },
+                    { key: 'submissions', label: this.intl.t('inspection.form.submissions'), component: 'inspection-form/details/submissions' },
+                ],
+                ...PANEL_DEFAULTS,
+                ...options,
+            });
+        },
+    };
+
+    /**
+     * The header buttons of a form, shared by the details route and the
+     * context panel: publish a draft or generate a link for a published
+     * form, then edit and delete.
+     */
+    headerActionButtons(form, { onEdit, onDeleted } = {}) {
+        const isPublished = form?.is_published === true || form?.status === 'published';
+
+        return [
+            ...(isPublished ? [] : [{ icon: 'check', fn: () => this.publish(form), text: 'Publish', type: 'success', permission: 'fleet-ops publish inspection-form' }]),
+            ...(isPublished ? [{ icon: 'link', fn: () => this.generateLink(form), text: 'Generate Link', permission: 'fleet-ops view inspection-form' }] : []),
+            { icon: 'edit', fn: () => (onEdit ? onEdit(form) : this.transition.edit(form)), permission: 'fleet-ops update inspection-form' },
+            { icon: 'trash', fn: () => this.delete(form, { onConfirm: onDeleted }), type: 'danger', permission: 'fleet-ops delete inspection-form' },
+        ];
+    }
+
+    /**
+     * A form's structure — its field groups and their fields.
+     *
+     * The `inspection-form` model belongs to `@fleetbase/fleetops-data` and
+     * declares no attribute for the structure, so Ember Data drops it on the
+     * way in and on the way out. Both directions go through the internal
+     * endpoint directly instead: a read carries `field_groups` beside a flat
+     * `fields` list, and a write posts the whole thing back under
+     * `inspection_form.field_groups`, which is the key
+     * `InspectionFormController::syncStructureFromRequest()` reads.
+     */
+    async loadStructure(form) {
+        if (!form?.id) {
+            return [];
+        }
+
+        const response = await this.fetch.get(`inspection-forms/${form.id}`);
+
+        return normalizeFieldGroups(response?.inspection_form ?? response?.inspectionForm ?? response);
+    }
+
+    /**
+     * Writes the whole structure. The builder always posts every group and
+     * every field, so the server prunes what the post no longer lists — a
+     * field the post dropped is a field the author deleted.
+     */
+    async saveStructure(form, groups) {
+        if (!form?.id || !Array.isArray(groups) || groups.length === 0) {
+            return null;
+        }
+
+        return this.fetch.put(`inspection-forms/${form.id}`, {
+            inspection_form: { field_groups: serializeFieldGroups(groups) },
+        });
+    }
+
+    @action async publish(form) {
+        try {
+            await this.fetch.post(`inspection-forms/${form.id}/publish`);
+            this.notifications.success('Inspection form published.');
+            await this.refresh();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    @action async archive(form) {
+        try {
+            await this.fetch.post(`inspection-forms/${form.id}/archive`);
+            this.notifications.success('Inspection form archived.');
+            await this.refresh();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    /**
+     * Say whether a PIN went out, when one was asked to be sent. A delivery
+     * that failed is a warning and not an error: the link exists either way,
+     * and its PIN is on screen to share by hand.
+     */
+    notifyPinDelivery(delivery) {
+        if (!delivery) {
+            this.notifications.success(this.intl.t('inspection.link.generated-toast'));
+            return;
+        }
+
+        if (delivery.sent) {
+            this.notifications.success(this.intl.t(`inspection.link.pin-sent-${delivery.via}`, { to: delivery.to }));
+            return;
+        }
+
+        this.notifications.warning(this.intl.t('inspection.link.pin-not-sent', { reason: delivery.error }));
+    }
+
+    @action generateLink(form) {
+        if (form.status !== 'published') {
+            this.notifications.warning(this.intl.t('inspection.link.publish-first'));
+            return;
+        }
+
+        // Who the link is for, and the driver and vehicle being inspected, are
+        // each optional: anyone in the organisation may complete an inspection.
+        const formState = {
+            assignee: null,
+            driver: null,
+            vehicle: null,
+            expires_at: defaultLinkExpiry(),
+            pin_delivery: 'none',
+            generated: null,
+        };
+
+        return this.modalsManager.show('modals/inspection-link', {
+            title: 'Generate Inspection Link',
+            acceptButtonText: 'Generate Link',
+            acceptButtonIcon: 'link',
+            declineButtonText: 'Close',
+            form,
+            formState,
+            confirm: async (modal) => {
+                modal.startLoading();
+                try {
+                    const response = await this.fetch.post(`inspection-forms/${form.id}/generate-link`, {
+                        assignee: formState.assignee?.id,
+                        driver: formState.driver?.id,
+                        vehicle: formState.vehicle?.id,
+                        // The input holds local time with no zone; sent as it was,
+                        // the server read it as its own zone and the link expired
+                        // hours early or late. Sent as an instant, it means what
+                        // the dispatcher picked.
+                        expires_at: formState.expires_at ? new Date(formState.expires_at).toISOString() : null,
+                        single_use: true,
+                        pin_delivery: formState.pin_delivery,
+                    });
+                    const link = response?.link;
+                    const url = link?.path ? `${window.location.origin}${link.path}` : null;
+
+                    // Shown in the modal until it closes: the link, and the PIN to
+                    // share with it by some other way.
+                    set(formState, 'generated', { url, pin: link?.pin ?? null });
+
+                    // Every open link list watches this and reloads, so the link
+                    // that was just minted appears to be read, copied again or
+                    // revoked — rather than living only in the clipboard.
+                    this.linksChangedAt = Date.now();
+
+                    if (url) {
+                        await copyToClipboard(url);
+                    }
+
+                    this.notifyPinDelivery(response?.pin_delivery);
+
+                    modal.stopLoading();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+        });
+    }
+}