#10 - regulations for escooters

.env.example

@@ -62,3 +62,5 @@ GOOGLE_REDIRECT_URI=http://escooters.blumilk.localhost/login/google/redirect
 FACEBOOK_CLIENT_ID=
 FACEBOOK_CLIENT_SECRET=
 FACEBOOK_REDIRECT_URI=http://escooters.blumilk.localhost/login/facebook/redirect
+
+OPENAI_API_KEY=

app/Exceptions/ExceptionHandler.php

@@ -32,6 +32,10 @@ public function render($request, Throwable $exception)
             return back()->withErrors($exception->errors());
         }
 
+        if ($exception instanceof OpenAiException) {
+            return response()->json(["error" => $exception->getMessage()], $exception->getCode());
+        }
+
         $response = parent::render($request, $exception);
         $statusCode = $response->status();
 

app/Exceptions/OpenAiException.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Exceptions;
+
+use Exception;
+use Symfony\Component\HttpFoundation\Response;
+
+class OpenAiException extends Exception
+{
+    protected $message = "OpenAI API connection error";
+    protected $code = Response::HTTP_INTERNAL_SERVER_ERROR;
+}

app/Http/Controllers/RulesController.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Controllers;
+
+use App\Models\City;
+use App\Models\Country;
+use App\Models\Rules;
+use App\Services\OpenAIService;
+use Illuminate\Http\Request;
+
+class RulesController
+{
+    public function getRules(Country $country, City $city): array
+    {
+        $rules = Rules::query()
+            ->where("city_id", $city->id)
+            ->first();
+
+        if (!$rules || $rules->rules_en === null || $rules->rules_pl === null) {
+            $cityData = [
+                "cityId" => $city->id,
+                "countryId" => $country->id,
+                "cityName" => $city->name,
+                "countryName" => $country->name,
+            ];
+            $importer = new OpenAIService();
+            $data = $importer->importRulesForCity($cityData, true);
+        } else {
+            $data = [
+                "country" => $country->name,
+                "city" => $city->name,
+                "rules_en" => $rules->rules_en,
+                "rules_pl" => $rules->rules_pl,
+            ];
+        }
+
+        return $data;
+    }
+
+    public function importRules(Request $request, OpenAIService $importer): void
+    {
+        $force = $request->input("force", false);
+        $importer->importRulesForAllCities($force);
+    }
+}

app/Jobs/ImportCityRulesJob.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Jobs;
+
+use App\Services\OpenAIService;
+use Illuminate\Bus\Batchable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+
+class ImportCityRulesJob implements ShouldQueue
+{
+    use Dispatchable;
+    use InteractsWithQueue;
+    use SerializesModels;
+    use Batchable;
+
+    public function __construct(
+        private array $cityData,
+        private bool $force,
+    ) {}
+
+    public function handle(OpenAIService $openAIService): array
+    {
+        return $openAIService->importRulesForCity($this->cityData, $this->force);
+    }
+}

app/Models/Rules.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class Rules extends Model
+{
+    protected $table = "rules_for_cities";
+    protected $fillable = [
+        "city_id",
+        "country_id",
+        "rules_en",
+        "rules_pl",
+    ];
+
+    public function city(): BelongsTo
+    {
+        return $this->belongsTo(City::class);
+    }
+
+    public function country(): BelongsTo
+    {
+        return $this->belongsTo(Country::class);
+    }
+}

app/Services/OpenAIService.php

