@fleetbase/fleetops-engine 0.6.55 → 0.6.57

package/server/src/Support/Ai/Capabilities/OrderInsightsCapability.php

@@ -0,0 +1,95 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Ai\Capabilities;
+
+use Fleetbase\Ai\Models\AiTask;
+use Fleetbase\Ai\Support\AiRelativeDateResolver;
+use Fleetbase\FleetOps\Models\Order;
+
+class OrderInsightsCapability extends AbstractFleetOpsAICapability
+{
+    public function key(): string
+    {
+        return 'fleet-ops.order_insights';
+    }
+
+    public function label(): string
+    {
+        return 'Fleet-Ops order insights';
+    }
+
+    public function description(): string
+    {
+        return 'Answers bounded aggregate questions about Fleet-Ops orders, statuses, and order values.';
+    }
+
+    public function permissions(): array
+    {
+        return ['fleet-ops see order'];
+    }
+
+    public function resolve(AiTask $task): array
+    {
+        if (!$this->can('fleet-ops see order')) {
+            return ['authorized' => false, 'message' => 'Current user cannot access Fleet-Ops orders.'];
+        }
+
+        $prompt = $this->prompt($task);
+        $window = $this->dateWindow($prompt);
+        $amount = $this->amountThreshold($prompt);
+        $query  = Order::where('company_uuid', session('company'));
+
+        if ($window) {
+            $query->whereBetween('created_at', [$window['start'], $window['end']]);
+        }
+
+        if ($amount !== null) {
+            $query->whereHas('transaction', fn ($transaction) => $transaction->where('amount', '>', $amount));
+        }
+
+        $total = (clone $query)->count();
+
+        return [
+            'authorized'        => true,
+            'metric'            => 'orders',
+            'date_window'       => $window ? [
+                'label'    => $window['label'],
+                'timezone' => $window['timezone'],
+                'start'    => $window['start']->toIso8601String(),
+                'end'      => $window['end']->toIso8601String(),
+            ] : null,
+            'amount_threshold'  => $amount,
+            'count'             => $total,
+            'counts_by_status'  => (clone $query)
+                ->selectRaw('status, count(*) as aggregate')
+                ->groupBy('status')
+                ->pluck('aggregate', 'status')
+                ->all(),
+            'sample_order_ids'  => (clone $query)->latest()->limit(10)->pluck('public_id')->filter()->values()->all(),
+        ];
+    }
+
+    protected function matchesPrompt(string $prompt): bool
+    {
+        return str_contains($prompt, 'order') && $this->containsAny($prompt, ['how many', 'count', 'report', 'value', 'over', 'status', 'today', 'yesterday', 'tomorrow', 'last week', 'this week', 'next week', 'last month', 'this month', 'last 30 days', 'completed', 'active']);
+    }
+
+    protected function amountThreshold(string $prompt): ?float
+    {
+        if (preg_match('/(?:over|greater than|above)\s+\$?([0-9]+(?:\.[0-9]+)?)/', $prompt, $matches)) {
+            return (float) $matches[1];
+        }
+
+        return null;
+    }
+
+    protected function dateWindow(string $prompt): ?array
+    {
+        return $this->relativeDateResolver()->resolveWindow($prompt);
+    }
+
+    protected function relativeDateResolver(): AiRelativeDateResolver
+    {
+        return function_exists('app') ? app(AiRelativeDateResolver::class) : new AiRelativeDateResolver(null);
+    }
+}

package/server/src/Support/Ai/Capabilities/SearchResourcesCapability.php

