@fleetbase/fleetops-engine 0.6.45 → 0.6.47

package/addon/services/map-settings.js

@@ -0,0 +1,75 @@
+import Service from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+
+const DEFAULT_SETTINGS = {
+    mapProvider: 'leaflet',
+    googleMapsApiKey: '',
+    googleMapsMapId: '',
+};
+
+export default class MapSettingsService extends Service {
+    @service fetch;
+    @tracked settings = { ...DEFAULT_SETTINGS };
+    @tracked isLoaded = false;
+    @tracked loadPromise = null;
+
+    get mapProvider() {
+        return this.settings.mapProvider ?? 'leaflet';
+    }
+
+    get googleMapsApiKey() {
+        return this.settings.googleMapsApiKey ?? '';
+    }
+
+    get googleMapsMapId() {
+        return this.settings.googleMapsMapId ?? '';
+    }
+
+    get isGoogleMaps() {
+        return this.mapProvider === 'google';
+    }
+
+    async load({ force = false } = {}) {
+        if (!force && this.isLoaded) {
+            return this.settings;
+        }
+
+        if (!force && this.loadPromise) {
+            return this.loadPromise;
+        }
+
+        this.loadPromise = this.fetch
+            .get('fleet-ops/settings/map')
+            .then((settings) => this.applySettings(settings))
+            .catch(() => {
+                this.settings = { ...DEFAULT_SETTINGS };
+                this.isLoaded = true;
+                return this.settings;
+            })
+            .finally(() => {
+                this.loadPromise = null;
+            });
+
+        return this.loadPromise;
+    }
+
+    applySettings(settings = {}) {
+        this.settings = {
+            ...DEFAULT_SETTINGS,
+            ...settings,
+        };
+        this.isLoaded = true;
+        return this.settings;
+    }
+
+    setMapProvider(mapProvider = 'leaflet') {
+        this.settings = {
+            ...this.settings,
+            mapProvider,
+        };
+
+        this.isLoaded = true;
+        return this.settings;
+    }
+}

package/addon/services/movement-tracker.js

@@ -1,3 +1,17 @@
+/**
+ * MovementTrackerService
+ *
+ * Handles real-time marker movement via SocketCluster events.
+ * Refactored to use the provider-agnostic MapManagerService instead of
+ * accessing Leaflet marker objects directly.
+ *
+ * The EventBuffer is preserved, but marker manipulation now goes through
+ * `mapManager.updateMarkerPosition()` and `mapManager.setMarkerRotation()`
+ * so it works with any map provider.
+ *
+ * Backward-compatible: the `model.leafletLayer` path is still tried as
+ * a last resort so that existing code continues to work during migration.
+ */
 import Service from '@ember/service';
 import { tracked } from '@glimmer/tracking';
 import { inject as service } from '@ember/service';
