@fleetbase/fleetops-engine 0.6.22 → 0.6.23

package/composer.json

@@ -1,6 +1,6 @@
 {
     "name": "fleetbase/fleetops-api",
-    "version": "0.6.22",
+    "version": "0.6.23",
     "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.23",
     "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.23",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "fleetbase": {
         "route": "fleet-ops"

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/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/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();