@fleetbase/fleetops-engine 0.6.47 → 0.6.49

package/server/src/Support/Analytics/IssuesInsights.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Analytics;
+
+use Fleetbase\FleetOps\Models\Issue;
+use Illuminate\Support\Carbon;
+
+/**
+ * Issues breakdown: category pie, priority histogram, open vs resolved counts,
+ * and average resolution time (hours).
+ */
+class IssuesInsights extends AbstractAnalytics
+{
+    public function get(): array
+    {
+        $companyUuid = $this->company->uuid;
+        $start       = $this->start ?? Carbon::now()->subDays(30)->toDateTime();
+        $end         = $this->end ?? Carbon::now()->toDateTime();
+
+        $byCategory = Issue::where('company_uuid', $companyUuid)
+            ->whereBetween('created_at', [$start, $end])
+            ->selectRaw('category, COUNT(*) as total')
+            ->groupBy('category')
+            ->orderByRaw('total DESC')
+            ->get();
+
+        $byPriority = Issue::where('company_uuid', $companyUuid)
+            ->whereBetween('created_at', [$start, $end])
+            ->selectRaw('priority, COUNT(*) as total')
+            ->groupBy('priority')
+            ->pluck('total', 'priority');
+
+        $open = Issue::where('company_uuid', $companyUuid)
+            ->where('status', 'pending')
+            ->count();
+
+        $resolvedInWindow = Issue::where('company_uuid', $companyUuid)
+            ->whereNotNull('resolved_at')
+            ->whereBetween('resolved_at', [$start, $end])
+            ->get(['created_at', 'resolved_at']);
+
+        $totalHours = 0.0;
+        foreach ($resolvedInWindow as $issue) {
+            $totalHours += (Carbon::parse($issue->resolved_at)->getTimestamp()
+                          - Carbon::parse($issue->created_at)->getTimestamp()) / 3600;
+        }
+
+        $avgResolutionHours = $resolvedInWindow->count() > 0
+            ? round($totalHours / $resolvedInWindow->count(), 1)
+            : null;
+
+        return [
+            'by_category' => [
+                'labels' => $byCategory->pluck('category')->map(fn ($c) => $c ?: 'Uncategorized')->all(),
+                'data'   => $byCategory->pluck('total')->map(fn ($v) => (int) $v)->all(),
+            ],
+            'by_priority' => [
+                'high'   => (int) ($byPriority['high'] ?? 0),
+                'medium' => (int) ($byPriority['medium'] ?? 0),
+                'low'    => (int) ($byPriority['low'] ?? 0),
+            ],
+            'open'                   => $open,
+            'resolved_this_period'   => $resolvedInWindow->count(),
+            'avg_resolution_hours'   => $avgResolutionHours,
+        ];
+    }
+}

package/server/src/Support/Analytics/LiveFleet.php

