@fleetbase/fleetops-engine 0.6.49 → 0.6.51

package/addon/routes/operations/service-rates/index.js

@@ -27,7 +27,7 @@ export default class OperationsServiceRatesIndexRoute extends Route {
     model(params) {
         return this.store.query('service-rate', {
             ...params,
-            with: ['parcelFees', 'rateFees', 'zone', 'serviceArea'],
+            with: ['parcelFees', 'rateFees.zone', 'rateFees.serviceArea', 'zone', 'serviceArea'],
         });
     }
 }

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/geofence.js

@@ -9,6 +9,7 @@ import Service, { inject as service } from '@ember/service';
 import { action } from '@ember/object';
 import { debug } from '@ember/debug';
 import { dasherize } from '@ember/string';
+import { later } from '@ember/runloop';
 import toMultiPolygon from '../utils/to-multi-polygon';
 
 export default class GeofenceService extends Service {
@@ -173,9 +174,11 @@ export default class GeofenceService extends Service {
                 },
                 {
                     callback: (serviceArea) => {
-                        this.#resetDraftSession({ hideControl: true, removeDraft: true });
-                        this.#showServiceArea(serviceArea);
+                        this.#finishDraftSave((draftLayer) => {
+                            this.#reloadThenFocusServiceArea(serviceArea, { draftLayer });
+                        });
                     },
+                    refresh: false,
                 }
             );
             return;
@@ -184,7 +187,7 @@ export default class GeofenceService extends Service {
         if (this._draftSession.mode === 'zone') {
             const serviceArea = this._draftSession.serviceArea;
             this.zoneActions.modal.create(
-                { border: geoJson, service_area_uuid: serviceArea.id },
+                { border: geoJson, service_area: serviceArea },
                 {
                     decline: (modal) => {
                         this.#resetDraftSession({ hideControl: true, removeDraft: true });
@@ -193,10 +196,11 @@ export default class GeofenceService extends Service {
                 },
                 {
                     callback: (zone) => {
-                        serviceArea?.zones?.pushObject?.(zone);
-                        this.#resetDraftSession({ hideControl: true, removeDraft: true });
-                        this.#showZone(zone);
+                        this.#finishDraftSave((draftLayer) => {
+                            this.#reloadThenFocusZone(serviceArea, zone, { draftLayer });
+                        });
                     },
+                    refresh: false,
                 }
             );
             return;
@@ -246,19 +250,19 @@ export default class GeofenceService extends Service {
                 } else {
                     record.setProperties({
                         border: geoJson,
-                        service_area_uuid: selectedServiceArea.id,
-                        serviceArea: selectedServiceArea,
+                        service_area: selectedServiceArea,
                     });
                 }
 
                 return record.save().then((savedRecord) => {
-                    this.#resetDraftSession({ hideControl: true, removeDraft: true });
-
                     if (selectedLayerType === 'Service Area') {
-                        this.#showServiceArea(savedRecord);
+                        this.#finishDraftSave((draftLayer) => {
+                            this.#reloadThenFocusServiceArea(savedRecord, { draftLayer });
+                        });
                     } else {
-                        selectedServiceArea?.zones?.pushObject?.(savedRecord);
-                        this.#showZone(savedRecord);
+                        this.#finishDraftSave((draftLayer) => {
+                            this.#reloadThenFocusZone(selectedServiceArea, savedRecord, { draftLayer });
+                        });
                     }
 
                     return savedRecord;
@@ -289,28 +293,168 @@ export default class GeofenceService extends Service {
         this._draftSession = null;
     }
 
+    #finishDraftSave(callback) {
+        const draftLayer = this._draftSession?.draftLayer ?? null;
+        callback?.(draftLayer);
+        this.#resetDraftSession({ hideControl: true, removeDraft: false });
+    }
+
     async #editPolygonLayer(originalLayer, { focusBounds = null } = {}) {
         return this.mapManager.editPolygon(originalLayer, { focusBounds });
     }
 
     #showZone(zone, { pin = false } = {}) {
-        const layer = this.mapManager.getOverlay(zone.id) ?? zone?.leafletLayer ?? null;
+        const overlay = this.mapManager.getOverlay(zone.id);
+        const layer = overlay ?? zone?.leafletLayer ?? null;
         this.#setLayerPinned(layer, pin);
