@fleetbase/fleetops-engine 0.6.20 → 0.6.21

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

@@ -12,4 +12,26 @@ class DeviceController extends FleetOpsController
      * @var string
      */
     public $resource = 'device';
+
+    /**
+     * 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']);
+    }
+
+    /**
+     * Query callback when finding record.
+     *
+     * @param \Illuminate\Database\Query\Builder $query
+     * @param Request                            $request
+     */
+    public static function onFindRecord($query, $request): void
+    {
+        $query->with(['telematic', 'warranty']);
+    }
 }

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

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

@@ -0,0 +1,170 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers;
+
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Support\Telematics\TelematicProviderRegistry;
+use Fleetbase\FleetOps\Support\Telematics\TelematicService;
+use Fleetbase\Support\IdempotencyManager;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Str;
+
+/**
+ * Class TelematicWebhookController.
+ *
+ * Handles webhook ingestion from telematics providers.
+ */
+class TelematicWebhookController extends Controller
+{
+    protected TelematicProviderRegistry $registry;
+    protected TelematicService $service;
+    protected IdempotencyManager $idempotency;
+
+    public function __construct(
+        TelematicProviderRegistry $registry,
+        TelematicService $service,
+        IdempotencyManager $idempotency,
+    ) {
+        $this->registry    = $registry;
+        $this->service     = $service;
+        $this->idempotency = $idempotency;
+    }
+
+    /**
+     * Handle provider webhook.
+     */
+    public function handle(Request $request, string $providerKey): JsonResponse
+    {
+        $correlationId = Str::uuid()->toString();
+
+        Log::info('Webhook received', [
+            'correlation_id' => $correlationId,
+            'provider'       => $providerKey,
+            'headers'        => $request->headers->all(),
+        ]);
+
+        // Check idempotency
+        $idempotencyKey = $request->header('X-Idempotency-Key');
+        if ($idempotencyKey && $this->idempotency->isDuplicate($idempotencyKey)) {
+            Log::info('Duplicate webhook detected', [
+                'correlation_id'  => $correlationId,
+                'idempotency_key' => $idempotencyKey,
+            ]);
+
+            return response()->json(['status' => 'duplicate'], 200);
+        }
+
+        // Get provider
+        $provider = $this->registry->resolve($providerKey);
+
+        // Find telematic for this provider
+        $telematic = Telematic::where('provider', $providerKey)->first();
+
+        if (!$telematic) {
+            Log::warning('No telematic found for provider', [
+                'correlation_id' => $correlationId,
+                'provider'       => $providerKey,
+            ]);
+
+            return response()->json(['error' => 'No telematic configured'], 404);
+        }
+
+        // Validate signature
+        $signature   = $request->header('X-Webhook-Signature');
+        $credentials = $this->service->getCredentials($telematic);
+
+        if ($signature && !$provider->validateWebhookSignature($request->getContent(), $signature, $credentials)) {
+            Log::warning('Invalid webhook signature', [
+                'correlation_id' => $correlationId,
+                'provider'       => $providerKey,
+            ]);
+
+            return response()->json(['error' => 'Invalid signature'], 403);
+        }
+
+        // Process webhook
+        try {
+            $result = $provider->processWebhook($request->all(), $request->headers->all());
+
+            // Link devices
+            foreach ($result['devices'] as $deviceData) {
+                $this->service->linkDevice($telematic, $deviceData);
+            }
+
+            // Store events (TODO: implement event storage)
+            // Store sensors (TODO: implement sensor storage)
+
+            // Mark as processed
+            if ($idempotencyKey) {
+                $this->idempotency->markProcessed($idempotencyKey);
+            }
+
+            Log::info('Webhook processed successfully', [
+                'correlation_id' => $correlationId,
+                'devices_count'  => count($result['devices']),
+                'events_count'   => count($result['events']),
+            ]);
+
+            return response()->json(['status' => 'processed'], 200);
+        } catch (\Exception $e) {
+            Log::error('Webhook processing failed', [
+                'correlation_id' => $correlationId,
+                'error'          => $e->getMessage(),
+            ]);
+
+            return response()->json(['error' => 'Processing failed'], 500);
+        }
+    }
+
+    /**
+     * Handle custom provider ingest.
+     */
+    public function ingest(Request $request, string $id): JsonResponse
+    {
+        $telematic = Telematic::where('uuid', $id)->firstOrFail();
+
+        $correlationId = Str::uuid()->toString();
+
+        Log::info('Custom ingest received', [
+            'correlation_id' => $correlationId,
+            'telematic_uuid' => $id,
+        ]);
+
+        // Check idempotency
+        $idempotencyKey = $request->header('X-Idempotency-Key');
+        if ($idempotencyKey && $this->idempotency->isDuplicate($idempotencyKey)) {
+            return response()->json(['status' => 'duplicate'], 200);
+        }
+
+        try {
+            // Process devices
+            if ($request->has('devices')) {
+                foreach ($request->input('devices') as $deviceData) {
+                    $this->service->linkDevice($telematic, $deviceData);
+                }
+            }
+
+            // Mark as processed
+            if ($idempotencyKey) {
+                $this->idempotency->markProcessed($idempotencyKey);
+            }
+
+            Log::info('Custom ingest processed', [
+                'correlation_id' => $correlationId,
+                'devices_count'  => count($request->input('devices', [])),
+            ]);
+
+            return response()->json(['status' => 'ingested'], 200);
+        } catch (\Exception $e) {
+            Log::error('Custom ingest failed', [
+                'correlation_id' => $correlationId,
+                'error'          => $e->getMessage(),
+            ]);
+
+            return response()->json(['error' => 'Ingest failed'], 500);
+        }
+    }
+}

package/server/src/Http/Filter/DeviceEventFilter.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Http\Filter\Filter;
+
+class DeviceEventFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder->where(
+            function ($query) {
+                $query->where('company_uuid', $this->session->get('company'));
+            }
+        );
+    }
+
+    public function queryForPublic()
+    {
+        $this->builder->where('company_uuid', $this->session->get('company'));
+    }
+
+    public function query(?string $searchQuery)
+    {
+        $this->builder->search($searchQuery);
+    }
+
+    public function telematic(?string $telematic)
+    {
+        $this->builder->whereHas('device', function ($query) use ($telematic) {
+            $query->whereHas('telematic', function ($query) use ($telematic) {
+                $query->where('uuid', $telematic);
+                $query->orWhere('public_id', $telematic);
+            });
+        });
+    }
+
+    public function device(?string $device)
+    {
+        $this->builder->whereHas('device', function ($query) use ($device) {
+            $query->where('uuid', $device);
+            $query->orWhere('public_id', $device);
+        });
+    }
+
+    public function createdAt($createdAt)
+    {
+        $createdAt = Utils::dateRange($createdAt);
+
+        if (is_array($createdAt)) {
+            $this->builder->whereBetween('created_at', $createdAt);
+        } else {
+            $this->builder->whereDate('created_at', $createdAt);
+        }
+    }
+
+    public function updatedAt($updatedAt)
+    {
+        $updatedAt = Utils::dateRange($updatedAt);
+
+        if (is_array($updatedAt)) {
+            $this->builder->whereBetween('updated_at', $updatedAt);
+        } else {
+            $this->builder->whereDate('updated_at', $updatedAt);
+        }
+    }
+}