@@ -0,0 +1,127 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Analytics;
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\Metrics\OrdersInProgressMetric;
+
+/**
+ * Real-time fleet snapshot used as the initial-state payload for Live Fleet Map.
+ * After this single GET the frontend subscribes to `company.{uuid}` and applies
+ * `driver.location_changed` / `order.*` events incrementally instead of polling.
+ *
+ * Reads from `Driver.location` and `Vehicle.location` directly — does NOT scan the
+ * high-frequency Position table.
+ */
+class LiveFleet extends AbstractAnalytics
+{
+    public function get(): array
+    {
+        $companyUuid = $this->company->uuid;
+
+        // Driver.name is a virtual attribute backed by users.name — eager-load the
+        // user so the accessor resolves cleanly without a per-record query.
+        $drivers = Driver::with(['user:uuid,name,avatar_uuid'])
+            ->where('drivers.company_uuid', $companyUuid)
+            ->whereNotNull('drivers.location')
+            ->where(function ($q) {
+                $q->where('drivers.online', true)->orWhereNotNull('drivers.current_job_uuid');
+            })
+            ->get();
+
+        // Vehicles tracked independently of drivers (telematics-connected rigs may
+        // report position without an active driver session).
+        $vehicles = Vehicle::where('company_uuid', $companyUuid)
+            ->whereNotNull('location')
+            ->get();
+
+        $activeOrderUuids = $drivers->pluck('current_job_uuid')->filter()->unique()->values();
+
+        $activeOrders = Order::whereIn('uuid', $activeOrderUuids)
+            ->where('company_uuid', $companyUuid)
+            ->whereIn('status', OrdersInProgressMetric::IN_PROGRESS_STATUSES)
+            ->get(['uuid', 'driver_assigned_uuid', 'status', 'tracking_number_uuid']);
+
+        return [
+            'drivers' => $drivers->map(fn ($d) => $this->driverPayload($d))
+                ->filter(fn ($d) => $d['lat'] !== null && $d['lng'] !== null)
+                ->values()
+                ->all(),
+            'vehicles' => $vehicles->map(fn ($v) => $this->vehiclePayload($v))
+                ->filter(fn ($v) => $v['lat'] !== null && $v['lng'] !== null)
+                ->values()
+                ->all(),
+            'active_orders' => $activeOrders->map(fn ($o) => [
+                'uuid'        => $o->uuid,
+                'driver_uuid' => $o->driver_assigned_uuid,
+                'status'      => $o->status,
+            ])->all(),
+        ];
+    }
+
+    private function driverPayload(Driver $d): array
+    {
+        [$lat, $lng] = $this->extractLatLng($d->location);
+
+        return [
+            'uuid'               => $d->uuid,
+            'public_id'          => $d->public_id,
+            'name'               => $d->name,
+            // avatar_url falls back to vehicle avatar then a default;
+            // vehicle_avatar is what the operational live-map renders.
+            'avatar_url'         => $d->avatar_url,
+            'vehicle_avatar'     => $d->vehicle_avatar,
+            'online'             => (bool) $d->online,
+            'heading'            => (float) ($d->heading ?? 0),
+            'current_order_uuid' => $d->current_job_uuid,
+            'lat'                => $lat,
+            'lng'                => $lng,
+            'updated_at'         => $d->last_location_update_at,
+        ];
+    }
+
+    private function vehiclePayload(Vehicle $v): array
+    {
+        [$lat, $lng] = $this->extractLatLng($v->location);
+
+        return [
+            'uuid'         => $v->uuid,
+            'public_id'    => $v->public_id,
+            'name'         => $v->display_name,
+            'plate_number' => $v->plate_number,
+            'avatar_url'   => $v->avatar_url,
+            'photo_url'    => $v->photo_url,
+            'online'       => (bool) ($v->online ?? false),
+            'driver_name'  => $v->driver_name,
+            'heading'      => (float) ($v->heading ?? 0),
+            'lat'          => $lat,
+            'lng'          => $lng,
+        ];
+    }
+
+    /**
+     * Pull [lat, lng] out of whatever shape the spatial accessor handed us.
+     * Supports Point objects, [lat, lng] arrays, and {lat, lng} hashes.
+     *
+     * @return array{0:float|null,1:float|null}
+     */
+    private function extractLatLng($location): array
+    {
+        if (is_object($location) && method_exists($location, 'getLat')) {
+            return [$location->getLat(), $location->getLng()];
+        }
+
+        if (is_array($location)) {
+            // Point::toArray usually returns ['lat' => ..., 'lng' => ...] but
+            // GeoJSON-shape `coordinates` is [lng, lat]; handle both.
+            return [
+                $location['lat'] ?? $location[1] ?? null,
+                $location['lng'] ?? $location[0] ?? null,
+            ];
+        }
+
+        return [null, null];
+    }
+}

