@fleetbase/fleetops-engine 0.6.12 → 0.6.14

package/addon/components/customer/orders.js

@@ -6,8 +6,7 @@ import { isArray } from '@ember/array';
 import { later } from '@ember/runloop';
 import { debug } from '@ember/debug';
 import { task, timeout } from 'ember-concurrency';
-import { OSRMv1, Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
-import getRoutingHost from '@fleetbase/ember-core/utils/get-routing-host';
+import { Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
 import engineService from '@fleetbase/ember-core/decorators/engine-service';
 import registerComponent from '@fleetbase/ember-core/utils/register-component';
 import OrderProgressCardComponent from '../order-progress-card';
@@ -26,6 +25,7 @@ export default class CustomerOrdersComponent extends Component {
     @service modalsManager;
     @service customerSession;
     @service hostRouter;
+    @service leafletRouterControl;
     @engineService('@fleetbase/fleetops-engine') movementTracker;
     @engineService('@fleetbase/fleetops-engine') location;
     @tracked orders = [];
@@ -226,7 +226,6 @@ export default class CustomerOrdersComponent extends Component {
 
     @action displayOrderRoute() {
         const waypoints = this.getRouteCoordinatesFromOrder(this.selectedOrder);
-        const routingHost = getRoutingHost();
         if (this.cannotRouteWaypoints(waypoints)) {
             return;
         }
@@ -240,15 +239,14 @@ export default class CustomerOrdersComponent extends Component {
             debug(`Leaflet Map Error: ${error.message}`);
         }
 
-        const router = new OSRMv1({
-            serviceUrl: `${routingHost}/route/v1`,
-            profile: 'driving',
-        });
+        const routingService = this.currentUser.getOption('routing', { router: 'osrm' }).router;
+        const { router, formatter } = this.leafletRouterControl.get(routingService);
 
         this.routeControl = new RoutingControl({
-            fitSelectedRoutes: false,
             router,
+            formatter,
             waypoints,
+            fitSelectedRoutes: false,
             alternativeClassName: 'hidden',
             addWaypoints: false,
             markerOptions: {

package/addon/components/layout/fleet-ops-sidebar.js

@@ -162,6 +162,14 @@ export default class LayoutFleetOpsSidebarComponent extends Component {
                 permission: 'fleet-ops view notification-settings',
                 visible: this.abilities.can('fleet-ops see notification-settings'),
             },
+            {
+                intl: 'fleet-ops.component.layout.fleet-ops-sidebar.routing',
+                title: this.intl.t('fleet-ops.component.layout.fleet-ops-sidebar.routing'),
+                icon: 'route',
+                route: 'settings.routing',
+                permission: 'fleet-ops view routing-settings',
+                visible: this.abilities.can('fleet-ops see routing-settings'),
+            },
         ];
 
         const createPanel = (intl, routePrefix, items = []) => ({

package/addon/components/live-map.js

@@ -9,8 +9,7 @@ import { later } from '@ember/runloop';
 import { debug } from '@ember/debug';
 import { allSettled } from 'rsvp';
 import { task } from 'ember-concurrency';
-import { OSRMv1, Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
-import getRoutingHost from '@fleetbase/ember-core/utils/get-routing-host';
+import { Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
 import getWithDefault from '@fleetbase/ember-core/utils/get-with-default';
 
 /**
@@ -37,6 +36,7 @@ export default class LiveMapComponent extends Component {
     @service contextPanel;
     @service leafletMapManager;
     @service leafletContextmenuManager;
+    @service leafletRouterControl;
     @service theme;
 
     /**
@@ -1126,7 +1126,6 @@ export default class LiveMapComponent extends Component {
 
         // create order route preview
         const waypoints = this.getRouteCoordinatesFromOrder(order);
-        const routingHost = getRoutingHost();
         if (this.cannotRouteWaypoints(waypoints)) {
             return;
         }
@@ -1140,15 +1139,14 @@ export default class LiveMapComponent extends Component {
             debug(`Leaflet Map Error: ${error.message}`);
         }
 
-        const router = new OSRMv1({
-            serviceUrl: `${routingHost}/route/v1`,
-            profile: 'driving',
-        });
+        const routingService = this.currentUser.getOption('routing', { router: 'osrm' }).router;
+        const { router, formatter } = this.leafletRouterControl.get(routingService);
 
         this.routeControl = new RoutingControl({
-            fitSelectedRoutes: false,
             router,
+            formatter,
             waypoints,
+            fitSelectedRoutes: false,
             alternativeClassName: 'hidden',
             addWaypoints: false,
             markerOptions: {

package/addon/components/order-config/fields-editor.js

@@ -197,7 +197,7 @@ export default class OrderConfigFieldsEditorComponent extends Component {
         }
     }
 
-    /* eslint no-unused-vars: "off" */
+    /* eslint-disable no-unused-vars */
     @action sortMetaFieldOptions(metaField, el, target) {
         // const { fields } = this;
         // const { index } = el.dataset;

package/addon/components/route-optimization-engine-select-button.hbs

@@ -0,0 +1,25 @@
+<DropdownButton
+    @text="Optimize Route"
+    @icon="caret-down"
+    @type="magic"
+    @size="sm"
+    @iconPrefix="fas"
+    @triggerClass="hidden md:flex"
+    @helpText="Optimize route using an integrated optimization engine"
+    @disabled={{@disabled}}
+    @isLoading={{@isLoading}}
+    @renderInPlace={{true}}
+    as |dd|
+>
+    <div class="next-dd-menu" aria-labelledby="user-menu">
+        <div class="px-1">
+            {{#each this.routeOptimization.availableServices as |service|}}
+                <a href="javascript:;" class="next-dd-item" {{on "click" (dropdown-fn dd this.handleClick service)}}>
+                    <div >
+                        <div class="text-sm">{{service.name}}</div>
+                    </div>
+                </a>
+            {{/each}}
+        </div>
+    </div>
+</DropdownButton>

package/addon/components/route-optimization-engine-select-button.js

@@ -0,0 +1,13 @@
+import Component from '@glimmer/component';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+
+export default class RouteOptimizationEngineSelectButtonComponent extends Component {
+    @service routeOptimization;
+
+    @action handleClick({ key }) {
+        if (typeof this.args.onClick === 'function') {
+            this.args.onClick(key);
+        }
+    }
+}

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

@@ -9,11 +9,9 @@ import { isBlank } from '@ember/utils';
 import { dasherize } from '@ember/string';
 import { next } from '@ember/runloop';
 import { task } from 'ember-concurrency';
-import { OSRMv1, Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
+import { Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
 import { debug } from '@ember/debug';
-import polyline from '@fleetbase/ember-core/utils/polyline';
 import isNotEmpty from '@fleetbase/ember-core/utils/is-not-empty';
-import getRoutingHost from '@fleetbase/ember-core/utils/get-routing-host';
 import getWithDefault from '@fleetbase/ember-core/utils/get-with-default';
 import isModel from '@fleetbase/ember-core/utils/is-model';
 
@@ -31,95 +29,22 @@ L.Bounds.prototype.intersects = function (bounds) {
 export default class OperationsOrdersIndexNewController extends BaseController {
     @controller('operations.orders.index') ordersController;
 
-    /**
-     * Inject the `modalsManager` service
-     *
-     * @var {Service}
-     */
     @service modalsManager;
-
-    /**
-     * Inject the `notifications` service
-     *
-     * @var {Service}
-     */
     @service notifications;
-
-    /**
-     * Inject the `loader` service
-     *
-     * @var {Service}
-     */
     @service loader;
-
-    /**
-     * Inject the `currentUser` service
-     *
-     * @var {Service}
-     */
     @service currentUser;
-
-    /**
-     * Inject the `hostRouter` service
-     *
-     * @var {Service}
-     */
     @service hostRouter;
-
-    /**
-     * Inject the `fileQueue` service
-     *
-     * @var {Service}
-     */
     @service fileQueue;
-
-    /**
-     * Inject the `intl` service
-     *
-     * @var {Service}
-     */
     @service intl;
-
-    /**
-     * Inject the `fetch` service
-     *
-     * @var {Service}
-     */
     @service fetch;
-
-    /**
-     * Inject the `store` service
-     *
-     * @var {Service}
-     */
     @service store;
-
-    /**
-     * Inject the `contextPanel` service
-     *
-     * @var {Service}
-     */
     @service contextPanel;
-
-    /**
-     * Inject the `universe` service
-     *
-     * @var {Service}
-     */
     @service universe;
+    @service routeOptimization;
+    @service leafletRouterControl;
+    @service osrm;
 
-    /**
-     * Create an OrderModel instance.
-     *
-     * @var {OrderModel}
-     */
     @tracked order = this.store.createRecord('order', { meta: [] });
-
-    /**
-     * Create an PayloadModel instance.
-     *
-     * @var {OrderModel}
-     */
     @tracked payload = this.store.createRecord('payload');
     @tracked driversQuery = {};
     @tracked vehiclesQuery = {};
@@ -139,7 +64,6 @@ export default class OperationsOrdersIndexNewController extends BaseController {
     @tracked isCreatingOrder = false;
     @tracked isMultipleDropoffOrder = false;
     @tracked isViewingRoutePreview = false;
-    @tracked isOptimizingRoute = false;
     @tracked optimizedRouteMarkers = [];
     @tracked optimizedRoutePolyline;
     @tracked isFetchingQuotes = false;
@@ -191,14 +115,8 @@ export default class OperationsOrdersIndexNewController extends BaseController {
         'application/x-tar',
     ];
 
-    get renderableComponents() {
-        const renderableComponents = this.universe.getRenderableComponentsFromRegistry('fleet-ops:template:operations:orders:new');
-        return renderableComponents;
-    }
-
-    get renderableEntityInputComponents() {
-        const renderableComponents = this.universe.getRenderableComponentsFromRegistry('fleet-ops:template:operations:orders:new:entities-input');
-        return renderableComponents;
+    get hasRouteOptimizationEngines() {
+        return this.routeOptimization.availableEngines.length > 1;
     }
 
     @not('isServicable') isNotServicable;
@@ -873,13 +791,12 @@ export default class OperationsOrdersIndexNewController extends BaseController {
         const canPreviewRoute = this.routePreviewArray.length > 0;
 
         if (canPreviewRoute) {
-            const routingHost = getRoutingHost(payload, waypoints);
-            const router = new OSRMv1({
-                serviceUrl: `${routingHost}/route/v1`,
-                profile: 'driving',
-            });
+            const routingService = this.currentUser.getOption('routing', { router: 'osrm' }).router;
+            const { router, formatter } = this.leafletRouterControl.get(routingService);
 
             this.previewRouteControl = new RoutingControl({
+                router,
+                formatter,
                 waypoints: this.routePreviewCoordinates,
                 alternativeClassName: 'hidden',
                 addWaypoints: false,
@@ -892,7 +809,6 @@ export default class OperationsOrdersIndexNewController extends BaseController {
                         iconAnchor: [12, 41],
                     }),
                 },
-                router,
             }).addTo(leafletMap);
 
             this.previewRouteControl.on('routesfound', (event) => {
@@ -939,68 +855,54 @@ export default class OperationsOrdersIndexNewController extends BaseController {
         }
     }
 
-    @task *optimizeRoute() {
-        this.isOptimizingRoute = true;
-
-        // Build the coordinate list we’ll send to OSRM
-        const driverAssigned = this.order.driver_assigned;
-        const driverPosition = driverAssigned?.location?.coordinates; // [lon,lat] | undefined
-        const originalCoords = this.getCoordinatesFromPayload(); // [[lon,lat], …]
-        const coordinates = driverPosition ? [driverPosition, ...originalCoords] : [...originalCoords];
-        const hasDriverStart = Boolean(driverPosition);
-        const source = 'first';
-        const destination = 'any';
-        const roundtrip = false; // don’t loop back
-        const routingHost = getRoutingHost(this.payload, this.waypoints);
-
-        // Call the OSRM /trip service
+    @task *optimizeRouteWithService(service) {
         try {
-            const response = yield this.fetch.routing(coordinates, { source, destination, roundtrip, annotations: true }, { host: routingHost });
-
-            if (response?.code !== 'Ok') {
-                throw new Error(`OSRM error: ${response?.code}`);
-            }
-
-            // Pair each OSRM waypoint with its Waypoint model
-            const modelsByInputIndex = hasDriverStart ? [null, ...this.waypoints] : this.waypoints;
-
-            const pairs = response.waypoints.map((wp, idx) => ({
-                model: modelsByInputIndex[idx], // Ember model or null (driver)
-                wp,
-            }));
-
-            // Drop the driver start if present
-            const payloadPairs = hasDriverStart ? pairs.slice(1) : pairs;
-
-            // Sort by the optimised order
-            payloadPairs.sort((a, b) => a.wp.waypoint_index - b.wp.waypoint_index);
-
-            // Extract the Ember models (null-safe)
-            const sortedWaypoints = payloadPairs.map((p) => p.model).filter(Boolean);
+            const result = yield this.routeOptimization.optimize(service, {
+                context: 'create_order',
+                order: this.order,
+                payload: this.payload,
+                waypoints: this.waypoints,
+                coordinates: this.getCoordinatesFromPayload(),
+            });
+            this.handleRouteOptimization(result);
+        } catch (err) {
+            this.notifications.error(err.message ?? this.intl.t('fleet-ops.operations.orders.index.new.route-error'));
+        }
+    }
 
-            // Update map layers & UI
-            this.removeRoutingControlPreview();
-            this.removeOptimizedRoute(this.leafletMap);
-            this.clearLayers();
+    @task *optimizeRoute() {
+        try {
+            const result = yield this.osrm.optimize({
+                context: 'create_order',
+                order: this.order,
+                payload: this.payload,
+                waypoints: this.waypoints,
+                coordinates: this.getCoordinatesFromPayload(),
+            });
 
-            const trip = response.trips?.[0];
-            const route = polyline.decode(trip.geometry); // [[lat,lon], …]
+            this.handleRouteOptimization(result);
+        } catch (err) {
+            this.notifications.error(this.intl.t('fleet-ops.operations.orders.index.new.route-error'));
+        }
+    }
 
-            this.waypoints = sortedWaypoints;
-            this.setOptimizedRoute(route, trip, response.waypoints);
-            this.previewDraftOrderRoute(this.payload, this.waypoints, this.isMultipleDropoffOrder);
-            this.updatePayloadCoordinates();
+    handleRouteOptimization({ sortedWaypoints, route, trip, result }) {
+        // Update map layers & UI
+        this.removeRoutingControlPreview();
+        this.removeOptimizedRoute(this.leafletMap);
+        this.clearLayers();
 
-            this.order.set('is_route_optimized', true);
+        // Update controller state
+        this.waypoints = sortedWaypoints;
+        if (route) {
+            this.setOptimizedRoute(route, trip, result.waypoints);
+        }
+        this.previewDraftOrderRoute(this.payload, this.waypoints, this.isMultipleDropoffOrder);
+        this.updatePayloadCoordinates();
 
-            if (this.isUsingIntegratedVendor) {
-                this.getQuotes();
-            }
-        } catch (err) {
-            debug('Error optimizing route', err);
-            this.notifications.error(this.intl.t('fleet-ops.operations.orders.index.new.route-error'));
-        } finally {
-            this.isOptimizingRoute = false;
+        this.order.set('is_route_optimized', true);
+        if (this.isUsingIntegratedVendor) {
+            this.getQuotes();
         }
     }
 

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

@@ -6,8 +6,7 @@ import { action, computed } from '@ember/object';
 import { later } from '@ember/runloop';
 import { not, notEmpty, alias } from '@ember/object/computed';
 import { task } from 'ember-concurrency';
-import { OSRMv1, Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
-import getRoutingHost from '@fleetbase/ember-core/utils/get-routing-host';
+import { Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
 
 export default class OperationsOrdersIndexViewController extends BaseController {
     @controller('operations.orders.index') ordersController;
@@ -24,6 +23,7 @@ export default class OperationsOrdersIndexViewController extends BaseController
     @service socket;
     @service universe;
     @service contextPanel;
+    @service leafletRouterControl;
 
     @tracked isLoadingAdditionalData = false;
     @tracked isWaypointsCollapsed;
@@ -276,6 +276,7 @@ export default class OperationsOrdersIndexViewController extends BaseController
             }
 
             this.forceRemoveRoutePreview();
+            this.routeControl = null;
             resolve(true);
         });
     }
@@ -372,9 +373,8 @@ export default class OperationsOrdersIndexViewController extends BaseController
         const leafletMap = this.leafletMap;
         const payload = this.model.payload;
         const waypoints = this.getPayloadCoordinates(payload);
-        const routingHost = getRoutingHost(payload, this.getPayloadWaypointsAsArray());
 
-        if (!waypoints || waypoints.length < 2 || !leafletMap) {
+        if (!waypoints || waypoints.length < 2 || !leafletMap || this.routeControl) {
             return;
         }
 
@@ -382,12 +382,12 @@ export default class OperationsOrdersIndexViewController extends BaseController
         leafletMap.stop();
         leafletMap.flyTo(waypoints.firstObject);
 
-        const router = new OSRMv1({
-            serviceUrl: `${routingHost}/route/v1`,
-            profile: 'driving',
-        });
+        const routingService = this.currentUser.getOption('routing', { router: 'osrm' }).router;
+        const { router, formatter } = this.leafletRouterControl.get(routingService);
 
         this.routeControl = new RoutingControl({
+            router,
+            formatter,
             waypoints,
             markerOptions: {
                 icon: L.icon({
@@ -400,7 +400,6 @@ export default class OperationsOrdersIndexViewController extends BaseController
             },
             alternativeClassName: 'hidden',
             addWaypoints: false,
-            router,
         }).addTo(leafletMap);
 
         this.routeControl.on('routesfound', (event) => {

package/addon/controllers/settings/routing.js

@@ -0,0 +1,47 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { task } from 'ember-concurrency';
+
+export default class SettingsRoutingController extends Controller {
+    @service fetch;
+    @service notifications;
+    @service currentUser;
+    @service leafletRouterControl;
+    @tracked routerService = 'osrm';
+
+    constructor() {
+        super(...arguments);
+        this.getSettings.perform();
+    }
+
+    /**
+     * Save routing settings.
+     *
+     * @memberof SettingsRoutingController
+     */
+    @task *saveSettings() {
+        try {
+            yield this.fetch.post('fleet-ops/settings/routing-settings', { router: this.routerService });
+            // Save in local memory too
+            this.currentUser.setOption('routing', { router: this.routerService });
+            this.notifications.success('Routing setting saved.');
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    /**
+     * Get routing settings.
+     *
+     * @memberof SettingsRoutingController
+     */
+    @task *getSettings() {
+        try {
+            const { router } = yield this.fetch.get('fleet-ops/settings/routing-settings');
+            this.routerService = router;
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+}

package/addon/engine.js

@@ -9,6 +9,9 @@ import AdminAvatarManagementComponent from './components/admin/avatar-management
 import CustomerOrdersComponent from './components/customer/orders';
 import CustomerAdminSettingsComponent from './components/customer/admin-settings';
 import OrderTrackingLookupComponent from './components/order-tracking-lookup';
+import { RouterControl } from './services/leaflet-router-control';
+import { OSRMv1 } from '@fleetbase/leaflet-routing-machine';
+import getRoutingHost from '@fleetbase/ember-core/utils/get-routing-host';
 
 const { modulePrefix } = config;
 const externalRoutes = ['console', 'extensions'];
@@ -57,6 +60,29 @@ export default class FleetOpsEngine extends Engine {
             },
         });
 
+        // Register OSRM as route optimization service
+        const routeOptimization = app.lookup('service:route-optimization');
+        const osrm = app.lookup('service:osrm');
+        if (routeOptimization && osrm) {
+            routeOptimization.register('osrm', osrm);
+        }
+
+        // Register OSRM as Routing Controler
+        const leafletRouterControl = app.lookup('service:leaflet-router-control');
+        if (leafletRouterControl) {
+            const routingHost = getRoutingHost();
+            leafletRouterControl.register(
+                'osrm',
+                new RouterControl({
+                    name: 'OSRM',
+                    router: new OSRMv1({
+                        serviceUrl: `${routingHost}/route/v1`,
+                        profile: 'driving',
+                    }),
+                })
+            );
+        }
+
         // widgets for registry
         const KeyMetricsWidgetDefinition = {
             widgetId: 'fleet-ops-key-metrics-widget',
@@ -106,6 +132,7 @@ export default class FleetOpsEngine extends Engine {
             'fleet-ops:template:operations:orders:view',
             'fleet-ops:template:operations:orders:new',
             'fleet-ops:template:operations:orders:new:entities-input',
+            'fleet-ops:template:operations:orders:new:entities-input:entity',
         ]);
 
         universe.afterBoot(function (universe) {

package/addon/routes/application.js

@@ -10,6 +10,8 @@ export default class ApplicationRoute extends Route {
     @service abilities;
     @service hostRouter;
     @service notifications;
+    @service fetch;
+    @service currentUser;
 
     @action loading(transition) {
         const resourceName = getResourceNameFromTransition(transition, { humanize: true });
@@ -25,5 +27,11 @@ export default class ApplicationRoute extends Route {
         }
 
         this.location.getUserLocation();
+        this.#loadRoutingSettings();
+    }
+
+    async #loadRoutingSettings() {
+        const routingSetting = await this.fetch.get('fleet-ops/settings/routing-settings');
+        this.currentUser.setOption('routing', routingSetting);
     }
 }

package/addon/routes/operations/orders/index/view.js

@@ -12,10 +12,18 @@ export default class OperationsOrdersIndexViewRoute extends Route {
     @service abilities;
     @service intl;
 
-    @action willTransition() {
-        if (this.controller) {
+    @action willTransition(transition) {
+        // if we're coming _from_ this route and going _to_ a different one, then reset
+        let fromName = transition.from?.name;
+        let toName = transition.to.name;
+
+        // transition.from is null on initial page load, so guard that
+        if (fromName && fromName !== toName) {
             this.controller.resetView();
         }
+
+        // bubble the event on up so Ember can finish the transition
+        return true;
     }
 
     @action error(error) {
@@ -75,13 +83,14 @@ export default class OperationsOrdersIndexViewRoute extends Route {
                 // Only reload if the order has a status change stemming from an updated event OR
                 // if a waypoint has been completed which will trigger `order.completed`
                 const statusChanged = event === 'order.updated' && data.status !== model.status;
-                const shouldReload = ['order.completed', 'waypoint.activity', 'order.created'].includes(event);
+                const shouldReload = ['order.completed', 'waypoint.activity', 'entity.activity', 'order.created'].includes(event);
                 if (statusChanged || shouldReload) {
                     this.refresh();
 
                     // reload the controller stuff as well
                     if (this.controller) {
                         this.controller.loadOrderRelations.perform(model);
+                        this.controller.displayOrderRoute();
                     }
                 }
 

package/addon/routes/settings/routing.js

@@ -0,0 +1,3 @@
+import Route from '@ember/routing/route';
+
+export default class SettingsRoutingRoute extends Route {}

package/addon/routes.js

@@ -4,6 +4,7 @@ export default buildRoutes(function () {
     this.route('settings', function () {
         this.route('navigator-app');
         this.route('notifications');
+        this.route('routing');
         this.route('payments', function () {
             this.route('index', { path: '/' });
             this.route('onboard');