@fleetbase/fleetops-engine 0.6.22 → 0.6.24

package/addon/components/map/drawer/position-listing.hbs

@@ -27,7 +27,7 @@
             </div>
         </div>
 
-        <div class="w-48 {{if this.isReplaying 'hidden' ''}}">
+        <div class="w-48 {{if (or this.isReplaying this.isPaused) 'hidden' ''}}">
             <DatePicker
                 @value={{this.dateFilter}}
                 @range={{true}}

package/addon/components/map/leaflet-live-map.js

@@ -34,7 +34,7 @@ export default class MapLeafletLiveMapComponent extends Component {
 
     /** tracked properties */
     @tracked ready = false;
-    @tracked zoom = this.args.zoom ?? 14;
+    @tracked zoom = this.getValidZoom();
     @tracked latitude = this.location.getLatitude();
     @tracked longitude = this.location.getLongitude();
     @tracked contextmenuItems = [];
@@ -45,6 +45,29 @@ export default class MapLeafletLiveMapComponent extends Component {
     @tracked vehicles = [];
     @tracked places = [];
 
+    constructor() {
+        super(...arguments);
+
+        // Store bound function reference for proper cleanup
+        this._locationUpdateHandler = this.#handleLocationUpdate.bind(this);
+
+        // Listen for location updates from the location service
+        this.universe.on('user.located', this._locationUpdateHandler);
+
+        // Ensure we have valid coordinates on initialization
+        this.#updateCoordinatesFromLocation();
+    }
+
+    willDestroy() {
+        super.willDestroy();
+
+        // Clean up event listener using stored reference
+        if (this._locationUpdateHandler) {
+            this.universe.off('user.located', this._locationUpdateHandler);
+            this._locationUpdateHandler = null;
+        }
+    }
+
     @action didLoad({ target: map }) {
         this.#setMap(map);
         this.#createMapContextMenu(map);
@@ -189,6 +212,46 @@ export default class MapLeafletLiveMapComponent extends Component {
         return this.ready === true;
     }
 
+    /**
+     * Get valid zoom level for map initialization
+     * @returns {number} Valid zoom level between 1-20
+     */
+    getValidZoom() {
+        const zoom = this.args.zoom;
+        // Validate zoom is a valid number within Leaflet bounds (1-20)
+        if (typeof zoom === 'number' && !isNaN(zoom) && zoom >= 1 && zoom <= 20) {
+            return zoom;
+        }
+        // Return default zoom of 14 if invalid
+        return 14;
+    }
+
+    /**
+     * Handles location updates from the location service
+     * @param {Object} coordinates - The new coordinates
+     */
+    #handleLocationUpdate(coordinates) {
+        if (coordinates && typeof coordinates.latitude === 'number' && typeof coordinates.longitude === 'number') {
+            this.latitude = coordinates.latitude;
+            this.longitude = coordinates.longitude;
+
+            // Update map position if map is loaded
+            if (this.map && this.map.setView) {
+                this.map.setView([coordinates.latitude, coordinates.longitude], this.zoom);
+            }
+        }
+    }
+
+    /**
+     * Updates coordinates from location service on initialization
+     */
+    #updateCoordinatesFromLocation() {
+        // Initial coordinates are already set via tracked properties
+        // This method ensures we have the latest location service values
+        this.latitude = this.location.getLatitude();
+        this.longitude = this.location.getLongitude();
+    }
+
     #setMap(map) {
         set(map, 'livemap', this);
         this.map = map;
@@ -417,6 +480,38 @@ export default class MapLeafletLiveMapComponent extends Component {
         return contextmenuRegistry;
     }
 
+    /**
+     * Safely gets a valid latitude value with fallback to default
+     * @returns {number} Valid latitude value
+     */
+    #getValidLatitude() {
+        const lat = this.location.getLatitude();
+
+        // Validate latitude is a number and within valid range (-90 to 90)
+        if (typeof lat === 'number' && !isNaN(lat) && lat >= -90 && lat <= 90) {
+            return lat;
+        }
+
+        // Fallback to default Singapore latitude
+        return 1.369;
+    }
+
+    /**
+     * Safely gets a valid longitude value with fallback to default
+     * @returns {number} Valid longitude value
+     */
+    #getValidLongitude() {
+        const lng = this.location.getLongitude();
+
+        // Validate longitude is a number and within valid range (-180 to 180)
+        if (typeof lng === 'number' && !isNaN(lng) && lng >= -180 && lng <= 180) {
+            return lng;
+        }
+
+        // Fallback to default Singapore longitude
+        return 103.8864;
+    }
+
     #changeTileSource(source) {
         switch (source) {
             case 'dark':

package/addon/controllers/connectivity/events/index.js

@@ -39,7 +39,6 @@ export default class ConnectivityEventsIndexController extends Controller {
             resizable: true,
             sortable: true,
             filterable: true,
-            filterParam: 'name',
             filterComponent: 'filter/string',
         },
         {

package/addon/controllers/management/contacts.js

@@ -1,21 +1,23 @@
 import Controller from '@ember/controller';
-import { tracked } from '@glimmer/tracking';
 import { inject as service } from '@ember/service';
 import { getOwner } from '@ember/application';
 import getCurrentNestedController from '@fleetbase/ember-core/utils/get-current-nested-controller';
 
 export default class ManagementContactsController extends Controller {
     @service hostRouter;
-    @tracked tabs = [
-        {
-            route: 'management.contacts.index',
-            label: 'Contacts',
-        },
-        {
-            route: 'management.contacts.customers',
-            label: 'Customers',
-        },
-    ];
+
+    get tabs() {
+        return [
+            {
+                route: 'management.contacts.index',
+                label: 'Contacts',
+            },
+            {
+                route: 'management.contacts.customers',
+                label: 'Customers',
+            },
+        ];
+    }
 
     get childController() {
         return getCurrentNestedController(getOwner(this), this.hostRouter.currentRouteName);

package/addon/services/location.js

@@ -69,7 +69,11 @@ export default class LocationService extends Service {
      * @returns {number} The current latitude.
      */
     getLatitude() {
-        return this.latitude;
+        // Ensure we always return a valid number within geographic bounds
+        if (typeof this.latitude === 'number' && !isNaN(this.latitude) && this.latitude >= -90 && this.latitude <= 90) {
+            return this.latitude;
+        }
+        return this.constructor.DEFAULT_LATITUDE;
     }
 
     /**
@@ -77,7 +81,11 @@ export default class LocationService extends Service {
      * @returns {number} The current longitude.
      */
     getLongitude() {
-        return this.longitude;
+        // Ensure we always return a valid number within geographic bounds
+        if (typeof this.longitude === 'number' && !isNaN(this.longitude) && this.longitude >= -180 && this.longitude <= 180) {
+            return this.longitude;
+        }
+        return this.constructor.DEFAULT_LONGITUDE;
     }
 
     /**

package/addon/templates/management/contacts.hbs

@@ -9,6 +9,7 @@
                 @onSearch={{perform this.childController.search}}
                 @table={{this.childController.table}}
                 @bulkActionIconOnly={{true}}
+                @controller={{this.childController}}
             />
         </div>
     </:actions>

package/composer.json

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

package/extension.json

@@ -1,6 +1,6 @@
 {
     "name": "Fleet-Ops",
-    "version": "0.6.22",
+    "version": "0.6.24",
     "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.22",
+    "version": "0.6.24",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "fleetbase": {
         "route": "fleet-ops"
@@ -43,7 +43,7 @@
     "dependencies": {
         "@babel/core": "^7.23.2",
         "@fleetbase/ember-core": "^0.3.6",
-        "@fleetbase/ember-ui": "^0.3.8",
+        "@fleetbase/ember-ui": "^0.3.9",
         "@fleetbase/fleetops-data": "^0.1.21",
         "@fleetbase/leaflet-routing-machine": "^3.2.17",
         "@fortawesome/ember-fontawesome": "^2.0.0",

package/server/migrations/2025_11_01_103634_add_performance_indexes_to_fleetops_tables.php

@@ -0,0 +1,245 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        // ============================================================
+        // ORDERS TABLE INDEXES
+        // ============================================================
+        Schema::table('orders', function (Blueprint $table) {
+            /**
+             * Index 1: company_uuid + status.
+             *
+             * WHY: The most common query is "get all orders for company X with status Y"
+             * USED BY: OrderFilter status filtering, dashboard queries
+             * QUERY: WHERE company_uuid = ? AND status IN (?, ?, ?)
+             *
+             * This index allows MySQL to:
+             * 1. Jump to all rows for the company (first column)
+             * 2. Filter by status within that company (second column)
+             *
+             * Without this, MySQL would use company_uuid index, then scan all
+             * matching rows to filter by status (slow for large datasets).
+             */
+            if (!$this->indexExists('orders', 'idx_orders_company_status')) {
+                $table->index(['company_uuid', 'status'], 'idx_orders_company_status');
+            }
+
+            /**
+             * Index 2: company_uuid + driver_assigned_uuid.
+             *
+             * WHY: Finding unassigned orders is a critical operation
+             * USED BY: OrderFilter unassigned() method, driver assignment UI
+             * QUERY: WHERE company_uuid = ? AND driver_assigned_uuid IS NULL
+             *
+             * This index is particularly efficient for IS NULL checks because
+             * MySQL stores NULL values in indexes (unlike some databases).
+             */
+            if (!$this->indexExists('orders', 'idx_orders_company_driver')) {
+                $table->index(['company_uuid', 'driver_assigned_uuid'], 'idx_orders_company_driver');
+            }
+
+            /**
+             * Index 3: company_uuid + created_at.
+             *
+             * WHY: Date-based filtering and sorting is extremely common
+             * USED BY: Date range filters, "recent orders" queries
+             * QUERY: WHERE company_uuid = ? AND created_at >= ? AND created_at <= ?
+             * ORDER BY: created_at DESC
+             *
+             * This index supports both filtering AND sorting efficiently.
+             * The ORDER BY can use the index for sorting without a filesort operation.
+             */
+            if (!$this->indexExists('orders', 'idx_orders_company_created')) {
+                $table->index(['company_uuid', 'created_at'], 'idx_orders_company_created');
+            }
+
+            /**
+             * Index 4: company_uuid + scheduled_at.
+             *
+             * WHY: Scheduled orders need to be queried efficiently
+             * USED BY: Scheduler, upcoming deliveries view
+             * QUERY: WHERE company_uuid = ? AND scheduled_at >= ? AND scheduled_at <= ?
+             */
+            if (!$this->indexExists('orders', 'idx_orders_company_scheduled')) {
+                $table->index(['company_uuid', 'scheduled_at'], 'idx_orders_company_scheduled');
+            }
+
+            /**
+             * Index 5: company_uuid + dispatched + status.
+             *
+             * WHY: Finding dispatched orders with specific statuses
+             * USED BY: Active orders view, driver assignment
+             * QUERY: WHERE company_uuid = ? AND dispatched = 1 AND status IN (?, ?)
+             *
+             * This is a 3-column composite index. MySQL will use it for:
+             * - company_uuid alone
+             * - company_uuid + dispatched
+             * - company_uuid + dispatched + status (full index)
+             *
+             * But NOT for dispatched alone or status alone.
+             */
+            if (!$this->indexExists('orders', 'idx_orders_company_dispatched_status')) {
+                $table->index(['company_uuid', 'dispatched', 'status'], 'idx_orders_company_dispatched_status');
+            }
+
+            /**
+             * Index 6: company_uuid + tracking_number_uuid.
+             *
+             * WHY: Common join key and filtering key for tracking data.
+             * USED BY: OrderFilter, tracking joins
+             * QUERY: WHERE company_uuid = ? AND tracking_number_uuid = ?
+             */
+            if (!$this->indexExists('orders', 'idx_orders_company_tracking')) {
+                $table->index(['company_uuid', 'tracking_number_uuid'], 'idx_orders_company_tracking');
+            }
+        });
+
+        // ============================================================
+        // PAYLOADS TABLE INDEXES
+        // ============================================================
+        Schema::table('payloads', function (Blueprint $table) {
+            /**
+             * Index 6-8: Foreign key indexes.
+             *
+             * WHY: JOINs require indexes on both sides of the join condition
+             * USED BY: All queries that JOIN orders to payloads to places
+             *
+             * When we JOIN payloads to places:
+             * JOIN places ON places.uuid = payloads.pickup_uuid
+             *
+             * MySQL needs an index on payloads.pickup_uuid to efficiently
+             * find matching rows. Without it, MySQL does a full table scan
+             * of the payloads table for each place.
+             */
+            if (!$this->indexExists('payloads', 'pickup_uuid')) {
+                $table->index('pickup_uuid', 'idx_payloads_pickup');
+            }
+            if (!$this->indexExists('payloads', 'dropoff_uuid')) {
+                $table->index('dropoff_uuid', 'idx_payloads_dropoff');
+            }
+            if (!$this->indexExists('payloads', 'return_uuid')) {
+                $table->index('return_uuid', 'idx_payloads_return');
+            }
+        });
+
+        // ============================================================
+        // WAYPOINTS TABLE INDEXES
+        // ============================================================
+        Schema::table('waypoints', function (Blueprint $table) {
+            /**
+             * Index 9: payload_uuid.
+             *
+             * WHY: Loading waypoints for a payload is a 1-to-many relationship
+             * USED BY: Eager loading payload.waypoints
+             * QUERY: WHERE payload_uuid = ?
+             *
+             * Without this index, loading waypoints for 378 payloads would
+             * require 378 table scans of the waypoints table.
+             */
+            if (!$this->indexExists('waypoints', 'payload_uuid')) {
+                $table->index('payload_uuid', 'idx_waypoints_payload');
+            }
+
+            /**
+             * Index 10: Composite index for deleted waypoints.
+             *
+             * WHY: We frequently query non-deleted waypoints for a payload
+             * QUERY: WHERE payload_uuid = ? AND deleted_at IS NULL
+             *
+             * This composite index is more efficient than two separate indexes
+             * because it allows MySQL to filter on both conditions using one index.
+             */
+            if (!$this->indexExists('waypoints', 'idx_waypoints_payload_deleted')) {
+                $table->index(['payload_uuid', 'deleted_at'], 'idx_waypoints_payload_deleted');
+            }
+        });
+
+        // ============================================================
+        // TRACKING_STATUSES TABLE INDEXES
+        // ============================================================
+        Schema::table('tracking_statuses', function (Blueprint $table) {
+            /**
+             * Index 11: tracking_number_uuid.
+             *
+             * WHY: Loading tracking statuses for an order
+             * USED BY: Eager loading order.trackingStatuses
+             * QUERY: WHERE tracking_number_uuid = ?
+             */
+            if (!$this->indexExists('tracking_statuses', 'tracking_number_uuid')) {
+                $table->index('tracking_number_uuid', 'idx_tracking_statuses_tracking_number');
+            }
+        });
+
+        // ============================================================
+        // ENTITIES TABLE INDEXES
+        // ============================================================
+
+        Schema::table('entities', function (Blueprint $table) {
+            /**
+             * Index 12: payload_uuid.
+             *
+             * WHY: Loading entities for a payload
+             * USED BY: Eager loading payload.entities
+             * QUERY: WHERE payload_uuid = ?
+             */
+            if (!$this->indexExists('entities', 'payload_uuid')) {
+                $table->index('payload_uuid', 'idx_entities_payload');
+            }
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('orders', function (Blueprint $table) {
+            $table->dropIndex('idx_orders_company_status');
+            $table->dropIndex('idx_orders_company_driver');
+            $table->dropIndex('idx_orders_company_created');
+            $table->dropIndex('idx_orders_company_scheduled');
+            $table->dropIndex('idx_orders_company_dispatched_status');
+            $table->dropIndex('idx_orders_company_tracking');
+        });
+
+        Schema::table('payloads', function (Blueprint $table) {
+            $table->dropIndex('idx_payloads_pickup');
+            $table->dropIndex('idx_payloads_dropoff');
+            $table->dropIndex('idx_payloads_return');
+        });
+
+        Schema::table('waypoints', function (Blueprint $table) {
+            $table->dropIndex('idx_waypoints_payload');
+            $table->dropIndex('idx_waypoints_payload_deleted');
+        });
+
+        Schema::table('tracking_statuses', function (Blueprint $table) {
+            $table->dropIndex('idx_tracking_statuses_tracking_number');
+        });
+
+        Schema::table('entities', function (Blueprint $table) {
+            $table->dropIndex('idx_entities_payload');
+        });
+    }
+
+    /**
+     * Check if an index exists on a table.
+     *
+     * This helper method prevents errors when running migrations multiple times
+     * or when indexes already exist from previous manual additions.
+     */
+    private function indexExists(string $table, string $indexName): bool
+    {
+        $indexes = DB::select("SHOW INDEX FROM {$table} WHERE Key_name = ?", [$indexName]);
+
+        return count($indexes) > 0;
+    }
+};

package/server/src/Console/Commands/DispatchAdhocOrders.php

@@ -18,37 +18,42 @@ class DispatchAdhocOrders extends Command
      *
      * @var string
      */
-    protected $signature = 'fleetops:dispatch-adhoc {--sandbox} {--testing}';
+    protected $signature = 'fleetops:dispatch-adhoc 
+        {--sandbox : Run in sandbox mode} 
+        {--testing : Enable testing mode (no geospatial filters)} 
+        {--days=2 : Only include orders dispatched in the past N days (default: 2)}';
 
     /**
      * The console command description.
      *
      * @var string
      */
-    protected $description = 'Dispatch & ping adhoc orders where no driver is assigned, only if order isn\'t assigned after 2 minutes';
+    protected $description = 'Dispatch & ping ad-hoc orders without assigned drivers (within a recent time window)';
 
     /**
      * Execute the console command.
-     *
-     * Processes and dispatches ad-hoc orders based on their scheduled dispatch time and driver availability.
-     * Orders without an assigned driver and that have surpassed the dispatch time threshold are considered for dispatch.
-     * The command supports sandbox and testing modes for different operational environments.
      */
     public function handle(): void
     {
         date_default_timezone_set('UTC');
 
         $sandboxMode = Utils::castBoolean($this->option('sandbox'));
+        $testingMode = Utils::castBoolean($this->option('testing'));
+        $days        = max(1, (int) $this->option('days'));
+
         $this->info('Running in ' . ($sandboxMode ? 'sandbox' : 'production') . ' mode.');
+        $this->info("Looking back {$days} day(s) for dispatchable orders...");
+
+        $orders = $this->getDispatchableOrders($days);
 
-        $orders = $this->getDispatchableOrders();
+        if ($orders->isEmpty()) {
+            $this->info('No dispatchable orders found in the given timeframe.');
+
+            return;
+        }
 
         $this->alert($orders->count() . ' orders found for ad-hoc dispatch. Current Time: ' . Carbon::now()->toDateTimeString());
-        $this->table(['Order', 'Dispatched At'], $orders->map(
-            function ($order) {
-                return [$order->public_id, $order->dispatched_at];
-            }
-        ));
+        $this->table(['Order', 'Dispatched At'], $orders->map(fn ($order) => [$order->public_id, $order->dispatched_at]));
 
         foreach ($orders as $order) {
             $pickup   = $order->getPickupLocation();
@@ -59,7 +64,7 @@ class DispatchAdhocOrders extends Command
                 continue;
             }
 
-            $drivers = $this->getNearbyDriversForOrder($order, $pickup, $distance);
+            $drivers = $this->getNearbyDriversForOrder($order, $pickup, $distance, $testingMode);
 
             $this->line('Checking order ' . $order->public_id . ' for nearby drivers within ' . $distance . ' meters.');
 
@@ -68,7 +73,6 @@ class DispatchAdhocOrders extends Command
                 $this->info('Order ' . $order->public_id . ' dispatched successfully to ' . $drivers->count() . ' nearby drivers.');
                 foreach ($drivers as $driver) {
                     $this->info('Pinging driver ' . $driver->name . ' (' . $driver->public_id . ') ...');
-                    // Do the ping
                     $driver->notify(new OrderPing($order, $distance));
                 }
             } else {
@@ -78,44 +82,36 @@ class DispatchAdhocOrders extends Command
     }
 
     /**
-     * Retrieve a collection of dispatchable orders that meet specific conditions.
-     *
-     * This method queries orders that are eligible for dispatching based on multiple constraints:
-     * - Orders must be adhoc, dispatched, but not yet started.
-     * - Orders must have a `dispatched_at` timestamp within a configurable time window:
-     *     - Not older than the given expiry limit (default 72 hours).
-     *     - At least the given interval old (default 4 minutes).
-     * - Orders must not have a driver already assigned and must not be deleted or canceled.
-     * - Orders must belong to companies that have at least one associated user with an online driver.
-     * - Orders must have an associated payload.
+     * Retrieve a collection of dispatchable orders created or dispatched within the last N days.
      *
-     * The query is executed against the appropriate database connection, depending on
-     * whether the `sandbox` option is enabled.
+     * @param int $days            Number of days to look back (default: 2)
+     * @param int $intervalMinutes Minimum age of the order in minutes to be considered dispatchable (default: 4)
+     * @param int $expiryHours     Maximum dispatchable age in hours (default: 72)
      *
-     * @param int $interval    minimum age of the order in minutes to be considered dispatchable (default: 4)
-     * @param int $expiryHours maximum age of the order in hours before it expires and is no longer dispatchable (default: 72)
-     *
-     * @return \Illuminate\Support\Collection a collection of eligible `Order` models with their related `company` and `payload`
+     * @return \Illuminate\Support\Collection
      */
-    public function getDispatchableOrders(int $interval = 4, int $expiryHours = 72): Collection
+    public function getDispatchableOrders(int $days = 2, int $intervalMinutes = 4, int $expiryHours = 72): Collection
     {
-        $sandbox  = Utils::castBoolean($this->option('sandbox'));
+        $sandbox = Utils::castBoolean($this->option('sandbox'));
+
+        $cutoffDate = Carbon::now()->subDays($days);
+        $now        = Carbon::now();
 
         return Order::on($sandbox ? 'sandbox' : 'mysql')
             ->withoutGlobalScopes()
             ->where(['adhoc' => 1, 'dispatched' => 1, 'started' => 0])
             ->whereBetween('dispatched_at', [
-                Carbon::now()->subHours($expiryHours),           // not older than 72 hours
-                Carbon::now()->subMinutes($interval),  // older than interval minutes
+                $now->subHours($expiryHours),   // not older than 72 hours
+                $now->subMinutes($intervalMinutes),
             ])
+            ->where('created_at', '>=', $cutoffDate)
             ->whereNull('driver_assigned_uuid')
             ->whereNull('deleted_at')
             ->where('status', '!=', 'canceled')
             ->whereHas('company', function ($q) {
                 $q->whereHas('users', function ($q) {
                     $q->whereHas('driver', function ($q) {
-                        $q->where('online', 1);
-                        $q->whereNull('deleted_at');
+                        $q->where('online', 1)->whereNull('deleted_at');
                     });
                 });
             })
@@ -125,48 +121,24 @@ class DispatchAdhocOrders extends Command
     }
 
     /**
-     * Fetches nearby drivers for a given order based on the pickup location and distance.
-     *
-     * Retrieves drivers who are within a specified distance from the pickup location of the order.
-     * The method supports a testing mode to simulate driver availability.
-     *
-     * @param Order $order    the order for which drivers are being sought
-     * @param Point $pickup   the geographic point representing the pickup location
-     * @param int   $distance the maximum distance (in meters) within which drivers should be located
-     *
-     * @return Collection returns a collection of nearby drivers
+     * Fetch nearby drivers for a given order.
      */
-    public function getNearbyDriversForOrder(Order $order, Point $pickup, int $distance): Collection
+    public function getNearbyDriversForOrder(Order $order, Point $pickup, int $distance, bool $testing = false): Collection
     {
-        $testing = Utils::castBoolean($this->option('testing'));
-
-        if ($testing) {
-            // one for testing when cannoty be geospatially accurate
-            $drivers = Driver::where(['online' => 1])
-                ->where(function ($q) use ($order) {
-                    $q->where('company_uuid', $order->company_uuid);
-                    $q->orWhereHas('user', function ($q) use ($order) {
-                        $q->where('company_uuid', $order->company_uuid);
-                    });
-                })
-                ->whereNull('deleted_at')
-                ->withoutGlobalScopes()
-                ->get();
-        } else {
-            $drivers = Driver::where(['online' => 1])
-                ->where(function ($q) use ($order) {
-                    $q->where('company_uuid', $order->company_uuid);
-                    $q->orWhereHas('user', function ($q) use ($order) {
-                        $q->where('company_uuid', $order->company_uuid);
-                    });
-                })
-                ->whereNull('deleted_at')
-                ->distanceSphere('location', $pickup, $distance)
-                ->distanceSphereValue('location', $pickup)
-                ->withoutGlobalScopes()
-                ->get();
+        $driverQuery = Driver::query()
+            ->where(['online' => 1])
+            ->where(function ($q) use ($order) {
+                $q->where('company_uuid', $order->company_uuid)
+                    ->orWhereHas('user', fn ($q) => $q->where('company_uuid', $order->company_uuid));
+            })
+            ->whereNull('deleted_at')
+            ->withoutGlobalScopes();
+
+        if (!$testing) {
+            $driverQuery->distanceSphere('location', $pickup, $distance)
+                ->distanceSphereValue('location', $pickup);
         }
 
-        return $drivers;
+        return $driverQuery->get();
     }
 }

package/server/src/Console/Commands/FixInvalidPolymorphicRelationTypeNamespaces.php

@@ -87,7 +87,7 @@ class FixInvalidPolymorphicRelationTypeNamespaces extends Command
             }
 
             if ($record->isDirty()) {
-                $record->save();
+                $record->saveQuietly();
                 $this->info("Saved changes for $modelName ID {$record->public_id}.");
             }
         }

package/server/src/Console/Commands/TrackOrderDistanceAndTime.php

@@ -5,91 +5,135 @@ namespace Fleetbase\FleetOps\Console\Commands;
 use Fleetbase\FleetOps\Models\Order;
 use Illuminate\Console\Command;
 use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\Cache;
 
 class TrackOrderDistanceAndTime extends Command
 {
     /**
      * The name and signature of the console command.
      *
-     * @var string
+     * Options:
+     *  --provider=           : distance/time provider (calculate, google, osrm). Defaults to config(fleetops.distance_matrix.provider)
+     *  --days=               : only include orders created in last N days (default: 2)
+     *  --chunk=              : records per chunk (default: 250)
+     *  --no-lock             : skip single-run lock (not recommended)
+     *  --dry                 : dry-run, do not mutate anything
      */
-    protected $signature = 'fleetops:update-estimations {--provider : The distance and time calculation provider (calculate, google, or osrm)}';
+    protected $signature = 'fleetops:update-estimations
+        {--provider= : The distance and time calculation provider (calculate, google, or osrm)}
+        {--days=2 : Only include orders created in the last N days}
+        {--chunk=250 : How many orders to process per chunk}
+        {--no-lock : Skip process locking}
+        {--dry : Dry run (don\'t persist changes)}';
 
-    /**
-     * The console command description.
-     *
-     * @var string
-     */
-    protected $description = 'Track and update order distance and time estimations';
+    protected $description = 'Track and update order distance and time estimations for recent, active orders';
 
-    /**
-     * Execute the console command.
-     *
-     * @return int
-     */
-    public function handle()
+    public function handle(): int
     {
-        // Set UTC as default timezone
+        // Always operate in UTC
         date_default_timezone_set('UTC');
 
-        // Determine the provider
-        $provider = $this->option('provider');
-        if (!$provider) {
-            $provider = config('fleetops.distance_matrix.provider');
-        }
-        $this->info("Using '{$provider}' as the provider for calculations.");
-
-        // Get all active/ready orders
-        $orders = $this->getActiveOrders();
-
-        // Notify Current Time and # of Orders
-        $this->alert('Found ' . $orders->count() . ' orders to update tracking estimations. Current Time: ' . Carbon::now()->toDateTimeString());
-
-        // Update for each order
-        $updated = 0;
-        foreach ($orders as $order) {
-            try {
-                // Update order distance and time estimations based on the provider
-                $order->setDistanceAndTime(['provider' => $provider]);
-                $updated++;
-                $this->info("Order ID {$order->id} - Distance & Time estimations updated.");
-            } catch (\Exception $e) {
-                $this->error("Failed to update Order ID {$order->id} - Error: " . $e->getMessage());
+        $provider = $this->option('provider') ?: (string) config('fleetops.distance_matrix.provider');
+        $days     = max(1, (int) $this->option('days'));           // guardrail
+        $perChunk = max(50, (int) $this->option('chunk'));         // sane lower bound
+        $dryRun   = (bool) $this->option('dry');
+        $useLock  = !$this->option('no-lock');
+
+        $this->info("Using provider: {$provider}");
+        $this->info("Looking back: last {$days} day(s)");
+        $this->info("Chunk size: {$perChunk}" . ($dryRun ? ' (dry-run)' : ''));
+
+        // Prevent overlapping executions (e.g., cron overlap)
+        $lock = null;
+        if ($useLock) {
+            $lock = Cache::lock('fleetops:update-estimations', 3600); // 1h lock window
+            if (!$lock->get()) {
+                $this->warn('Another run appears to be in progress (lock active). Use --no-lock to bypass.');
+
+                return self::SUCCESS;
             }
         }
 
-        // Summary info
-        $this->info("Updated $updated/" . $orders->count() . " orders' Distance & Time Estimations.");
+        try {
+            $cutoff = Carbon::now()->subDays($days);
+
+            // Build the base query (no data loaded yet)
+            $base = $this->activeOrdersQuery($cutoff);
+
+            // Count total to set up a progress bar without loading all rows
+            $total = (clone $base)->count('id');
+            if ($total === 0) {
+                $this->info('No qualifying orders found. Exiting.');
+
+                return self::SUCCESS;
+            }
+
+            $this->alert('Found ' . number_format($total) . ' orders to update. Current Time: ' . Carbon::now()->toDateTimeString());
+            $bar = $this->output->createProgressBar($total);
+            $bar->start();
+
+            $updated = 0;
+            $errors  = 0;
+
+            // Stream through the dataset in stable primary-key order
+            $base->orderBy('id')->chunkById($perChunk, function ($orders) use ($provider, $dryRun, $bar, &$updated, &$errors) {
+                // Eager-load relationships per chunk to avoid N+1
+                $orders->load(['payload', 'payload.waypoints', 'payload.pickup', 'payload.dropoff']);
+
+                foreach ($orders as $order) {
+                    try {
+                        if (!$dryRun) {
+                            $order->setDistanceAndTime(['provider' => $provider]);
+                        }
+                        $updated++;
+                    } catch (\Throwable $e) {
+                        $errors++;
+                        $this->error("Order {$order->id} failed: {$e->getMessage()}");
+                    } finally {
+                        $bar->advance();
+                    }
+                }
+
+                // Optional: small micro-sleep can smooth out DB/API burstiness
+                // usleep(20000); // 20ms
+            });
+
+            $bar->finish();
+            $this->newLine(2);
+
+            $this->info(($dryRun ? '[Dry Run] ' : '') . "Updated {$updated}/" . number_format($total) . ' orders.');
+            if ($errors > 0) {
+                $this->warn("Encountered {$errors} error(s). Check logs for details.");
+            }
+
+            return self::SUCCESS;
+        } finally {
+            if ($lock) {
+                $lock->release();
+            }
+        }
     }
 
     /**
-     * Retrieves active orders that meet specific criteria.
-     *
-     * This method returns a collection of active orders with the following conditions:
-     * - Not in 'completed' or 'canceled' status.
-     * - Not marked as deleted (`deleted_at` is null).
-     * - Associated with a company (`company_uuid` is not null).
-     * - The order process has started (`started_at` is not null).
-     * - Contains a payload (`payload` relationship exists).
-     * - Created within the past month.
-     *
-     * The result includes related payload data, waypoints, and information about pickup and dropoff points.
-     * Global scopes are not applied to this query.
+     * Base query for "active" orders in the last N days.
      *
-     * @return \Illuminate\Database\Eloquent\Collection collection of relevant Order objects
+     * Conditions:
+     * - Not completed/canceled
+     * - Not soft-deleted
+     * - Has company & started_at
+     * - Has payload
+     * - created_at >= cutoff
+     * - Without global scopes (as in original)
      */
-    protected function getActiveOrders()
+    protected function activeOrdersQuery(Carbon $cutoff)
     {
-        $oneMonthAgo = Carbon::now()->subMonth();
-
-        return Order::whereNotIn('status', ['completed', 'canceled'])
-                    ->whereNull('deleted_at')
-                    ->whereNotNull('company_uuid')
-                    ->whereNotNull('started_at')
-                    ->where('created_at', '>=', $oneMonthAgo)
-                    ->whereHas('payload')
-                    ->with(['payload', 'payload.waypoints', 'payload.pickup', 'payload.dropoff'])
-                    ->withoutGlobalScopes()
-                    ->get();
+        return Order::query()
+            ->withoutGlobalScopes()
+            ->whereNotIn('status', ['completed', 'canceled'])
+            ->whereNull('deleted_at')
+            ->whereNotNull('company_uuid')
+            ->whereNotNull('started_at')
+            ->where('created_at', '>=', $cutoff)
+            ->whereHas('payload');
     }
 }

package/server/src/Http/Controllers/Api/v1/DriverController.php

@@ -332,15 +332,14 @@ class DriverController extends Controller
         try {
             $driver = Driver::findRecordOrFail($id);
         } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
-            return response()->json(
-                [
-                    'error' => 'Driver resource not found.',
-                ],
-                404
-            );
+            return response()->apiError('Driver resource not found.', 404);
+        }
+
+        // If no lat/lng provided, maintain compatibility and just return existing driver resource
+        if (empty($latitude) && empty($longitude)) {
+            return new DriverResource($driver);
         }
 
-        // check if driver needs a geocoded update to set city and country they are currently in
         $isGeocodable = Carbon::parse($driver->updated_at)->diffInMinutes(Carbon::now(), false) > 10 || empty($driver->country) || empty($driver->city);
 
         $positionData = [
@@ -352,37 +351,38 @@ class DriverController extends Controller
             'speed'     => $speed,
         ];
 
-        // Append current order to data if applicable
-        $order = $driver->getCurrentOrder();
-        if ($order) {
+        if ($order = $driver->getCurrentOrder()) {
             $positionData['order_uuid'] = $order->uuid;
-            // Get destination
-            $destination  = $order->payload?->getPickupOrCurrentWaypoint();
+            $destination                = $order->payload?->getPickupOrCurrentWaypoint();
+
             if ($destination) {
                 $positionData['destination_uuid'] = $destination->uuid;
             }
         }
 
-        $driver->update($positionData);
+        $driver->updateQuietly($positionData);
         $driver->createPosition($positionData);
 
-        // If vehicle is assigned to driver load it and sync position data
         $driver->loadMissing('vehicle');
-        if ($driver->vehicle) {
-            $driver->vehicle->update($positionData);
-            $driver->vehicle->createPosition($positionData);
-            broadcast(new VehicleLocationChanged($driver->vehicle, ['driver' => $driver->public_id]));
+        if ($vehicle = $driver->vehicle) {
+            $vehicle->updateQuietly($positionData);
+            $vehicle->createPosition($positionData);
+            broadcast(new VehicleLocationChanged($vehicle, ['driver' => $driver->public_id]));
         }
 
         if ($isGeocodable) {
-            // attempt to geocode and fill country and city
-            $geocoded = Geocoder::reverse($latitude, $longitude)->get()->first();
-
-            if ($geocoded) {
-                $driver->update([
-                    'city'    => $geocoded->getLocality(),
-                    'country' => $geocoded->getCountry()->getCode(),
-                ]);
+            try {
+                $geocoded = Geocoder::reverse($latitude, $longitude)->get()->first();
+                if ($geocoded) {
+                    $driver->updateQuietly([
+                        'city'    => $geocoded->getLocality(),
+                        'country' => $geocoded->getCountry()->getCode(),
+                    ]);
+                }
+            } catch (\Throwable $e) {
+                if (app()->bound('sentry')) {
+                    app('sentry')->captureException($e);
+                }
             }
         }
 

package/server/src/Http/Controllers/Api/v1/VehicleController.php

@@ -227,12 +227,12 @@ class VehicleController extends Controller
         try {
             $vehicle = Vehicle::findRecordOrFail($id);
         } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
-            return response()->json(
-                [
-                    'error' => 'Vehicle resource not found.',
-                ],
-                404
-            );
+            return response()->apiError('Vehicle resource not found.', 404);
+        }
+
+        // If no lat/lng provided, maintain compatibility and just return existing driver resource
+        if (empty($latitude) && empty($longitude)) {
+            return new VehicleResource($vehicle);
         }
 
         $positionData = [
@@ -260,7 +260,7 @@ class VehicleController extends Controller
             }
         }
 
-        $vehicle->update($positionData);
+        $vehicle->updateQuietly($positionData);
         $vehicle->createPosition($positionData);
 
         broadcast(new VehicleLocationChanged($vehicle));

package/server/src/Http/Filter/OrderFilter.php

@@ -12,31 +12,46 @@ class OrderFilter extends Filter
 {
     public function queryForInternal()
     {
-        $this->builder
-            ->where('company_uuid', $this->request->session()->get('company'))
-            ->whereHas(
-                'payload',
-                function ($q) {
-                    $q->where(
-                        function ($q) {
-                            $q->whereHas('waypoints');
-                            $q->orWhereHas('pickup');
-                            $q->orWhereHas('dropoff');
-                        }
-                    );
-                    $q->with(['entities', 'waypoints', 'dropoff', 'pickup', 'return']);
-                }
-            )
-            ->whereHas('trackingNumber')
-            ->whereHas('trackingStatuses')
-            ->with(
-                [
-                    'payload',
-                    'trackingNumber',
-                    'trackingStatuses',
-                    'driverAssigned',
-                ]
-            );
+        $companyUuid = $this->request->session()->get('company');
+
+        // apply company scope first for indexed filtering
+        $this->builder->where('orders.company_uuid', $companyUuid);
+
+        // replace ambiguous whereRelation with qualified whereHas to avoid alias clashes
+        $this->builder->whereHas('payload', function ($payloadQuery) {
+            $payloadQuery->where(function ($q) {
+                $q->whereHas('waypoints', function ($w) {
+                    $w->whereNotNull('waypoints.uuid');
+                });
+                $q->orWhereHas('pickup', function ($p) {
+                    $p->whereNotNull('places.uuid');
+                });
+                $q->orWhereHas('dropoff', function ($d) {
+                    $d->whereNotNull('places.uuid');
+                });
+            });
+        });
+
+        // ensure associated tracking data exists
+        $this->builder->whereHas('trackingNumber', function ($q) {
+            $q->select('uuid');
+        });
+
+        $this->builder->whereHas('trackingStatuses', function ($q) {
+            $q->select('uuid');
+        });
+
+        // eager load main relationships to reduce N+1 overhead
+        $this->builder->with([
+            'payload.entities',
+            'payload.waypoints',
+            'payload.pickup',
+            'payload.dropoff',
+            'payload.return',
+            'trackingNumber',
+            'trackingStatuses',
+            'driverAssigned',
+        ]);
     }
 
     public function queryForPublic()
@@ -108,6 +123,8 @@ class OrderFilter extends Filter
             $this->builder->whereNotIn('status', ['created', 'completed', 'expired', 'order_canceled', 'canceled', 'pending']);
             // remove the searchBuilder where clause
             $this->builder->removeWhereFromQuery('status', 'active');
+
+            return;
         }
 
         $status = Utils::arrayFrom($status);

package/server/src/Http/Resources/v1/Payload.php

@@ -38,6 +38,7 @@ class Payload extends FleetbaseResource
             'cod_amount'            => $this->cod_amount ?? null,
             'cod_currency'          => $this->cod_currency ?? null,
             'cod_payment_method'    => $this->cod_payment_method ?? null,
+            'payment_method'        => $this->payment_method ?? null,
             'meta'                  => data_get($this, 'meta', Utils::createObject()),
             'updated_at'            => $this->updated_at,
             'created_at'            => $this->created_at,

package/server/src/Models/Order.php

@@ -881,7 +881,7 @@ class Order extends Model
         $route = new Route($attributes);
         $route->save();
 
-        $this->update(['route_uuid' => $route->uuid]);
+        $this->updateQuietly(['route_uuid' => $route->uuid]);
 
         return $this;
     }
@@ -998,7 +998,7 @@ class Order extends Model
                 'meta'               => $meta,
             ]);
 
-            return $this->update([
+            return $this->updateQuietly([
                 'purchase_rate_uuid' => $purchasedRate->uuid,
             ]);
         }
@@ -1030,7 +1030,7 @@ class Order extends Model
                 'status'                 => 'success',
             ]);
 
-            $this->update(['transaction_uuid' => $transaction->uuid]);
+            $this->updateQuietly(['transaction_uuid' => $transaction->uuid]);
         } catch (\Throwable $e) {
         }
 
