@fleetbase/fleetops-engine 0.6.54 → 0.6.56

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/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)");
+});

package/server/tests/ServiceRateRouteValidationTest.php

@@ -0,0 +1,101 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\ServiceRateController;
+use Illuminate\Http\Request;
+use Illuminate\Support\Collection;
+
+function fleetopsServiceRateRouteRequest(array $query = []): Request
+{
+    $request = Request::create('/int/v1/service-rates/for-route', 'GET', $query);
+    $session = app('session.store');
+    $session->put('company', 'company_test');
+    $request->setLaravelSession($session);
+
+    return $request;
+}
+
+function fleetopsServiceRateRouteController()
+{
+    return new class extends ServiceRateController {
+        public ?Collection $waypoints  = null;
+        public ?Closure $queryCallback = null;
+
+        protected function getServicableForWaypoints(Collection $waypoints, Closure $queryCallback): array
+        {
+            $this->waypoints     = $waypoints;
+            $this->queryCallback = $queryCallback;
+
+            return [['id' => 'service_rate_test']];
+        }
+    };
+}
+
+test('service rates for route requires coordinates', function ($query) {
+    $response = fleetopsServiceRateRouteController()->getServicesForRoute(fleetopsServiceRateRouteRequest($query));
+
+    expect($response->getStatusCode())->toBe(422);
+})->with([
+    'missing coordinates' => [[]],
+    'empty coordinates'   => [['coordinates' => '']],
+]);
+
+test('service rates for route requires at least two coordinates', function () {
+    $response = fleetopsServiceRateRouteController()->getServicesForRoute(fleetopsServiceRateRouteRequest([
+        'coordinates' => '1.3621663,103.8845049',
+    ]));
+
+    expect($response->getStatusCode())->toBe(422);
+});
+
+test('service rates for route rejects malformed coordinates', function ($coordinates) {
+    $response = fleetopsServiceRateRouteController()->getServicesForRoute(fleetopsServiceRateRouteRequest([
+        'coordinates' => $coordinates,
+    ]));
+
+    expect($response->getStatusCode())->toBe(422);
+})->with([
+    'missing longitude' => ['1.3621663;1.353151,103.86458'],
+    'missing latitude'  => [',103.8845049;1.353151,103.86458'],
+    'blank segment'     => ['1.3621663,103.8845049;;1.353151,103.86458'],
+    'non numeric'       => ['north,103.8845049;1.353151,103.86458'],
+]);
+
+test('service rates for route converts coordinate pairs to waypoints', function () {
+    $controller = fleetopsServiceRateRouteController();
+    $response   = $controller->getServicesForRoute(fleetopsServiceRateRouteRequest([
+        'coordinates'  => '1.3621663,103.8845049;1.353151,103.86458',
+        'service_type' => 'delivery',
+    ]));
+
+    expect($response->getStatusCode())->toBe(200)
+        ->and($controller->waypoints)->toHaveCount(2)
+        ->and($controller->waypoints->first()->x())->toBe(103.8845049)
+        ->and($controller->waypoints->first()->y())->toBe(1.3621663);
+});
+
+test('service rates for route ignores placeholder service type values', function ($serviceType) {
+    $controller = fleetopsServiceRateRouteController();
+    $controller->getServicesForRoute(fleetopsServiceRateRouteRequest([
+        'coordinates'  => '1.3621663,103.8845049;1.353151,103.86458',
+        'service_type' => $serviceType,
+    ]));
+
+    $query = new class {
+        public array $wheres = [];
+
+        public function where($column, $value)
+        {
+            $this->wheres[] = [$column, $value];
+
+            return $this;
+        }
+    };
+
+    ($controller->queryCallback)($query);
+
+    expect($query->wheres)->toBe([['company_uuid', 'company_test']]);
+})->with([
+    'undefined' => ['undefined'],
+    'null'      => ['null'],
+    'empty'     => [''],
+]);