@@ -0,0 +1,133 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services;
+
+use App\Exceptions\OpenAiException;
+use App\Jobs\ImportCityRulesJob;
+use App\Models\City;
+use App\Models\ImportInfo;
+use App\Models\ImportInfoDetail;
+use App\Models\Rules;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Support\Facades\Bus;
+use Illuminate\Support\Facades\Storage;
+use OpenAI;
+use Throwable;
+
+class OpenAIService implements ShouldQueue
+{
+    private OpenAI\Client $client;
+    private array $countriesKnownToHaveUniformRules;
+
+    public function __construct()
+    {
+        try {
+            $this->client = OpenAI::client(env("OPENAI_API_KEY"));
+        } catch (Throwable $e) {
+            throw new OpenAiException();
+        }
+
+        $this->countriesKnownToHaveUniformRules = Storage::disk("public")->json("citiesKnownToHaveUniformRules.json");
+    }
+
+    public function importRulesForAllCities(bool $force): void
+    {
+        $cities = City::query()->whereHas("cityProviders")->orderBy("country_id")->get();
+
+        $importInfo = ImportInfo::query()->create([
+            "who_runs_it" => "admin",
+            "status" => "running",
+        ]);
+        $jobs = [];
+
+        foreach ($cities as $city) {
+            $cityData = [
+                "cityId" => $city->id,
+                "countryId" => $city->country_id,
+                "cityName" => $city->name,
+                "countryName" => $city->country->name,
+            ];
+            $jobs[] = new ImportCityRulesJob($cityData, $force);
+            ImportCityRulesJob::dispatch($cityData, $force);
+        }
+
+        Bus::batch($jobs)
+            ->catch(function () use ($importInfo): void {
+                ImportInfoDetail::query()->updateOrCreate([
+                    "import_info_id" => $importInfo->id,
+                    "provider_name" => "OpenAI",
+                    "code" => 400,
+                ]);
+            })->finally(function () use ($importInfo): void {
+                ImportInfo::query()->where("id", $importInfo->id)->update([
+                    "status" => "finished",
+                ]);
+            })
+            ->dispatch();
+    }
+
+    public function importRulesForCity(array $cityData, bool $force): array
+    {
+        $cityId = $cityData["cityId"];
+        $countryId = $cityData["countryId"];
+        $cityName = $cityData["cityName"];
+        $countryName = $cityData["countryName"];
+
+        $promptEn = "Act as a helpful assistant. Explain what are the legal limitations for riding electric scooters in $cityName, $countryName? Contain information about: max speed, helmet requirements, allowed ABV, passengers, other relevant details. Be formal, speak English. Don't include city name in your response. If you don't have information answering the question, write 'null'.";
+        $promptPl = "Translate to polish: ";
+        $currentRulesInCountry = Rules::query()->where("country_id", $countryId)->first();
+
+        if ($this->checkIfRulesExist($countryName, $currentRulesInCountry) && !$force) {
+            $rulesEn = $currentRulesInCountry->rules_en;
+            $rulesPl = $currentRulesInCountry->rules_pl;
+        } else {
+            $rulesEn = $this->askGPT($promptEn);
+            $rulesPl = $this->askGPT($promptPl . $rulesEn);
+        }
+
+        if (strlen($rulesEn) < 700 || strlen($rulesPl) < 700) {
+            return [
+                "city" => $cityName,
+                "country" => $countryName,
+                "rules_en" => null,
+                "rules_pl" => null,
+            ];
+        }
+
+        Rules::query()->updateOrCreate([
+            "city_id" => $cityId,
+            "country_id" => $countryId,
+            "rules_en" => $rulesEn,
+            "rules_pl" => $rulesPl,
+        ]);
+
+        return [
+            "city" => $cityName,
+            "country" => $countryName,
+            "rules_en" => $rulesEn,
+            "rules_pl" => $rulesPl,
+        ];
+    }
+
+    private function askGPT(string $prompt): string
+    {
+        $response = $this->client->chat()->create([
+            "model" => "gpt-3.5-turbo",
+            "messages" => [
+                [
+                    "role" => "user",
+                    "content" => $prompt,
+                ],
+            ],
+        ]);
+
+        return $response["choices"][0]["message"]["content"];
+    }
+
+    private function checkIfRulesExist(string $countryName, object $currentRulesInCountry): bool
+    {
+        return in_array($countryName, $this->countriesKnownToHaveUniformRules, true) && $currentRulesInCountry !== null && $currentRulesInCountry->rules_en !== null && $currentRulesInCountry->rules_pl !== null;
+    }
+}

composer.json

@@ -8,13 +8,14 @@
         "php": "^8.2",
         "ext-dom": "*",
         "ext-pdo": "*",
-        "dedoc/scramble": "^0.9.0",
         "guzzlehttp/guzzle": "^7.7",
+        "dedoc/scramble": "^0.9.0",
         "inertiajs/inertia-laravel": "^1.0.0",
         "laravel/framework": "^10.13.0",
         "laravel/sanctum": "^3.2.5",
         "laravel/socialite": "^5.10",
         "laravel/tinker": "^2.8.1",
+        "openai-php/client": "^0.8.1",
         "sentry/sentry-laravel": "^3.7",
         "spatie/laravel-permission": "^6.1",
         "stichoza/google-translate-php": "^5.1",