termanager2/app/Livewire/Assegnazioni/Assegna.php

<?php

namespace App\Livewire\Assegnazioni;

use App\Livewire\Concerns\RicordaRitorno;
use Livewire\Component;
use Livewire\Attributes\Computed;
use Livewire\Attributes\Locked;
use App\Models\Territorio;
use App\Models\Proclamatore;
use App\Models\Assegnazione;
use App\Models\AnnoTeocratico;
use App\Notifications\LinkTerritorio;
use App\Services\ConfigurazionePosta;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Notification;

class Assegna extends Component
{
    use RicordaRitorno;

    // ─── Invio del link ─────────────────────────────────────────
    //
    // Dopo l'assegnazione non si torna subito alla pagina: si sceglie il
    // canale (copia link sempre; WhatsApp ed email solo se il proclamatore ha
    // numero / indirizzo), si dice se il link è partito, e solo allora si va
    // avanti. Se la procedura si interrompe, l'assegnazione resta con
    // link_da_inviare e lo si segnala dove compare.

    /** L'assegnazione di cui si sta mandando il link. */
    #[Locked]
    public ?int $invioId = null;

    /** Il canale usato in questo invio (Assegnazione::CANALI_LINK). */
    #[Locked]
    public ?string $canaleUsato = null;

    public string $erroreInvio = '';

    public ?int $territorio_id = null;
    public ?int $proclamatore_id = null;
    public string $assigned_at = '';
    public string $territorioSearch = '';
    public string $linkSearch = '';

    // Optional pre-selection from parent context
    public ?int $preselectedTerritorioId = null;

    public function mount(?int $territorioId = null)
    {
        $this->preselectedTerritorioId = $territorioId;
        $this->territorio_id = $territorioId;
        $this->assigned_at = now()->format('Y-m-d');

        // ?invia=<id>: riprende l'invio di un link rimasto in sospeso (dalla
        // scheda del territorio).
        if ($invia = request()->integer('invia')) {
            $this->apriInvio($invia);
        }
    }

    protected function rules(): array
    {
        return [
            'territorio_id' => 'required|exists:territori,id',
            'proclamatore_id' => 'required|exists:proclamatori,id',
            'assigned_at' => 'required|date|before_or_equal:today',
        ];
    }

    public function save()
    {
        $this->validate();

        $territorio = Territorio::findOrFail($this->territorio_id);

        // Gli errori vanno sul campo e non in sessione: il messaggio flash
        // sta nel telaio della pagina, che Livewire non ridisegna, e il
        // rifiuto passerebbe inosservato.
        if ($territorio->assegnazioneCorrente) {
            $this->addError('territorio_id', "Il territorio {$territorio->numero} è già assegnato a {$territorio->assegnazioneCorrente->proclamatore->nome_completo}.");
            return;
        }

        if (!$territorio->attivo) {
            $this->addError('territorio_id', "Il territorio {$territorio->numero} è inattivo.");
            return;
        }

        $proclamatore = Proclamatore::findOrFail($this->proclamatore_id);
        if (!$proclamatore->attivo) {
            $this->addError('proclamatore_id', "Il proclamatore {$proclamatore->nome_completo} è inattivo.");
            return;
        }

        $assignedDate = \Carbon\Carbon::parse($this->assigned_at);
        $annoTeocratico = AnnoTeocratico::perData($assignedDate);

        // Controllo e inserimento sotto lo stesso lock sulla riga del
        // territorio: un doppio clic o due schede aperte non possono più
        // superare entrambi il controllo e creare due assegnazioni aperte.
        $esito = DB::transaction(function () use ($territorio, $assignedDate, $annoTeocratico) {
            Territorio::whereKey($territorio->id)->lockForUpdate()->first();

            $conflitto = Assegnazione::sovrappostaA($territorio->id, $assignedDate);
            if ($conflitto) {
                return "Il territorio {$territorio->numero} risulta assegnato {$conflitto->descrizionePeriodo()}: "
                    . ($conflitto->returned_at
                        ? 'la data di assegnazione non può essere precedente al suo rientro.'
                        : 'registrane prima il rientro.');
            }

            return Assegnazione::create([
                'territorio_id' => $this->territorio_id,
                'proclamatore_id' => $this->proclamatore_id,
                'anno_teocratico_id' => $annoTeocratico->id,
                'assigned_at' => $assignedDate,
                'created_by' => auth()->id(),
                // C'è un link da mandare solo se il territorio ha il PDF.
                'link_da_inviare' => (bool) $territorio->pdf_path,
            ]);
        });

        if (is_string($esito)) {
            $this->addError('assigned_at', $esito);

            return;
        }

        $assegnazione = $esito;

        activity()->causedBy(auth()->user())
            ->performedOn($assegnazione)
            // L'id, non il nome: nome e cognome sono cifrati nel database, e
            // copiati qui in chiaro restavano leggibili anche dopo
            // l'anonimizzazione. Il registro mostra il nome di oggi.
            ->withProperties([
                'territorio' => $territorio->numero,
                'proclamatore_id' => $proclamatore->id,
            ])
            ->log('assigned');

        // Non si va avanti: si apre l'invio del link (vedi in cima).
        $this->apriInvio($assegnazione->id);
    }