@@ -14,10 +28,41 @@ export class EventBuffer {
     @tracked intervalId;
     @tracked model;
 
-    constructor(model, { callback = null, waitTime = 1000 * 3 }) {
+    /** @type {import('./map-manager').default|null} */
+    mapManager = null;
+
+    constructor(model, { callback = null, waitTime = 1000 * 3, mapManager = null }) {
         this.model = model;
         this.callback = callback;
         this.waitTime = waitTime;
+        this.mapManager = mapManager;
+    }
+
+    /**
+     * Resolve the marker id for the tracked model.
+     * @returns {string|null}
+     */
+    #getMarkerId() {
+        return this.model?.id ?? null;
+    }
+
+    /**
+     * Calculate distance in metres between two positions.
+     * Uses the adapter when available, falls back to Haversine.
+     *
+     * @param {{ lat: number, lng: number }} prev
+     * @param {number[]} nextLatLng - [lat, lng]
+     * @returns {number}
+     */
+    #calcDistance(prev, nextLatLng) {
+        if (this.mapManager) {
+            return this.mapManager.distanceBetween(prev.lat, prev.lng, nextLatLng[0], nextLatLng[1]);
+        }
+        const R = 6371000;
+        const dLat = ((nextLatLng[0] - prev.lat) * Math.PI) / 180;
+        const dLng = ((nextLatLng[1] - prev.lng) * Math.PI) / 180;
+        const a = Math.sin(dLat / 2) ** 2 + Math.cos((prev.lat * Math.PI) / 180) * Math.cos((nextLatLng[0] * Math.PI) / 180) * Math.sin(dLng / 2) ** 2;
+        return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
     }
 
     start() {
@@ -52,70 +97,74 @@ export class EventBuffer {
     @task *process() {
         debug('Processing movement tracker event buffer.');
 
-        // Take a snapshot of events to process and clear buffer immediately
-        // This prevents losing events that arrive during processing
         const eventsToProcess = [...this.events];
-        this.events = []; // Clear immediately to accept new events
+        this.events = [];
 
-        // Sort events by created_at
         eventsToProcess.sort((a, b) => new Date(a.created_at) - new Date(b.created_at));
         debug(`[MovementTracker EventBuffer processing ${eventsToProcess.length} events]`);
 
-        // Process sorted events
         for (const output of eventsToProcess) {
             const { event, data } = output;
 
-            // get movingObject marker
-            const marker = this.model.leafletLayer || this.model._layer || this.model._marker;
-            if (!marker || !marker._map) {
+            // Resolve marker via adapter (provider-agnostic) or Leaflet fallback
+            const markerId = this.#getMarkerId();
+            const hasAdapterMarker = markerId && this.mapManager?.hasMarker(markerId);
+            const leafletMarker = !hasAdapterMarker ? this.model?.leafletLayer || this.model?._layer || this.model?._marker : null;
+
+            if (!hasAdapterMarker && (!leafletMarker || !leafletMarker._map)) {
                 debug('No marker or marker not on map yet');
                 continue;
             }
 
-            // log incoming event
             debug(`${event} - ${data.id} ${data.additionalData?.index ? '#' + data.additionalData?.index : ''} (${output.created_at}) [ ${data.location.coordinates.join(' ')} ]`);
 
-            // GeoJSON -> Leaflet [lat, lng]
+            // GeoJSON -> [lat, lng]
             const [lng, lat] = data.location.coordinates;
             const nextLatLng = [lat, lng];
 
-            // Calc speed
-            const map = marker._map;
-            const prev = marker.getLatLng();
-            const meters = map ? map.distance(prev, nextLatLng) : prev.distanceTo(nextLatLng);
+            // Calculate distance for animation duration
+            let meters = 0;
+            if (hasAdapterMarker) {
+                const adapterCenter = this.mapManager.getCenter?.();
+                if (adapterCenter) meters = this.#calcDistance(adapterCenter, nextLatLng);
+            } else if (leafletMarker) {
+                const map = leafletMarker._map;
+                const prev = leafletMarker.getLatLng();
+                meters = map ? map.distance(prev, nextLatLng) : prev.distanceTo(nextLatLng);
+            }
 
-            // Assume payload speed is m/s; if it's km/h, convert: mps = kmh / 3.6
             let mps = Number.isFinite(data.speed) && data.speed > 0 ? data.speed : null;
-
-            // Reduce animation duration and clamp between 100ms and 500ms
-            // This makes animations faster and prevents long delays
             const durationMs = mps ? Math.max(100, Math.min((meters / mps) * 1000, 500)) : 500;
 
             try {
-                // Apply rotation if heading is valid
-                if (typeof marker.setRotationAngle === 'function' && Number.isFinite(data.heading) && data.heading !== -1) {
-                    marker.setRotationAngle(data.heading);
-                }
-
-                // Move marker with animation
-                if (typeof marker.slideTo === 'function') {
-                    marker.slideTo(nextLatLng, { duration: durationMs });
-                } else {
-                    marker.setLatLng(nextLatLng);
+                if (hasAdapterMarker) {
+                    // ── Provider-agnostic path ─────────────────────────────
+                    if (Number.isFinite(data.heading) && data.heading !== -1) {
+                        this.mapManager.setMarkerRotation(markerId, data.heading);
+                    }
+                    this.mapManager.updateMarkerPosition(markerId, lat, lng, true, durationMs);
+                } else if (leafletMarker) {
+                    // ── Leaflet backward-compat path ───────────────────────
+                    if (typeof leafletMarker.setRotationAngle === 'function' && Number.isFinite(data.heading) && data.heading !== -1) {
+                        leafletMarker.setRotationAngle(data.heading);
+                    }
+                    if (typeof leafletMarker.slideTo === 'function') {
+                        leafletMarker.slideTo(nextLatLng, { duration: durationMs });
+                    } else {
+                        leafletMarker.setLatLng(nextLatLng);
+                    }
                 }
 
                 if (typeof this.callback === 'function') {
                     this.callback(output, { nextLatLng, duration: durationMs, mps });
                 }
 
-                // Wait for animation to complete
                 yield timeout(durationMs + 50);
             } catch (err) {
                 debug('MovementTracker EventBuffer error: ' + err.message);
             }
         }
 
-        // Don't clear here - we already cleared at the start
         debug(`[MovementTracker EventBuffer finished processing ${eventsToProcess.length} events]`);
     }
 }
@@ -123,6 +172,8 @@ export class EventBuffer {
 export default class MovementTrackerService extends Service {
     @service socket;
     @service universe;
+    @service mapManager;
+
     @tracked channels = [];
     @tracked buffers = new Map();
 
@@ -138,7 +189,7 @@ export default class MovementTrackerService extends Service {
     #getBuffer(key, model, opts = {}) {
         let buf = this.buffers.get(key);
         if (!buf) {
-            buf = new EventBuffer(model, opts);
+            buf = new EventBuffer(model, { ...opts, mapManager: this.mapManager });
             buf.start();
             this.buffers.set(key, buf);
         }

package/addon/services/order-actions.js

@@ -13,11 +13,16 @@ export default class OrderActionsService extends ResourceActionService {
         this.initialize('order', {
             defaultAttributes: {
                 meta: {},
-                payload: this.store.createRecord('payload'),
             },
         });
     }
 
+    createNewInstance(attributes = {}) {
+        const payload = attributes.payload ?? this.store.createRecord('payload');
+
+        return super.createNewInstance({ ...attributes, payload });
+    }
+
     transition = {
         view: (order) => this.transitionTo('operations.orders.index.details', order),
         edit: (order) => this.transitionTo('operations.orders.index.edit', order),
@@ -116,6 +121,10 @@ export default class OrderActionsService extends ResourceActionService {
                 this.resourceContextPanel.close(saveOptions.overlay.id);
             }
 
+            if (saveOptions?.refresh === true) {
+                yield this.hostRouter.refresh();
+            }
+
             return updatedOrder;
         } catch (error) {
             this.notifications.serverError(error);
@@ -287,6 +296,7 @@ export default class OrderActionsService extends ResourceActionService {
             saveDisabled: false,
             saveOptions: {
                 closePanel: true,
+                refresh: true,
             },
         });
     }

package/addon/services/osrm.js

@@ -1,4 +1,5 @@
 import RouteOptimizationInterfaceService from './route-optimization-interface';
+import { isArray } from '@ember/array';
 import getRoutingHost from '@fleetbase/ember-core/utils/get-routing-host';
 import polyline from '@fleetbase/ember-core/utils/polyline';
 import { debug } from '@ember/debug';
@@ -6,21 +7,62 @@ import { debug } from '@ember/debug';
 export default class OsrmService extends RouteOptimizationInterfaceService {
     name = 'OSRM';
 
-    async optimize({ order, payload, waypoints, coordinates: originalCoords }, options = {}) {
+    async computeRoute(waypoints = [], options = {}) {
+        const normalizedWaypoints = (isArray(waypoints) ? waypoints : [])
+            .map(([lat, lng]) => [Number(lat), Number(lng)])
+            .filter(([lat, lng]) => Number.isFinite(lat) && Number.isFinite(lng));
+
+        if (normalizedWaypoints.length < 2) {
+            throw new Error('At least 2 waypoints are required to compute a route.');
+        }
+
+        const routingHost = getRoutingHost(options.payload, options.waypoints);
+        const coordStr = normalizedWaypoints.map(([lat, lng]) => `${lng},${lat}`).join(';');
+        const response = await fetch(`${routingHost}/route/v1/driving/${coordStr}?overview=full&geometries=polyline&steps=true`);
+
+        if (!response.ok) {
+            throw new Error(`OSRM route request failed with status ${response.status}`);
+        }
+
+        const result = await response.json();
+        const route = result?.routes?.[0];
+        if (!route?.geometry) {
+            throw new Error('OSRM route request returned no geometry.');
+        }
+
+        const coordinates = polyline.decode(route.geometry);
+        const bounds = this.#boundsFromCoordinates(coordinates);
+
+        return {
+            engine: 'osrm',
+            waypoints: normalizedWaypoints,
+            coordinates,
+            bounds,
+            summary: {
+                totalDistance: route.distance ?? 0,
+                totalTime: route.duration ?? 0,
+            },
+            legs: route.legs ?? [],
+            raw: result,
+        };
+    }
+
+    async optimize({ order, payload, waypoints, coordinates: originalCoords, preserveEndpoints = false }, 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 hasDriverStart = this.#isValidDriverPosition(driverPosition);
+        const coordinates = hasDriverStart ? [driverPosition, ...originalCoords] : [...originalCoords];
         const source = 'first';
-        const destination = 'any';
+        const destination = preserveEndpoints ? 'last' : '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 });
+            const result = await this.fetch.routing(coordinates, { source, destination, roundtrip }, { host: routingHost, ...options });
 
             // Pair each OSRM waypoint with its Waypoint model
-            const modelsByInputIndex = hasDriverStart ? [null, ...waypoints] : waypoints;
+            const endpointModels = preserveEndpoints ? [null, ...waypoints, null] : waypoints;
+            const modelsByInputIndex = hasDriverStart ? [null, ...endpointModels] : endpointModels;
             const pairs = result.waypoints.map((wp, idx) => ({
                 model: modelsByInputIndex[idx], // Ember model or null (driver)
                 wp,
@@ -43,4 +85,35 @@ export default class OsrmService extends RouteOptimizationInterfaceService {
             throw err;
         }
     }
+
+    #boundsFromCoordinates(coordinates = []) {
+        if (!coordinates.length) {
+            return [
+                [0, 0],
+                [0, 0],
+            ];
+        }
+
+        const lats = coordinates.map(([lat]) => lat);
+        const lngs = coordinates.map(([, lng]) => lng);
+
+        return [
+            [Math.min(...lats), Math.min(...lngs)],
+            [Math.max(...lats), Math.max(...lngs)],
+        ];
+    }
+
+    #isValidDriverPosition(driverPosition) {
+        if (!isArray(driverPosition) || driverPosition.length < 2) {
+            return false;
+        }
+
+        const [lng, lat] = driverPosition.map(Number);
+
+        if (!Number.isFinite(lat) || !Number.isFinite(lng)) {
+            return false;
+        }
+
+        return lat !== 0 && lng !== 0;
+    }
 }