@fleetbase/fleetops-engine 0.6.55 → 0.6.57

package/server/tests/MetricsRegistryTest.php

@@ -4,6 +4,7 @@ use Fleetbase\FleetOps\Support\Metrics\AbstractMetric;
 use Fleetbase\FleetOps\Support\Metrics\OrdersInProgressMetric;
 use Fleetbase\FleetOps\Support\Metrics\Registry;
 use Fleetbase\FleetOps\Support\Metrics\TotalTimeTraveledMetric;
+use Fleetbase\Models\Transaction;
 
 test('registry exposes every known metric slug', function () {
     $slugs = Registry::slugs();
@@ -66,13 +67,52 @@ test('money metrics return float values to preserve cents', function () {
 });
 
 test('money metrics filter by currency to avoid mixed-currency sums', function () {
-    $earnings  = file_get_contents(dirname(__DIR__) . '/src/Support/Metrics/EarningsMetric.php');
-    $fuelCosts = file_get_contents(dirname(__DIR__) . '/src/Support/Metrics/FuelCostsMetric.php');
-    $aov       = file_get_contents(dirname(__DIR__) . '/src/Support/Metrics/AvgOrderValueMetric.php');
+    $earnings      = file_get_contents(dirname(__DIR__) . '/src/Support/Metrics/EarningsMetric.php');
+    $fuelCosts     = file_get_contents(dirname(__DIR__) . '/src/Support/Metrics/FuelCostsMetric.php');
+    $aov           = file_get_contents(dirname(__DIR__) . '/src/Support/Metrics/AvgOrderValueMetric.php');
+    $activeRevenue = file_get_contents(dirname(__DIR__) . '/src/Support/Metrics/ActiveRevenueQuery.php');
 
-    expect($earnings)->toContain("->where('currency'");
+    expect($earnings)->toContain('ActiveRevenueQuery::forCompany');
     expect($fuelCosts)->toContain("->where('currency'");
-    expect($aov)->toContain("->where('currency'");
+    expect($aov)->toContain('ActiveRevenueQuery::forCompany');
+    expect($activeRevenue)->toContain("->where('currency'");
+});
+
+test('earnings use the shared active revenue query', function () {
+    $earnings     = file_get_contents(dirname(__DIR__) . '/src/Support/Metrics/EarningsMetric.php');
+    $aov          = file_get_contents(dirname(__DIR__) . '/src/Support/Metrics/AvgOrderValueMetric.php');
+    $revenueTrend = file_get_contents(dirname(__DIR__) . '/src/Support/Analytics/RevenueTrend.php');
+
+    expect($earnings)->toContain('ActiveRevenueQuery::forCompany');
+    expect($aov)->toContain('ActiveRevenueQuery::forCompany');
+    expect($revenueTrend)->toContain('ActiveRevenueQuery::forCompany');
+});
+
+test('active revenue query excludes inactive financial and operational lifecycle records', function () {
+    $source = file_get_contents(dirname(__DIR__) . '/src/Support/Metrics/ActiveRevenueQuery.php');
+
+    expect($source)->toContain("where('direction', Transaction::DIRECTION_CREDIT)");
+    expect($source)->toContain("whereIn('status', self::ACTIVE_STATUSES)");
+    expect($source)->toContain("whereNull('voided_at')");
+    expect($source)->toContain("whereNull('reversed_at')");
+    expect($source)->toContain("whereNull('parent_transaction_uuid')");
+    expect($source)->toContain('excludeInactiveOrders');
+    expect($source)->toContain('excludeInactiveInvoices');
+    expect($source)->toContain('ledger_invoices.deleted_at');
+    expect($source)->toContain('orders.deleted_at');
+    expect(Fleetbase\FleetOps\Support\Metrics\ActiveRevenueQuery::ACTIVE_STATUSES)->toBe([Transaction::STATUS_SUCCESS]);
+    expect(Fleetbase\FleetOps\Support\Metrics\ActiveRevenueQuery::ACTIVE_STATUSES)->not->toContain('completed');
+    expect(Fleetbase\FleetOps\Support\Metrics\ActiveRevenueQuery::ACTIVE_STATUSES)->not->toContain('paid');
+});
+
+test('active revenue query treats invoice status as invalidation only', function () {
+    $inactiveInvoiceStatuses = Fleetbase\FleetOps\Support\Metrics\ActiveRevenueQuery::INACTIVE_INVOICE_STATUSES;
+
+    expect($inactiveInvoiceStatuses)->not->toContain('draft');
+    expect($inactiveInvoiceStatuses)->toContain('void');
+    expect($inactiveInvoiceStatuses)->toContain('voided');
+    expect($inactiveInvoiceStatuses)->toContain('cancelled');
+    expect($inactiveInvoiceStatuses)->toContain('canceled');
 });
 
 test('ordersInProgress uses an explicit allowlist rather than an exclusion list', function () {

package/server/tests/OrderPayloadPlaceResolutionTest.php

@@ -0,0 +1,53 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Order;
+
+function fleetopsOrderPayloadResolutionProbe(bool $hasExistingUuid)
+{
+    return new class($hasExistingUuid) extends Order {
+        public function __construct(private bool $hasExistingUuid = false)
+        {
+            parent::__construct();
+        }
+
+        public function shouldResolveForTest(array $attributes, string $role): bool
+        {
+            return $this->shouldResolvePayloadPlace($attributes, $role);
+        }
+
+        protected function hasExistingPayloadPlaceUuid(?array $attributes, string $role): bool
+        {
+            return $this->hasExistingUuid;
+        }
+    };
+}
+
+test('order payload creation prefers existing place uuid over embedded place object', function () {
+    $order = fleetopsOrderPayloadResolutionProbe(true);
+
+    expect($order->shouldResolveForTest([
+        'pickup_uuid' => '628892cc-271c-89fd-cdaa-39d02b40bd13',
+        'pickup'      => [
+            'uuid'     => '628892cc-271c-89fd-cdaa-39d02b40bd13',
+            'location' => [
+                'bbox'        => [103.851, 1.2816, 103.851, 1.2816],
+                'type'        => 'Point',
+                'coordinates' => [103.851, 1.2816],
+            ],
+        ],
+    ], 'pickup'))->toBeFalse();
+});
+
+test('order payload creation resolves embedded place when no valid uuid exists', function () {
+    $order = fleetopsOrderPayloadResolutionProbe(false);
+
+    expect($order->shouldResolveForTest([
+        'pickup' => [
+            'location' => [
+                'bbox'        => [103.851, 1.2816, 103.851, 1.2816],
+                'type'        => 'Point',
+                'coordinates' => [103.851, 1.2816],
+            ],
+        ],
+    ], 'pickup'))->toBeTrue();
+});

package/server/tests/PointResolutionTest.php

@@ -0,0 +1,63 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\FleetOps\Support\Utils;
+
+function fleetopsBboxPoint(): array
+{
+    return [
+        'bbox'        => [103.851, 1.2816, 103.851, 1.2816],
+        'type'        => 'Point',
+        'coordinates' => [103.851, 1.2816],
+    ];
+}
+
+test('point resolution accepts GeoJSON point with bbox', function () {
+    $point = Utils::getPointFromMixed(fleetopsBboxPoint());
+
+    expect($point->getLat())->toBe(1.2816)
+        ->and($point->getLng())->toBe(103.851);
+});
+
+test('point resolution accepts feature wrapped GeoJSON point with bbox', function () {
+    $point = Utils::getPointFromMixed([
+        'type'     => 'Feature',
+        'geometry' => fleetopsBboxPoint(),
+    ]);
+
+    expect($point->getLat())->toBe(1.2816)
+        ->and($point->getLng())->toBe(103.851);
+});
+
+test('point resolution rejects malformed feature points cleanly', function () {
+    expect(fn () => Utils::getPointFromMixed([
+        'type'     => 'Feature',
+        'geometry' => [
+            'type'        => 'Point',
+            'coordinates' => [],
+        ],
+    ]))->toThrow(Exception::class, 'Attempted to resolve Point from invalid location.');
+});
+
+test('coordinate helper does not collapse bbox GeoJSON point to zero', function () {
+    $point = Utils::getPointFromCoordinates([
+        'type'     => 'Feature',
+        'geometry' => fleetopsBboxPoint(),
+    ]);
+
+    expect($point->getLat())->toBe(1.2816)
+        ->and($point->getLng())->toBe(103.851);
+});
+
+test('structured place normalization accepts bbox GeoJSON point locations', function () {
+    $place = Place::mergeStructuredPlaceAttributes([
+        'name'     => 'AI Pickup',
+        'street1'  => '16 Simon Walk',
+        'city'     => 'Singapore',
+        'country'  => 'SG',
+        'location' => fleetopsBboxPoint(),
+    ]);
+
+    expect($place['location']->getLat())->toBe(1.2816)
+        ->and($place['location']->getLng())->toBe(103.851);
+});

package/server/tests/PublicFleetOpsRestEndpointsTest.php

@@ -0,0 +1,191 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\DeviceController;
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\EquipmentController;
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\FuelTransactionController;
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\PartController;
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\SensorController;
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\WorkOrderController;
+use Fleetbase\FleetOps\Http\Resources\v1\Device;
+use Fleetbase\FleetOps\Http\Resources\v1\Equipment;
+use Fleetbase\FleetOps\Http\Resources\v1\FuelTransaction;
+use Fleetbase\FleetOps\Http\Resources\v1\Part;
+use Fleetbase\FleetOps\Http\Resources\v1\Sensor;
+use Fleetbase\FleetOps\Http\Resources\v1\WorkOrder;
+
+test('new first-class fleetops rest routes are registered in the consumable v1 namespace', function () {
+    $routes = file_get_contents(dirname(__DIR__) . '/src/routes.php');
+
+    foreach (['equipment', 'parts', 'work-orders', 'devices', 'sensors', 'fuel-transactions'] as $prefix) {
+        expect($routes)->toContain("\$router->group(['prefix' => '{$prefix}']");
+    }
+
+    expect($routes)
+        ->toContain('EquipmentController@create')
+        ->toContain('PartController@create')
+        ->toContain('WorkOrderController@send')
+        ->toContain('DeviceController@attach')
+        ->toContain('DeviceController@detach')
+        ->toContain('SensorController@create')
+        ->toContain('FuelTransactionController@matchVehicle')
+        ->toContain('FuelTransactionController@matchOrder')
+        ->toContain('FuelTransactionController@reprocess')
+        ->toContain('FuelTransactionController@review');
+});
+
+test('public fuel transaction api keeps provider naming internal only', function () {
+    $publicRoutes = file_get_contents(dirname(__DIR__) . '/src/routes.php');
+    $publicGroup  = substr($publicRoutes, 0, strpos($publicRoutes, 'Internal FleetOps API Routes'));
+    $controller   = file_get_contents(dirname(__DIR__) . '/src/Http/Controllers/Api/v1/FuelTransactionController.php');
+
+    expect($publicGroup)
+        ->toContain("['prefix' => 'fuel-transactions']")
+        ->not->toContain("['prefix' => 'fuel-provider-transactions']")
+        ->and($controller)
+        ->toContain('class FuelTransactionController')
+        ->toContain('FuelProviderTransaction')
+        ->toContain("'FuelTransaction resource not found.'");
+});
+
+test('new public controllers expose the expected rest methods', function () {
+    $controllers = [
+        EquipmentController::class       => ['create', 'query', 'find', 'update', 'delete'],
+        PartController::class            => ['create', 'query', 'find', 'update', 'delete'],
+        WorkOrderController::class       => ['create', 'query', 'find', 'update', 'delete', 'send'],
+        DeviceController::class          => ['create', 'query', 'find', 'update', 'delete', 'attach', 'detach'],
+        SensorController::class          => ['create', 'query', 'find', 'update', 'delete'],
+        FuelTransactionController::class => ['create', 'query', 'find', 'update', 'delete', 'matchVehicle', 'matchOrder', 'reprocess', 'review'],
+    ];
+
+    foreach ($controllers as $controller => $methods) {
+        foreach ($methods as $method) {
+            expect(method_exists($controller, $method))->toBeTrue("{$controller}::{$method} missing");
+        }
+    }
+});
+
+test('new public resources preserve internal uuid fields behind internal request checks', function () {
+    foreach ([Equipment::class, Part::class, WorkOrder::class, Device::class, Sensor::class, FuelTransaction::class] as $resource) {
+        expect(class_exists($resource))->toBeTrue();
+    }
+
+    $internalFields = [
+        'Equipment.php'       => ['uuid', 'company_uuid', 'warranty_uuid', 'photo_uuid', 'equipable_uuid'],
+        'Part.php'            => ['uuid', 'company_uuid', 'vendor_uuid', 'warranty_uuid', 'photo_uuid', 'asset_uuid'],
+        'Device.php'          => ['uuid', 'company_uuid', 'telematic_uuid', 'attachable_uuid', 'warranty_uuid', 'photo_uuid'],
+        'Sensor.php'          => ['uuid', 'company_uuid', 'device_uuid', 'warranty_uuid', 'telematic_uuid', 'photo_uuid', 'sensorable_uuid'],
+        'FuelTransaction.php' => ['uuid', 'fuel_provider_connection_uuid', 'fuel_report_uuid', 'vehicle_uuid', 'driver_uuid', 'order_uuid'],
+        'WorkOrder.php'       => ['uuid', 'company_uuid', 'schedule_uuid', 'created_by_uuid', 'updated_by_uuid', 'target_uuid', 'assignee_uuid'],
+    ];
+
+    foreach ($internalFields as $resourceFile => $fields) {
+        $source = file_get_contents(dirname(__DIR__) . '/src/Http/Resources/v1/' . $resourceFile);
+
+        expect($source)->toContain("'id'");
+
+        foreach ($fields as $field) {
+            expect($source)
+                ->toContain("'{$field}'")
+                ->toMatch("/'{$field}'\\s*=>\\s*\\\$this->when\\(Http::isInternalRequest\\(\\)/");
+        }
+    }
+});
+
+test('new shared resources do not expose unguarded uuid fields', function () {
+    foreach ([
+        'Equipment.php',
+        'Part.php',
+        'Device.php',
+        'Sensor.php',
+        'FuelTransaction.php',
+        'WorkOrder.php',
+    ] as $resourceFile) {
+        $source = file_get_contents(dirname(__DIR__) . '/src/Http/Resources/v1/' . $resourceFile);
+
+        preg_match_all("/'([^']*uuid)'\\s*=>\\s*([^,\\n]+)/i", $source, $matches, PREG_SET_ORDER);
+
+        foreach ($matches as $match) {
+            expect($match[2])->toContain('Http::isInternalRequest()');
+        }
+    }
+});
+
+test('new shared resources preserve public and internal relationship shapes', function () {
+    foreach ([
+        'Equipment.php',
+        'Part.php',
+        'Device.php',
+        'Sensor.php',
+        'FuelTransaction.php',
+    ] as $resourceFile) {
+        $source = file_get_contents(dirname(__DIR__) . '/src/Http/Resources/v1/' . $resourceFile);
+
+        expect($source)
+            ->toContain('resolveLoadedRelation')
+            ->toContain('Resolve::httpResourceForModel($model)')
+            ->toContain('$model->public_id');
+    }
+});
+
+test('new public resolver rejects uuid lookup while preserving public and internal identifiers', function () {
+    $resolver = file_get_contents(dirname(__DIR__) . '/src/Http/Controllers/Api/v1/Concerns/ResolvesFleetOpsApiResources.php');
+
+    expect($resolver)
+        ->not->toContain("where('uuid', \$id)")
+        ->not->toContain("orWhere('uuid', \$id)")
+        ->toContain("orWhere('public_id', \$id)")
+        ->toContain("orWhere('internal_id', \$id)")
+        ->toContain('rejectUuidIdentifiers')
+        ->toContain('Use public_id or internal_id values instead');
+});
+
+test('public controllers reject uuid shaped request keys', function () {
+    foreach ([
+        'EquipmentController.php',
+        'PartController.php',
+        'WorkOrderController.php',
+        'DeviceController.php',
+        'SensorController.php',
+        'FuelTransactionController.php',
+    ] as $controllerFile) {
+        $source = file_get_contents(dirname(__DIR__) . '/src/Http/Controllers/Api/v1/' . $controllerFile);
+
+        expect($source)->toContain('rejectUuidIdentifiers($request)');
+    }
+});
+
+test('new public list endpoints have company scoped filters', function () {
+    foreach ([
+        'EquipmentFilter.php',
+        'PartFilter.php',
+        'WorkOrderFilter.php',
+        'DeviceFilter.php',
+        'SensorFilter.php',
+        'FuelProviderTransactionFilter.php',
+    ] as $filterFile) {
+        $source = file_get_contents(dirname(__DIR__) . '/src/Http/Filter/' . $filterFile);
+
+        expect($source)
+            ->toContain('public function queryForPublic()')
+            ->toContain("where('company_uuid', \$this->session->get('company'))");
+    }
+});
+
+test('fuel transaction filter applies public company scoping and public id relation filters without raw uuid matching', function () {
+    $filter = file_get_contents(dirname(__DIR__) . '/src/Http/Filter/FuelProviderTransactionFilter.php');
+
+    expect($filter)
+        ->toContain('public function queryForPublic()')
+        ->toContain('$this->queryForInternal();')
+        ->toContain('public function vehicle(?string $vehicle)')
+        ->toContain('public function driver(?string $driver)')
+        ->toContain('public function order(?string $order)')
+        ->toContain('public function fuelReport(?string $fuelReport)')
+        ->toContain("where('public_id', \$identifier)")
+        ->toContain("orWhere('internal_id', \$identifier)")
+        ->toContain('if ($allowUuid)')
+        ->not->toContain("where('vehicle_uuid', \$vehicle)")
+        ->not->toContain("where('driver_uuid', \$driver)")
+        ->not->toContain("where('order_uuid', \$order)")
+        ->not->toContain("where('fuel_report_uuid', \$fuelReport)");
+});