@fleetbase/fleetops-engine 0.6.19 → 0.6.21

package/server/src/Console/Commands/ReplayVehicleLocations.php

@@ -0,0 +1,225 @@
+<?php
+
+namespace Fleetbase\FleetOps\Console\Commands;
+
+use Carbon\Carbon;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\Support\SocketCluster\SocketClusterService;
+use Illuminate\Console\Command;
+
+class ReplayVehicleLocations extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'vehicle:replay-locations 
+                            {file : Path to the JSON file containing vehicle location data}
+                            {--speed=1 : Speed multiplier for replay (1 = real-time, 2 = 2x speed, 0.5 = half speed)}
+                            {--vehicle= : Filter by specific vehicle ID (optional)}
+                            {--limit= : Limit the number of events to process (optional)}
+                            {--sleep= : Set a manual sleep for replay (in seconds)}
+                            {--skip-sleep : Skip sleep delays and send all events immediately}';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Replay vehicle location events from JSON file with timing simulation via SocketCluster';
+
+    /**
+     * Execute the console command.
+     *
+     * @return int
+     */
+    public function handle()
+    {
+        $filePath        = $this->argument('file');
+        $speedMultiplier = (float) $this->option('speed');
+        $vehicleFilter   = $this->option('vehicle');
+        $limit           = $this->option('limit') ? (int) $this->option('limit') : null;
+        $skipSleep       = $this->option('skip-sleep');
+        $sleep           = $this->option('sleep') ? (int) $this->option('sleep') : null;
+
+        // Validate file exists
+        if (!file_exists($filePath)) {
+            $this->error("File not found: {$filePath}");
+
+            return Command::FAILURE;
+        }
+
+        // Validate speed multiplier
+        if ($speedMultiplier <= 0) {
+            $this->error('Speed multiplier must be greater than 0');
+
+            return Command::FAILURE;
+        }
+
+        $this->info('Starting vehicle location replay...');
+        $this->info("File: {$filePath}");
+        $this->info("Speed: {$speedMultiplier}x");
+
+        if ($vehicleFilter) {
+            $this->info("Filtering for vehicle: {$vehicleFilter}");
+        }
+
+        if ($skipSleep) {
+            $this->warn('Sleep delays disabled - sending all events immediately');
+        }
+
+        // Load and parse JSON data
+        $this->info('Loading location data...');
+        $jsonContent    = file_get_contents($filePath);
+        $locationEvents = json_decode($jsonContent, true);
+
+        if (json_last_error() !== JSON_ERROR_NONE) {
+            $this->error('Failed to parse JSON: ' . json_last_error_msg());
+
+            return Command::FAILURE;
+        }
+
+        if (!is_array($locationEvents) || empty($locationEvents)) {
+            $this->error('Invalid or empty location data');
+
+            return Command::FAILURE;
+        }
+
+        // Filter by vehicle if specified
+        if ($vehicleFilter) {
+            $locationEvents = array_filter($locationEvents, function ($event) use ($vehicleFilter) {
+                return isset($event['data']['id']) && $event['data']['id'] === $vehicleFilter;
+            });
+            $locationEvents = array_values($locationEvents); // Re-index array
+        }
+
+        $totalEvents = count($locationEvents);
+
+        if ($totalEvents === 0) {
+            $this->warn('No events found matching the criteria');
+
+            return Command::SUCCESS;
+        }
+
+        // Apply limit if specified
+        if ($limit && $limit < $totalEvents) {
+            $locationEvents = array_slice($locationEvents, 0, $limit);
+            $totalEvents    = $limit;
+        }
+
+        $this->info("Total events to process: {$totalEvents}");
+        $this->newLine();
+
+        // Initialize SocketCluster client
+        $socketClusterClient = new SocketClusterService();
+
+        // Statistics tracking
+        $successCount      = 0;
+        $errorCount        = 0;
+        $startTime         = microtime(true);
+        $previousTimestamp = null;
+
+        // Process each location event
+        foreach ($locationEvents as $index => $event) {
+            $eventNumber = $index + 1;
+            $vehicleId   = $event['data']['id'] ?? 'unknown';
+            $eventId     = $event['id'] ?? 'unknown';
+            $createdAt   = $event['created_at'] ?? null;
+
+            // Get vehicle record
+            $vehicle = Vehicle::where('public_id', $vehicleId)->first();
+            if (!$vehicle) {
+                continue;
+            }
+
+            // Calculate sleep duration based on timestamp difference
+            if (!$skipSleep && $previousTimestamp !== null && $createdAt !== null) {
+                try {
+                    $currentTime   = Carbon::parse($createdAt);
+                    $previousTime  = Carbon::parse($previousTimestamp);
+                    $diffInSeconds = $currentTime->diffInSeconds($previousTime);
+
+                    // Apply speed multiplier
+                    $sleepDuration = $diffInSeconds / $speedMultiplier;
+
+                    if ($sleep) {
+                        $this->info("[{$eventNumber}/{$totalEvents}] Waiting {$sleep}s (real: {$diffInSeconds}s)...");
+                        sleep((int) $sleep);
+                    } elseif ($sleepDuration > 0) {
+                        $this->info("[{$eventNumber}/{$totalEvents}] Waiting {$sleepDuration}s (real: {$diffInSeconds}s)...");
+                        sleep((int) $sleepDuration);
+
+                        // Handle fractional seconds
+                        $fractional = $sleepDuration - floor($sleepDuration);
+                        if ($fractional > 0) {
+                            usleep((int) ($fractional * 1000000));
+                        }
+                    }
+                } catch (\Exception $e) {
+                    $this->warn("Failed to calculate time difference: {$e->getMessage()}");
+                }
+            }
+
+            // Update previous timestamp
+            $previousTimestamp = $createdAt;
+
+            // Prepare channel names
+            $channels = ["vehicle.{$vehicleId}", "vehicle.{$vehicle->uuid}"];
+
+            foreach ($channels as $channel) {
+                // Send event via SocketCluster
+                try {
+                    $sent = $socketClusterClient->send($channel, $event);
+
+                    $location = $event['data']['location']['coordinates'] ?? ['N/A', 'N/A'];
+                    $speed    = $event['data']['speed'] ?? 'N/A';
+                    $heading  = $event['data']['heading'] ?? 'N/A';
+
+                    $this->line(sprintf(
+                        "[{$eventNumber}/{$totalEvents}] ✓ Sent event %s for vehicle %s | Channel: %s | Coords: [%.6f, %.6f] | Speed: %s | Heading: %s | Time: %s",
+                        $eventId,
+                        $vehicleId,
+                        $channel,
+                        $location[0],
+                        $location[1],
+                        $speed,
+                        $heading,
+                        $createdAt ?? 'N/A'
+                    ));
+
+                    $successCount++;
+                } catch (\WebSocket\ConnectionException $e) {
+                    $this->error("[{$eventNumber}/{$totalEvents}] ✗ Connection error for event {$eventId}: {$e->getMessage()}");
+                    $errorCount++;
+                } catch (\WebSocket\TimeoutException $e) {
+                    $this->error("[{$eventNumber}/{$totalEvents}] ✗ Timeout error for event {$eventId}: {$e->getMessage()}");
+                    $errorCount++;
+                } catch (\Throwable $e) {
+                    $this->error("[{$eventNumber}/{$totalEvents}] ✗ Error for event {$eventId}: {$e->getMessage()}");
+                    $errorCount++;
+                }
+            }
+        }
+
+        // Summary
+        $endTime  = microtime(true);
+        $duration = round($endTime - $startTime, 2);
+
+        $this->newLine();
+        $this->info('=== Replay Complete ===');
+        $this->info("Total events processed: {$totalEvents}");
+        $this->info("Successful: {$successCount}");
+
+        if ($errorCount > 0) {
+            $this->error("Failed: {$errorCount}");
+        } else {
+            $this->info("Failed: {$errorCount}");
+        }
+
+        $this->info("Duration: {$duration}s");
+        $this->info('Average rate: ' . round($totalEvents / max($duration, 0.001), 2) . ' events/second');
+
+        return $errorCount > 0 ? Command::FAILURE : Command::SUCCESS;
+    }
+}