package/server/src/Support/Analytics/MaintenanceOverview.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Analytics;
+
+use Fleetbase\FleetOps\Models\Maintenance;
+use Illuminate\Support\Carbon;
+
+/**
+ * Maintenance summary: overdue count, next-7-day schedule, in-progress count,
+ * month-to-date and year-to-date spend, plus a short list of upcoming items.
+ */
+class MaintenanceOverview extends AbstractAnalytics
+{
+    public function get(): array
+    {
+        $companyUuid = $this->company->uuid;
+        $currency    = $this->companyCurrency();
+        $now         = Carbon::now();
+
+        $overdue = Maintenance::where('company_uuid', $companyUuid)
+            ->where('scheduled_at', '<', $now)
+            ->where('status', '!=', 'completed')
+            ->where('status', '!=', 'canceled')
+            ->count();
+
+        $next7d = Maintenance::where('company_uuid', $companyUuid)
+            ->whereBetween('scheduled_at', [$now, $now->copy()->addDays(7)])
+            ->whereIn('status', ['scheduled', 'pending'])
+            ->count();
+
+        $inProgress = Maintenance::where('company_uuid', $companyUuid)
+            ->where('status', 'in_progress')
+            ->count();
+
+        $costThisMonth = (float) Maintenance::where('company_uuid', $companyUuid)
+            ->where('currency', $currency)
+            ->where('status', 'completed')
+            ->whereBetween('completed_at', [$now->copy()->startOfMonth(), $now])
+            ->sum('total_cost');
+
+        $costYtd = (float) Maintenance::where('company_uuid', $companyUuid)
+            ->where('currency', $currency)
+            ->where('status', 'completed')
+            ->whereBetween('completed_at', [$now->copy()->startOfYear(), $now])
+            ->sum('total_cost');
+
+        $upcoming = Maintenance::where('company_uuid', $companyUuid)
+            ->whereIn('status', ['scheduled', 'pending'])
+            ->whereNotNull('scheduled_at')
+            ->where('scheduled_at', '>=', $now)
+            ->orderBy('scheduled_at', 'asc')
+            ->limit(8)
+            ->get(['uuid', 'maintainable_uuid', 'maintainable_type', 'type', 'priority', 'scheduled_at']);
+
+        return [
+            'overdue'           => $overdue,
+            'scheduled_next_7d' => $next7d,
+            'in_progress'       => $inProgress,
+            'cost_this_month'   => round($costThisMonth, 2),
+            'cost_ytd'          => round($costYtd, 2),
+            'currency'          => $currency,
+            'upcoming'          => $upcoming->map(fn ($m) => [
+                'uuid'         => $m->uuid,
+                'type'         => $m->type,
+                'priority'     => $m->priority,
+                'scheduled_at' => $m->scheduled_at,
+            ])->all(),
+        ];
+    }
+}

package/server/src/Support/Analytics/OnTimeDelivery.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Analytics;
+
+use Fleetbase\FleetOps\Models\Order;
+use Illuminate\Support\Carbon;
+
+/**
+ * Percentage of completed orders that finished within the SLA window
+ * (scheduled_at + sla_minutes). Orders without a scheduled_at are excluded
+ * — you can't be on-time against an undefined target.
+ */
+class OnTimeDelivery extends AbstractAnalytics
+{
+    protected int $slaMinutes = 30;
+
+    public function slaMinutes(int $minutes): self
+    {
+        $this->slaMinutes = max(0, $minutes);
+
+        return $this;
+    }
+
+    public function get(): array
+    {
+        $start = $this->start ?? Carbon::now()->subDays(30)->toDateTime();
+        $end   = $this->end ?? Carbon::now()->toDateTime();
+
+        [$onTime, $late, $total] = $this->bucketCounts($start, $end);
+
+        $duration            = $end->getTimestamp() - $start->getTimestamp();
+        $compareEnd          = clone $start;
+        $compareStart        = (new \DateTime())->setTimestamp($start->getTimestamp() - $duration);
+        [, , $prevTotal]     = $this->bucketCounts($compareStart, $compareEnd);
+        $prevOnTime          = $this->bucketCounts($compareStart, $compareEnd)[0];
+        $prevPct             = $prevTotal > 0 ? ($prevOnTime / $prevTotal) * 100 : 0;
+        $currentPct          = $total > 0 ? ($onTime / $total) * 100 : 0;
+        $deltaPct            = round($currentPct - $prevPct, 1);
+
+        return [
+            'on_time_pct'   => round($currentPct, 1),
+            'on_time'       => $onTime,
+            'late'          => $late,
+            'total'         => $total,
+            'sla_minutes'   => $this->slaMinutes,
+            'delta_pct'     => $deltaPct,
+        ];
+    }
+
+    /** @return array{0:int,1:int,2:int} [onTime, late, total] */
+    private function bucketCounts(\DateTimeInterface $start, \DateTimeInterface $end): array
+    {
+        $slaSeconds = $this->slaMinutes * 60;
+
+        $orders = Order::where('company_uuid', $this->company->uuid)
+            ->where('status', 'completed')
+            ->whereNotNull('scheduled_at')
+            ->whereNotNull('updated_at')
+            ->whereBetween('updated_at', [$start, $end])
+            ->selectRaw('TIMESTAMPDIFF(SECOND, scheduled_at, updated_at) as drift_seconds')
+            ->get();
+
+        $onTime = 0;
+        $late   = 0;
+        foreach ($orders as $row) {
+            if ((int) $row->drift_seconds <= $slaSeconds) {
+                $onTime++;
+            } else {
+                $late++;
+            }
+        }
+
+        return [$onTime, $late, $onTime + $late];
+    }
+}