-        this.mapManager.showPolygon(zone.id);
+        if (overlay) {
+            this.mapManager.showPolygon(zone.id);
+        } else if (layer) {
+            this.mapManager.showLayer?.(layer);
+        }
+    }
+
+    #includeServiceArea(serviceArea) {
+        if (!serviceArea?.id) return;
+
+        const currentServiceAreas = this.serviceAreaActions.serviceAreas;
+        if (!currentServiceAreas) {
+            this.serviceAreaActions.serviceAreas = [serviceArea];
+            return;
+        }
+
+        const serviceAreas = Array.from(currentServiceAreas);
+        const exists = serviceAreas.some((existingServiceArea) => existingServiceArea?.id === serviceArea.id);
+        if (exists) return;
+
+        this.serviceAreaActions.serviceAreas = [...serviceAreas, serviceArea];
+    }
+
+    #includeZone(serviceArea, zone) {
+        if (!serviceArea?.id || !zone?.id) return;
+
+        const zones = serviceArea.zones;
+        if (!zones) {
+            serviceArea.set?.('zones', [zone]);
+            this.serviceAreaActions.serviceAreas = Array.from(this.serviceAreaActions.serviceAreas ?? []);
+            return;
+        }
+
+        const exists = Array.from(zones).some((existingZone) => existingZone?.id === zone.id);
+        if (exists) return;
+
+        if (typeof zones.pushObject === 'function') {
+            zones.pushObject(zone);
+        } else if (typeof zones.addObject === 'function') {
+            zones.addObject(zone);
+        } else if (typeof zones.push === 'function') {
+            zones.push(zone);
+        }
+
+        this.serviceAreaActions.serviceAreas = Array.from(this.serviceAreaActions.serviceAreas ?? []);
+    }
+
+    #reloadThenFocusServiceArea(serviceArea, options = {}) {
+        this.#reloadServiceAreas()
+            .then((serviceAreas) => {
+                const canonicalServiceArea = this.#findResource(serviceAreas, serviceArea) ?? serviceArea;
+                this.#focusServiceAreaAfterCreate(canonicalServiceArea, options);
+            })
+            .catch(() => {
+                this.#includeServiceArea(serviceArea);
+                this.#focusServiceAreaAfterCreate(serviceArea, options);
+            });
+    }
+
+    #reloadThenFocusZone(serviceArea, zone, options = {}) {
+        this.#reloadServiceAreas()
+            .then((serviceAreas) => {
+                const canonicalServiceArea = this.#findResource(serviceAreas, serviceArea) ?? serviceArea;
+                const canonicalZone = this.#findResource(canonicalServiceArea?.zones, zone) ?? zone;
+                this.#focusZoneAfterCreate(canonicalZone, options);
+            })
+            .catch(() => {
+                this.#includeZone(serviceArea, zone);
+                this.#focusZoneAfterCreate(zone, options);
+            });
+    }
+
+    #reloadServiceAreas() {
+        return Promise.resolve(this.serviceAreaActions.loadAll.perform()).then(() => this.serviceAreaActions.serviceAreas ?? []);
+    }
+
+    #findResource(resources, resource) {
+        if (!resource || !resources) return null;
+
+        const resourceId = resource.id ?? resource.public_id;
+        const publicId = resource.public_id ?? resource.id;
+
+        return (
+            Array.from(resources).find((candidate) => {
+                return candidate?.id === resourceId || candidate?.id === publicId || candidate?.public_id === publicId || candidate?.public_id === resourceId;
+            }) ?? null
+        );
+    }
+
+    #focusServiceAreaAfterCreate(serviceArea, options = {}) {
+        this.#focusWhenReady([serviceArea], () => this.focusServiceArea(serviceArea), options);
+    }
+
+    #focusZoneAfterCreate(zone, options = {}) {
+        this.#focusWhenReady([zone], () => this.focusZone(zone), options);
+    }
+
+    #focusWhenReady(models, focus, { attempts = 60, delay = 100, draftLayer = null } = {}) {
+        const overlays = models
+            .map((model) => {
+                const overlay = this.mapManager.getOverlay(model?.id);
+                if (overlay) {
+                    return overlay;
+                }
+
+                return model?.leafletLayer === draftLayer ? null : model?.leafletLayer;
+            })
+            .filter(Boolean);
+        const allRegistered = overlays.length === models.length;
+
+        if (allRegistered || attempts <= 0) {
+            focus();
+            if (draftLayer && !draftLayer.__removedAfterCreate && !overlays.includes(draftLayer)) {
+                draftLayer.__removedAfterCreate = true;
+                this.mapManager.removeLayer(draftLayer);
+            }
+            return;
+        }
+
+        later(this, () => this.#focusWhenReady(models, focus, { attempts: attempts - 1, delay, draftLayer }), delay);
     }
 
     #showServiceArea(serviceArea, { pin = false } = {}) {
         [serviceArea, ...(serviceArea.zones ?? [])].forEach((model) => {
-            const layer = this.mapManager.getOverlay(model.id) ?? model?.leafletLayer ?? null;
+            const overlay = this.mapManager.getOverlay(model.id);
+            const layer = overlay ?? model?.leafletLayer ?? null;
             this.#setLayerPinned(layer, pin);
-            this.mapManager.showPolygon(model.id);
+            if (overlay) {
+                this.mapManager.showPolygon(model.id);
+            } else if (layer) {
+                this.mapManager.showLayer?.(layer);
+            }
         });
     }
 
     #hideServiceArea(serviceArea) {
         [serviceArea, ...(serviceArea.zones ?? [])].forEach((model) => {
-            this.#setLayerPinned(model?.leafletLayer ?? this.mapManager.getOverlay(model.id), false);
-            this.mapManager.hidePolygon(model.id);
+            const overlay = this.mapManager.getOverlay(model.id);
+            const layer = model?.leafletLayer;
+
+            this.#setLayerPinned(layer ?? overlay, false);
+            if (overlay) {
+                this.mapManager.hidePolygon(model.id);
+            }
+
+            if (layer && layer !== overlay) {
+                this.mapManager.hideLayer?.(layer);
+            }
         });
     }
 

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