package/server/src/Contracts/TelematicProviderDescriptor.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace Fleetbase\FleetOps\Contracts;
+
+use Fleetbase\FleetOps\Support\Utils;
+
+/**
+ * Class TelematicProviderDescriptor.
+ *
+ * Data Transfer Object for provider metadata.
+ * Used by the ProviderRegistry to describe available providers.
+ */
+class TelematicProviderDescriptor
+{
+    public string $key;
+    public string $label;
+    public string $type; // 'native' or 'custom'
+    public ?string $driverClass;
+    public ?string $icon;
+    public ?string $description;
+    public ?string $docsUrl;
+    public array $requiredFields;
+    public bool $supportsWebhooks;
+    public bool $supportsDiscovery;
+    public array $metadata;
+
+    /**
+     * Create a new ProviderDescriptor instance.
+     */
+    public function __construct(array $data)
+    {
+        $this->key               = $data['key'];
+        $this->label             = $data['label'];
+        $this->type              = $data['type'] ?? 'native';
+        $this->driverClass       = $data['driver_class'] ?? null;
+        $this->icon              = $data['icon'] ?? null;
+        $this->description       = $data['description'] ?? null;
+        $this->docsUrl           = $data['docs_url'] ?? null;
+        $this->requiredFields    = $data['required_fields'] ?? [];
+        $this->supportsWebhooks  = $data['supports_webhooks'] ?? false;
+        $this->supportsDiscovery = $data['supports_discovery'] ?? false;
+        $this->metadata          = $data['metadata'] ?? [];
+    }
+
+    /**
+     * Convert to array for JSON serialization.
+     */
+    public function toArray(): array
+    {
+        return [
+            'key'                => $this->key,
+            'label'              => $this->label,
+            'type'               => $this->type,
+            'icon'               => $this->icon,
+            'description'        => $this->description,
+            'docs_url'           => $this->docsUrl,
+            'required_fields'    => $this->requiredFields,
+            'supports_webhooks'  => $this->supportsWebhooks,
+            'supports_discovery' => $this->supportsDiscovery,
+            'metadata'           => $this->metadata,
+            'webhook_url'        => Utils::apiUrl('webhooks/telematics/' . $this->key),
+        ];
+    }
+
+    /**
+     * Get JSON representation.
+     */
+    public function toJson(): string
+    {
+        return json_encode($this->toArray());
+    }
+}