@@ -0,0 +1,195 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Ai\Capabilities;
+
+use Fleetbase\Ai\Models\AiTask;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Sensor;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\WorkOrder;
+
+class SearchResourcesCapability extends AbstractFleetOpsAICapability
+{
+    public function key(): string
+    {
+        return 'fleet-ops.search_resources';
+    }
+
+    public function label(): string
+    {
+        return 'Search Fleet-Ops resources';
+    }
+
+    public function description(): string
+    {
+        return 'Finds relevant Fleet-Ops orders, vehicles, drivers, work orders, maintenances, devices, sensors, and telematics.';
+    }
+
+    public function permissions(): array
+    {
+        return [
+            'fleet-ops see order',
+            'fleet-ops see vehicle',
+            'fleet-ops see driver',
+            'fleet-ops see work-order',
+            'fleet-ops see maintenance',
+            'fleet-ops see device',
+            'fleet-ops see sensor',
+            'fleet-ops see telematic',
+        ];
+    }
+
+    public function resolve(AiTask $task): array
+    {
+        $prompt = (string) $task->prompt;
+        $terms  = $this->searchTerms($prompt);
+
+        return [
+            'query_terms' => $terms,
+            'results'     => array_filter([
+                'orders'       => $this->orders($terms),
+                'vehicles'     => $this->vehicles($terms),
+                'drivers'      => $this->drivers($terms),
+                'work_orders'  => $this->workOrders($terms),
+                'maintenances' => $this->maintenances($terms),
+                'devices'      => $this->devices($terms),
+                'sensors'      => $this->sensors($terms),
+                'telematics'   => $this->telematics($terms),
+            ]),
+        ];
+    }
+
+    protected function matchesPrompt(string $prompt): bool
+    {
+        return $this->containsAny($prompt, ['find', 'show', 'open', 'look up', 'tell me about', 'status of', 'order', 'vehicle', 'driver', 'work order', 'maintenance', 'device', 'sensor', 'telematic']);
+    }
+
+    protected function orders(array $terms): array
+    {
+        if (!$this->can('fleet-ops see order')) {
+            return [];
+        }
+
+        return Order::with(['transaction', 'trackingNumber'])
+            ->where('company_uuid', session('company'))
+            ->where(function ($query) use ($terms) {
+                $this->whereLikeAny($query, ['public_id', 'internal_id', 'uuid', 'status', 'type'], $terms);
+                $query->orWhereHas('trackingNumber', fn ($tracking) => $this->whereLikeAny($tracking, ['tracking_number', 'barcode'], $terms));
+            })
+            ->limit(5)
+            ->get()
+            ->map(fn (Order $order) => [
+                'id'                   => $order->public_id,
+                'uuid'                 => $order->uuid,
+                'tracking'             => $order->tracking,
+                'status'               => $order->status,
+                'type'                 => $order->type,
+                'transaction_amount'   => $order->transaction_amount,
+                'transaction_currency' => $order->transaction_currency,
+                'route'                => 'console.fleet-ops.operations.orders.index.details',
+                'models'               => [$order->public_id ?: $order->uuid],
+            ])
+            ->values()
+            ->all();
+    }
+
+    protected function vehicles(array $terms): array
+    {
+        if (!$this->can('fleet-ops see vehicle')) {
+            return [];
+        }
+
+        return Vehicle::where('company_uuid', session('company'))
+            ->where(fn ($query) => $this->whereLikeAny($query, ['name', 'make', 'model', 'plate_number', 'vin', 'public_id', 'internal_id'], $terms))
+            ->limit(5)
+            ->get()
+            ->map(fn (Vehicle $vehicle) => [
+                'id'       => $vehicle->public_id,
+                'uuid'     => $vehicle->uuid,
+                'name'     => $vehicle->display_name ?: $vehicle->name,
+                'plate'    => $vehicle->plate_number,
+                'status'   => $vehicle->status,
+                'route'    => 'console.fleet-ops.management.vehicles.index.details',
+                'models'   => [$vehicle->public_id ?: $vehicle->uuid],
+            ])
+            ->values()
+            ->all();
+    }
+
+    protected function drivers(array $terms): array
+    {
+        if (!$this->can('fleet-ops see driver')) {
+            return [];
+        }
+
+        return Driver::with('user')
+            ->where('company_uuid', session('company'))
+            ->where(function ($query) use ($terms) {
+                $this->whereLikeAny($query, ['public_id', 'uuid', 'drivers_license_number', 'status'], $terms);
+                $query->orWhereHas('user', fn ($user) => $this->whereLikeAny($user, ['name', 'email', 'phone'], $terms));
+            })
+            ->limit(5)
+            ->get()
+            ->map(fn (Driver $driver) => [
+                'id'     => $driver->public_id,
+                'uuid'   => $driver->uuid,
+                'name'   => data_get($driver, 'user.name'),
+                'status' => $driver->status,
+                'route'  => 'console.fleet-ops.management.drivers.index.details',
+                'models' => [$driver->public_id ?: $driver->uuid],
+            ])
+            ->values()
+            ->all();
+    }
+
+    protected function workOrders(array $terms): array
+    {
+        return $this->generic(WorkOrder::class, 'fleet-ops see work-order', ['public_id', 'uuid', 'code', 'subject', 'status', 'priority'], 'console.fleet-ops.maintenance.work-orders.index.details', $terms);
+    }
+
+    protected function maintenances(array $terms): array
+    {
+        return $this->generic(Maintenance::class, 'fleet-ops see maintenance', ['public_id', 'uuid', 'status', 'type', 'summary', 'notes'], 'console.fleet-ops.maintenance.maintenances.index.details', $terms);
+    }
+
+    protected function devices(array $terms): array
+    {
+        return $this->generic(Device::class, 'fleet-ops see device', ['public_id', 'uuid', 'name', 'device_id', 'imei', 'serial_number', 'status'], 'console.fleet-ops.connectivity.devices.index.details', $terms);
+    }
+
+    protected function sensors(array $terms): array
+    {
+        return $this->generic(Sensor::class, 'fleet-ops see sensor', ['public_id', 'uuid', 'name', 'internal_id', 'serial_number', 'imei', 'type', 'sensor_type', 'status'], 'console.fleet-ops.connectivity.sensors.index.details', $terms);
+    }
+
+    protected function telematics(array $terms): array
+    {
+        return $this->generic(Telematic::class, 'fleet-ops see telematic', ['public_id', 'uuid', 'name', 'provider', 'status'], 'console.fleet-ops.connectivity.telematics.details', $terms);
+    }
+
+    protected function generic(string $modelClass, string $permission, array $columns, string $route, array $terms): array
+    {
+        if (!$this->can($permission)) {
+            return [];
+        }
+
+        return $modelClass::where('company_uuid', session('company'))
+            ->where(fn ($query) => $this->whereLikeAny($query, $columns, $terms))
+            ->limit(5)
+            ->get()
+            ->map(fn ($record) => [
+                'id'     => $record->public_id,
+                'uuid'   => $record->uuid,
+                'name'   => $record->name ?? $record->subject ?? $record->summary ?? $record->description ?? null,
+                'status' => $record->status ?? null,
+                'route'  => $route,
+                'models' => [$record->public_id ?: $record->uuid],
+            ])
+            ->values()
+            ->all();
+    }
+}

