feat: ajout du provisionnement des comptes Gitea pour les utilisateurs lors de la soumission de suggestions

app/Http/Controllers/SuggestionController.php

@@ -4,6 +4,7 @@ namespace App\Http\Controllers;
 
 use App\Models\Utilisateur;
 use App\Services\GiteaIssueService;
+use App\Services\GiteaUserService;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Validation\Rule;
@@ -17,7 +18,7 @@ class SuggestionController extends Controller
     }
 
     // Traiter la suggestion et créer un ticket dans Gitea
-    public function store(Request $request, GiteaIssueService $gitea)
+    public function store(Request $request, GiteaIssueService $gitea, GiteaUserService $giteaUsers)
     {
         $data = $request->validate([
             'type' => ['required', Rule::in(['Modification', 'Ajout', 'Correction'])],
@@ -37,6 +38,10 @@ class SuggestionController extends Controller
         $user = Auth::user();
         $auteur = $user->Pseudo ?? 'Utilisateur';
 
+        // Compte Gitea de l'utilisateur (créé au premier envoi) pour que le
+        // ticket soit ouvert en son nom et qu'il puisse le suivre.
+        $compte = $giteaUsers->assurerCompte($user);
+
         $title = "[{$data['type']}] {$data['titre']}";
 
         $body = "**Type de demande :** {$data['type']}\n"
@@ -46,9 +51,20 @@ class SuggestionController extends Controller
             ."---\n"
             .'_Ticket créé automatiquement depuis le formulaire de suggestions du site._';
 
-        if ($gitea->createIssue($title, $body)) {
-            return redirect()->route('suggestions.create')
+        if ($gitea->createIssue($title, $body, $compte['username'] ?? null)) {
+            $redirect = redirect()->route('suggestions.create')
                 ->with('success', 'Merci ! Votre suggestion a bien été transmise à l\'équipe.');
+
+            // Identifiants affichés UNE seule fois, uniquement si le compte vient d'être créé.
+            if ($compte !== null && $compte['motDePasseInitial'] !== null) {
+                $redirect->with('gitea_compte', [
+                    'url' => rtrim((string) config('services.gitea.url'), '/'),
+                    'username' => $compte['username'],
+                    'mot_de_passe' => $compte['motDePasseInitial'],
+                ]);
+            }
+
+            return $redirect;
         }
 
         return back()->withInput()->withErrors([

app/Models/Utilisateur.php

@@ -11,6 +11,7 @@ use Illuminate\Support\Carbon;
  * @property string $Email
  * @property string $MotDePasse
  * @property string $Pseudo
+ * @property string|null $GiteaUsername
  * @property string $Statut
  * @property int $ID_Role
  * @property Carbon $DateInscription
@@ -37,6 +38,7 @@ class Utilisateur extends Authenticatable
         'Email',
         'MotDePasse',
         'Pseudo',
+        'GiteaUsername',
         'Statut',
         'ID_Role',
         'DateInscription',

app/Services/GiteaIssueService.php

@@ -2,6 +2,7 @@
 
 namespace App\Services;
 
+use Illuminate\Http\Client\Response;
 use Illuminate\Support\Facades\Http;
 use Illuminate\Support\Facades\Log;
 
@@ -10,9 +11,13 @@ class GiteaIssueService
     /**
      * Crée un ticket (issue) dans le dépôt Gitea configuré.
      *
+     * Si $sudo est fourni (username Gitea de l'utilisateur), le ticket est
+     * créé en son nom via l'en-tête "Sudo" (nécessite un token admin). En cas
+     * de refus, on retombe sur une création avec le compte de service.
+     *
      * @return bool true si le ticket a bien été créé, false sinon.
      */
-    public function createIssue(string $title, string $body): bool
+    public function createIssue(string $title, string $body, ?string $sudo = null): bool
     {
         $url = rtrim((string) config('services.gitea.url'), '/');
         $repo = trim((string) config('services.gitea.repo'), '/');
@@ -25,14 +30,15 @@ class GiteaIssueService
         }
 
         try {
-            // Gitea attend l'en-tête "Authorization: token <TOKEN>".
-            $response = Http::withToken($token, 'token')
-                ->acceptJson()
-                ->timeout(10)
-                ->post("{$url}/api/v1/repos/{$repo}/issues", [
-                    'title' => $title,
-                    'body' => $body,
+            $response = $this->postIssue($url, $repo, $token, $title, $body, $sudo);
+
+            if ($sudo !== null && $response->failed()) {
+                Log::warning('Création du ticket au nom de l\'utilisateur refusée, repli sur le compte de service.', [
+                    'sudo' => $sudo,
+                    'status' => $response->status(),
                 ]);
+                $response = $this->postIssue($url, $repo, $token, $title, $body, null);
+            }
         } catch (\Throwable $e) {
             Log::error('Appel API Gitea impossible : '.$e->getMessage());
 
@@ -50,4 +56,27 @@ class GiteaIssueService
 
         return true;
     }
+
+    private function postIssue(
+        string $url,
+        string $repo,
+        string $token,
+        string $title,
+        string $body,
+        ?string $sudo,
+    ): Response {
+        // Gitea attend l'en-tête "Authorization: token <TOKEN>".
+        $request = Http::withToken($token, 'token')
+            ->acceptJson()
+            ->timeout(10);
+
+        if ($sudo !== null) {
+            $request = $request->withHeaders(['Sudo' => $sudo]);
+        }
+
+        return $request->post("{$url}/api/v1/repos/{$repo}/issues", [
+            'title' => $title,
+            'body' => $body,
+        ]);
+    }
 }

app/Services/GiteaUserService.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\Utilisateur;
+use Illuminate\Http\Client\PendingRequest;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Str;
+
+/**
+ * Provisionnement des comptes Gitea des utilisateurs du site.
+ *
+ * Au premier envoi de suggestion, un compte Gitea est créé pour
+ * l'utilisateur (API admin) afin qu'il puisse suivre, commenter et
+ * créer ses propres tickets. Le mot de passe initial n'est renvoyé
+ * qu'une seule fois et n'est jamais stocké côté application.
+ */
+class GiteaUserService
+{
+    /**
+     * Garantit que l'utilisateur possède un compte Gitea.
+     *
+     * @return array{username: string, motDePasseInitial: string|null}|null
+     *                                                                      null si Gitea n'est pas configuré ou si la création a échoué
+     *                                                                      (le ticket sera alors créé avec le compte de service).
+     */
+    public function assurerCompte(Utilisateur $utilisateur): ?array
+    {
+        if ($utilisateur->GiteaUsername) {
+            return ['username' => $utilisateur->GiteaUsername, 'motDePasseInitial' => null];
+        }
+
+        $client = $this->client();
+
+        if ($client === null) {
+            return null;
+        }
+
+        // Un compte existe peut-être déjà avec cet email (créé hors du site) : on le réutilise.
+        if ($existant = $this->chercherParEmail($client, $utilisateur->Email)) {
+            $utilisateur->GiteaUsername = $existant;
+            $utilisateur->save();
+
+            return ['username' => $existant, 'motDePasseInitial' => null];
+        }
+
+        $username = $this->genererUsername($utilisateur);
+        $motDePasse = Str::password(16);
+
+        try {
+            $response = $client->post('/api/v1/admin/users', [
+                'username' => $username,
+                'email' => $utilisateur->Email,
+                'password' => $motDePasse,
+                'full_name' => $utilisateur->Pseudo ?? $username,
+                'must_change_password' => true,
+                'send_notify' => false,
+            ]);
+        } catch (\Throwable $e) {
+            Log::error('Appel API Gitea (création utilisateur) impossible : '.$e->getMessage());
+
+            return null;
+        }
+
+        if ($response->failed()) {
+            Log::warning('Création du compte Gitea échouée (token admin requis ?)', [
+                'status' => $response->status(),
+                'body' => $response->body(),
+            ]);
+
+            return null;
+        }
+
+        $utilisateur->GiteaUsername = $username;
+        $utilisateur->save();
+
+        return ['username' => $username, 'motDePasseInitial' => $motDePasse];
+    }
+
+    private function client(): ?PendingRequest
+    {
+        $url = rtrim((string) config('services.gitea.url'), '/');
+        $token = (string) (config('services.gitea.admin_token') ?: config('services.gitea.token'));
+
+        if ($url === '' || $token === '') {
+            Log::warning('Gitea non configuré (URL / token manquant) : compte utilisateur non créé.');
+
+            return null;
+        }
+
+        return Http::baseUrl($url)
+            ->withToken($token, 'token')
+            ->acceptJson()
+            ->timeout(10);
+    }
+
+    private function chercherParEmail(PendingRequest $client, string $email): ?string
+    {
+        try {
+            $response = $client->get('/api/v1/admin/emails/search', ['q' => $email]);
+        } catch (\Throwable) {
+            return null;
+        }
+
+        if ($response->failed()) {
+            return null;
+        }
+
+        foreach ($response->json() ?? [] as $entree) {
+            if (strcasecmp($entree['email'] ?? '', $email) === 0) {
+                return $entree['username'] ?? null;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Username déterministe et unique : pseudo en slug, suffixé de l'ID interne.
+     */
+    private function genererUsername(Utilisateur $utilisateur): string
+    {
+        $base = Str::slug((string) ($utilisateur->Pseudo ?? ''));
+
+        if ($base === '') {
+            $base = 'utilisateur';
+        }
+
+        return Str::limit($base, 30, '').'-'.$utilisateur->ID_Utilisateur;
+    }
+}