package/addon/services/issue-actions.js

@@ -2,6 +2,7 @@ import ResourceActionService from '@fleetbase/ember-core/services/resource-actio
 import { inject as service } from '@ember/service';
 import { action } from '@ember/object';
 import { format } from 'date-fns';
+import { issueStatuses } from '../utils/fleet-ops-options';
 
 export default class IssueActionsService extends ResourceActionService {
     @service driverActions;
@@ -92,6 +93,76 @@ export default class IssueActionsService extends ResourceActionService {
         },
     };
 
+    get closedStatuses() {
+        return ['closed', 'resolved', 'completed'];
+    }
+
+    openStatusModal(issue, options = {}) {
+        return this.modalsManager.show('modals/issue-status', {
+            issue,
+            statusOptions: issueStatuses,
+            onSaved: options.onSaved,
+        });
+    }
+
+    openAssignModal(issue, options = {}) {
+        return this.modalsManager.show('modals/issue-assign', {
+            issue,
+            onSaved: options.onSaved,
+        });
+    }
+
+    openCloseIssueModal(issue, options = {}) {
+        return this.modalsManager.show('modals/issue-close', {
+            issue,
+            onSaved: options.onSaved,
+        });
+    }
+
+    confirmReopenIssue(issue, options = {}) {
+        this.modalsManager.confirm({
+            title: `Re-open ${issue.public_id || 'issue'}?`,
+            body: 'This will move the issue back into an active re-opened state and clear the active resolution date.',
+            acceptButtonText: 'Re-open Issue',
+            acceptButtonIcon: 'rotate-left',
+            confirm: async (modal) => {
+                modal.startLoading();
+
+                try {
+                    const meta = issue.meta ?? {};
+                    const reopenHistory = Array.isArray(meta.reopen_history) ? meta.reopen_history : [];
+                    const user = this.currentUser.user;
+
+                    issue.status = 're_opened';
+                    issue.resolved_at = null;
+                    issue.meta = {
+                        ...meta,
+                        reopen_history: [
+                            ...reopenHistory,
+                            {
+                                reopened_at: new Date().toISOString(),
+                                reopened_by_uuid: user?.id,
+                                reopened_by_name: user?.name,
+                            },
+                        ],
+                    };
+
+                    await issue.save();
+                    this.notifications.success('Issue re-opened.');
+
+                    if (typeof options.onSaved === 'function') {
+                        await options.onSaved(issue);
+                    }
+
+                    modal.done();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+        });
+    }
+
     @action async viewDriver(issue) {
         const driver = await issue.loadDriver();
         if (driver) {

package/addon/services/leaflet-contextmenu-manager.js

@@ -85,6 +85,33 @@ export default class LeafletContextmenuManagerService extends Service {
         return null;
     }
 
+    /**
+     * Remove a registered context menu and detach it from its layer when possible.
+     *
+     * @param {string} registryName - The public context menu registry name.
+     * @returns {Object|null} The removed registry, or null when none existed.
+     */
+    removeContextMenu(registryName) {
+        const internalRegistryName = this.createInternalRegistryName(registryName);
+        const registry = this.contextMenuRegistry[internalRegistryName];
+
+        if (!registry) {
+            return null;
+        }
+
+        try {
+            registry.contextmenuApi?.removeAllItems?.();
+            registry.layer?.unbindContextMenu?.();
+        } catch (error) {
+            // Context menus are disposable UI state; stale layer cleanup should not block record deletion.
+        }
+
+        delete this.contextMenuRegistry[internalRegistryName];
+        this.contextMenuRegistry = { ...this.contextMenuRegistry };
+
+        return registry;
+    }
+
     /**
      * Creates an internal registry name by camelizing the provided registry name and appending "ConextmenuRegistry" to it.
      *

package/addon/services/leaflet-map-manager.js

@@ -7,6 +7,7 @@ import { renderCompleted, waitForInsertedAndSized } from '@fleetbase/ember-ui/ut
 import { Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
 import { getLayerById, findLayer, flyToLayer } from '../utils/leaflet';
 import isUuid from '@fleetbase/ember-core/utils/is-uuid';
+import ensureLeafletPluginsReady from '../utils/leaflet-plugin-loader';
 
 export default class LeafletMapManagerService extends Service {
     @service leafletRoutingControl;
@@ -92,6 +93,7 @@ export default class LeafletMapManagerService extends Service {
     }
 
     async ensureInteractive({ timeoutMs = 8000 } = {}) {
+        await ensureLeafletPluginsReady({ timeoutMs });
         await this.whenMapLoaded({ timeoutMs });
 
         // always ask Leaflet for the live container