    /** Apre l'invio del link: subito dopo l'assegnazione, o da un'assegnazione rimasta in sospeso. */
    public function apriInvio(int $assegnazioneId): void
    {
        $this->authorize('territori.assign');

        $assegnazione = Assegnazione::aperte()->find($assegnazioneId);
        if (! $assegnazione) {
            return;
        }

        $this->invioId = $assegnazione->id;
        $this->canaleUsato = null;
        $this->erroreInvio = '';
    }

    /** Copia link o WhatsApp: l'invio vero lo fa chi usa l'app, qui si annota il canale. */
    public function canale(string $canale): void
    {
        $assegnazione = $this->assegnazioneInInvio();
        if (! $assegnazione || ! in_array($canale, ['copia', 'whatsapp'], true)) {
            return;
        }

        if ($canale === 'whatsapp' && ! $assegnazione->proclamatore?->whatsappUrl()) {
            return;
        }

        $this->canaleUsato = $canale;
        $this->erroreInvio = '';
    }

    /** Email: la manda l'applicazione, subito (vedi LinkTerritorio). */
    public function inviaEmail(): void
    {
        $assegnazione = $this->assegnazioneInInvio();
        $email = trim((string) $assegnazione?->proclamatore?->email);
        $link = $assegnazione?->shortPdfUrl();

        if (! $assegnazione || $email === '' || ! $link || ! app(ConfigurazionePosta::class)->funzionante()) {
            return;
        }

        try {
            Notification::route('mail', $email)->notifyNow(new LinkTerritorio($assegnazione, $link));
        } catch (\Throwable $e) {
            report($e);
            $this->erroreInvio = "L'email non è partita: controlla il server di posta, oppure usa un altro canale.";

            return;
        }

        $this->canaleUsato = 'email';
        $this->erroreInvio = '';
    }

    /**
     * La risposta a "Hai inviato il link?": la si registra e solo adesso si
     * va avanti. "Sì" vuole un canale usato; "No" lascia il link da inviare.
     */
    public function concludiInvio(bool $inviato)
    {
        $assegnazione = $this->assegnazioneInInvio();
        if (! $assegnazione) {
            $this->invioId = null;

            return null;
        }

        if ($inviato && $this->canaleUsato === null) {
            $this->erroreInvio = 'Scegli prima come mandare il link.';

            return null;
        }

        $assegnazione->registraInvioLink($inviato, $this->canaleUsato);

        // Nel log il canale e l'id del proclamatore, mai nome, numero o email.
        activity()->causedBy(auth()->user())
            ->performedOn($assegnazione)
            ->withProperties([
                'territorio' => $assegnazione->territorio?->numero,
                'proclamatore_id' => $assegnazione->proclamatore_id,
                'canale' => $inviato ? $this->canaleUsato : null,
            ])
            ->log($inviato ? 'link_inviato' : 'link_non_inviato');

        $numero = $assegnazione->territorio?->numero;
        $nome = $assegnazione->proclamatore?->nome_completo;
        $this->reset(['invioId', 'canaleUsato', 'erroreInvio']);

        session()->flash('success', $inviato
            ? "Territorio {$numero} assegnato a {$nome}: link inviato."
            : "Territorio {$numero} assegnato a {$nome}. Il link è ancora da inviare: lo trovi segnalato nell'elenco.");
        return $this->redirect($this->destinazione(route('assegnazioni.assegna')), navigate: true);
    }

