@fleetbase/fleetops-engine 0.6.19 → 0.6.21

package/server/src/Http/Controllers/Internal/v1/OrderController.php

@@ -774,55 +774,30 @@ class OrderController extends FleetOpsController
     }
 
     /**
-     * Retrieve all distinct order statuses for the authenticated company.
-     *
-     * This endpoint compiles:
-     * 1. All unique `status` values from the `orders` table for the current company.
-     * 2. Optionally, all `Activity` codes defined in `OrderConfig` records that are
-     *    actually referenced by existing orders (via `order_config_uuid`).
-     *
-     * ---
-     * ### Query Parameters
-     * - `include_order_config_activities` (bool, optional)
-     *   When true, includes `Activity` codes from relevant `OrderConfig` instances.
-     *
-     * - `order_config_key` (string, optional)
-     *   Restricts both `orders` and `order_configs` to a specific configuration key.
-     *
-     * ---
-     * ### Behavior
-     * - Only includes order configs that are actually used by orders.
-     * - Uses the `activities()` method on each `OrderConfig` to extract all activity codes.
-     * - Merges and deduplicates both order statuses and activity codes.
-     *
-     * ---
-     * ### Example Response
-     * ```json
-     * [
-     *   "created",
-     *   "dispatched",
-     *   "completed",
-     *   "canceled",
-     *   "pickup_ready",
-     *   "awaiting_payment"
-     * ]
-     * ```
-     *
-     * @return \Illuminate\Http\JsonResponse
+     * Return distinct order statuses (and optionally activity codes) for a company,
+     * filtered by order_config_uuid or order_config_key if provided.
      */
     public function statuses(Request $request)
     {
-        $companyUuid = $request->user()->company_uuid ?? session('company');
-
+        $companyUuid       = $request->user()->company_uuid ?? session('company');
         $includeActivities = $request->boolean('include_order_config_activities', true);
-        $orderConfigKey    = trim((string) $request->string('order_config_key'));
 
-        // Get distinct statuses from orders
+        // Use input() + trim to get plain strings (Request::string() returns Stringable in newer Laravel)
+        $orderConfigKey = trim((string) $request->input('order_config_key', ''));
+        $orderConfigId  = trim((string) $request->input('order_config_uuid', ''));
+
+        // ---------------------------
+        // Build base orders query
+        // ---------------------------
         $ordersQuery = DB::table('orders')
             ->where('company_uuid', $companyUuid)
-            ->whereNotNull('status');
+            ->whereNotNull('status')
+            ->whereNull('deleted_at');
 
-        if ($orderConfigKey !== '') {
+        // Prefer filtering by UUID (most precise), else by key
+        if ($orderConfigId !== '') {
+            $ordersQuery->where('order_config_uuid', $orderConfigId);
+        } elseif ($orderConfigKey !== '') {
             $ordersQuery->whereExists(function ($q) use ($companyUuid, $orderConfigKey) {
                 $q->select(DB::raw(1))
                   ->from('order_configs as oc')
@@ -832,34 +807,38 @@ class OrderController extends FleetOpsController
             });
         }
 
+        // Distinct order statuses
         $orderStatuses = $ordersQuery->distinct()->pluck('status')->filter();
 
-        // Optionally include activity codes from used order configs
+        // ---------------------------------------
+        // Optionally include activity codes
+        // (must use the SAME target config set)
+        // ---------------------------------------
         $activityCodes = collect();
 
         if ($includeActivities) {
-            $configUuidsOnOrders = DB::table('orders')
-                ->where('company_uuid', $companyUuid)
-                ->when($orderConfigKey !== '', function ($q) use ($companyUuid, $orderConfigKey) {
-                    $q->whereExists(function ($sub) use ($companyUuid, $orderConfigKey) {
-                        $sub->select(DB::raw(1))
-                            ->from('order_configs as oc')
-                            ->whereColumn('oc.uuid', 'orders.order_config_uuid')
-                            ->where('oc.company_uuid', $companyUuid)
-                            ->where('oc.key', $orderConfigKey);
-                    });
-                })
-                ->whereNotNull('order_config_uuid')
-                ->distinct()
-                ->pluck('order_config_uuid')
-                ->filter();
+            // Determine target config UUIDs once, honoring UUID > key > all-on-company
+            if ($orderConfigId !== '') {
+                $targetConfigUuids = collect([$orderConfigId]);
+            } elseif ($orderConfigKey !== '') {
+                $targetConfigUuids = DB::table('order_configs')
+                    ->where('company_uuid', $companyUuid)
+                    ->where('key', $orderConfigKey)
+                    ->pluck('uuid');
+            } else {
+                // No filter given; derive from orders in this company
+                $targetConfigUuids = DB::table('orders')
+                    ->where('company_uuid', $companyUuid)
+                    ->whereNotNull('order_config_uuid')
+                    ->distinct()
+                    ->pluck('order_config_uuid');
+            }
 
-            if ($configUuidsOnOrders->isNotEmpty()) {
+            if ($targetConfigUuids->isNotEmpty()) {
                 $orderConfigs = OrderConfig::where('company_uuid', $companyUuid)
-                    ->whereIn('uuid', $configUuidsOnOrders)
+                    ->whereIn('uuid', $targetConfigUuids)
                     ->get();
 
-                /** @var OrderConfig $config */
                 foreach ($orderConfigs as $config) {
                     if (!method_exists($config, 'activities')) {
                         continue;
@@ -867,19 +846,22 @@ class OrderController extends FleetOpsController
 
                     $activities = $config->activities();
 
-                    if ($activities instanceof Collection) {
-                        $codes = $activities
-                            ->map(fn ($activity) => $activity->code ?? null)
-                            ->filter()
-                            ->values();
+                    // Handle Collection/array gracefully
+                    $codes = collect($activities)
+                        ->map(function ($activity) {
+                            return data_get($activity, 'code');
+                        })
+                        ->filter()
+                        ->values();
 
-                        $activityCodes = $activityCodes->merge($codes);
-                    }
+                    $activityCodes = $activityCodes->merge($codes);
                 }
             }
         }
 
-        // Merge & deduplicate everything
+        // ---------------------------------------
+        // Merge & return
+        // ---------------------------------------
         $result = $orderStatuses
             ->merge($activityCodes)
             ->unique()

package/server/src/Http/Controllers/Internal/v1/PositionController.php

@@ -0,0 +1,240 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
+
+use Fleetbase\FleetOps\Http\Controllers\FleetOpsController;
+use Fleetbase\FleetOps\Jobs\ReplayPositions;
+use Fleetbase\FleetOps\Models\Position;
+use Fleetbase\FleetOps\Support\Utils;
+use Illuminate\Http\Request;
+
+class PositionController extends FleetOpsController
+{
+    /**
+     * The resource to query.
+     *
+     * @var string
+     */
+    public $resource = 'position';
+
+    /**
+     * Replay positions on a custom channel.
+     *
+     * @return \Illuminate\Http\Response
+     */
+    public function replay(Request $request)
+    {
+        $positionIds = $request->input('position_ids', []);
+        $channelId   = $request->input('channel_id');
+        $speed       = max((float) $request->input('speed', 1), 0.1); // avoid division by zero
+        $subjectUuid = $request->input('subject_uuid');
+
+        if (!$channelId) {
+            return response()->error('Channel ID is required');
+        }
+
+        if (empty($positionIds)) {
+            return response()->error('Position IDs are required');
+        }
+
+        $positions = Position::whereIn('uuid', $positionIds)
+            ->where('company_uuid', session('company'))
+            ->orderBy('created_at')
+            ->get();
+
+        if ($positions->isEmpty()) {
+            return response()->error('No positions found');
+        }
+
+        // Dispatch async job (will handle replay logic)
+        ReplayPositions::dispatch($positions, $channelId, $speed, $subjectUuid);
+
+        return response()->json([
+            'status'          => 'ok',
+            'message'         => 'Replay started',
+            'channel_id'      => $channelId,
+            'total_positions' => $positions->count(),
+        ]);
+    }
+
+    /**
+     * Get position statistics/metrics.
+     *
+     * @return \Illuminate\Http\Response
+     */
+    public function metrics(Request $request)
+    {
+        $positionIds = $request->input('position_ids', []);
+
+        if (empty($positionIds)) {
+            return response()->error('Position IDs are required');
+        }
+
+        $positions = Position::whereIn('uuid', $positionIds)
+            ->where('company_uuid', session('company'))
+            ->orderBy('created_at', 'asc')
+            ->get();
+
+        if ($positions->isEmpty()) {
+            return response()->json([
+                'metrics' => [],
+            ]);
+        }
+
+        // Calculate metrics
+        $metrics = $this->calculateMetrics($positions);
+
+        return response()->json([
+            'metrics' => $metrics,
+        ]);
+    }
+
+    /**
+     * Calculate metrics from positions.
+     *
+     * @param \Illuminate\Support\Collection $positions
+     *
+     * @return array
+     */
+    private function calculateMetrics($positions)
+    {
+        $totalDistance         = 0;
+        $maxSpeed              = 0;
+        $avgSpeed              = 0;
+        $speedingEvents        = [];
+        $dwellTimes            = [];
+        $accelerationEvents    = [];
+        $speedLimit            = 100; // km/h - configurable
+        $dwellThreshold        = 300; // 5 minutes in seconds
+        $accelerationThreshold = 2.5; // m/s²
+
+        $previousPosition = null;
+        $previousSpeed    = null;
+        $dwellStart       = null;
+
+        foreach ($positions as $index => $position) {
+            $speed = $position->speed ?? 0;
+
+            // Track max speed
+            if ($speed > $maxSpeed) {
+                $maxSpeed = $speed;
+            }
+
+            // Check for speeding (convert m/s to km/h)
+            $speedKmh = $speed * 3.6;
+            if ($speedKmh > $speedLimit) {
+                $speedingEvents[] = [
+                    'position_uuid' => $position->uuid,
+                    'speed'         => round($speedKmh, 2),
+                    'timestamp'     => $position->created_at->toDateTimeString(),
+                ];
+            }
+
+            // Calculate distance and dwell time
+            if ($previousPosition) {
+                // Calculate distance using Haversine formula
+                // $distance = $this->calculateDistance($previousPosition, $position);
+                $distance = Utils::vincentyGreatCircleDistance($previousPosition->coordinates, $position->coordinates);
+                // dd($previousPosition, $position, $distance);
+                $totalDistance += $distance;
+
+                // Check for dwell (low speed or no movement)
+                if ($speed < 0.5) { // Less than 0.5 m/s
+                    if ($dwellStart === null) {
+                        $dwellStart = $previousPosition->created_at;
+                    }
+                } else {
+                    if ($dwellStart !== null) {
+                        $dwellDuration = $previousPosition->created_at->diffInSeconds($dwellStart);
+                        if ($dwellDuration >= $dwellThreshold) {
+                            $dwellTimes[] = [
+                                'start'    => $dwellStart->toDateTimeString(),
+                                'end'      => $previousPosition->created_at->toDateTimeString(),
+                                'duration' => $dwellDuration,
+                            ];
+                        }
+                        $dwellStart = null;
+                    }
+                }
+
+                // Calculate acceleration
+                if ($previousSpeed !== null) {
+                    $timeDiff = $position->created_at->diffInSeconds($previousPosition->created_at);
+                    if ($timeDiff > 0) {
+                        $acceleration = abs($speed - $previousSpeed) / $timeDiff;
+                        if ($acceleration > $accelerationThreshold) {
+                            $accelerationEvents[] = [
+                                'position_uuid' => $position->uuid,
+                                'acceleration'  => round($acceleration, 2),
+                                'type'          => $speed > $previousSpeed ? 'acceleration' : 'deceleration',
+                                'timestamp'     => $position->created_at->toDateTimeString(),
+                            ];
+                        }
+                    }
+                }
+            }
+
+            $previousPosition = $position;
+            $previousSpeed    = $speed;
+        }
+
+        // Calculate average speed
+        $speeds   = $positions->pluck('speed')->filter()->toArray();
+        $avgSpeed = count($speeds) > 0 ? array_sum($speeds) / count($speeds) : 0;
+
+        // Calculate total duration
+        $firstPosition = $positions->first();
+        $lastPosition  = $positions->last();
+        $totalDuration = $lastPosition->created_at->diffInSeconds($firstPosition->created_at);
+
+        return [
+            'total_distance'      => round($totalDistance / 1000, 2), // Convert to km
+            'total_duration'      => $totalDuration, // seconds
+            'max_speed'           => round($maxSpeed * 3.6, 2), // km/h
+            'avg_speed'           => round($avgSpeed * 3.6, 2), // km/h
+            'speeding_events'     => $speedingEvents,
+            'speeding_count'      => count($speedingEvents),
+            'dwell_times'         => $dwellTimes,
+            'dwell_count'         => count($dwellTimes),
+            'acceleration_events' => $accelerationEvents,
+            'acceleration_count'  => count($accelerationEvents),
+            'total_positions'     => $positions->count(),
+        ];
+    }
+
+    /**
+     * Calculate distance between two positions using Haversine formula.
+     *
+     * @param Position $pos1
+     * @param Position $pos2
+     *
+     * @return float Distance in meters
+     */
+    private function calculateDistance($pos1, $pos2)
+    {
+        $coords1 = [$pos1->latitude, $pos1->longitude];
+        $coords2 = [$pos2->latitude, $pos2->longitude];
+
+        if (!isset($coords1[0]) || !isset($coords2[0]) || !isset($coords1[1]) || !isset($coords2[1])) {
+            return 0;
+        }
+
+        $lat1 = deg2rad($coords1[0]);
+        $lon1 = deg2rad($coords1[1]);
+        $lat2 = deg2rad($coords2[0]);
+        $lon2 = deg2rad($coords2[1]);
+
+        $earthRadius = 6371000; // meters
+
+        $dLat = $lat2 - $lat1;
+        $dLon = $lon2 - $lon1;
+
+        $a = sin($dLat / 2) * sin($dLat / 2) +
+            cos($lat1) * cos($lat2) *
+            sin($dLon / 2) * sin($dLon / 2);
+
+        $c = 2 * atan2(sqrt($a), sqrt(1 - $a));
+
+        return $earthRadius * $c;
+    }
+}

package/server/src/Http/Controllers/Internal/v1/SensorController.php

@@ -12,4 +12,15 @@ class SensorController extends FleetOpsController
      * @var string
      */
     public $resource = 'sensor';
+
+    /**
+     * Query callback when querying record.
+     *
+     * @param \Illuminate\Database\Query\Builder $query
+     * @param Request                            $request
+     */
+    public static function onQueryRecord($query, $request): void
+    {
+        $query->with(['telematic', 'warranty']);
+    }
 }

package/server/src/Http/Controllers/Internal/v1/TelematicController.php

@@ -3,6 +3,11 @@
 namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
 
 use Fleetbase\FleetOps\Http\Controllers\FleetOpsController;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Support\Telematics\TelematicProviderRegistry;
+use Fleetbase\FleetOps\Support\Telematics\TelematicService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
 
 class TelematicController extends FleetOpsController
 {
@@ -12,4 +17,140 @@ class TelematicController extends FleetOpsController
      * @var string
      */
     public $resource = 'telematic';
+
+    protected TelematicService $telematicService;
+    protected TelematicProviderRegistry $registry;
+
+    public function __construct(TelematicService $service, TelematicProviderRegistry $registry)
+    {
+        parent::__construct();
+        $this->telematicService  = $service;
+        $this->registry          = $registry;
+    }
+
+    /**
+     * Query callback when querying record.
+     *
+     * @param \Illuminate\Database\Query\Builder $query
+     * @param Request                            $request
+     */
+    public static function onQueryRecord($query, $request): void
+    {
+        $query->with(['warranty']);
+    }
+
+    /**
+     * List available providers.
+     */
+    public function providers(): JsonResponse
+    {
+        $providers = $this->registry->all()->map(fn ($p) => $p->toArray());
+
+        return response()->json($providers->values());
+    }
+
+    /**
+     * Test connection to provider.
+     */
+    public function testConnection(Request $request, string $id): JsonResponse
+    {
+        $telematic = Telematic::where('uuid', $id)
+            ->where('company_uuid', session('company'))
+            ->firstOrFail();
+
+        $async = $request->input('async', false);
+
+        $result = $this->telematicService->testConnection($telematic, $async);
+
+        if ($async) {
+            return response()->json($result, 202);
+        }
+
+        return response()->json($result);
+    }
+
+    /**
+     * Test connection to provider.
+     */
+    public function testCredentials(Request $request, string $key): JsonResponse
+    {
+        $credentials = $request->array('credentials', []);
+        $async       = $request->input('async', false);
+
+        try {
+            $provider = $this->registry->resolve($key);
+            if (!$provider) {
+                return response()->error('Unable to resolve telematic provider.');
+            }
+            $result   = $provider->testConnection($credentials);
+        } catch (\Exception $e) {
+            return response()->error($e->getMessage());
+        }
+
+        if ($async) {
+            return response()->json($result, 202);
+        }
+
+        return response()->json($result);
+    }
+
+    /**
+     * Discover devices from provider.
+     */
+    public function discover(Request $request, string $id): JsonResponse
+    {
+        $telematic = Telematic::where('uuid', $id)
+            ->where('company_uuid', session('company'))
+            ->firstOrFail();
+
+        $jobId = $this->telematicService->discoverDevices($telematic, [
+            'limit'   => $request->input('limit', 100),
+            'filters' => $request->input('filters', []),
+        ]);
+
+        return response()->json([
+            'job_id'  => $jobId,
+            'message' => 'Device discovery initiated',
+        ], 202);
+    }
+
+    /**
+     * Get devices for a telematic.
+     */
+    public function devices(Request $request, string $id): JsonResponse
+    {
+        $telematic = Telematic::where('uuid', $id)
+            ->where('company_uuid', session('company'))
+            ->firstOrFail();
+
+        $devices = $this->telematicService->getDevices($telematic, [
+            'status' => $request->input('status'),
+            'search' => $request->input('search'),
+        ]);
+
+        return response()->json([
+            'data' => $devices,
+        ]);
+    }
+
+    /**
+     * Link a device to a telematic.
+     */
+    public function linkDevice(Request $request, string $id): JsonResponse
+    {
+        $telematic = Telematic::where('uuid', $id)
+            ->where('company_uuid', session('company'))
+            ->firstOrFail();
+
+        $request->validate([
+            'external_id' => 'required|string',
+            'device_name' => 'required|string',
+        ]);
+
+        $device = $this->telematicService->linkDevice($telematic, $request->all());
+
+        return response()->json([
+            'device' => $device,
+        ], 201);
+    }
 }