package/server/src/Contracts/TelematicProviderInterface.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace Fleetbase\FleetOps\Contracts;
+
+use Fleetbase\FleetOps\Models\Telematic;
+
+/**
+ * Interface TelematicProviderInterface.
+ *
+ * Core contract that all telematics providers must implement.
+ * Defines the standard methods for authentication, device discovery,
+ * webhook handling, and data normalization.
+ */
+interface TelematicProviderInterface
+{
+    /**
+     * Connect to the provider using the given telematic configuration.
+     */
+    public function connect(Telematic $telematic): void;
+
+    /**
+     * Test the connection to the provider.
+     *
+     * @param array $credentials Provider credentials
+     *
+     * @return array ['success' => bool, 'message' => string, 'metadata' => array]
+     */
+    public function testConnection(array $credentials): array;
+
+    /**
+     * Fetch devices from the provider.
+     *
+     * @param array $options Options including limit, cursor, filters
+     *
+     * @return array ['devices' => array, 'next_cursor' => string|null, 'has_more' => bool]
+     */
+    public function fetchDevices(array $options = []): array;
+
+    /**
+     * Fetch detailed information for a specific device.
+     *
+     * @param string $externalId Provider's device identifier
+     *
+     * @return array Device details
+     */
+    public function fetchDeviceDetails(string $externalId): array;
+
+    /**
+     * Normalize a device payload from the provider into FleetOps format.
+     *
+     * @param array $payload Raw device data from provider
+     *
+     * @return array Normalized device data
+     */
+    public function normalizeDevice(array $payload): array;
+
+    /**
+     * Normalize an event payload from the provider into FleetOps format.
+     *
+     * @param array $payload Raw event data from provider
+     *
+     * @return array Normalized event data
+     */
+    public function normalizeEvent(array $payload): array;
+
+    /**
+     * Normalize sensor data from the provider into FleetOps format.
+     *
+     * @param array $payload Raw sensor data from provider
+     *
+     * @return array Normalized sensor data
+     */
+    public function normalizeSensor(array $payload): array;
+
+    /**
+     * Validate a webhook signature.
+     *
+     * @param string $payload     Raw webhook payload
+     * @param string $signature   Signature from webhook headers
+     * @param array  $credentials Provider credentials
+     *
+     * @return bool True if signature is valid
+     */
+    public function validateWebhookSignature(string $payload, string $signature, array $credentials): bool;
+
+    /**
+     * Process a webhook payload from the provider.
+     *
+     * @param array $payload Webhook payload
+     * @param array $headers Webhook headers
+     *
+     * @return array ['devices' => array, 'events' => array, 'sensors' => array]
+     */
+    public function processWebhook(array $payload, array $headers = []): array;
+
+    /**
+     * Get the provider's credential schema.
+     *
+     * @return array Array of field definitions
+     */
+    public function getCredentialSchema(): array;
+
+    /**
+     * Check if the provider supports webhooks.
+     */
+    public function supportsWebhooks(): bool;
+
+    /**
+     * Check if the provider supports device discovery.
+     */
+    public function supportsDiscovery(): bool;
+
+    /**
+     * Get rate limit information for the provider.
+     *
+     * @return array ['requests_per_minute' => int, 'burst_size' => int]
+     */
+    public function getRateLimits(): array;
+}