@@ -1518,7 +1518,7 @@ class Order extends Model
 
         $matrix = Utils::getPreliminaryDistanceMatrix($origin, $destination);
 
-        $this->update(['distance' => $matrix->distance, 'time' => $matrix->time]);
+        $this->updateQuietly(['distance' => $matrix->distance, 'time' => $matrix->time]);
 
         return $this;
     }
@@ -1529,16 +1529,28 @@ class Order extends Model
      *
      * @return Order the updated Order instance
      */
-    public function setDistanceAndTime($options = []): Order
+    public function setDistanceAndTime(array $options = []): self
     {
         $origin      = $this->getCurrentOriginPosition();
         $destination = $this->getDestinationPosition();
-        $matrix      = Utils::getDrivingDistanceAndTime($origin, $destination, $options);
-        if ($origin === null || $destination === null) {
+
+        if (!$origin || !$destination) {
             return $this;
         }
 
-        $this->update(['distance' => $matrix->distance, 'time' => $matrix->time]);
+        // Fetch distance/time — bail early if external call fails
+        $matrix = Utils::getDrivingDistanceAndTime($origin, $destination, $options);
+        if (!$matrix || !isset($matrix->distance, $matrix->time)) {
+            return $this;
+        }
+
+        // Only update if values changed to prevent redundant writes
+        if ($this->distance !== $matrix->distance || $this->time !== $matrix->time) {
+            $this->updateQuietly([
+                'distance' => $matrix->distance,
+                'time'     => $matrix->time,
+            ]);
+        }
 
         return $this;
     }

package/server/src/Models/Place.php

@@ -555,14 +555,13 @@ class Place extends Model
             }
 
             // If has $attributes['address']