package/server/src/Support/Analytics/OperationsPulse.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Analytics;
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Issue;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\Metrics\OrdersInProgressMetric;
+use Illuminate\Support\Carbon;
+
+/**
+ * Real-time operational snapshot. Returns a small map of tile data + deltas
+ * vs the same window 24 hours ago for the rate-of-change indicators.
+ */
+class OperationsPulse extends AbstractAnalytics
+{
+    public function get(): array
+    {
+        $companyUuid = $this->company->uuid;
+
+        $activeOrders        = Order::where('company_uuid', $companyUuid)
+            ->whereIn('status', OrdersInProgressMetric::IN_PROGRESS_STATUSES)
+            ->count();
+
+        $driversOnline       = Driver::where('company_uuid', $companyUuid)
+            ->where('online', true)
+            ->whereNotNull('current_job_uuid')
+            ->count();
+
+        $totalDrivers        = Driver::where('company_uuid', $companyUuid)->count();
+
+        $vehiclesDeployed    = Vehicle::where('company_uuid', $companyUuid)
+            ->whereHas('driver', fn ($q) => $q->whereNotNull('current_job_uuid'))
+            ->count();
+
+        $totalVehicles       = Vehicle::where('company_uuid', $companyUuid)->count();
+
+        $issuesOpen          = Issue::where('company_uuid', $companyUuid)
+            ->where('status', 'pending')
+            ->count();
+
+        $todayStart          = Carbon::today();
+        $yesterdayStart      = Carbon::yesterday();
+        $todaySoFar          = Carbon::now();
+        $yesterdaySamePoint  = $yesterdayStart->copy()->setTime($todaySoFar->hour, $todaySoFar->minute);
+
+        $completedToday      = Order::where('company_uuid', $companyUuid)
+            ->where('status', 'completed')
+            ->whereBetween('updated_at', [$todayStart, $todaySoFar])
+            ->count();
+
+        $completedYesterdayToTime = Order::where('company_uuid', $companyUuid)
+            ->where('status', 'completed')
+            ->whereBetween('updated_at', [$yesterdayStart, $yesterdaySamePoint])
+            ->count();
+
+        return [
+            'active_orders'     => ['value' => $activeOrders, 'delta_pct' => null],
+            'completed_today'   => [
+                'value'     => $completedToday,
+                'delta_pct' => $this->deltaPct($completedToday, $completedYesterdayToTime),
+            ],
+            'drivers_online'    => [
+                'value'      => $driversOnline,
+                'of'         => $totalDrivers,
+                'pct_of_max' => $totalDrivers > 0 ? round(($driversOnline / $totalDrivers) * 100, 1) : 0.0,
+            ],
+            'vehicles_deployed' => [
+                'value'      => $vehiclesDeployed,
+                'of'         => $totalVehicles,
+                'pct_of_max' => $totalVehicles > 0 ? round(($vehiclesDeployed / $totalVehicles) * 100, 1) : 0.0,
+            ],
+            'issues_open'       => ['value' => $issuesOpen, 'delta_pct' => null],
+        ];
+    }
+
+    private function deltaPct(int $current, int $previous): ?float
+    {
+        if ($previous === 0) {
+            return $current > 0 ? 100.0 : null;
+        }
+
+        return round((($current - $previous) / $previous) * 100, 1);
+    }
+}

