++ gruppi di servizio: utenza dell'ex sorvegliante riattivabile, cestino e anonimizzazione, registro senza nomi

Un ex sorvegliante puo' guidare un gruppo nuovo: si riattiva la sua utenza. Il sorvegliante di un gruppo attivo non si cestina ne' si anonimizza; anonimizzando un ex sorvegliante si anonimizza anche l'utenza. Nel registro delle attivita' nome ed email dell'utenza del sorvegliante diventano "proclamatore #id". La voce "Il mio gruppo" dipende dal ruolo: l'amministratore passa ogni @can. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 17:55:38 +02:00
parent 96084499f5
commit f48d0e96c0
9 changed files with 164 additions and 12 deletions
--- a/HANDOFF.md
+++ b/HANDOFF.md
@@ -157,6 +157,20 @@ e non vede nient'altro. Scelte dell'utente:
  `LimitaSorvegliante`), gruppo archiviato (`sciolto_at`) per lo storico. I
  territori già dati restano ai membri. Si riparte con un gruppo nuovo.

+Casi aggiunti di mio, da far confermare all'utente:
+- Un ex sorvegliante può guidare un gruppo nuovo: `crea()` **riattiva** la
+  sua utenza disattivata (un proclamatore, un'utenza: `users.proclamatore_id`
+  è unico), con email e password temporanea nuove.
+- Il sorvegliante di un gruppo **attivo** non si sposta nel cestino né si
+  anonimizza (`ProclamatoreIndex`): prima si scioglie il gruppo. Un membro
+  spostato nel cestino lascia il gruppo. `Proclamatore::anonimizza()`
+  anonimizza anche l'utenza dell'ex sorvegliante (nome, email, password,
+  ruoli).
+- L'utenza del sorvegliante porta nome ed email del proclamatore: nel registro
+  delle attività `User::tapActivity()` li sostituisce con "proclamatore #id",
+  come vale per tutti i proclamatori. Restano invece in chiaro nella tabella
+  `users`, come per ogni utente.
+
 Dove sta:
 - Migrazione `2026_10_20_000010_gruppi_di_servizio`: tabella
  `gruppi_servizio`, colonne `gruppo_servizio_id` su proclamatori, territori e
--- a/README.md
+++ b/README.md
@@ -758,7 +758,10 @@ docker compose --profile dev up -d --build
  ancora dati tornano in reparto, i membri si liberano, l'utenza viene
  disattivata (anche una sessione aperta si chiude) e il gruppo resta nello
  storico. I territori già dati restano ai membri. Per ripartire si crea un
-  gruppo nuovo
+  gruppo nuovo; se il sorvegliante è lo stesso, si riattiva la sua utenza
+- Il sorvegliante di un gruppo attivo non si sposta nel cestino né si
+  anonimizza: prima si scioglie il gruppo. Anonimizzando un ex sorvegliante
+  si anonimizza anche la sua utenza

 ### Campagne
 - CRUD con date di inizio e fine
@@ -858,7 +861,8 @@ una revoca ha effetto immediato senza bisogno di ricaricare la pagina.
 - **Diritto all'oblio**: funzione di anonimizzazione irreversibile
 - **Retention**: cancellazione automatica dei log oltre il periodo configurato
 - **No dati sensibili nei log**: l'audit registra gli identificativi, non i nomi