package/server/src/Support/Ai/FleetOpsAiQueryResources.php

@@ -0,0 +1,150 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Ai;
+
+use Fleetbase\Ai\Support\AiQueryableResource;
+use Fleetbase\Ai\Support\AiQueryRegistry;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Fleet;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Zone;
+
+class FleetOpsAiQueryResources
+{
+    public static function register(AiQueryRegistry $registry): void
+    {
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.drivers',
+            label: 'Fleet-Ops drivers',
+            module: 'fleet-ops',
+            modelClass: Driver::class,
+            permission: 'fleet-ops see driver',
+            aliases: ['drivers', 'driver'],
+            fields: [
+                'online'         => ['column' => 'online', 'type' => 'boolean'],
+                'status'         => ['column' => 'status', 'type' => 'string'],
+                'current_status' => ['column' => 'current_status', 'type' => 'string'],
+                'city'           => ['column' => 'city', 'type' => 'string'],
+                'country'        => ['column' => 'country', 'type' => 'string'],
+                'vehicle_uuid'   => ['column' => 'vehicle_uuid', 'type' => 'uuid'],
+                'updated_at'     => ['column' => 'updated_at', 'type' => 'datetime'],
+                'created_at'     => ['column' => 'created_at', 'type' => 'datetime'],
+            ],
+            sampleFields: ['public_id', 'name', 'status', 'current_status', 'online', 'city', 'country', 'vehicle_uuid'],
+            locationField: 'location',
+            directivePermission: 'fleet-ops list driver',
+            maxLimit: 500,
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.vehicles',
+            label: 'Fleet-Ops vehicles',
+            module: 'fleet-ops',
+            modelClass: Vehicle::class,
+            permission: 'fleet-ops see vehicle',
+            aliases: ['vehicles', 'vehicle'],
+            fields: [
+                'online'      => ['column' => 'online', 'type' => 'boolean'],
+                'status'      => ['column' => 'status', 'type' => 'string'],
+                'driver_uuid' => ['column' => 'driver_uuid', 'type' => 'uuid'],
+                'city'        => ['column' => 'city', 'type' => 'string'],
+                'country'     => ['column' => 'country', 'type' => 'string'],
+                'updated_at'  => ['column' => 'updated_at', 'type' => 'datetime'],
+                'created_at'  => ['column' => 'created_at', 'type' => 'datetime'],
+            ],
+            sampleFields: ['public_id', 'display_name', 'status', 'online', 'city', 'country', 'driver_uuid'],
+            locationField: 'location',
+            directivePermission: 'fleet-ops list vehicle',
+            maxLimit: 500,
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.devices',
+            label: 'Fleet-Ops devices',
+            module: 'fleet-ops',
+            modelClass: Device::class,
+            permission: 'fleet-ops see device',
+            aliases: ['devices', 'device'],
+            fields: [
+                'online'          => ['column' => 'online', 'type' => 'boolean'],
+                'status'          => ['column' => 'status', 'type' => 'string'],
+                'provider'        => ['column' => 'provider', 'type' => 'string'],
+                'telematic_uuid'  => ['column' => 'telematic_uuid', 'type' => 'uuid'],
+                'attachable_uuid' => ['column' => 'attachable_uuid', 'type' => 'uuid'],
+                'last_online_at'  => ['column' => 'last_online_at', 'type' => 'datetime'],
+                'updated_at'      => ['column' => 'updated_at', 'type' => 'datetime'],
+            ],
+            sampleFields: ['public_id', 'name', 'status', 'online', 'provider', 'telematic_uuid', 'attachable_uuid'],
+            directivePermission: 'fleet-ops list device',
+            maxLimit: 500,
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.orders',
+            label: 'Fleet-Ops orders',
+            module: 'fleet-ops',
+            modelClass: Order::class,
+            permission: 'fleet-ops see order',
+            aliases: ['orders', 'order'],
+            fields: [
+                'status'                => ['column' => 'status', 'type' => 'string'],
+                'type'                  => ['column' => 'type', 'type' => 'string'],
+                'driver_assigned_uuid'  => ['column' => 'driver_assigned_uuid', 'type' => 'uuid'],
+                'vehicle_assigned_uuid' => ['column' => 'vehicle_assigned_uuid', 'type' => 'uuid'],
+                'created_at'            => ['column' => 'created_at', 'type' => 'datetime'],
+                'scheduled_at'          => ['column' => 'scheduled_at', 'type' => 'datetime'],
+            ],
+            sampleFields: ['public_id', 'status', 'type', 'driver_assigned_uuid', 'vehicle_assigned_uuid', 'created_at'],
+            directivePermission: 'fleet-ops list order',
+            maxLimit: 500,
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.fleets',
+            label: 'Fleet-Ops fleets',
+            module: 'fleet-ops',
+            modelClass: Fleet::class,
+            permission: 'fleet-ops see fleet',
+            aliases: ['fleets', 'fleet'],
+            fields: [
+                'status'     => ['column' => 'status', 'type' => 'string'],
+                'task'       => ['column' => 'task', 'type' => 'string'],
+                'updated_at' => ['column' => 'updated_at', 'type' => 'datetime'],
+            ],
+            sampleFields: ['public_id', 'name', 'status', 'task'],
+            directivePermission: 'fleet-ops list fleet',
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.service_areas',
+            label: 'Fleet-Ops service areas',
+            module: 'fleet-ops',
+            modelClass: ServiceArea::class,
+            permission: 'fleet-ops see service-area',
+            aliases: ['service areas', 'service area', 'service_areas'],
+            fields: [
+                'status'  => ['column' => 'status', 'type' => 'string'],
+                'country' => ['column' => 'country', 'type' => 'string'],
+                'type'    => ['column' => 'type', 'type' => 'string'],
+            ],
+            sampleFields: ['public_id', 'name', 'status', 'country', 'type'],
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.zones',
+            label: 'Fleet-Ops zones',
+            module: 'fleet-ops',
+            modelClass: Zone::class,
+            permission: 'fleet-ops see zone',
+            aliases: ['zones', 'zone'],
+            fields: [
+                'status'            => ['column' => 'status', 'type' => 'string'],
+                'service_area_uuid' => ['column' => 'service_area_uuid', 'type' => 'uuid'],
+            ],
+            sampleFields: ['public_id', 'name', 'status', 'service_area_uuid'],
+        ));
+    }
+}

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