package/server/src/Support/Analytics/OrdersByStatus.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Analytics;
+
+use Fleetbase\FleetOps\Models\Order;
+use Illuminate\Support\Carbon;
+
+/**
+ * Daily count of orders bucketed by status. One stacked bar per day, with
+ * a fixed status palette so the colour coding stays consistent over time.
+ */
+class OrdersByStatus extends AbstractAnalytics
+{
+    /** Status → display label + colour for stacked bars. */
+    private const STATUS_PALETTE = [
+        'completed'   => ['label' => 'Completed',   'color' => '#22c55e'],
+        'in_progress' => ['label' => 'In Progress', 'color' => '#3485e2'],
+        'dispatched'  => ['label' => 'Dispatched',  'color' => '#8b5cf6'],
+        'canceled'    => ['label' => 'Canceled',    'color' => '#ef4444'],
+        'failed'      => ['label' => 'Failed',      'color' => '#f59e0b'],
+    ];
+
+    public function get(): array
+    {
+        $start = $this->start ?? Carbon::now()->subDays(14)->toDateTime();
+        $end   = $this->end ?? Carbon::now()->toDateTime();
+
+        $rows = Order::where('company_uuid', $this->company->uuid)
+            ->whereBetween('created_at', [$start, $end])
+            ->whereIn('status', array_keys(self::STATUS_PALETTE))
+            ->selectRaw('DATE(created_at) as bucket, status, COUNT(*) as total')
+            ->groupBy('bucket', 'status')
+            ->orderBy('bucket')
+            ->get();
+
+        $cursor    = Carbon::instance($start)->startOfDay();
+        $endDay    = Carbon::instance($end)->startOfDay();
+        $labels    = [];
+        $byStatus  = array_fill_keys(array_keys(self::STATUS_PALETTE), []);
+
+        while ($cursor <= $endDay) {
+            $labels[] = $cursor->format('M j');
+            foreach (array_keys(self::STATUS_PALETTE) as $status) {
+                $match = $rows->first(fn ($r) => $r->bucket === $cursor->format('Y-m-d') && $r->status === $status);
+                $byStatus[$status][] = $match ? (int) $match->total : 0;
+            }
+            $cursor->addDay();
+        }
+
+        $datasets = [];
+        foreach (self::STATUS_PALETTE as $status => $cfg) {
+            $datasets[] = [
+                'label'           => $cfg['label'],
+                'data'            => $byStatus[$status],
+                'backgroundColor' => $cfg['color'],
+            ];
+        }
+
+        return [
+            'labels'   => $labels,
+            'datasets' => $datasets,
+        ];
+    }
+}

package/server/src/Support/Analytics/RevenueTrend.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Analytics;
+
+use Fleetbase\Models\Transaction;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\DB;
+
+/**
+ * Time-series of revenue (sum of transactions) per bucket, filtered to the
+ * company's primary currency. Returns Chart.js-shaped { labels, datasets, summary }.
+ */
+class RevenueTrend extends AbstractAnalytics
+{
+    protected string $groupBy = 'day';
+
+    public function groupBy(string $unit): self
+    {
+        $this->groupBy = in_array($unit, ['day', 'week', 'month'], true) ? $unit : 'day';
+
+        return $this;
+    }
+
+    public function get(): array
+    {
+        $currency  = $this->companyCurrency();
+        $start     = $this->start ?? Carbon::now()->subDays(30)->toDateTime();
+        $end       = $this->end ?? Carbon::now()->toDateTime();
+
+        $format    = match ($this->groupBy) {
+            'week'  => '%x-W%v',
+            'month' => '%Y-%m',
+            default => '%Y-%m-%d',
+        };
+
+        $rows = Transaction::where('company_uuid', $this->company->uuid)
+            ->where('currency', $currency)
+            ->whereBetween('created_at', [$start, $end])
+            ->selectRaw('DATE_FORMAT(created_at, ?) as bucket, SUM(amount) as total', [$format])
+            ->groupBy('bucket')
+            ->orderBy('bucket')
+            ->get();
+
+        $labels = $rows->pluck('bucket')->all();
+        $data   = $rows->pluck('total')->map(fn ($v) => (float) $v)->all();
+        $total  = array_sum($data);
+
+        $duration       = $end->getTimestamp() - $start->getTimestamp();
+        $compareStart   = (clone $start);
+        $compareStart   = (new \DateTime())->setTimestamp($start->getTimestamp() - $duration);
+        $previousTotal  = (float) Transaction::where('company_uuid', $this->company->uuid)
+            ->where('currency', $currency)
+            ->whereBetween('created_at', [$compareStart, $start])
+            ->sum('amount');
+
+        $deltaPct = $previousTotal > 0
+            ? round((($total - $previousTotal) / $previousTotal) * 100, 1)
+            : ($total > 0 ? 100.0 : 0.0);
+
+        return [
+            'labels'   => $labels,
+            'datasets' => [
+                [
+                    'label'           => 'Revenue',
+                    'data'            => $data,
+                    'borderColor'     => '#3485e2',
+                    'backgroundColor' => 'rgba(52, 133, 226, 0.1)',
+                    'fill'            => true,
+                    'tension'         => 0.3,
+                ],
+            ],
+            'summary' => [
+                'total'     => round($total, 2),
+                'currency'  => $currency,
+                'delta_pct' => $deltaPct,
+            ],
+        ];
+    }
+}