-  in chiaro
+  in chiaro (anche per l'utenza di un sorvegliante di gruppo, che porta il nome
+  di un proclamatore)
 - **Attenzione ai backup**: il pacchetto `.zip` e l'export XML contengono i dati
  dei proclamatori **in chiaro** (l'export li legge decifrati). Vanno custoditi
  in un luogo protetto e cancellati quando non servono
--- a/app/Livewire/Gruppi/GruppiIndex.php
+++ b/app/Livewire/Gruppi/GruppiIndex.php
@@ -77,10 +77,10 @@ class GruppiIndex extends Component
            ->get();

        // Possono diventare sorveglianti i proclamatori attivi senza gruppo e
-        // senza già un'utenza.
+        // senza un'utenza attiva (quella di un gruppo sciolto si riattiva).
        $candidati = Proclamatore::attivi()
            ->whereNull('gruppo_servizio_id')
-            ->whereDoesntHave('utente')
+            ->whereDoesntHave('utente', fn ($q) => $q->whereNull('disattivato_at'))
            ->get();

        return view('livewire.gruppi.gruppi-index', [
--- a/app/Livewire/Proclamatori/ProclamatoreIndex.php
+++ b/app/Livewire/Proclamatori/ProclamatoreIndex.php
@@ -6,6 +6,7 @@ use App\Livewire\Concerns\Avvisa;
 use Livewire\Attributes\Url;
 use Livewire\Component;
 use Livewire\WithPagination;
+use App\Models\GruppoServizio;
 use App\Models\Proclamatore;

 class ProclamatoreIndex extends Component
@@ -70,7 +71,12 @@ class ProclamatoreIndex extends Component
            $this->avvisaErrore("Il proclamatore {$proclamatore->nome_completo} ha assegnazioni aperte. Rientra prima i territori.");
            return;
        }
+        if ($this->sorveglianteDiUnGruppo($proclamatore, 'spostarlo nel cestino')) {
+            return;
+        }

+        // Nel cestino non resta membro di un gruppo.
+        $proclamatore->update(['gruppo_servizio_id' => null]);
        $proclamatore->delete();
        $this->avvisa("Proclamatore {$proclamatore->nome_completo} spostato nel cestino.");
    }
@@ -80,10 +86,27 @@ class ProclamatoreIndex extends Component
        $this->authorize('settings.manage');

        $proclamatore = Proclamatore::findOrFail($id);
+        if ($this->sorveglianteDiUnGruppo($proclamatore, 'anonimizzarlo')) {
+            return;
+        }
+
        $proclamatore->anonimizza();
        $this->avvisa("Dati personali del proclamatore anonimizzati (GDPR).");
    }

+    /** Il sorvegliante di un gruppo attivo si toglie sciogliendo il gruppo, non da qui. */
+    private function sorveglianteDiUnGruppo(Proclamatore $proclamatore, string $azione): bool
+    {
+        $gruppo = GruppoServizio::attivi()->where('sorvegliante_id', $proclamatore->id)->first();
+        if (! $gruppo) {
+            return false;
+        }
+
+        $this->avvisaErrore("{$proclamatore->nome_completo} è il sorvegliante del gruppo {$gruppo->nome}: per {$azione} va prima sciolto il gruppo (Gruppi di servizio).");
+
+        return true;
+    }
+
    public function render()
    {
        // withCount rather than letting the view call
--- a/app/Models/Proclamatore.php
+++ b/app/Models/Proclamatore.php
@@ -108,7 +108,22 @@ class Proclamatore extends Model
        $this->nome = 'Anonimo';
        $this->cognome = 'Proclamatore #' . $this->id;
        $this->attivo = false;
+        $this->gruppo_servizio_id = null;
        $this->save();
        $this->delete(); // soft delete
+
+        // L'utenza di un ex sorvegliante (già disattivata: il sorvegliante di
+        // un gruppo attivo non si anonimizza) porta nome ed email in chiaro.
+        $utente = $this->utente()->first();
+        if ($utente) {
+            $utente->syncRoles([]);
+            $utente->forceFill([
+                'name' => 'Anonimo',
+                'email' => "utente-{$utente->id}@anonimo.invalid",
+                'password' => \Illuminate\Support\Str::random(40),
+                'remember_token' => null,
+                'disattivato_at' => $utente->disattivato_at ?? now(),
+            ])->save();
+        }
    }
 }
--- a/app/Models/User.php
+++ b/app/Models/User.php
@@ -91,6 +91,32 @@ class User extends Authenticatable implements MustVerifyEmail
            ->dontSubmitEmptyLogs();
    }

