@fleetbase/fleetops-engine 0.6.46 → 0.6.48

package/addon/controllers/settings/routing.js

@@ -1,6 +1,7 @@
 import Controller from '@ember/controller';
 import { tracked } from '@glimmer/tracking';
 import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
 import { task } from 'ember-concurrency';
 
 export default class SettingsRoutingController extends Controller {
@@ -12,6 +13,19 @@ export default class SettingsRoutingController extends Controller {
     @tracked displayEngine = 'osrm';
     @tracked optimizationEngine = 'osrm';
     @tracked routingUnit = 'km';
+    @tracked trackingProvider = 'google_routes';
+    @tracked trackingFallbacks = ['osrm', 'calculated'];
+    @tracked trackingTrafficEnabled = true;
+    @tracked trackingCacheTtlSeconds = 60;
+    @tracked trackingRouteCacheTtlSeconds = 600;
+    @tracked trackingStaleLocationThresholdSeconds = 300;
+    @tracked trackingDefaultVehicleSpeedKph = 35;
+    @tracked showTrackingAdvancedSettings = false;
+    @tracked trackingProviderOptions = [
+        { value: 'google_routes', label: 'Google Routes' },
+        { value: 'osrm', label: 'OSRM' },
+        { value: 'calculated', label: 'Calculated' },
+    ];
     @tracked routingUnitOptions = [
         { label: 'Kilometers', value: 'km' },
         { label: 'Miles', value: 'mi' },
@@ -39,6 +53,8 @@ export default class SettingsRoutingController extends Controller {
                 optimization_engine: this.optimizationEngine,
                 unit: this.routingUnit,
             });
+            const trackingSettings = this.trackingSettingsPayload;
+            yield this.fetch.post('fleet-ops/settings/tracking-settings', trackingSettings);
             yield this.performAdditionalSaveTasks();
             // Save in local memory too
             this.currentUser.setOption('routing', {
@@ -47,7 +63,8 @@ export default class SettingsRoutingController extends Controller {
                 routing_optimization_engine: this.optimizationEngine,
                 unit: this.routingUnit,
             });
-            this.notifications.success('Routing setting saved.');
+            this.currentUser.setOption('tracking', trackingSettings);
+            this.notifications.success('Routing and tracking settings saved.');
         } catch (error) {
             this.notifications.serverError(error);
         }
@@ -64,11 +81,91 @@ export default class SettingsRoutingController extends Controller {
             this.displayEngine = display_engine ?? router ?? 'osrm';
             this.optimizationEngine = optimization_engine ?? display_engine ?? router ?? 'osrm';
             this.routingUnit = unit;
+            const trackingSettings = yield this.fetch.get('fleet-ops/settings/tracking-settings');
+            this.trackingProvider = trackingSettings.provider ?? 'google_routes';
+            this.trackingFallbacks = this.normalizeFallbacks(trackingSettings.fallbacks);
+            this.trackingTrafficEnabled = trackingSettings.traffic_enabled ?? true;
+            this.trackingCacheTtlSeconds = trackingSettings.cache_ttl_seconds ?? 60;
+            this.trackingRouteCacheTtlSeconds = trackingSettings.route_cache_ttl_seconds ?? 600;
+            this.trackingStaleLocationThresholdSeconds = trackingSettings.stale_location_threshold_seconds ?? 300;
+            this.trackingDefaultVehicleSpeedKph = trackingSettings.default_vehicle_speed_kph ?? 35;
+            this.trackingProviderOptions = this.normalizeProviderOptions(trackingSettings.providers ?? this.trackingProviderOptions);
         } catch (error) {
             this.notifications.serverError(error);
         }
     }
 
+    get selectedTrackingFallbackOptions() {
+        const selected = new Set(this.normalizeFallbacks(this.trackingFallbacks));
+
+        return this.trackingProviderOptions.filter((option) => selected.has(this.optionValue(option)));
+    }
+
+    get trackingSettingsPayload() {
+        return {
+            provider: this.trackingProvider,
+            fallbacks: this.normalizeFallbacks(this.trackingFallbacks),
+            traffic_enabled: this.trackingTrafficEnabled,
+            cache_ttl_seconds: Number(this.trackingCacheTtlSeconds) || 60,
+            route_cache_ttl_seconds: Number(this.trackingRouteCacheTtlSeconds) || 600,
+            stale_location_threshold_seconds: Number(this.trackingStaleLocationThresholdSeconds) || 300,
+            default_vehicle_speed_kph: Number(this.trackingDefaultVehicleSpeedKph) || 35,
+        };
+    }
+
+    normalizeFallbacks(fallbacks) {
+        if (Array.isArray(fallbacks)) {
+            return fallbacks
+                .map((fallback) => this.optionValue(fallback))
+                .map((fallback) => String(fallback).trim())
+                .filter(Boolean);
+        }
+
+        return String(fallbacks ?? '')
+            .split(',')
+            .map((fallback) => fallback.trim())
+            .filter(Boolean);
+    }
+
+    normalizeProviderOptions(options = []) {
+        return options.map((option) => {
+            const value = this.optionValue(option);
+            const label = option?.label ?? option?.name ?? this.providerLabel(value);
+
+            return {
+                ...option,
+                key: option?.key ?? value,
+                name: option?.name ?? label,
+                value,
+                label,
+            };
+        });
+    }
+
+    providerLabel(value) {
+        if (value === 'osrm') {
+            return 'OSRM';
+        }
+
+        return String(value ?? '')
+            .replace(/[_-]+/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim()
+            .replace(/\b\w/g, (character) => character.toUpperCase());
+    }
+
+    optionValue(option) {
+        return typeof option === 'object' && option !== null ? (option.value ?? option.key) : option;
+    }
+
+    @action setTrackingFallbacks(options) {
+        this.trackingFallbacks = this.normalizeFallbacks(options);
+    }
+
+    @action toggleTrackingAdvancedSettings() {
+        this.showTrackingAdvancedSettings = !this.showTrackingAdvancedSettings;
+    }
+
     registerSaveTask(key, task) {
         if (!key || typeof task?.perform !== 'function') {
             return;

package/addon/helpers/format-duration.js

@@ -0,0 +1,38 @@
+import { helper } from '@ember/component/helper';
+
+export function formatDurationValue(seconds) {
+    const value = Number(seconds);
+
+    if (!Number.isFinite(value)) {
+        return '0s';
+    }
+
+    const totalSeconds = Math.max(0, Math.ceil(value));
+    const days = Math.floor(totalSeconds / 86400);
+    const hours = Math.floor((totalSeconds % 86400) / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const remainingSeconds = totalSeconds % 60;
+    const parts = [];
+
+    if (days) {
+        parts.push(`${days}d`);
+    }
+
+    if (hours) {
+        parts.push(`${hours}h`);
+    }
+
+    if (!days && minutes) {
+        parts.push(`${minutes}m`);
+    }
+
+    if (!days && !hours && parts.length < 2 && remainingSeconds) {
+        parts.push(`${remainingSeconds}s`);
+    }
+
+    return parts.length ? parts.join(' ') : '0s';
+}
+
+export default helper(function formatDuration([seconds]) {
+    return formatDurationValue(seconds);
+});

package/addon/routes/application.js

@@ -29,6 +29,7 @@ export default class ApplicationRoute extends Route {
 
         await this.location.getUserLocation();
         await this.#loadRoutingSettings();
+        await this.#loadTrackingSettings();
         await this.#loadMapSettings();
     }
 
@@ -37,6 +38,11 @@ export default class ApplicationRoute extends Route {
         this.currentUser.setOption('routing', routingSetting);
     }
 
+    async #loadTrackingSettings() {
+        const trackingSettings = await this.fetch.get('fleet-ops/settings/tracking-settings');
+        this.currentUser.setOption('tracking', trackingSettings);
+    }
+
     async #loadMapSettings() {
         await this.mapSettings.load();
     }

package/addon/services/order-list-overlay.js

@@ -185,12 +185,12 @@ export default class OrderListOverlayService extends Service {
 
     #peekActiveOrders() {
         // Consider an order "active" if it has an assigned driver and is not terminal
-        const TERMINAL = ['created', 'completed', 'canceled', 'expired'];
+        const TERMINAL = ['created', 'completed', 'canceled', 'expired', 'order_canceled', 'pending'];
         return this.#peekOrders((order) => !!order.driver_assigned && !TERMINAL.includes(order.status));
     }
 
     #peekDriverActiveOrders(driver) {
-        const TERMINAL = ['created', 'completed', 'canceled', 'expired'];
+        const TERMINAL = ['created', 'completed', 'canceled', 'expired', 'order_canceled', 'pending'];
         return this.#peekOrders((order) => !!order.driver_assigned && order.driver_assigned?.id === driver.id && !TERMINAL.includes(order.status));
     }