package/server/src/Support/Analytics/TopDrivers.php

@@ -0,0 +1,92 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Analytics;
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Order;
+use Illuminate\Support\Carbon;
+
+/**
+ * Ranked driver leaderboard. Single GROUP BY join on orders → drivers so this
+ * scales without N+1 even on large fleets.
+ */
+class TopDrivers extends AbstractAnalytics
+{
+    protected int $limit = 10;
+    protected string $sortBy = 'orders_completed';
+
+    public function limit(int $limit): self
+    {
+        $this->limit = max(1, min(50, $limit));
+
+        return $this;
+    }
+
+    public function sortBy(string $key): self
+    {
+        $this->sortBy = in_array($key, ['orders_completed', 'distance', 'on_time'], true)
+            ? $key
+            : 'orders_completed';
+
+        return $this;
+    }
+
+    public function get(): array
+    {
+        $start = $this->start ?? Carbon::now()->subDays(30)->toDateTime();
+        $end   = $this->end ?? Carbon::now()->toDateTime();
+
+        $sortColumn = match ($this->sortBy) {
+            'distance' => 'distance_m',
+            'on_time'  => 'on_time_pct',
+            default    => 'orders_completed',
+        };
+
+        // `drivers.name` and `drivers.photo_uuid` aren't real columns — they're
+        // virtual attributes that resolve via the related users row. Join users
+        // explicitly so we can SELECT them at the SQL level.
+        $rows = Order::where('orders.company_uuid', $this->company->uuid)
+            ->where('orders.status', 'completed')
+            ->whereNotNull('orders.driver_assigned_uuid')
+            ->whereBetween('orders.updated_at', [$start, $end])
+            ->join('drivers', 'drivers.uuid', '=', 'orders.driver_assigned_uuid')
+            ->join('users', 'users.uuid', '=', 'drivers.user_uuid')
+            ->groupBy('drivers.uuid', 'users.name', 'users.avatar_uuid')
+            ->selectRaw('
+                drivers.uuid as driver_uuid,
+                users.name as name,
+                users.avatar_uuid as avatar_uuid,
+                COUNT(orders.uuid) as orders_completed,
+                COALESCE(SUM(orders.distance), 0) as distance_m,
+                SUM(CASE
+                    WHEN orders.scheduled_at IS NOT NULL
+                     AND TIMESTAMPDIFF(SECOND, orders.scheduled_at, orders.updated_at) <= 1800
+                    THEN 1 ELSE 0 END) as on_time_count,
+                SUM(CASE WHEN orders.scheduled_at IS NOT NULL THEN 1 ELSE 0 END) as scheduled_count
+            ')
+            ->orderByRaw("{$sortColumn} DESC")
+            ->limit($this->limit)
+            ->get();
+
+        $result = $rows->map(function ($r) {
+            $scheduled = (int) $r->scheduled_count;
+            $onTimePct = $scheduled > 0
+                ? round(((int) $r->on_time_count / $scheduled) * 100, 1)
+                : null;
+
+            return [
+                'driver_uuid'      => $r->driver_uuid,
+                'name'             => $r->name,
+                'avatar_uuid'      => $r->avatar_uuid,
+                'orders_completed' => (int) $r->orders_completed,
+                'distance_m'       => (float) $r->distance_m,
+                'on_time_pct'      => $onTimePct,
+            ];
+        })->all();
+
+        return [
+            'rows'    => $result,
+            'sort_by' => $this->sortBy,
+        ];
+    }
+}