@@ -2,7 +2,7 @@
 
 namespace Fleetbase\FleetOps\Support\Analytics;
 
-use Fleetbase\Models\Transaction;
+use Fleetbase\FleetOps\Support\Metrics\ActiveRevenueQuery;
 use Illuminate\Support\Carbon;
 
 /**
@@ -32,9 +32,7 @@ class RevenueTrend extends AbstractAnalytics
             default => '%Y-%m-%d',
         };
 
-        $rows = Transaction::where('company_uuid', $this->company->uuid)
-            ->where('currency', $currency)
-            ->whereBetween('created_at', [$start, $end])
+        $rows = ActiveRevenueQuery::forCompany($this->company, $currency, $start, $end)
             ->selectRaw('DATE_FORMAT(created_at, ?) as bucket, SUM(amount) as total', [$format])
             ->groupBy('bucket')
             ->orderBy('bucket')
@@ -47,10 +45,7 @@ class RevenueTrend extends AbstractAnalytics
         $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');
+        $previousTotal  = (float) ActiveRevenueQuery::forCompany($this->company, $currency, $compareStart, $start)->sum('amount');
 
         $deltaPct = $previousTotal > 0
             ? round((($total - $previousTotal) / $previousTotal) * 100, 1)

package/server/src/Support/Metrics/ActiveRevenueQuery.php

@@ -0,0 +1,121 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Metrics;
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\Models\Company;
+use Fleetbase\Models\Transaction;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Facades\Schema;
+
+class ActiveRevenueQuery
+{
+    public const ACTIVE_STATUSES               = [Transaction::STATUS_SUCCESS];
+    public const INACTIVE_TRANSACTION_STATUSES = ['pending', 'failed', 'cancelled', 'canceled', 'void', 'voided', 'expired', 'reversed', 'refunded', 'ignored'];
+    public const INACTIVE_ORDER_STATUSES       = ['canceled', 'cancelled', 'order_canceled'];
+    public const INACTIVE_INVOICE_STATUSES     = ['void', 'voided', 'cancelled', 'canceled'];
+
+    public static function forCompany(Company $company, string $currency, ?\DateTimeInterface $start = null, ?\DateTimeInterface $end = null): Builder
+    {
+        $query = Transaction::query()
+            ->where('company_uuid', $company->uuid)
+            ->where('currency', $currency)
+            ->where('direction', Transaction::DIRECTION_CREDIT)
+            ->whereIn('status', self::ACTIVE_STATUSES)
+            ->whereNotIn('status', self::INACTIVE_TRANSACTION_STATUSES)
+            ->whereNull('deleted_at')
+            ->whereNull('voided_at')
+            ->whereNull('reversed_at')
+            ->whereNull('parent_transaction_uuid');
+
+        if ($start && $end) {
+            $query->whereBetween('created_at', [$start, $end]);
+        }
+
+        static::excludeInactiveOrders($query);
+        static::excludeInactiveInvoices($query);
+
+        return $query;
+    }
+
+    protected static function excludeInactiveOrders(Builder $query): void
+    {
+        if (!Schema::hasTable('orders')) {
+            return;
+        }
+
+        foreach (['subject_uuid' => 'subject_type', 'context_uuid' => 'context_type'] as $uuidColumn => $typeColumn) {
+            $query->whereNotExists(function ($subQuery) use ($uuidColumn, $typeColumn) {
+                $subQuery->selectRaw('1')
+                    ->from('orders')
+                    ->whereColumn('orders.uuid', "transactions.{$uuidColumn}")
+                    ->where("transactions.{$typeColumn}", Order::class)
+                    ->where(function ($orderQuery) {
+                        static::inactiveOrderConstraint($orderQuery);
+                    });
+            });
+        }
+
+        $query->whereNotExists(function ($subQuery) {
+            $subQuery->selectRaw('1')
+                ->from('orders')
+                ->whereColumn('orders.transaction_uuid', 'transactions.uuid')
+                ->where(function ($orderQuery) {
+                    static::inactiveOrderConstraint($orderQuery);
+                });
+        });
+    }
+
+    protected static function excludeInactiveInvoices(Builder $query): void
+    {
+        $invoiceClass = 'Fleetbase\\Ledger\\Models\\Invoice';
+
+        if (!class_exists($invoiceClass) || !Schema::hasTable('ledger_invoices')) {
+            return;
+        }
+
+        foreach (['subject_uuid' => 'subject_type', 'context_uuid' => 'context_type'] as $uuidColumn => $typeColumn) {
+            $query->whereNotExists(function ($subQuery) use ($uuidColumn, $typeColumn, $invoiceClass) {
+                $subQuery->selectRaw('1')
+                    ->from('ledger_invoices')
+                    ->whereColumn('ledger_invoices.uuid', "transactions.{$uuidColumn}")
+                    ->where("transactions.{$typeColumn}", $invoiceClass)
+                    ->where(function ($invoiceQuery) {
+                        static::inactiveInvoiceConstraint($invoiceQuery);
+                    });
+            });
+        }
+
+        $query->whereNotExists(function ($subQuery) {
+            $subQuery->selectRaw('1')
+                ->from('ledger_invoices')
+                ->whereColumn('ledger_invoices.transaction_uuid', 'transactions.uuid')
+                ->where(function ($invoiceQuery) {
+                    static::inactiveInvoiceConstraint($invoiceQuery);
+                });
+        });
+    }
+
+    protected static function inactiveOrderConstraint($query): void
+    {
+        $query->whereNotNull('orders.deleted_at')
+            ->orWhereIn('orders.status', self::INACTIVE_ORDER_STATUSES);
+    }
+
+    protected static function inactiveInvoiceConstraint($query): void
+    {
+        $query->whereNotNull('ledger_invoices.deleted_at')
+            ->orWhereIn('ledger_invoices.status', self::INACTIVE_INVOICE_STATUSES);
+
+        if (Schema::hasTable('orders')) {
+            $query->orWhereExists(function ($orderQuery) {
+                $orderQuery->selectRaw('1')
+                    ->from('orders')
+                    ->whereColumn('orders.uuid', 'ledger_invoices.order_uuid')
+                    ->where(function ($inactiveOrderQuery) {
+                        static::inactiveOrderConstraint($inactiveOrderQuery);
+                    });
+            });
+        }
+    }
+}

package/server/src/Support/Metrics/AvgOrderValueMetric.php

@@ -3,7 +3,6 @@
 namespace Fleetbase\FleetOps\Support\Metrics;
 
 use Fleetbase\FleetOps\Models\Order;
-use Fleetbase\Models\Transaction;
 
 /**
  * Average revenue per completed order in the period. Computed as
@@ -39,12 +38,7 @@ class AvgOrderValueMetric extends MoneyMetric
             return 0.0;
         }
 
-        $revenueQuery = Transaction::where('company_uuid', $this->company->uuid)
-            ->where('currency', $this->currency());
-
-        if ($this->currentStart && $this->currentEnd) {
-            $revenueQuery->whereBetween('created_at', [$this->currentStart, $this->currentEnd]);
-        }
+        $revenueQuery = ActiveRevenueQuery::forCompany($this->company, $this->currency(), $this->currentStart, $this->currentEnd);
 
         $totalRevenue = (float) $revenueQuery->sum('amount');
 

package/server/src/Support/Metrics/EarningsMetric.php

@@ -2,8 +2,6 @@
 
 namespace Fleetbase\FleetOps\Support\Metrics;
 
-use Fleetbase\Models\Transaction;
-
 class EarningsMetric extends MoneyMetric
 {
     public static function slug(): string
@@ -13,14 +11,7 @@ class EarningsMetric extends MoneyMetric
 
     protected function query(?\DateTimeInterface $start, ?\DateTimeInterface $end)
     {
-        $query = Transaction::where('company_uuid', $this->company->uuid)
-            ->where('currency', $this->currency());
-
-        if ($start && $end) {
-            $query->whereBetween('created_at', [$start, $end]);
-        }
-
-        return $query;
+        return ActiveRevenueQuery::forCompany($this->company, $this->currency(), $start, $end);
     }
 
     protected function aggregate($query): float