+    /**
+     * L'utenza di un sorvegliante porta nome (ed email, spesso) di un
+     * proclamatore: nel registro delle attività i proclamatori compaiono solo
+     * con l'identificativo, quindi anche qui.
+     */
+    public function tapActivity(\Spatie\Activitylog\Contracts\Activity $activity, string $eventName): void
+    {
+        $proclamatoreId = $this->proclamatore_id ?? $this->getOriginal('proclamatore_id');
+        if (! $proclamatoreId) {
+            return;
+        }
+
+        $activity->properties = collect($activity->properties)->map(function ($valori) use ($proclamatoreId) {
+            if (! is_array($valori)) {
+                return $valori;
+            }
+            foreach (['name', 'email'] as $campo) {
+                if (array_key_exists($campo, $valori)) {
+                    $valori[$campo] = "proclamatore #{$proclamatoreId}";
+                }
+            }
+
+            return $valori;
+        });
+    }
+
    protected static function booted(): void
    {
        // Un indirizzo nuovo va confermato di nuovo, chiunque lo cambi.
--- a/app/Services/GruppiServizio.php
+++ b/app/Services/GruppiServizio.php
@@ -42,28 +42,32 @@ class GruppiServizio
        if ($sorvegliante->gruppo_servizio_id) {
            throw new InvalidArgumentException("{$sorvegliante->nome_completo} fa già parte di un altro gruppo.");
        }
-        if ($sorvegliante->utente()->exists()) {
+        // Chi è stato sorvegliante di un gruppo sciolto ha già un'utenza,
+        // disattivata: si riattiva quella (un proclamatore, un'utenza).
+        $esistente = $sorvegliante->utente()->first();
+        if ($esistente && ! $esistente->isDisattivato()) {
            throw new InvalidArgumentException("{$sorvegliante->nome_completo} ha già un'utenza.");
        }
-        if (User::where('email', $email)->exists()) {
+        if (User::where('email', $email)->when($esistente, fn ($q) => $q->whereKeyNot($esistente->id))->exists()) {
            throw new InvalidArgumentException("L'email {$email} è già usata da un altro utente.");
        }

        $password = Str::password(12, symbols: false);

-        $gruppo = DB::transaction(function () use ($nome, $sorvegliante, $email, $membri, $password) {
+        $gruppo = DB::transaction(function () use ($nome, $sorvegliante, $email, $membri, $password, $esistente) {
            $gruppo = GruppoServizio::create(['nome' => $nome, 'sorvegliante_id' => $sorvegliante->id]);
            $sorvegliante->update(['gruppo_servizio_id' => $gruppo->id]);
            $this->aggiungiMembri($gruppo, $membri);

-            $utente = User::create([
+            $utente = $esistente ?? new User(['proclamatore_id' => $sorvegliante->id]);
+            $utente->forceFill([
                'name' => $sorvegliante->nome_completo,
                'email' => $email,
                'password' => $password,
                'password_change_required' => true,
-                'proclamatore_id' => $sorvegliante->id,
-            ]);
-            $utente->assignRole('sorvegliante');
+                'disattivato_at' => null,
+            ])->save();
+            $utente->syncRoles(['sorvegliante']);

            activity()->causedBy(auth()->user())->performedOn($gruppo)
                ->withProperties(['sorvegliante_id' => $sorvegliante->id, 'utente_id' => $utente->id])
--- a/resources/views/livewire/privacy.blade.php
+++ b/resources/views/livewire/privacy.blade.php
@@ -100,7 +100,7 @@
            <section>
                <h2 class="text-lg font-semibold text-gray-900 mb-2">Conservazione dei dati</h2>
                <ul class="list-disc list-inside space-y-1">
-                    <li>I dati di un proclamatore possono essere anonimizzati su richiesta: nome e cognome vengono cancellati in modo irreversibile.</li>
+                    <li>I dati di un proclamatore possono essere anonimizzati su richiesta: nome e cognome vengono cancellati in modo irreversibile, insieme a nome ed email dell'utenza se è stato sorvegliante di un gruppo.</li>
                    <li>Territori e proclamatori eliminati restano nel cestino finché non vengono eliminati definitivamente.</li>
                    <li>Il registro delle attività è conservato per <strong>{{ $auditRetention }} giorni</strong> (modificabile nelle impostazioni), poi cancellato automaticamente.</li>
                    <li>Lo storico delle assegnazioni è conservato per la durata necessaria alla gestione territoriale.</li>
--- a/tests/Feature/GruppiServizioTest.php
+++ b/tests/Feature/GruppiServizioTest.php
@@ -354,6 +354,72 @@ class GruppiServizioTest extends TestCase
        $this->actingAs($s->fresh())->get(route('profile'))->assertRedirect(route('login'));
    }

+    public function test_l_ex_sorvegliante_puo_guidare_un_gruppo_nuovo_con_la_stessa_utenza(): void
+    {
+        ['gruppo' => $vecchio, 'rossi' => $rossi, 'sorvegliante' => $s] = $this->gruppo();
+        app(GruppiServizio::class)->sciogli($vecchio);
+
+        $pagina = Livewire::test(GruppiIndex::class);
+        $this->assertContains((string) $rossi->id, collect($pagina->viewData('opzioniSorveglianti'))->pluck('valore')->all(), 'Torna tra i candidati');
+
+        [$nuovo, $password] = app(GruppiServizio::class)->crea('Zisa 2', $rossi->fresh(), 'mario.nuovo@example.test');
+
+        $utente = $s->fresh();
+        $this->assertSame(1, User::where('proclamatore_id', $rossi->id)->count(), 'Un proclamatore, un\'utenza');
+        $this->assertFalse($utente->isDisattivato());
+        $this->assertTrue($utente->hasRole('sorvegliante'));
+        $this->assertSame('mario.nuovo@example.test', $utente->email);
+        $this->assertTrue($utente->password_change_required);
+        $this->assertTrue(\Illuminate\Support\Facades\Hash::check($password, $utente->password));
+        $this->assertSame($nuovo->id, $utente->gruppoSorvegliato()?->id);
+    }
+
+    // ─── Proclamatori: cestino, anonimizzazione, registro ───────
+
+    public function test_il_sorvegliante_di_un_gruppo_attivo_non_si_cestina_ne_si_anonimizza(): void
+    {
+        ['rossi' => $rossi, 'verdi' => $verdi] = $this->gruppo();
+
+        Livewire::test(\App\Livewire\Proclamatori\ProclamatoreIndex::class)
+            ->call('deleteProclamatore', $rossi->id)
+            ->call('anonimizza', $rossi->id);
+        $this->assertFalse($rossi->fresh()->trashed());
+        $this->assertSame('Rossi', $rossi->fresh()->cognome);
+
+        // Un membro qualsiasi sì, e lascia il gruppo.
+        Livewire::test(\App\Livewire\Proclamatori\ProclamatoreIndex::class)->call('deleteProclamatore', $verdi->id);
+        $this->assertTrue($verdi->fresh()->trashed());
+        $this->assertNull($verdi->fresh()->gruppo_servizio_id);
+    }
+
+    public function test_anonimizzare_un_ex_sorvegliante_anonimizza_anche_la_sua_utenza(): void
+    {
+        ['gruppo' => $gruppo, 'rossi' => $rossi, 'sorvegliante' => $s] = $this->gruppo();
+        app(GruppiServizio::class)->sciogli($gruppo);
+
+        Livewire::test(\App\Livewire\Proclamatori\ProclamatoreIndex::class)->call('anonimizza', $rossi->id);
+
+        $utente = $s->fresh();
+        $this->assertSame('Anonimo', $utente->name);
+        $this->assertStringEndsWith('@anonimo.invalid', $utente->email);
+        $this->assertTrue($utente->isDisattivato());
+        $this->assertCount(0, $utente->roles);
+    }
+
+    public function test_nel_registro_delle_attivita_l_utenza_del_sorvegliante_non_ha_nome_ne_email(): void
+    {
+        ['sorvegliante' => $s] = $this->gruppo();
+        $s->update(['email' => 'mario.rossi@example.test']);
+
+        $voci = \Spatie\Activitylog\Models\Activity::where('subject_type', User::class)->where('subject_id', $s->id)->get();
+        $this->assertNotEmpty($voci);
+        foreach ($voci as $voce) {
+            $json = json_encode($voce->properties);
+            $this->assertStringNotContainsString('Rossi', $json);
+            $this->assertStringNotContainsString('mario', $json);
+        }
+    }
+
    // ─── Backup ─────────────────────────────────────────────────

    public function test_l_xml_conserva_gruppi_membri_pacchetto_e_utenza(): void