@fleetbase/solid-engine 0.0.3 → 0.0.5

package/server/src/Services/ResourceSyncService.php

@@ -0,0 +1,336 @@
+<?php
+
+namespace Fleetbase\Solid\Services;
+
+use Fleetbase\Solid\Models\SolidIdentity;
+use Fleetbase\Solid\Client\SolidClient;
+use Illuminate\Support\Facades\Log;
+
+class ResourceSyncService
+{
+    /**
+     * Import resources into a pod.
+     *
+     * @param SolidIdentity $identity
+     * @param string $podUrl
+     * @param array $resourceTypes
+     * @return array
+     */
+    public function importResources(SolidIdentity $identity, string $podUrl, array $resourceTypes): array
+    {
+        $imported = [];
+        $errors = [];
+        $totalCount = 0;
+
+        foreach ($resourceTypes as $resourceType) {
+            try {
+                Log::info('[IMPORTING RESOURCE TYPE]', ['type' => $resourceType, 'pod_url' => $podUrl]);
+                
+                $result = $this->importResourceType($identity, $podUrl, $resourceType);
+                $imported[$resourceType] = $result['count'];
+                $totalCount += $result['count'];
+                
+                Log::info('[RESOURCE TYPE IMPORTED]', [
+                    'type' => $resourceType,
+                    'count' => $result['count'],
+                ]);
+            } catch (\Throwable $e) {
+                Log::error('[RESOURCE IMPORT ERROR]', [
+                    'type' => $resourceType,
+                    'error' => $e->getMessage(),
+                ]);
+                $errors[$resourceType] = $e->getMessage();
+            }
+        }
+
+        return [
+            'imported' => $imported,
+            'errors' => $errors,
+            'total_count' => $totalCount,
+        ];
+    }
+
+    /**
+     * Import a specific resource type.
+     *
+     * @param SolidIdentity $identity
+     * @param string $podUrl
+     * @param string $resourceType
+     * @return array
+     */
+    protected function importResourceType(SolidIdentity $identity, string $podUrl, string $resourceType): array
+    {
+        // Get resources from Fleetops
+        $resources = $this->getFleetopsResources($resourceType);
+        
+        if (empty($resources)) {
+            return ['count' => 0];
+        }
+
+        // Create container for this resource type
+        $containerUrl = rtrim($podUrl, '/') . '/' . $resourceType . '/';
+        $this->createContainer($identity, $containerUrl);
+
+        // Import each resource
+        $count = 0;
+        foreach ($resources as $resource) {
+            try {
+                $turtle = $this->convertToRDF($resourceType, $resource);
+                $resourceUrl = $containerUrl . $resource->public_id . '.ttl';
+                
+                $this->storeResource($identity, $resourceUrl, $turtle);
+                $count++;
+            } catch (\Throwable $e) {
+                Log::warning('[RESOURCE IMPORT FAILED]', [
+                    'type' => $resourceType,
+                    'id' => $resource->public_id ?? 'unknown',
+                    'error' => $e->getMessage(),
+                ]);
+            }
+        }
+
+        return ['count' => $count];
+    }
+
+    /**
+     * Get Fleetops resources by type.
+     *
+     * @param string $resourceType
+     * @return \Illuminate\Support\Collection
+     */
+    protected function getFleetopsResources(string $resourceType)
+    {
+        $modelMap = [
+            'vehicles' => \Fleetbase\FleetOps\Models\Vehicle::class,
+            'drivers' => \Fleetbase\FleetOps\Models\Driver::class,
+            'contacts' => \Fleetbase\FleetOps\Models\Contact::class,
+            'orders' => \Fleetbase\FleetOps\Models\Order::class,
+        ];
+
+        if (!isset($modelMap[$resourceType])) {
+            throw new \Exception("Unknown resource type: {$resourceType}");
+        }
+
+        $modelClass = $modelMap[$resourceType];
+        
+        // Get current company's resources
+        $companyId = session('company');
+        
+        Log::info('[FETCHING FLEETOPS RESOURCES]', [
+            'resource_type' => $resourceType,
+            'model_class' => $modelClass,
+            'company_id' => $companyId,
+        ]);
+        
+        if (!$companyId) {
+            Log::warning('[NO COMPANY ID]', ['session' => session()->all()]);
+            // Try to get from auth user
+            $user = auth()->user();
+            if ($user && isset($user->company_uuid)) {
+                $companyId = $user->company_uuid;
+                Log::info('[USING USER COMPANY]', ['company_id' => $companyId]);
+            }
+        }
+        
+        if (!$companyId) {
+            Log::error('[CANNOT DETERMINE COMPANY]');
+            return collect([]);
+        }
+        
+        $query = $modelClass::where('company_uuid', $companyId)
+            ->limit(100); // Limit for now to avoid overwhelming the pod
+            
+        $count = $query->count();
+        Log::info('[RESOURCE QUERY]', [
+            'resource_type' => $resourceType,
+            'count' => $count,
+            'sql' => $query->toSql(),
+            'bindings' => $query->getBindings(),
+        ]);
+        
+        return $query->get();
+    }
+
+    /**
+     * Convert a resource to RDF/Turtle format.
+     *
+     * @param string $resourceType
+     * @param mixed $resource
+     * @return string
+     */
+    protected function convertToRDF(string $resourceType, $resource): string
+    {
+        $baseUri = "http://fleetbase.io/ns/{$resourceType}/";
+        $resourceUri = $baseUri . $resource->public_id;
+
+        $turtle = "@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .\n";
+        $turtle .= "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n";
+        $turtle .= "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .\n";
+        $turtle .= "@prefix fb: <http://fleetbase.io/ns/> .\n";
+        $turtle .= "@prefix fb{$resourceType}: <{$baseUri}> .\n\n";
+
+        $turtle .= "<{$resourceUri}>\n";
+        $turtle .= "    a fb:{$this->getResourceClass($resourceType)} ;\n";
+        $turtle .= "    fb:id \"{$resource->public_id}\" ;\n";
+
+        // Add resource-specific properties
+        $properties = $this->getResourceProperties($resourceType, $resource);
+        foreach ($properties as $property => $value) {
+            if ($value !== null && $value !== '') {
+                $turtle .= "    fb:{$property} " . $this->formatRDFValue($value) . " ;\n";
+            }
+        }
+
+        // Remove trailing semicolon and add period
+        $turtle = rtrim($turtle, " ;\n") . " .\n";
+
+        return $turtle;
+    }
+
+    /**
+     * Get RDF class name for resource type.
+     *
+     * @param string $resourceType
+     * @return string
+     */
+    protected function getResourceClass(string $resourceType): string
+    {
+        return ucfirst(rtrim($resourceType, 's'));
+    }
+
+    /**
+     * Get properties for a resource type.
+     *
+     * @param string $resourceType
+     * @param mixed $resource
+     * @return array
+     */
+    protected function getResourceProperties(string $resourceType, $resource): array
+    {
+        switch ($resourceType) {
+            case 'vehicles':
+                return [
+                    'name' => $resource->name,
+                    'make' => $resource->make,
+                    'model' => $resource->model,
+                    'year' => $resource->year,
+                    'vin' => $resource->vin,
+                    'plate_number' => $resource->plate_number,
+                    'status' => $resource->status,
+                    'created_at' => $resource->created_at?->toIso8601String(),
+                    'updated_at' => $resource->updated_at?->toIso8601String(),
+                ];
+
+            case 'drivers':
+                return [
+                    'name' => $resource->name,
+                    'email' => $resource->email,
+                    'phone' => $resource->phone,
+                    'license_number' => $resource->drivers_license_number,
+                    'status' => $resource->status,
+                    'created_at' => $resource->created_at?->toIso8601String(),
+                    'updated_at' => $resource->updated_at?->toIso8601String(),
+                ];
+
+            case 'contacts':
+                return [
+                    'name' => $resource->name,
+                    'email' => $resource->email,
+                    'phone' => $resource->phone,
+                    'type' => $resource->type,
+                    'created_at' => $resource->created_at?->toIso8601String(),
+                    'updated_at' => $resource->updated_at?->toIso8601String(),
+                ];
+
+            case 'orders':
+                return [
+                    'tracking_number' => $resource->public_id,
+                    'status' => $resource->status,
+                    'type' => $resource->type,
+                    'scheduled_at' => $resource->scheduled_at?->toIso8601String(),
+                    'created_at' => $resource->created_at?->toIso8601String(),
+                    'updated_at' => $resource->updated_at?->toIso8601String(),
+                ];
+
+            default:
+                return [];
+        }
+    }
+
+    /**
+     * Format a value for RDF.
+     *
+     * @param mixed $value
+     * @return string
+     */
+    protected function formatRDFValue($value): string
+    {
+        if (is_numeric($value)) {
+            return "\"{$value}\"^^xsd:integer";
+        }
+
+        if (is_bool($value)) {
+            return $value ? '"true"^^xsd:boolean' : '"false"^^xsd:boolean';
+        }
+
+        // Escape quotes and special characters
+        $escaped = str_replace(['"', '\\'], ['\\"', '\\\\'], (string)$value);
+        return "\"{$escaped}\"";
+    }
+
+    /**
+     * Create a container in the pod.
+     *
+     * @param SolidIdentity $identity
+     * @param string $containerUrl
+     * @return void
+     */
+    protected function createContainer(SolidIdentity $identity, string $containerUrl): void
+    {
+        try {
+            $response = $identity->request('put', $containerUrl, '', [
+                'headers' => [
+                    'Content-Type' => 'text/turtle',
+                    'Link' => '<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"',
+                ],
+            ]);
+
+            Log::info('[CONTAINER CREATED]', [
+                'url' => $containerUrl,
+                'status' => $response->status(),
+            ]);
+        } catch (\Throwable $e) {
+            // Container might already exist, that's okay
+            Log::debug('[CONTAINER CREATION SKIPPED]', [
+                'url' => $containerUrl,
+                'reason' => $e->getMessage(),
+            ]);
+        }
+    }
+
+    /**
+     * Store a resource in the pod.
+     *
+     * @param SolidIdentity $identity
+     * @param string $resourceUrl
+     * @param string $turtle
+     * @return void
+     */
+    protected function storeResource(SolidIdentity $identity, string $resourceUrl, string $turtle): void
+    {
+        $response = $identity->request('put', $resourceUrl, $turtle, [
+            'headers' => [
+                'Content-Type' => 'text/turtle',
+            ],
+        ]);
+
+        if (!$response->successful()) {
+            throw new \Exception("Failed to store resource: {$response->body()}");
+        }
+
+        Log::debug('[RESOURCE STORED]', [
+            'url' => $resourceUrl,
+            'status' => $response->status(),
+        ]);
+    }
+}