    private function assegnazioneInInvio(): ?Assegnazione
    {
        if (! $this->invioId) {
            return null;
        }

        $this->authorize('territori.assign');

        return Assegnazione::with(['territorio', 'proclamatore'])->find($this->invioId);
    }

    public function toggleLinkSent(int $assegnazioneId): void
    {
        $this->authorize('territori.assign');
        $assegnazione = Assegnazione::findOrFail($assegnazioneId);
        $assegnazione->registraInvioLink(! $assegnazione->link_sent, $assegnazione->link_canale);
    }

    #[Computed]
    public function selectedThumbnailUrl(): ?string
    {
        if (!$this->territorio_id) {
            return null;
        }
        $t = Territorio::find($this->territorio_id);
        return $t?->miniaturaUrl();
    }

    public function render()
    {
        $territoriQuery = Territorio::where('attivo', true)
            ->whereDoesntHave('assegnazioni', fn($q) => $q->aperte())
            ->with(['zona', 'tipologia']);

        if (trim($this->territorioSearch) !== '') {
            $term = trim($this->territorioSearch);
            $territoriQuery->where(function ($q) use ($term) {
                $q->where('numero', 'like', "%{$term}%")
                    ->orWhereHas('zona', fn($z) => $z->where('nome', 'like', "%{$term}%"))
                    ->orWhereHas('tipologia', fn($t) => $t->where('nome', 'like', "%{$term}%"));
            });
        }

        $territoriDisponibili = $territoriQuery
            ->orderBy('numero')
            ->get();

        $proclamatoriAttivi = Proclamatore::attivi()
            ->get()
            ->sortBy(fn($p) => mb_strtolower($p->cognome . ' ' . $p->nome));

        // All currently assigned territories with links
        $assegnazioniAperte = Assegnazione::aperte()
            ->with(['territorio.zona', 'proclamatore'])
            ->get()
            ->sortBy(fn($a) => (int) $a->territorio?->numero);

        // Ricerca rapida nella lista dei link: numero territorio, zona,
        // proclamatore in un solo campo. In memoria perché nome/cognome del
        // proclamatore sono cifrati e non filtrabili via SQL.
        $assegnazioniAperteVisibili = $assegnazioniAperte;
        if (trim($this->linkSearch) !== '') {
            $term = mb_strtolower(trim($this->linkSearch));
            $assegnazioniAperteVisibili = $assegnazioniAperte->filter(function ($a) use ($term) {
                $haystack = mb_strtolower(
                    ($a->territorio?->numero ?? '') . ' ' .
                    ($a->territorio?->zona?->nome ?? '') . ' ' .
                    ($a->proclamatore?->nome_completo ?? '')
                );
                return str_contains($haystack, $term);
            })->values();
        }

        // Il link scade alla soglia rientro (giorni_per_smarrito).
        $sogliaRientro = max(1, (int) \App\Models\Setting::getValue('giorni_per_smarrito', 120));

        // L'invio in corso; se nel frattempo l'assegnazione è rientrata o
        // sparita non c'è più niente da mandare.
        $invio = $this->invioId ? Assegnazione::aperte()->with(['territorio', 'proclamatore'])->find($this->invioId) : null;
        if ($this->invioId && ! $invio) {
            $this->reset(['invioId', 'canaleUsato', 'erroreInvio']);
        }

        return view('livewire.assegnazioni.assegna', [
            'invio' => $invio,
            'postaAttiva' => $invio ? app(ConfigurazionePosta::class)->funzionante() : false,
            'territoriDisponibili' => $territoriDisponibili,
            'proclamatoriAttivi' => $proclamatoriAttivi,
            'assegnazioniAperte' => $assegnazioniAperte,
            'assegnazioniAperteVisibili' => $assegnazioniAperteVisibili,
            'sogliaRientro' => $sogliaRientro,
        ]);
    }
}