package/server/src/Exceptions/TelematicProviderException.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Fleetbase\FleetOps\Exceptions;
+
+use Exception;
+
+/**
+ * Class TelematicProviderException.
+ *
+ * Base exception for provider-related errors.
+ */
+class TelematicProviderException extends \Exception
+{
+}

package/server/src/Exceptions/TelematicRateLimitExceededException.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Fleetbase\FleetOps\Exceptions;
+
+/**
+ * Class TelematicRateLimitExceededException.
+ *
+ * Exception thrown when provider rate limit is exceeded.
+ */
+class TelematicRateLimitExceededException extends ProviderException
+{
+}

package/server/src/Http/Controllers/Api/v1/DriverController.php

@@ -343,23 +343,34 @@ class DriverController extends Controller
         // check if driver needs a geocoded update to set city and country they are currently in
         $isGeocodable = Carbon::parse($driver->updated_at)->diffInMinutes(Carbon::now(), false) > 10 || empty($driver->country) || empty($driver->city);
 
-        $driver->update([
-            'location' => new Point($latitude, $longitude),
-            'altitude' => $altitude,
-            'heading'  => $heading,
-            'speed'    => $speed,
-        ]);
+        $positionData = [
+            'location'  => new Point($latitude, $longitude),
+            'latitude'  => $latitude,
+            'longitude' => $longitude,
+            'altitude'  => $altitude,
+            'heading'   => $heading,
+            'speed'     => $speed,
+        ];
+
+        // Append current order to data if applicable
+        $order = $driver->getCurrentOrder();
+        if ($order) {
+            $positionData['order_uuid'] = $order->uuid;
+            // Get destination
+            $destination  = $order->payload?->getPickupOrCurrentWaypoint();
+            if ($destination) {
+                $positionData['destination_uuid'] = $destination->uuid;
+            }
+        }
+
+        $driver->update($positionData);
+        $driver->createPosition($positionData);
 
         // If vehicle is assigned to driver load it and sync position data
         $driver->loadMissing('vehicle');
         if ($driver->vehicle) {
-            $driver->vehicle->update([
-                'location' => new Point($latitude, $longitude),
-                'altitude' => $altitude,
-                'heading'  => $heading,
-                'speed'    => $speed,
-            ]);
-            $driver->vehicle->createPositionWithOrderContext();
+            $driver->vehicle->update($positionData);
+            $driver->vehicle->createPosition($positionData);
             broadcast(new VehicleLocationChanged($driver->vehicle, ['driver' => $driver->public_id]));
         }
 
@@ -376,7 +387,6 @@ class DriverController extends Controller
         }
 
         broadcast(new DriverLocationChanged($driver));
-        $driver->createPositionWithOrderContext();
 
         return new DriverResource($driver);
     }

package/server/src/Http/Controllers/Api/v1/VehicleController.php

@@ -235,15 +235,35 @@ class VehicleController extends Controller
             );
         }
 
-        $vehicle->update([
-            'location' => new Point($latitude, $longitude),
-            'altitude' => $altitude,
-            'heading'  => $heading,
-            'speed'    => $speed,
-        ]);
+        $positionData = [
+            'location'  => new Point($latitude, $longitude),
+            'latitude'  => $latitude,
+            'longitude' => $longitude,
+            'altitude'  => $altitude,
+            'heading'   => $heading,
+            'speed'     => $speed,
+        ];
+
+        // Get vehicle driver
+        $vehicle->loadMissing('driver');
+        $driver = $vehicle->driver;
+        if ($driver) {
+            // Append current order to data if applicable
+            $order = $driver->getCurrentOrder();
+            if ($order) {
+                $positionData['order_uuid'] = $order->uuid;
+                // Get destination
+                $destination  = $order->payload?->getPickupOrCurrentWaypoint();
+                if ($destination) {
+                    $positionData['destination_uuid'] = $destination->uuid;
+                }
+            }
+        }
+
+        $vehicle->update($positionData);
+        $vehicle->createPosition($positionData);
 
         broadcast(new VehicleLocationChanged($vehicle));
-        $vehicle->createPositionWithOrderContext();
 
         return new VehicleResource($vehicle);
     }

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