package/server/src/Services/VehicleSyncService.php

@@ -0,0 +1,289 @@
+<?php
+
+namespace Fleetbase\Solid\Services;
+
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\Solid\Models\SolidIdentity;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Str;
+
+class VehicleSyncService
+{
+    /**
+     * Get vehicles available for sync.
+     */
+    public function getAvailableVehicles(): array
+    {
+        try {
+            $vehicles = Vehicle::with(['driver', 'vendor', 'category'])
+                ->where('company_uuid', session('company'))
+                ->get();
+
+            return $vehicles->map(function ($vehicle) {
+                return [
+                    'id'           => $vehicle->uuid,
+                    'display_name' => $this->getVehicleDisplayName($vehicle),
+                    'make'         => $vehicle->make,
+                    'model'        => $vehicle->model,
+                    'year'         => $vehicle->year,
+                    'plate_number' => $vehicle->plate_number,
+                    'vin'          => $vehicle->vin,
+                    'status'       => $vehicle->status,
+                    'driver_name'  => $vehicle->driver?->name,
+                    'vendor_name'  => $vehicle->vendor?->name,
+                    'last_seen'    => $vehicle->updated_at?->diffForHumans(),
+                    'sync_status'  => 'not_synced', // TODO: Track actual sync status
+                ];
+            })->toArray();
+        } catch (\Throwable $e) {
+            Log::error('[GET AVAILABLE VEHICLES ERROR]', [
+                'error' => $e->getMessage(),
+            ]);
+            throw $e;
+        }
+    }
+
+    /**
+     * Sync selected vehicles to a pod.
+     */
+    public function syncVehiclesToPod(SolidIdentity $identity, string $podUrl, array $vehicleIds): array
+    {
+        $syncedCount = 0;
+        $failedCount = 0;
+        $details     = [];
+
+        try {
+            $vehicles = Vehicle::with(['driver', 'vendor', 'category'])
+                ->whereIn('uuid', $vehicleIds)
+                ->where('company_uuid', session('company'))
+                ->get();
+
+            foreach ($vehicles as $vehicle) {
+                try {
+                    $this->syncSingleVehicle($identity, $podUrl, $vehicle);
+                    $syncedCount++;
+                    $details[] = [
+                        'vehicle_id' => $vehicle->uuid,
+                        'status'     => 'success',
+                        'message'    => 'Synced successfully',
+                    ];
+                } catch (\Throwable $e) {
+                    $failedCount++;
+                    $details[] = [
+                        'vehicle_id' => $vehicle->uuid,
+                        'status'     => 'failed',
+                        'message'    => $e->getMessage(),
+                    ];
+
+                    Log::error('[VEHICLE SYNC FAILED]', [
+                        'vehicle_id' => $vehicle->uuid,
+                        'error'      => $e->getMessage(),
+                    ]);
+                }
+            }
+
+            Log::info('[VEHICLE SYNC COMPLETED]', [
+                'pod_url'      => $podUrl,
+                'synced_count' => $syncedCount,
+                'failed_count' => $failedCount,
+            ]);
+
+            return [
+                'synced_count' => $syncedCount,
+                'failed_count' => $failedCount,
+                'details'      => $details,
+            ];
+        } catch (\Throwable $e) {
+            Log::error('[SYNC VEHICLES TO POD ERROR]', [
+                'pod_url'     => $podUrl,
+                'vehicle_ids' => $vehicleIds,
+                'error'       => $e->getMessage(),
+            ]);
+            throw $e;
+        }
+    }
+
+    /**
+     * Sync a single vehicle to the pod.
+     */
+    private function syncSingleVehicle(SolidIdentity $identity, string $podUrl, Vehicle $vehicle): void
+    {
+        // Generate RDF/Turtle content for the vehicle
+        $rdfContent = $this->generateVehicleRDF($vehicle);
+
+        // Create filename
+        $filename    = $this->generateVehicleFilename($vehicle);
+        $resourceUrl = rtrim($podUrl, '/') . '/' . $filename;
+
+        // Store the vehicle data in the pod
+        $response = $identity->request('put', $resourceUrl, $rdfContent, [
+            'headers' => [
+                'Content-Type' => 'text/turtle',
+            ],
+        ]);
+
+        if (!$response->successful()) {
+            throw new \Exception('Failed to store vehicle data: ' . $response->body());
+        }
+
+        Log::info('[VEHICLE SYNCED]', [
+            'vehicle_id'   => $vehicle->uuid,
+            'resource_url' => $resourceUrl,
+            'status'       => $response->status(),
+        ]);
+    }
+
+    /**
+     * Generate RDF/Turtle content for a vehicle.
+     */
+    private function generateVehicleRDF(Vehicle $vehicle): string
+    {
+        $turtle = "@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .\n";
+        $turtle .= "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n";
+        $turtle .= "@prefix dc: <http://purl.org/dc/terms/> .\n";
+        $turtle .= "@prefix foaf: <http://xmlns.com/foaf/0.1/> .\n";
+        $turtle .= "@prefix vehicle: <http://fleetbase.io/ontology/vehicle#> .\n";
+        $turtle .= "@prefix fleet: <http://fleetbase.io/ontology/fleet#> .\n\n";
+
+        $vehicleUri = "<#vehicle-{$vehicle->uuid}>";
+
+        $turtle .= "$vehicleUri a vehicle:Vehicle ;\n";
+        $turtle .= "    dc:identifier \"{$vehicle->uuid}\" ;\n";
+
+        if ($vehicle->make) {
+            $turtle .= "    vehicle:make \"{$vehicle->make}\" ;\n";
+        }
+
+        if ($vehicle->model) {
+            $turtle .= "    vehicle:model \"{$vehicle->model}\" ;\n";
+        }
+
+        if ($vehicle->year) {
+            $turtle .= "    vehicle:year \"{$vehicle->year}\" ;\n";
+        }
+
+        if ($vehicle->trim) {
+            $turtle .= "    vehicle:trim \"{$vehicle->trim}\" ;\n";
+        }
+
+        if ($vehicle->type) {
+            $turtle .= "    vehicle:type \"{$vehicle->type}\" ;\n";
+        }
+
+        if ($vehicle->plate_number) {
+            $turtle .= "    vehicle:plateNumber \"{$vehicle->plate_number}\" ;\n";
+        }
+
+        if ($vehicle->vin) {
+            $turtle .= "    vehicle:vin \"{$vehicle->vin}\" ;\n";
+        }
+
+        if ($vehicle->status) {
+            $turtle .= "    fleet:status \"{$vehicle->status}\" ;\n";
+        }
+
+        if ($vehicle->online !== null) {
+            $onlineStatus = $vehicle->online ? 'true' : 'false';
+            $turtle .= "    fleet:online \"$onlineStatus\"^^<http://www.w3.org/2001/XMLSchema#boolean> ;\n";
+        }
+
+        // Add location if available
+        if ($vehicle->location) {
+            $turtle .= "    fleet:location [\n";
+            $turtle .= "        a fleet:Location ;\n";
+
+            if (isset($vehicle->location['coordinates'])) {
+                $coords = $vehicle->location['coordinates'];
+                if (isset($coords[0]) && isset($coords[1])) {
+                    $turtle .= "        fleet:longitude \"{$coords[0]}\"^^<http://www.w3.org/2001/XMLSchema#decimal> ;\n";
+                    $turtle .= "        fleet:latitude \"{$coords[1]}\"^^<http://www.w3.org/2001/XMLSchema#decimal> ;\n";
+                }
+            }
+
+            $turtle .= "    ] ;\n";
+        }
+
+        // Add driver relationship
+        if ($vehicle->driver) {
+            $turtle .= "    fleet:assignedDriver [\n";
+            $turtle .= "        a foaf:Person ;\n";
+            $turtle .= "        foaf:name \"{$vehicle->driver->name}\" ;\n";
+            $turtle .= "        dc:identifier \"{$vehicle->driver->uuid}\" ;\n";
+            $turtle .= "    ] ;\n";
+        }
+
+        // Add vendor relationship
+        if ($vehicle->vendor) {
+            $turtle .= "    fleet:vendor [\n";
+            $turtle .= "        a fleet:Vendor ;\n";
+            $turtle .= "        foaf:name \"{$vehicle->vendor->name}\" ;\n";
+            $turtle .= "        dc:identifier \"{$vehicle->vendor->uuid}\" ;\n";
+            $turtle .= "    ] ;\n";
+        }
+
+        // Add metadata
+        $turtle .= "    dc:created \"{$vehicle->created_at->toISOString()}\" ;\n";
+        $turtle .= "    dc:modified \"{$vehicle->updated_at->toISOString()}\" ;\n";
+        $turtle .= '    fleet:syncedAt "' . now()->toISOString() . "\" ;\n";
+        $turtle .= "    fleet:syncedFrom \"fleetbase\" .\n";
+
+        return $turtle;
+    }
+
+    /**
+     * Generate filename for vehicle resource.
+     */
+    private function generateVehicleFilename(Vehicle $vehicle): string
+    {
+        $identifier = $vehicle->plate_number ?: $vehicle->vin ?: $vehicle->uuid;
+        $slug       = Str::slug($identifier);
+
+        return "vehicle-{$slug}.ttl";
+    }
+
+    /**
+     * Get vehicle display name.
+     */
+    private function getVehicleDisplayName(Vehicle $vehicle): string
+    {
+        $parts = array_filter([
+            $vehicle->year,
+            $vehicle->make,
+            $vehicle->model,
+            $vehicle->trim,
+        ]);
+
+        $name = implode(' ', $parts);
+
+        if ($vehicle->plate_number) {
+            $name .= " ({$vehicle->plate_number})";
+        }
+
+        return $name ?: "Vehicle {$vehicle->uuid}";
+    }
+
+    /**
+     * Get sync status for a pod.
+     */
+    public function getSyncStatus(SolidIdentity $identity, string $podId): array
+    {
+        try {
+            // This would typically check a sync status table or cache
+            // For now, return a basic status
+            return [
+                'pod_id'          => $podId,
+                'last_sync'       => null,
+                'total_vehicles'  => 0,
+                'synced_vehicles' => 0,
+                'failed_vehicles' => 0,
+                'status'          => 'ready',
+            ];
+        } catch (\Throwable $e) {
+            Log::error('[GET SYNC STATUS ERROR]', [
+                'pod_id' => $podId,
+                'error'  => $e->getMessage(),
+            ]);
+            throw $e;
+        }
+    }
+}

