@fleetbase/fleetops-engine 0.6.50 → 0.6.51

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

@@ -4,16 +4,62 @@ import { inject as service } from '@ember/service';
 
 export default class ManagementIssuesIndexDetailsController extends Controller {
     @service hostRouter;
+    @service issueActions;
+
     @tracked tabs = [
         {
             route: 'management.issues.index.details.index',
             label: 'Overview',
         },
     ];
-    @tracked actionButtons = [
-        {
-            icon: 'pencil',
-            fn: () => this.hostRouter.transitionTo('console.fleet-ops.management.issues.index.edit', this.model),
-        },
-    ];
+
+    get isClosed() {
+        return ['closed', 'resolved', 'completed'].includes(this.model?.status);
+    }
+
+    get actionButtons() {
+        const workflowItems = [
+            {
+                label: 'Change Status',
+                icon: 'arrows-rotate',
+                fn: () => this.issueActions.openStatusModal(this.model, { onSaved: () => this.refreshIssue() }),
+            },
+            {
+                label: 'Assign Issue',
+                icon: 'user-check',
+                fn: () => this.issueActions.openAssignModal(this.model, { onSaved: () => this.refreshIssue() }),
+            },
+        ];
+
+        if (this.isClosed) {
+            workflowItems.push({
+                label: 'Re-open Issue',
+                icon: 'rotate-left',
+                fn: () => this.issueActions.confirmReopenIssue(this.model, { onSaved: () => this.refreshIssue() }),
+            });
+        } else {
+            workflowItems.push({
+                label: 'Close Issue',
+                icon: 'circle-check',
+                class: 'text-green-600 dark:text-green-400',
+                fn: () => this.issueActions.openCloseIssueModal(this.model, { onSaved: () => this.refreshIssue() }),
+            });
+        }
+
+        return [
+            {
+                icon: 'pencil',
+                fn: () => this.hostRouter.transitionTo('console.fleet-ops.management.issues.index.edit', this.model),
+            },
+            {
+                icon: 'ellipsis',
+                type: 'default',
+                items: workflowItems,
+            },
+        ];
+    }
+
+    refreshIssue() {
+        return this.model?.reload?.();
+    }
 }

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

@@ -9,6 +9,10 @@ export default class ManagementVendorsIndexDetailsController extends Controller
             route: 'management.vendors.index.details.index',
             label: 'Overview',
         },
