@fleetbase/fleetops-engine 0.6.11 → 0.6.13

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;
@@ -243,39 +243,42 @@ export default class OperationsOrdersIndexViewController extends BaseController
         this.customFieldGroups = customFieldGroups;
     }
 
-    @action resetView() {
-        this.removeRoutingControlPreview();
+    @action async resetView() {
+        await this.removeRoutingControlPreview();
         this.resetInterface();
     }
 
     @action resetInterface() {
-        const liveMap = this.leafletMap ? this.leafletMap.liveMap : null;
-        if (liveMap) {
-            liveMap.reload();
-            liveMap.showAll();
+        if (this.leafletMap && this.leafletMap.liveMap) {
+            this.leafletMap.liveMap.showAll();
+            this.leafletMap.liveMap.reload();
         }
     }
 
     @action removeRoutingControlPreview() {
-        const { leafletMap, routeControl } = this;
+        return new Promise((resolve) => {
+            const { leafletMap, routeControl } = this;
 
-        if (routeControl instanceof RoutingControl) {
-            try {
-                routeControl.remove();
-            } catch (e) {
-                // silent
+            if (routeControl instanceof RoutingControl) {
+                try {
+                    routeControl.remove();
+                } catch (e) {
+                    // silent
+                }
             }
-        }
 
-        if (leafletMap instanceof L.Map) {
-            try {
-                leafletMap.removeControl(routeControl);
-            } catch (e) {
-                // silent
+            if (leafletMap instanceof L.Map) {
+                try {
+                    leafletMap.removeControl(routeControl);
+                } catch (e) {
+                    // silent
+                }
             }
-        }
 
-        this.forceRemoveRoutePreview();
+            this.forceRemoveRoutePreview();
+            this.routeControl = null;
+            resolve(true);
+        });
     }
 
     @action forceRemoveRoutePreview() {
@@ -370,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;
         }
 
@@ -380,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({
@@ -398,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');

package/addon/services/leaflet-router-control.js

@@ -0,0 +1,64 @@
+import Service, { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { underscore } from '@ember/string';
+
+export class RouterControlRegistry {
+    @tracked routers = {};
+}
+
+export class RouterControl {
+    @tracked name;
+    @tracked router;
+    @tracked formatter;
+
+    constructor(init) {
+        const { name, router, formatter } = typeof init === 'function' ? init() : init;
+        this.name = name;
+        this.router = router;
+        this.formatter = formatter;
+    }
+}
+
+export default class LeafletRouterControlService extends Service {
+    @service universe;
+    registry = this.#initializeRegistry();
+
+    get availableEngines() {
+        return Object.keys(this.registry.routers).map(underscore);
+    }
+
+    get availableServices() {
+        return Object.entries(this.registry.routers).map(([key, control]) => ({
+            key,
+            name: control.name ?? key,
+        }));
+    }
+
+    register(name, getter) {
+        this.registry.routers = {
+            ...this.registry.routers,
+            [underscore(name)]: getter,
+        };
+    }
+
+    /* eslint-disable no-unused-vars */
+    unregister(name) {
+        let key = underscore(name);
+        let { [key]: _, ...rest } = this.registry.routers;
+        this.registry.routers = rest;
+    }
+
+    get(name) {
+        return this.registry.routers[underscore(name)];
+    }
+
+    #initializeRegistry() {
+        const registry = 'registry:router-controls';
+        const application = this.universe.getApplicationInstance();
+        if (!application.hasRegistration(registry)) {
+            application.register(registry, new RouterControlRegistry(), { instantiate: false });
+        }
+
+        return application.resolveRegistration(registry);
+    }
+}

package/addon/services/osrm.js

@@ -0,0 +1,46 @@
+import RouteOptimizationInterfaceService from './route-optimization-interface';
+import getRoutingHost from '@fleetbase/ember-core/utils/get-routing-host';
+import polyline from '@fleetbase/ember-core/utils/polyline';
+import { debug } from '@ember/debug';
+
+export default class OsrmService extends RouteOptimizationInterfaceService {
+    name = 'OSRM';
+
+    async optimize({ order, payload, waypoints, coordinates: originalCoords }, options = {}) {
+        const driverAssigned = order.driver_assigned;
+        const driverPosition = driverAssigned?.location?.coordinates; // [lon,lat] | undefined
+        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(payload, waypoints);
+
+        try {
+            const result = await this.fetch.routing(coordinates, { source, destination, roundtrip, annotations: true }, { host: routingHost, ...options });
+
+            // Pair each OSRM waypoint with its Waypoint model
+            const modelsByInputIndex = hasDriverStart ? [null, ...waypoints] : waypoints;
+            const pairs = result.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 trip = result.trips?.[0];
+            const route = polyline.decode(trip.geometry);
+
+            return { sortedWaypoints, trip, route, result };
+        } catch (err) {
+            debug(`[OSRM] Error routing trip : ${err.message}`);
+            throw err;
+        }
+    }
+}

package/addon/services/route-optimization-interface.js

@@ -0,0 +1,9 @@
+import Service, { inject as service } from '@ember/service';
+
+export default class RouteOptimizationInterfaceService extends Service {
+    @service fetch;
+
+    optimize() {
+        throw new Error(`${this.constructor.name} must implement optimize(params, options)`);
+    }
+}

package/addon/services/route-optimization.js

@@ -0,0 +1,67 @@
+import Service, { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { underscore } from '@ember/string';
+
+export class RouteOptimizationRegistry {
+    @tracked engines = {};
+}
+
+export default class RouteOptimizationService extends Service {
+    @service universe;
+    registry = this.#initializeRegistry();
+
+    get availableEngines() {
+        return Object.keys(this.registry.engines).map(underscore);
+    }
+
+    get availableServices() {
+        return Object.entries(this.registry.engines).map(([key, engine]) => ({
+            key,
+            name: engine.name ?? key,
+        }));
+    }
+
+    register(name, engine) {
+        if (typeof engine.optimize !== 'function') {
+            throw new Error(`Cannot register "${name}": missing optimize()`);
+        }
+
+        this.registry.engines = {
+            ...this.registry.engines,
+            [underscore(name)]: engine,
+        };
+    }
+
+    /* eslint-disable no-unused-vars */
+    unregister(name) {
+        let key = underscore(name);
+        let { [key]: _, ...rest } = this.registry.engines;
+        this.registry.engines = rest;
+    }
+
+    optimize(name, params = {}, options = {}) {
+        let engine = this.registry.engines[underscore(name)];
+        if (!engine) {
+            return Promise.reject(new Error(`No route optimization engine registered as "${name}"`));
+        }
+        return engine.optimize(params, options);
+    }
+
+    handler(name, context, data) {
+        let engine = this.registry.engines[underscore(name)];
+        if (!engine) {
+            throw new Error(`No route optimization engine registered as "${name}"`);
+        }
+        return engine.handler(context, data);
+    }
+
+    #initializeRegistry() {
+        const registry = 'registry:route-optimization-engines';
+        const application = this.universe.getApplicationInstance();
+        if (!application.hasRegistration(registry)) {
+            application.register(registry, new RouteOptimizationRegistry(), { instantiate: false });
+        }
+
+        return application.resolveRegistration(registry);
+    }
+}

package/addon/templates/operations/orders/index/new.hbs

@@ -315,17 +315,21 @@
                 </div>
                 <div class="flex flex-1 justify-end space-x-2">
                     {{#if this.isMultipleDropoffOrder}}
-                        <Button
-                            @type="magic"
-                            @icon="magic"
-                            @text={{t "fleet-ops.operations.orders.index.new.optimize-route"}}
-                            @size="sm"
-                            @onClick={{perform this.optimizeRoute}}
-                            @permission="fleet-ops optimize order"
-                            @helpText={{t "fleet-ops.operations.orders.index.new.optimize-route-help-text"}}
-                            @disabled={{lt this.waypoints.length 3}}
-                            @isLoading={{this.isOptimizingRoute}}
-                        />
+                        {{#if this.hasRouteOptimizationEngines}}
+                            <RouteOptimizationEngineSelectButton @onClick={{perform this.optimizeRouteWithService}} @isLoading={{this.optimizeRouteWithService.isRunning}} />
+                        {{else}}
+                            <Button
+                                @type="magic"
+                                @icon="magic"
+                                @text={{t "fleet-ops.operations.orders.index.new.optimize-route"}}
+                                @size="sm"
+                                @onClick={{perform this.optimizeRoute}}
+                                @permission="fleet-ops optimize order"
+                                @helpText={{t "fleet-ops.operations.orders.index.new.optimize-route-help-text"}}
+                                @disabled={{lt this.waypoints.length 3}}
+                                @isLoading={{this.optimizeRoute.isRunning}}
+                            />
+                        {{/if}}
                         <Button
                             @icon="map-marked-alt"
                             @text={{t "fleet-ops.operations.orders.index.new.add-waypoint"}}
@@ -630,11 +634,9 @@
                             </div>
                         </DropdownButton>
                     {{/if}}
-                    {{#if this.renderableEntityInputComponents}}
-                        {{#each this.renderableEntityInputComponents as |renderableEntityInputComponent|}}
-                            {{component renderableEntityInputComponent order=this.order controller=this}}
-                        {{/each}}
-                    {{/if}}
+                    <RegistryYield @registry="fleet-ops:template:operations:orders:new:entities-input" as |RegistryComponent|>
+                        <RegistryComponent @order={{this.order}} @controller={{this}} />
+                    </RegistryYield>
                 </div>
             {{/if}}
             {{#if this.isCsvImportedOrder}}
@@ -709,6 +711,9 @@
                                     <div>
                                         <Input @value={{entity.sku}} @type="text" class="w-full form-input form-input-sm" placeholder={{t "fleet-ops.operations.orders.index.new.sku"}} />
                                     </div>
+                                    <RegistryYield @registry="fleet-ops:template:operations:orders:new:entities-input:entity" as |RegistryComponent|>
+                                        <RegistryComponent @entity={{entity}} @order={{this.order}} @controller={{this}} />
+                                    </RegistryYield>
                                     {{#if this.waypoints.length}}
                                         <Select
                                             @value={{entity.destination_uuid}}

package/addon/templates/settings/routing.hbs

@@ -0,0 +1,32 @@
+<Layout::Section::Header @title={{t "fleet-ops.settings.routing.fleet-ops-routing-settings"}}>
+    <Button
+        @type="primary"
+        @size="sm"
+        @icon="save"
+        @text={{t "common.save-button-text"}}
+        @onClick={{perform this.saveSettings}}
+        @disabled={{this.saveSettings.isRunning}}
+        @isLoading={{or this.saveSettings.isRunning this.getSettings.isRunning}}
+    />
+</Layout::Section::Header>
+
+<Layout::Section::Body class="overflow-y-scroll h-full">
+    <div class="container mx-auto h-screen">
+        <div class="max-w-3xl my-10 mx-auto space-y-6">
+            <ContentPanel @title={{t "fleet-ops.settings.routing.configure-routing"}} @open={{true}} @pad={{true}} @panelBodyClass="bg-white dark:bg-gray-800">
+                <InputGroup @name="Routing Service" @helpText="Select the service which is responsible for calculating and plotting routes on the map.">
+                    <Select
+                        @value={{this.routerService}}
+                        @options={{this.leafletRouterControl.availableServices}}
+                        @optionLabel="name"
+                        @optionValue="key"
+                        @onSelect={{fn (mut this.routerService)}}
+                        @placeholder="Select routing service..."
+                        class="w-full"
+                    />
+                </InputGroup>
+            </ContentPanel>
+        </div>
+    </div>
+    <Spacer @height="600px" />
+</Layout::Section::Body>

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

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/route-optimization-engine-select-button';

package/app/controllers/settings/routing.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/controllers/settings/routing';

package/app/routes/settings/routing.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/routes/settings/routing';

package/app/services/leaflet-router-control.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/services/leaflet-router-control';

package/app/services/osrm.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/services/osrm';

package/app/services/route-optimization-interface.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/services/route-optimization-interface';

package/app/services/route-optimization.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/services/route-optimization';

package/app/templates/settings/routing.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/templates/settings/routing';

package/composer.json

@@ -1,6 +1,6 @@
 {
     "name": "fleetbase/fleetops-api",
-    "version": "0.6.11",
+    "version": "0.6.13",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "keywords": [
         "fleetbase-extension",

package/extension.json

@@ -1,6 +1,6 @@
 {
     "name": "Fleet-Ops",
-    "version": "0.6.11",
+    "version": "0.6.13",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "repository": "https://github.com/fleetbase/fleetops",
     "license": "AGPL-3.0-or-later",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fleetbase/fleetops-engine",
-    "version": "0.6.11",
+    "version": "0.6.13",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "fleetbase": {
         "route": "fleet-ops"
@@ -45,7 +45,7 @@
         "@fleetbase/ember-core": "latest",
         "@fleetbase/ember-ui": "latest",
         "@fleetbase/fleetops-data": "latest",
-        "@fleetbase/leaflet-routing-machine": "^3.2.16",
+        "@fleetbase/leaflet-routing-machine": "^3.2.17",
         "@fortawesome/ember-fontawesome": "^2.0.0",
         "@fortawesome/fontawesome-svg-core": "6.4.0",
         "@fortawesome/free-brands-svg-icons": "6.4.0",