package/server/src/Support/Utils.php

@@ -44,4 +44,14 @@ class Utils extends FleetbaseUtils
 
         return null;
     }
+
+    /**
+     * Get the Solid server URL from configuration.
+     *
+     * @return string
+     */
+    public static function getSolidServerUrl(): string
+    {
+        return config('solid.server.url', 'http://localhost:3000');
+    }
 }

package/server/src/routes.php

@@ -28,11 +28,35 @@ Route::prefix(config('solid.api.routing.prefix', 'solid'))->namespace('Fleetbase
                 $router->group(
                     ['prefix' => 'v1'],
                     function ($router) {
-                        $router->get('pods', 'SolidController@getPods');
                         $router->get('authenticate/{identifier}', 'SolidController@authenticate');
                         $router->group(['middleware' => ['fleetbase.protected']], function ($router) {
+                            // Authentication status and management
                             $router->get('account', 'SolidController@getAccountIndex');
                             $router->get('request-authentication', 'SolidController@requestAuthentication');
+                            $router->get('authentication-status', 'SolidController@getAuthenticationStatus');
+                            $router->post('logout', 'SolidController@logout');
+
+                            // Account and profile
+                            $router->get('account', 'SolidController@getAccountIndex');
+                            $router->get('profile', 'SolidController@getProfileData');
+
+                            // Data management routes (single-pod architecture)
+                            $router->get('data', 'DataController@index');
+                            $router->get('data/folder/{slug}', 'DataController@showFolder');
+                            $router->post('data/folder', 'DataController@createFolder');
+                            $router->delete('data/{type}/{slug}', 'DataController@deleteItem');
+                            $router->post('data/import', 'DataController@importResources');
+
+
+
+                            // Resource sync endpoints
+                            $router->get('sync-status', 'SolidController@getSyncStatus');
+                            $router->post('sync-vehicles', 'SolidController@syncVehicles');
+                            $router->post('sync-drivers', 'SolidController@syncDrivers');
+                            $router->post('sync-orders', 'SolidController@syncOrders');
+                            $router->post('sync-all', 'SolidController@syncAll');
+
+                            // Server configuration
                             $router->get('server-config', 'SolidController@getServerConfig');
                             $router->post('server-config', 'SolidController@saveServerConfig');
                         });

package/addon/components/modals/backup-pod.hbs

@@ -1,3 +0,0 @@
-<Modal::Default @modalIsOpened={{@modalIsOpened}} @options={{@options}} @confirm={{@onConfirm}} @decline={{@onDecline}}>
-    <div class="modal-body-container"></div>
-</Modal::Default>

package/addon/components/modals/create-pod.hbs

@@ -1,5 +0,0 @@
-<Modal::Default @modalIsOpened={{@modalIsOpened}} @options={{@options}} @confirm={{@onConfirm}} @decline={{@onDecline}}>
-    <div class="modal-body-container">
-        <InputGroup @name="Pod Name" @value={{@options.pod.name}} @helpText="Input a name for your new Pod" />
-    </div>
-</Modal::Default>