-            $address = $place['address'];
-            if (!empty($place['address'])) {
-                // return static::createFromGeocodingLookup($place['address'], $saveInstance);
+            $address = data_get($place, 'address');
+            if ($address) {
                 return static::create(array_merge($place, static::getValuesFromGeocodingLookup($address)));
             }
 
-            // Perform google lookup to fill address
-            $street1 = $place['street1'];
+            // Perform google lookup to fill street1
+            $street1 = data_get($place, 'street1');
             if ($street1) {
                 return static::create(array_merge($place, static::getValuesFromGeocodingLookup($street1)));
             }

package/server/src/Models/Vendor.php

@@ -70,7 +70,6 @@ class Vendor extends Model
         'meta',
         'callbacks',
         'phone',
-        'place_uuid',
         'country',
         'status',
         'notes',

package/server/src/Providers/FleetOpsServiceProvider.php

@@ -95,7 +95,7 @@ class FleetOpsServiceProvider extends CoreServiceProvider
         $this->scheduleCommands(function ($schedule) {
             $schedule->command('fleetops:dispatch-orders')->everyMinute()->withoutOverlapping()->storeOutputInDb();
             $schedule->command('fleetops:dispatch-adhoc')->everyMinute()->withoutOverlapping()->storeOutputInDb();
-            $schedule->command('fleetops:update-estimations')->everyFiveMinutes()->withoutOverlapping();
+            $schedule->command('fleetops:update-estimations')->everyTenMinutes()->withoutOverlapping();
             $schedule->command('fleetops:purge-service-quotes')->daily()->withoutOverlapping();
         });
         $this->registerNotifications();