@fleetbase/fleetops-engine 0.6.44 → 0.6.46

package/addon/services/position-playback.js

@@ -1,5 +1,15 @@
+/**
+ * PositionPlaybackService
+ *
+ * Refactored to use the provider-agnostic MapManagerService for all
+ * marker operations. The Leaflet-specific `marker._map`, `marker.slideTo`,
+ * `marker.setRotationAngle`, and `map.panTo` calls are replaced with
+ * adapter calls. Backward-compat: if `this.marker` is still a raw Leaflet
+ * marker (set via the old `leafletLayer` option), the Leaflet path is used.
+ */
 import Service from '@ember/service';
 import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
 import { task, timeout } from 'ember-concurrency';
 import { debug } from '@ember/debug';
 import { isArray } from '@ember/array';
@@ -21,14 +31,18 @@ import { isArray } from '@ember/array';
  * - Real-time replay: respects actual time intervals between positions
  */
 export default class PositionPlaybackService extends Service {
+    @service mapManager;
+
     @tracked isPlaying = false;
     @tracked isPaused = false;
     @tracked currentIndex = 0;
     @tracked positions = [];
     @tracked speed = 1;
     @tracked marker = null;
+    @tracked markerId = null;
     @tracked map = null;
     @tracked callback = null;
+    @tracked lastLatLng = null;
 
     /**
      * Initialize replay session with positions and marker
@@ -43,12 +57,19 @@ export default class PositionPlaybackService extends Service {
      */
     initialize(options = {}) {
         const { subject, leafletLayer, positions = [], speed = 1, callback = null, map = null } = options;
-
-        // Get marker from subject or manual layer
-        this.marker = leafletLayer || subject?.leafletLayer || subject?._layer || subject?._marker;
-
-        if (!this.marker) {
-            debug('[PositionPlayback] Warning: No leaflet marker found. Marker must be provided or subject must have leafletLayer property.');
+        const subjectId = subject?.id ?? null;
+        const existingLeafletMarker = leafletLayer || subject?.leafletLayer || subject?._layer || subject?._marker;
+
+        if (subjectId && this.mapManager?.hasMarker(subjectId)) {
+            this.markerId = subjectId;
+            this.marker = null;
+        } else if (existingLeafletMarker) {
+            this.markerId = null;
+            this.marker = existingLeafletMarker;
+        } else {
+            this.markerId = null;
+            this.marker = null;
+            debug('[PositionPlayback] Warning: No marker found. Provide a subject with a registered marker or leafletLayer property.');
         }
 
         this.positions = positions;
@@ -58,8 +79,9 @@ export default class PositionPlaybackService extends Service {
         this.currentIndex = 0;
         this.isPlaying = false;
         this.isPaused = false;
+        this.lastLatLng = this.#resolveCurrentLatLng();
 
-        debug(`[PositionPlayback] Initialized with ${positions.length} positions at ${speed}x speed`);
+        debug(`[PositionPlayback] Initialized with ${positions.length} positions at ${speed}x speed (markerId=${this.markerId ?? 'leaflet-compat'})`);
     }
 
     /**
@@ -173,35 +195,41 @@ export default class PositionPlaybackService extends Service {
         const position = this.positions[index];
         this.currentIndex = index;
 
-        if (!this.marker || !position) {
+        const useAdapter = this.markerId && this.mapManager?.hasMarker(this.markerId);
+
+        if (!useAdapter && !this.marker) {
             return;
         }
 
-        // Update marker position without animation
         const latLng = this.#getLatLngFromPosition(position);
         if (latLng) {
-            // Update rotation if heading is available
-            if (typeof this.marker.setRotationAngle === 'function' && Number.isFinite(position.heading) && position.heading !== -1) {
-                this.marker.setRotationAngle(position.heading);
-            }
-
-            if (typeof this.marker.slideTo === 'function') {
-                this.marker.slideTo(latLng, { duration: 100 });
+            if (useAdapter) {
+                // Provider-agnostic path
+                if (Number.isFinite(position.heading) && position.heading !== -1) {
+                    this.mapManager.setMarkerRotation(this.markerId, position.heading);
+                }
+                this.mapManager.updateMarkerPosition(this.markerId, latLng[0], latLng[1], true, 100);
+                this.mapManager.panTo(latLng[0], latLng[1]);
             } else {
-                this.marker.setLatLng(latLng);
-                requestAnimationFrame(() => {
-                    if (typeof this.marker.setRotationAngle === 'function' && Number.isFinite(position.heading) && position.heading !== -1) {
-                        this.marker.setRotationAngle(position.heading);
-                    }
-                });
-            }
-
-            // Pan map to position if map is provided
-            if (this.map) {
-                this.map.panTo(latLng, { animate: true });
+                // Leaflet backward-compat path
+                if (typeof this.marker.setRotationAngle === 'function' && Number.isFinite(position.heading) && position.heading !== -1) {
+                    this.marker.setRotationAngle(position.heading);
+                }
+                if (typeof this.marker.slideTo === 'function') {
+                    this.marker.slideTo(latLng, { duration: 100 });
+                } else {
+                    this.marker.setLatLng(latLng);
+                    requestAnimationFrame(() => {
+                        if (typeof this.marker.setRotationAngle === 'function' && Number.isFinite(position.heading) && position.heading !== -1) {
+                            this.marker.setRotationAngle(position.heading);
+                        }
+                    });
+                }
+                if (this.map) {
+                    this.map.panTo(latLng, { animate: true });
+                }
             }
 
-            // Trigger callback
             this.#triggerCallback(position, index, { animated: false });
         }
 
@@ -236,9 +264,11 @@ export default class PositionPlaybackService extends Service {
         this.stop();
         this.positions = [];
         this.marker = null;
+        this.markerId = null;
         this.map = null;
         this.callback = null;
         this.speed = 1;
+        this.lastLatLng = null;
 
         debug('[PositionPlayback] Reset complete');
     }
@@ -260,9 +290,11 @@ export default class PositionPlaybackService extends Service {
                 continue;
             }
 
-            // Get marker (it might have been updated)
-            const marker = this.marker;
-            if (!marker || !marker._map) {
+            // Resolve marker — prefer adapter, fall back to Leaflet
+            const useAdapter = this.markerId && this.mapManager?.hasMarker(this.markerId);
+            const marker = useAdapter ? null : this.marker;
+
+            if (!useAdapter && (!marker || !marker._map)) {
                 debug('[PositionPlayback] Marker not available or not on map');
                 this.currentIndex++;
                 continue;
@@ -276,26 +308,35 @@ export default class PositionPlaybackService extends Service {
                 continue;
             }
 
-            // Calculate animation duration based on distance and speed
-            const animationDuration = this.#calculateAnimationDuration(marker, latLng, position);
+            // Calculate animation duration
+            const animationDuration = useAdapter ? this.#calculateAnimationDurationFromAdapter(latLng, position) : this.#calculateAnimationDuration(marker, latLng, position);
 
             try {
-                // Apply rotation if heading is valid
-                if (typeof marker.setRotationAngle === 'function' && Number.isFinite(position.heading) && position.heading !== -1) {
-                    marker.setRotationAngle(position.heading);
-                }
-
-                // Move marker with animation
-                if (typeof marker.slideTo === 'function') {
-                    marker.slideTo(latLng, { duration: animationDuration });
+                if (useAdapter) {
+                    // ── Provider-agnostic path ─────────────────────────────
+                    if (Number.isFinite(position.heading) && position.heading !== -1) {
+                        this.mapManager.setMarkerRotation(this.markerId, position.heading);
+                    }
+                    this.mapManager.updateMarkerPosition(this.markerId, latLng[0], latLng[1], true, animationDuration);
+                    if (this.map || this.mapManager.isReady) {
+                        this.mapManager.panTo(latLng[0], latLng[1]);
+                    }
+                    this.lastLatLng = latLng;
                 } else {
-                    marker.setLatLng(latLng);
-                }
-
-                // Pan map to follow marker if map is provided
-                if (this.map) {
-                    const targetLatLng = marker._slideToLatLng ?? marker.getLatLng();
-                    this.map.panTo(targetLatLng, { animate: true });
+                    // ── Leaflet backward-compat path ───────────────────────
+                    if (typeof marker.setRotationAngle === 'function' && Number.isFinite(position.heading) && position.heading !== -1) {
+                        marker.setRotationAngle(position.heading);
+                    }
+                    if (typeof marker.slideTo === 'function') {
+                        marker.slideTo(latLng, { duration: animationDuration });
+                    } else {
+                        marker.setLatLng(latLng);
+                    }
+                    if (this.map) {
+                        const targetLatLng = marker._slideToLatLng ?? marker.getLatLng();
+                        this.map.panTo(targetLatLng, { animate: true });
+                    }
+                    this.lastLatLng = latLng;
                 }
 
                 // Trigger callback
@@ -444,23 +485,31 @@ export default class PositionPlaybackService extends Service {
         const prev = marker.getLatLng();
         const meters = map ? map.distance(prev, nextLatLng) : prev.distanceTo(nextLatLng);
 
-        // Get speed from position data (assume m/s)
         let mps = Number.isFinite(position.speed) && position.speed > 0 ? position.speed : null;
+        if (mps && position.speed_unit === 'kmh') mps = mps / 3.6;
 
-        // If speed is in km/h, convert to m/s
-        if (mps && position.speed_unit === 'kmh') {
-            mps = mps / 3.6;
-        }
-
-        // Calculate base duration for animation
-        let baseDuration = mps ? (meters / mps) * 1000 : 500;
-
-        // For animation, we want it relatively quick regardless of playback speed
-        // The playback speed affects the delay between positions, not the animation speed
-        // Clamp between 100ms and 1000ms for smooth animation
-        const duration = Math.max(100, Math.min(baseDuration, 1000));
+        const baseDuration = mps ? (meters / mps) * 1000 : 500;
+        return Math.max(100, Math.min(baseDuration, 1000));
+    }
 
-        return duration;
+    /**
+     * Calculate animation duration using the adapter (no direct Leaflet access).
+     *
+     * @private
+     * @param {Array} nextLatLng - [lat, lng]
+     * @param {Object} position
+     * @returns {number}
+     */
+    #calculateAnimationDurationFromAdapter(nextLatLng, position) {
+        const currentLatLng = this.lastLatLng ?? this.#resolveCurrentLatLng();
+        let meters = 0;
+        if (currentLatLng) {
+            meters = this.mapManager.distanceBetween(currentLatLng[0], currentLatLng[1], nextLatLng[0], nextLatLng[1]);
+        }
+        let mps = Number.isFinite(position.speed) && position.speed > 0 ? position.speed : null;
+        if (mps && position.speed_unit === 'kmh') mps = mps / 3.6;
+        const baseDuration = mps ? (meters / mps) * 1000 : 500;
+        return Math.max(100, Math.min(baseDuration, 1000));
     }
 
     /**
@@ -483,4 +532,28 @@ export default class PositionPlaybackService extends Service {
             });
         }
     }
+
+    #resolveCurrentLatLng() {
+        if (this.markerId && this.mapManager?.hasMarker?.(this.markerId)) {
+            const marker = this.mapManager.getMarker(this.markerId);
+            const position = marker?.position ?? marker?.getPosition?.();
+
+            if (position) {
+                const lat = typeof position.lat === 'function' ? position.lat() : position.lat;
+                const lng = typeof position.lng === 'function' ? position.lng() : position.lng;
+                if (Number.isFinite(lat) && Number.isFinite(lng)) {
+                    return [lat, lng];
+                }
+            }
+        }
+
+        if (this.marker?.getLatLng) {
+            const latlng = this.marker.getLatLng();
+            if (Number.isFinite(latlng?.lat) && Number.isFinite(latlng?.lng)) {
+                return [latlng.lat, latlng.lng];
+            }
+        }
+
+        return null;
+    }
 }

package/addon/services/route-engine.js

@@ -0,0 +1,83 @@
+import Service, { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { underscore } from '@ember/string';
+
+export class RouteEngineRegistry {
+    @tracked engines = {};
+}
+
+export default class RouteEngineService extends Service {
+    @service universe;
+    @service currentUser;
+    registry = this.#initializeRegistry();
+
+    get availableServices() {
+        return Object.entries(this.registry.engines)
+            .filter(([, registration]) => registration?.capabilities?.display === true)
+            .map(([key, registration]) => ({
+                key,
+                name: registration?.engine?.name ?? key,
+            }));
+    }
+
+    register(name, engine, capabilities = {}) {
+        const key = underscore(name);
+        const normalizedCapabilities = {
+            display: capabilities.display === true || typeof engine?.computeRoute === 'function',
+        };
+
+        if (!normalizedCapabilities.display) {
+            throw new Error(`Cannot register "${name}" as a route engine without computeRoute() support`);
+        }
+
+        this.registry.engines = {
+            ...this.registry.engines,
+            [key]: {
+                engine,
+                capabilities: normalizedCapabilities,
+            },
+        };
+    }
+
+    unregister(name) {
+        const key = underscore(name);
+        const rest = { ...this.registry.engines };
+        delete rest[key];
+        this.registry.engines = rest;
+    }
+
+    get(name) {
+        const key = underscore(name ?? this.getDisplayEngine());
+        const registration = this.registry.engines[key] ?? this.registry.engines.osrm;
+        return registration?.engine ?? null;
+    }
+
+    getDisplayEngine(fallback = 'osrm') {
+        const routingSettings = this.currentUser.getOption('routing', {});
+        return routingSettings.routing_display_engine ?? routingSettings.router ?? fallback;
+    }
+
+    getOptimizationEngine(fallback = null) {
+        const routingSettings = this.currentUser.getOption('routing', {});
+        return routingSettings.routing_optimization_engine ?? routingSettings.router ?? this.getDisplayEngine(fallback ?? 'osrm');
+    }
+
+    async compute(name, waypoints, options = {}) {
+        const engine = this.get(name);
+        if (!engine || typeof engine.computeRoute !== 'function') {
+            throw new Error(`No route engine registered as "${name}"`);
+        }
+
+        return engine.computeRoute(waypoints, options);
+    }
+
+    #initializeRegistry() {
+        const registry = 'registry:route-engines';
+        const application = this.universe.getApplicationInstance();
+        if (!application.hasRegistration(registry)) {
+            application.register(registry, new RouteEngineRegistry(), { instantiate: false });
+        }
+
+        return application.resolveRegistration(registry);
+    }
+}

package/addon/services/service-areas.js

@@ -312,6 +312,7 @@ export default class ServiceAreasService extends Service {
 
         this.modalsManager.show('modals/map-layer-form', {
             title: 'Create new Layer',
+            modalClass: 'flb-resource-modal',
             acceptButtonText: 'Create',
             acceptButtonIcon: 'magic',
             declineButtonIcon: 'times',
@@ -319,7 +320,13 @@ export default class ServiceAreasService extends Service {
             layerTypes: ['Service Area', 'Zone'],
             selectedLayerType: 'Service Area',
             serviceAreaTypes: this.serviceAreaTypes,
-            layerOptions: {},
+            layerOptions: {
+                trigger_on_entry: false,
+                trigger_on_exit: false,
+                dwell_threshold_minutes: null,
+                speed_limit_kmh: null,
+                description: null,
+            },
             confirm: (modal) => {
                 modal.startLoading();
 

package/addon/services/service-rate-actions.js

@@ -6,13 +6,17 @@ import serializePayload from '../utils/serialize-payload';
 export default class ServiceRateActionsService extends ResourceActionService {
     modelNamePath = 'service_name';
 
+    get defaultCurrency() {
+        return this.currentUser?.company?.currency || this.currentUser.currency || 'USD';
+    }
+
     constructor() {
         super(...arguments);
         this.initialize('service-rate', {
             defaultAttributes: {
                 rate_calculation_method: 'per_meter',
                 per_meter_unit: 'm',
-                currency: this.currentUser.currency,
+                currency: this.defaultCurrency,
                 parcel_fees: this.#getDefaultParcelFees(),
             },
         });
@@ -118,12 +122,13 @@ export default class ServiceRateActionsService extends ResourceActionService {
 
         const hasFacilitator = !isNone(order.facilitator);
         const facilitatorServiceType = order.facilitator?.get('service_types.firstObject.key') ?? order.type;
+        const routeSummary = order.route?.summary ?? order.route?.details?.summary ?? {};
 
         try {
             const serviceQuotes = yield this.fetch.post('service-quotes/preliminary', {
                 payload: serializePayload(order.payload),
-                distance: order.route.summary?.totalDistance,
-                time: order.route.summary?.totalTime,
+                distance: routeSummary.totalDistance,
+                time: routeSummary.totalTime,
                 service_type: hasFacilitator ? facilitatorServiceType : order.type,
                 facilitator: order.facilitator?.public_id,
                 scheduled_at: order.scheduled_at,