+        {
+            route: 'management.vendors.index.details.personnel',
+            label: 'Personnel',
+        },
     ];
     @tracked actionButtons = [
         {

package/addon/controllers/operations/orders/index/details.js

@@ -1,5 +1,6 @@
 import Controller, { inject as controller } from '@ember/controller';
 import { tracked } from '@glimmer/tracking';
+import { action } from '@ember/object';
 import { inject as service } from '@ember/service';
 import { isArray } from '@ember/array';
 import { task } from 'ember-concurrency';
@@ -19,6 +20,7 @@ export default class OperationsOrdersIndexDetailsController extends Controller {
     @tracked routingControl;
     @tracked routingCompleted = false;
     @tracked realtimeOrderPublicId = null;
+    @tracked proofReloadToken = 0;
 
     get routePoints() {
         return buildRoutePointsFromPayload(this.model?.payload);
@@ -97,9 +99,7 @@ export default class OperationsOrdersIndexDetailsController extends Controller {
                         disabled: this.model.status === 'canceled',
                         fn: () =>
                             this.orderActions.updateActivity(this.model, {
-                                onFinish: () => {
-                                    this.refresh.perform();
-                                },
+                                onFinish: this.handleActivityModalFinish,
                             }),
                     },
                     {
@@ -154,6 +154,14 @@ export default class OperationsOrdersIndexDetailsController extends Controller {
         ];
     }
 
+    @action handleActivityModalFinish(options) {
+        this.refresh.perform();
+
+        if (options?.proofCreated) {
+            this.proofReloadToken++;
+        }
+    }
+
     @task *refresh() {
         try {
             yield this.hostRouter.refresh();

package/addon/controllers/operations/orders/index.js

@@ -271,7 +271,7 @@ export default class OperationsOrdersIndexController extends Controller {
             },
             {
                 label: this.intl.t('column.transaction'),
-                cellComponent: 'table/cell/base',
+                cellComponent: 'table/cell/currency',
                 valuePath: 'transaction_amount',
                 resizable: true,
                 hidden: true,

package/addon/extension.js

@@ -117,6 +117,9 @@ export default {
         // Create registries
         this.createRegistries(registryService);
 
+        // // Register console home guidance
+        // this.registerHomeComponents(registryService);
+
         // Setup customer portal
         const isCustomerPortalInstalled = universe.extensionManager.isInstalled('@fleetbase/customer-portal-engine');
         if (isCustomerPortalInstalled) {
@@ -216,13 +219,23 @@ export default {
                 category: 'Analytics',
                 default: false,
             }),
+            new Widget({
+                id: 'fleet-ops-live-fleet-widget',
+                name: 'Live Fleet Map',
+                description: 'Real-time driver positions and active routes.',
+                icon: 'map-location-dot',
+                component: new ExtensionComponent('@fleetbase/fleetops-engine', 'widget/live-fleet'),
+                grid_options: { w: 8, h: 11, minW: 8, minH: 8 },
+                category: 'Maps',
+                default: true,
+            }),
             new Widget({
                 id: 'fleet-ops-revenue-trend-widget',
                 name: 'Revenue Trend',
                 description: 'Revenue over time with period comparison.',
                 icon: 'chart-line',
                 component: new ExtensionComponent('@fleetbase/fleetops-engine', 'widget/revenue-trend'),
-                grid_options: { w: 6, h: 6, minW: 5, minH: 5 },
+                grid_options: { w: 4, h: 11, minW: 4, minH: 8 },
                 category: 'Analytics',
                 default: true,
             }),
@@ -254,7 +267,7 @@ export default {
                 component: new ExtensionComponent('@fleetbase/fleetops-engine', 'widget/top-drivers'),
                 grid_options: { w: 6, h: 6, minW: 5, minH: 5 },
                 category: 'Analytics',
-                default: false,
+                default: true,
             }),
             new Widget({
                 id: 'fleet-ops-fuel-efficiency-widget',
@@ -296,21 +309,15 @@ export default {
                 category: 'Analytics',
                 default: false,
             }),
-            new Widget({
-                id: 'fleet-ops-live-fleet-widget',
-                name: 'Live Fleet Map',
-                description: 'Real-time driver positions and active routes.',
-                icon: 'map-location-dot',
-                component: new ExtensionComponent('@fleetbase/fleetops-engine', 'widget/live-fleet'),
-                grid_options: { w: 12, h: 10, minW: 8, minH: 8 },
-                category: 'Maps',
-                default: true,
-            }),
         ];
 
         widgetService.registerWidgets('dashboard', widgets);
     },
 
+    registerHomeComponents(registryService) {
+        registryService.registerRenderableComponent('console:home:before-dashboard', new ExtensionComponent('@fleetbase/fleetops-engine', 'home/getting-started-guidance'));
+    },
+
     createRegistries(registryService) {
         registryService.createRegistries([
             'engine:fleet-ops',

package/addon/helpers/format-duration.js

@@ -1,38 +1 @@
-import { helper } from '@ember/component/helper';
-
-export function formatDurationValue(seconds) {
-    const value = Number(seconds);
-
-    if (!Number.isFinite(value)) {
-        return '0s';
-    }
-
-    const totalSeconds = Math.max(0, Math.ceil(value));
-    const days = Math.floor(totalSeconds / 86400);
-    const hours = Math.floor((totalSeconds % 86400) / 3600);
-    const minutes = Math.floor((totalSeconds % 3600) / 60);
-    const remainingSeconds = totalSeconds % 60;
-    const parts = [];
-
-    if (days) {
-        parts.push(`${days}d`);
-    }
-
-    if (hours) {
-        parts.push(`${hours}h`);
-    }
-
-    if (!days && minutes) {
-        parts.push(`${minutes}m`);
-    }
-
-    if (!days && !hours && parts.length < 2 && remainingSeconds) {
-        parts.push(`${remainingSeconds}s`);
-    }
-
-    return parts.length ? parts.join(' ') : '0s';
-}
-
-export default helper(function formatDuration([seconds]) {
-    return formatDurationValue(seconds);
-});
+export { default, formatDurationValue } from '@fleetbase/ember-ui/helpers/format-duration';

package/addon/initializers/load-leaflet-assets.js

@@ -1,15 +1,14 @@
-import loadLeafletPlugins from '@fleetbase/ember-ui/utils/load-leaflet-plugins';
+import { debug } from '@ember/debug';
+import ensureLeafletPluginsReady from '../utils/leaflet-plugin-loader';
 
 export function initialize() {
     let waitForLeaflet = setInterval(() => {
         let leafletLoaded = window.L !== undefined;
         if (leafletLoaded) {
-            loadLeafletPlugins({
-                scripts: ['leaflet.contextmenu.js', 'leaflet.draw-src.js'],
-                stylesheets: ['leaflet.contextmenu.css', 'leaflet.draw.css'],
-                globalIndicatorKey: 'fleetopsLeafletPluginsLoaded',
-            });
             clearInterval(waitForLeaflet);
+            ensureLeafletPluginsReady().catch((error) => {
+                debug(error.message);
+            });
         }
     }, 100);
 }

package/addon/initializers/patch-ember-leaflet-tooltip-layer.js

@@ -0,0 +1,51 @@
+import TooltipLayer from 'ember-leaflet/components/tooltip-layer';
+
+function hasMethod(object, methodName) {
+    return typeof object?.[methodName] === 'function';
+}
+
+export function initialize() {
+    const prototype = TooltipLayer?.prototype;
+    if (!prototype || prototype.__fleetopsTooltipLayerPatched) {
+        return;
+    }
+
+    const addToContainer = prototype.addToContainer;
+    const removeFromContainer = prototype.removeFromContainer;
+    const removePopupListeners = prototype._removePopupListeners;
+
+    prototype.addToContainer = function () {
+        const parentLayer = this.args?.parent?._layer;
+        if (!this._layer || !hasMethod(parentLayer, 'bindTooltip')) {
+            return;
+        }
+
+        return addToContainer.call(this);
+    };
+
+    prototype.removeFromContainer = function () {
+        const parentLayer = this.args?.parent?._layer;
+        if (!hasMethod(parentLayer, 'unbindTooltip')) {
+            return;
+        }
+
+        return removeFromContainer.call(this);
+    };
+
+    prototype._removePopupListeners = function () {
+        const parentMap = this.args?.parent?._layer?._map;
+        if (!hasMethod(parentMap, 'removeEventListener')) {
+            return;
+        }
+
+        return removePopupListeners.call(this);
+    };
+
+    Object.defineProperty(prototype, '__fleetopsTooltipLayerPatched', {
+        value: true,
+    });
+}
+
+export default {
+    initialize,
+};

package/addon/routes/management/issues/index/details.js

@@ -28,6 +28,6 @@ export default class ManagementIssuesIndexDetailsRoute extends Route {
     };
 
     model({ public_id }) {
-        return this.store.queryRecord('issue', { public_id, single: true, with: ['driver', 'vehicle', 'assignee', 'reporter'] });
+        return this.store.queryRecord('issue', { public_id, single: true, with: ['driver', 'vehicle', 'assignee', 'reporter', 'order', 'files'] });
     }
 }

package/addon/routes.js

@@ -53,6 +53,7 @@ export default buildRoutes(function () {
                 this.route('new');
                 this.route('details', { path: '/:public_id' }, function () {
                     this.route('index', { path: '/' });
+                    this.route('personnel');
                 });
                 this.route('edit', { path: '/edit/:public_id' });
             });

package/addon/services/contact-actions.js

@@ -1,9 +1,15 @@
 import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
 import { inject as service } from '@ember/service';
-import { action } from '@ember/object';
+import { action, get } from '@ember/object';
+
+const INTERNAL_NAMESPACE = 'int/v1';
 
 export default class ContactActionsService extends ResourceActionService {
+    @service fetch;
     @service placeActions;
+    @service notifications;
+    @service hostRouter;
+    @service('universe/extension-manager') extensionManager;
 
     constructor() {
         super(...arguments);
@@ -112,4 +118,228 @@ export default class ContactActionsService extends ResourceActionService {
             }
         );
     }
+
+    hasLinkedUser(contact) {
+        const user = contact?.user;
+        return Boolean(contact?.user_uuid || (user && (get(user, 'id') || get(user, 'uuid'))));
+    }
+
+    linkedUserStatus(contact) {
+        const user = contact?.user;
+        return (user ? (get(user, 'status') ?? get(user, 'session_status')) : null) ?? 'active';
+    }
+
+    hasInactiveLogin(contact) {
+        return ['inactive', 'disabled', 'suspended'].includes(this.linkedUserStatus(contact));
+    }
+
+    isCustomerPortalInstalled() {
+        return this.extensionManager.isInstalled('@fleetbase/customer-portal-engine');
+    }
+
+    accountActionButton(contact, options = {}) {
+        if (!this.hasLinkedUser(contact)) {
+            return null;
+        }
+
+        return {
+            icon: 'ellipsis-h',
+            iconPrefix: 'fas',
+            renderInPlace: true,
+            items: this.accountActionItems(contact, options),
+        };
+    }
+
+    accountActionItems(contact, options = {}) {
+        const actions = [
+            {
+                text: 'Reset Password',
+                icon: 'key',
+                fn: () => this.openResetPasswordModal(contact),
+            },
+            {
+                text: 'Send Credentials',
+                icon: 'paper-plane',
+                fn: () => this.confirmSendCredentials(contact),
+            },
+            this.hasInactiveLogin(contact)
+                ? {
+                      text: 'Reactivate Login',
+                      icon: 'unlock',
+                      fn: () => this.confirmReactivatePortalLogin(contact),
+                  }
+                : {
+                      text: 'Deactivate Login',
+                      icon: 'lock',
+                      fn: () => this.confirmDeactivatePortalLogin(contact),
+                      class: 'text-red-500 hover:text-red-600',
+                  },
+        ];
+
+        if (this.isCustomerPortalInstalled()) {
+            actions.push(
+                {
+                    separator: true,
+                },
+                {
+                    text: 'Convert to Vendor',
+                    icon: 'building',
+                    fn: () => this.openConvertToVendorModal(contact, options),
+                }
+            );
+        }
+
+        return actions;
+    }
+
+    accountRowActionItems(options = {}) {
+        const hasCustomerPortal = this.isCustomerPortalInstalled();
+        const hasLinkedUser = (contact) => this.hasLinkedUser(contact);
+
+        const actions = [
+            {
+                label: 'Reset Password',
+                icon: 'key',
+                fn: (contact) => this.openResetPasswordModal(contact),
+                isVisible: hasLinkedUser,
+            },
+            {
+                label: 'Send Credentials',
+                icon: 'paper-plane',
+                fn: (contact) => this.confirmSendCredentials(contact),
+                isVisible: hasLinkedUser,
+            },
+            {
+                label: 'Deactivate Login',
+                icon: 'lock',
+                class: 'text-red-500 hover:text-red-600',
+                fn: (contact) => this.confirmDeactivatePortalLogin(contact),
+                isVisible: (contact) => hasLinkedUser(contact) && !this.hasInactiveLogin(contact),
+            },
+            {
+                label: 'Reactivate Login',
+                icon: 'unlock',
+                fn: (contact) => this.confirmReactivatePortalLogin(contact),
+                isVisible: (contact) => hasLinkedUser(contact) && this.hasInactiveLogin(contact),
+            },
+        ];
+
+        if (hasCustomerPortal) {
+            actions.push({
+                label: 'Convert to Vendor',
+                icon: 'building',
+                fn: (contact) => this.openConvertToVendorModal(contact, options),
+                isVisible: hasLinkedUser,
+            });
+        }
+
+        return actions;
+    }
+
+    openResetPasswordModal(contact) {
+        this.modalsManager.show('modals/reset-customer-credentials', {
+            customer: contact,
+        });
+    }
+
+    openConvertToVendorModal(contact, options = {}) {
+        this.modalsManager.show('modals/convert-customer-to-vendor', {
+            customer: contact,
+            onConverted: (vendor) => {
+                if (typeof options.onConverted === 'function') {
+                    options.onConverted(vendor);
+                    return;
+                }
+
+                if (vendor?.id) {
+                    this.hostRouter.transitionTo('console.fleet-ops.management.vendors.index.details', vendor.id);
+                }
+            },
+        });
+    }
+
+    confirmSendCredentials(contact) {
+        this.confirmLoginAction(contact, {
+            title: 'Send Portal Credentials',
+            body: 'Generate a new temporary password and email this contact their portal credentials.',
+            acceptButtonText: 'Send Credentials',
+            endpoint: 'customers/send-credentials',
+            successMessage: 'Portal credentials sent.',
+        });
+    }
+
+    confirmDeactivatePortalLogin(contact) {
+        this.confirmLoginAction(contact, {
+            title: 'Deactivate Login',
+            body: 'Deactivate portal access for this contact. Their profile and history will be preserved.',
+            acceptButtonText: 'Deactivate Login',
+            acceptButtonScheme: 'danger',
+            endpoint: 'customers/deactivate-portal-login',
+            successMessage: 'Portal login deactivated.',
+        });
+    }
+
+    confirmReactivatePortalLogin(contact) {
+        this.confirmLoginAction(contact, {
+            title: 'Reactivate Login',
+            body: 'Reactivate portal access for this contact.',
+            acceptButtonText: 'Reactivate Login',
+            endpoint: 'customers/reactivate-portal-login',
+            successMessage: 'Portal login reactivated.',
+        });
+    }
+
+    confirmLoginAction(contact, { title, body, acceptButtonText, acceptButtonScheme, endpoint, successMessage }) {
+        this.modalsManager.confirm({
+            title,
+            body,
+            acceptButtonText,
+            acceptButtonScheme,
+            confirm: async (modal) => {
+                modal.startLoading();
+
+                try {
+                    const response = await this.fetch.post(endpoint, { customer: contact?.id }, { namespace: INTERNAL_NAMESPACE });
+                    await this.updateContactFromResponse(contact, response);
+                    this.notifications.success(successMessage);
+                    modal.done();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+        });
+    }
+
+    async updateContactFromResponse(contact, response) {
+        const payload = response.customer ?? response.contact;
+
+        if (!payload || typeof contact?.setProperties !== 'function') {
+            return;
+        }
+
+        contact.setProperties(
+            this.withoutIdentityFields({
+                user_uuid: payload.user_uuid,
+            })
+        );
+
+        if (payload.user) {
+            const user = await contact.user;
+
+            if (typeof user?.setProperties === 'function') {
+                user.setProperties(this.withoutIdentityFields(payload.user));
+            }
+        }
+    }
+
+    withoutIdentityFields(payload = {}) {
+        const attributes = { ...payload };
+
+        delete attributes.id;
+        delete attributes.uuid;
+        delete attributes.public_id;
+
+        return attributes;
+    }
 }

package/addon/services/getting-started.js

@@ -0,0 +1,44 @@
+import Service from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { task } from 'ember-concurrency';
+
+export default class GettingStartedService extends Service {
+    @service fetch;
+
+    @tracked data = null;
+    @tracked error = null;
+
+    get isCompleted() {
+        return this.data?.is_completed === true;
+    }
+
+    get steps() {
+        return this.data?.steps ?? [];
+    }
+
+    get recommendations() {
+        return this.data?.recommendations ?? [];
+    }
+
+    get progress() {
+        return this.data?.progress ?? { completed: 0, total: 0, percent: 0 };
+    }
+
+    get nextStepKey() {
+        return this.data?.next_step;
+    }
+
+    get nextStep() {
+        return this.steps.find((step) => step.key === this.nextStepKey) ?? this.steps.find((step) => !step.completed);
+    }
+
+    @task({ drop: true }) *load() {
+        try {
+            this.data = yield this.fetch.get('fleet-ops/getting-started/status');
+            this.error = null;
+        } catch (error) {
+            this.error = error?.message ?? 'Failed to load getting started status';
+        }
+    }
+}