Editor piantine: bozza automatica e pubblicazione con anteprima
- Il disegno è bozza e si salva da solo; i dati del territorio si modificano dall'editor e valgono subito nel gestionale. - Un solo "Pubblica" (immagine + PDF), uguale in editor e gestione: anteprima preparata in coda su disco privato, conferma obbligatoria, rifiutata se nel frattempo è cambiato qualcosa di stampato. - Stati Bozza / Pubblicata / Modifiche da pubblicare, calcolati sull'impronta di confine e dati stampati e sul PDF in uso. - Gestione riscritta: stato, ricerca, filtri, storico paginato. - Editor ridisegnato a tre zone, utilizzabile anche su tablet e telefono. - Avvisi via evento (trait Avvisa + <x-avvisi>). - .gitattributes: script shell sempre LF, altrimenti il container locale su Windows non parte. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -2,45 +2,54 @@
|
||||
|
||||
namespace App\Livewire\Piantine;
|
||||
|
||||
use App\Livewire\Concerns\Avvisa;
|
||||
use App\Models\Territorio;
|
||||
use App\Models\TerritorioMappa;
|
||||
use App\Models\Tipologia;
|
||||
use App\Models\Zona;
|
||||
use App\Services\Piantine\PiantinaRenderer;
|
||||
use App\Services\Piantine\PiantineArea;
|
||||
use Illuminate\Support\Facades\DB;
|
||||
use Illuminate\Support\Facades\Storage;
|
||||
use Illuminate\Validation\Rule;
|
||||
use Livewire\Attributes\Layout;
|
||||
use Livewire\Attributes\Locked;
|
||||
use Livewire\Attributes\On;
|
||||
use Livewire\Component;
|
||||
|
||||
/**
|
||||
* Editor delle piantine a schermo intero (solo amministratore).
|
||||
*
|
||||
* Una pagina sola con la mappa grande quanto la finestra e i comandi in una
|
||||
* barra sottile in alto: tagliare un confine su una cartografia larga un terzo
|
||||
* di schermo significa sbagliarlo, e questo disegno finisce stampato su un
|
||||
* modulo che poi gira di mano in mano.
|
||||
* Tutto quello che si fa qui è bozza e si salva da solo: il confine a ogni
|
||||
* disegno o spostamento di vertice, il nome e il collegamento appena cambiano.
|
||||
* La bozza non tocca il PDF del territorio, che cambia solo con "Pubblica"
|
||||
* (anteprima e conferma, nel componente Pubblicazione). I dati del territorio
|
||||
* — numero, zona, tipologia, confini — sono invece dati del gestionale e si
|
||||
* salvano subito, come dalla scheda territorio.
|
||||
*
|
||||
* Il disegno viene prima del numero. Si taglia l'area guardando le strade, e
|
||||
* solo dopo si compila la scheda del territorio — che può anche non esistere
|
||||
* ancora: numero, zona, tipologia e confini si scrivono da qui, e se la zona o
|
||||
* la tipologia mancano si creano sul posto, senza abbandonare il disegno.
|
||||
* Disegnare crea sempre una piantina nuova: per cambiare il confine di quella
|
||||
* aperta ci sono "Modifica vertici" e "Ridisegna", espliciti. Prima un
|
||||
* disegno fatto con una piantina aperta ne sostituiva il confine in silenzio.
|
||||
*
|
||||
* Con la mappa si parla per eventi, e solo con il necessario: i dati di tutte
|
||||
* le piantine li chiede la mappa una volta (datiMappa), poi riceve solo la
|
||||
* piantina cambiata. Prima ogni richiesta rispediva tutte le geometrie e
|
||||
* l'area KML, fino a una decina di MB per aprire un pannello.
|
||||
*/
|
||||
#[Layout('components.layouts.editor')]
|
||||
class PiantineEditor extends Component
|
||||
{
|
||||
/** Piantina aperta, o null quando se ne sta disegnando una nuova. */
|
||||
use Avvisa;
|
||||
|
||||
/** Piantina aperta, o null quando non ce n'è nessuna selezionata. */
|
||||
#[Locked]
|
||||
public ?int $mappaId = null;
|
||||
|
||||
public string $nome = '';
|
||||
|
||||
/** Geometria appena disegnata, non ancora salvata. */
|
||||
public ?string $geometriaInAttesa = null;
|
||||
/** Ora dell'ultimo salvataggio automatico, per l'indicazione in testata. */
|
||||
public string $salvatoAlle = '';
|
||||
|
||||
public bool $pannelloAperto = false;
|
||||
|
||||
// ─── Scheda del territorio ──────────────────────────────────────────────
|
||||
// ─── Territorio ─────────────────────────────────────────────────────────
|
||||
|
||||
/** '' = nessun territorio, 'nuovo' = da creare, altrimenti l'id. */
|
||||
public string $territorioScelto = '';
|
||||
@@ -53,7 +62,6 @@ class PiantineEditor extends Component
|
||||
|
||||
public string $confini = '';
|
||||
|
||||
/** Campi di creazione al volo, aperti solo quando servono. */
|
||||
public string $nuovaZona = '';
|
||||
|
||||
public string $nuovaTipologia = '';
|
||||
@@ -61,7 +69,7 @@ class PiantineEditor extends Component
|
||||
public function mount(?int $mappa = null): void
|
||||
{
|
||||
if ($mappa !== null && TerritorioMappa::whereKey($mappa)->exists()) {
|
||||
$this->apri($mappa);
|
||||
$this->carica(TerritorioMappa::with('territorio')->find($mappa));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -73,38 +81,46 @@ class PiantineEditor extends Component
|
||||
$mappa = TerritorioMappa::with('territorio')->find(is_numeric($mappaId) ? (int) $mappaId : null);
|
||||
|
||||
if (! $mappa) {
|
||||
$this->avvisaErrore('Questa piantina non esiste più: forse è stata eliminata da un\'altra scheda.');
|
||||
$this->dispatch('piantina-rimossa', mappaId: (int) $mappaId);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
$this->mappaId = $mappa->id;
|
||||
$this->nome = (string) $mappa->nome;
|
||||
$this->geometriaInAttesa = null;
|
||||
$this->pannelloAperto = true;
|
||||
|
||||
$this->caricaScheda($mappa->territorio);
|
||||
$this->aggiornaMappaJs(inquadra: true);
|
||||
$this->carica($mappa);
|
||||
$this->dispatch('piantina-selezionata', mappaId: $mappa->id, inquadra: true);
|
||||
}
|
||||
|
||||
/** "Nuova piantina": si deseleziona e la mappa entra in modalità disegno. */
|
||||
public function nuova(): void
|
||||
{
|
||||
$this->svuota();
|
||||
$this->dispatch('piantina-selezionata', mappaId: null, inquadra: false);
|
||||
$this->dispatch('editor-disegna');
|
||||
}
|
||||
|
||||
private function carica(TerritorioMappa $mappa): void
|
||||
{
|
||||
$this->resetValidation();
|
||||
$this->mappaId = $mappa->id;
|
||||
$this->nome = (string) $mappa->nome;
|
||||
$this->salvatoAlle = '';
|
||||
$this->nuovaZona = '';
|
||||
$this->nuovaTipologia = '';
|
||||
$this->caricaTerritorio($mappa->territorio);
|
||||
}
|
||||
|
||||
private function svuota(): void
|
||||
{
|
||||
$this->resetValidation();
|
||||
$this->reset([
|
||||
'mappaId', 'nome', 'geometriaInAttesa',
|
||||
'mappaId', 'nome', 'salvatoAlle',
|
||||
'territorioScelto', 'numero', 'zonaId', 'tipologiaId', 'confini',
|
||||
'nuovaZona', 'nuovaTipologia',
|
||||
]);
|
||||
$this->resetValidation();
|
||||
$this->pannelloAperto = true;
|
||||
|
||||
$this->aggiornaMappaJs();
|
||||
}
|
||||
|
||||
public function chiudiPannello(): void
|
||||
{
|
||||
$this->pannelloAperto = false;
|
||||
}
|
||||
|
||||
/** Riempie i campi della scheda dal territorio collegato (o li svuota). */
|
||||
private function caricaScheda(?Territorio $territorio): void
|
||||
private function caricaTerritorio(?Territorio $territorio): void
|
||||
{
|
||||
$this->territorioScelto = $territorio ? (string) $territorio->id : '';
|
||||
$this->numero = (string) ($territorio->numero ?? '');
|
||||
@@ -113,12 +129,118 @@ class PiantineEditor extends Component
|
||||
$this->confini = (string) ($territorio->confini ?? '');
|
||||
}
|
||||
|
||||
/** Cambiare territorio nella tendina ricarica la sua scheda. */
|
||||
// ─── Confine (bozza, salvataggio automatico) ────────────────────────────
|
||||
|
||||
/**
|
||||
* Arriva dalla mappa dopo un disegno o lo spostamento di un vertice.
|
||||
* $nuova: il disegno è una piantina nuova (strumento "Disegna"), non il
|
||||
* confine ridisegnato di quella aperta.
|
||||
*/
|
||||
#[On('geometria-modificata')]
|
||||
public function salvaGeometria($geometry, bool $nuova = false): void
|
||||
{
|
||||
if (! $this->geometriaValida($geometry)) {
|
||||
$this->avvisaErrore('Il confine disegnato non è valido: ridisegnalo.');
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
$geojson = json_encode($geometry);
|
||||
$mappa = (! $nuova && $this->mappaId) ? TerritorioMappa::find($this->mappaId) : null;
|
||||
|
||||
if ($mappa) {
|
||||
$mappa->update(['geojson' => $geojson]);
|
||||
} else {
|
||||
$mappa = TerritorioMappa::create(['geojson' => $geojson]);
|
||||
$this->carica($mappa);
|
||||
activity()->causedBy(auth()->user())->log('piantina_creata');
|
||||
}
|
||||
|
||||
$this->salvato($mappa, seleziona: true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Anelli chiusi di almeno quattro punti con coordinate nei limiti: un
|
||||
* record malformato faceva fallire il disegno di tutte le piantine.
|
||||
*/
|
||||
private function geometriaValida($geometry): bool
|
||||
{
|
||||
if (! is_array($geometry) || ! is_array($geometry['coordinates'] ?? null)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$poligoni = match ($geometry['type'] ?? null) {
|
||||
'Polygon' => [$geometry['coordinates']],
|
||||
'MultiPolygon' => $geometry['coordinates'],
|
||||
default => null,
|
||||
};
|
||||
|
||||
if (! $poligoni) {
|
||||
return false;
|
||||
}
|
||||
|
||||
foreach ($poligoni as $anelli) {
|
||||
if (! is_array($anelli) || $anelli === []) {
|
||||
return false;
|
||||
}
|
||||
foreach ($anelli as $anello) {
|
||||
if (! is_array($anello) || count($anello) < 4) {
|
||||
return false;
|
||||
}
|
||||
foreach ($anello as $punto) {
|
||||
if (! is_array($punto) || count($punto) < 2
|
||||
|| ! is_numeric($punto[0]) || ! is_numeric($punto[1])
|
||||
|| abs($punto[0]) > 180 || abs($punto[1]) > 90) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/** Riporta il confine a quello pubblicato. */
|
||||
public function scartaModifiche(): void
|
||||
{
|
||||
$mappa = $this->mappaAperta();
|
||||
|
||||
if (! $mappa || ! $mappa->bozzaScartabile()) {
|
||||
return;
|
||||
}
|
||||
|
||||
$mappa->update(['geojson' => $mappa->geojson_pubblicato]);
|
||||
$this->salvato($mappa, seleziona: true);
|
||||
$this->avvisa('Confine riportato a quello pubblicato.');
|
||||
}
|
||||
|
||||
public function updatedNome(): void
|
||||
{
|
||||
$mappa = $this->mappaAperta();
|
||||
|
||||
if (! $mappa) {
|
||||
return;
|
||||
}
|
||||
|
||||
$nome = trim($this->nome);
|
||||
$mappa->update(['nome' => $nome !== '' ? mb_substr($nome, 0, 120) : null]);
|
||||
$this->salvato($mappa);
|
||||
}
|
||||
|
||||
// ─── Collegamento al territorio ─────────────────────────────────────────
|
||||
|
||||
public function updatedTerritorioScelto(string $valore): void
|
||||
{
|
||||
$this->resetValidation();
|
||||
$mappa = $this->mappaAperta();
|
||||
|
||||
if (! $mappa) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ($valore === 'nuovo') {
|
||||
// Si compilano i campi e si crea con il pulsante: un territorio
|
||||
// non nasce da un salvataggio automatico a metà digitazione.
|
||||
$this->numero = '';
|
||||
$this->zonaId = '';
|
||||
$this->tipologiaId = '';
|
||||
@@ -127,34 +249,158 @@ class PiantineEditor extends Component
|
||||
return;
|
||||
}
|
||||
|
||||
$this->caricaScheda($valore === '' ? null : Territorio::find($valore));
|
||||
}
|
||||
if ($valore === '') {
|
||||
$numero = $mappa->territorio?->numero;
|
||||
$mappa->update([
|
||||
'territorio_id' => null,
|
||||
// Senza territorio serve un'etichetta, altrimenti la piantina
|
||||
// finisce in elenco come un anonimo "Piantina #12".
|
||||
'nome' => $mappa->nome ?: ($numero ? "Ex territorio {$numero}" : null),
|
||||
]);
|
||||
$this->nome = (string) $mappa->nome;
|
||||
$this->caricaTerritorio(null);
|
||||
$this->salvato($mappa);
|
||||
|
||||
// ─── Disegno ────────────────────────────────────────────────────────────
|
||||
|
||||
#[On('poligono-disegnato')]
|
||||
public function poligonoDisegnato($geometry): void
|
||||
{
|
||||
if (! is_array($geometry)
|
||||
|| ! in_array($geometry['type'] ?? null, ['Polygon', 'MultiPolygon'], true)
|
||||
|| ! is_array($geometry['coordinates'] ?? null)) {
|
||||
return;
|
||||
}
|
||||
|
||||
$this->geometriaInAttesa = json_encode($geometry);
|
||||
$this->pannelloAperto = true;
|
||||
$territorio = Territorio::find($valore);
|
||||
if (! $territorio) {
|
||||
$this->addError('territorioScelto', 'Il territorio scelto non esiste più.');
|
||||
$this->caricaTerritorio($mappa->territorio);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
$occupata = TerritorioMappa::where('territorio_id', $territorio->id)->whereKeyNot($mappa->id)->exists();
|
||||
if ($occupata) {
|
||||
$this->addError('territorioScelto', "Il territorio {$territorio->numero} ha già una piantina.");
|
||||
$this->caricaTerritorio($mappa->territorio);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
$mappa->update(['territorio_id' => $territorio->id]);
|
||||
$this->caricaTerritorio($territorio);
|
||||
activity()->causedBy(auth()->user())->performedOn($territorio)->log('piantina_collegata');
|
||||
$this->salvato($mappa);
|
||||
}
|
||||
|
||||
public function scartaDisegno(): void
|
||||
public function creaTerritorio(): void
|
||||
{
|
||||
$this->geometriaInAttesa = null;
|
||||
$this->aggiornaMappaJs();
|
||||
$mappa = $this->mappaAperta();
|
||||
|
||||
if (! $mappa || $this->territorioScelto !== 'nuovo') {
|
||||
return;
|
||||
}
|
||||
|
||||
$this->numero = trim($this->numero);
|
||||
$this->confini = trim($this->confini);
|
||||
|
||||
$this->validate(
|
||||
[
|
||||
'numero' => ['required', 'string', 'max:20', Rule::unique('territori', 'numero')],
|
||||
'zonaId' => ['nullable', Rule::exists('zone', 'id')],
|
||||
'tipologiaId' => ['nullable', Rule::exists('tipologie', 'id')],
|
||||
'confini' => ['nullable', 'string', 'max:5000'],
|
||||
],
|
||||
$this->messaggiTerritorio(),
|
||||
);
|
||||
|
||||
try {
|
||||
$territorio = DB::transaction(function () use ($mappa) {
|
||||
$territorio = Territorio::create($this->valoriTerritorio() + ['attivo' => true]);
|
||||
$mappa->update(['territorio_id' => $territorio->id]);
|
||||
|
||||
return $territorio;
|
||||
});
|
||||
} catch (\Illuminate\Database\UniqueConstraintViolationException) {
|
||||
$this->addError('numero', 'Esiste già un territorio con questo numero.');
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
activity()->causedBy(auth()->user())->performedOn($territorio)->log('territorio_creato_da_piantine');
|
||||
|
||||
$this->caricaTerritorio($territorio);
|
||||
$this->salvato($mappa);
|
||||
$this->avvisa("Territorio {$territorio->numero} creato e collegato.");
|
||||
}
|
||||
|
||||
// ─── Dati del territorio (salvati subito nel gestionale) ────────────────
|
||||
|
||||
public function updatedNumero(): void
|
||||
{
|
||||
$this->salvaCampoTerritorio('numero');
|
||||
}
|
||||
|
||||
public function updatedZonaId(): void
|
||||
{
|
||||
$this->salvaCampoTerritorio('zonaId');
|
||||
}
|
||||
|
||||
public function updatedTipologiaId(): void
|
||||
{
|
||||
$this->salvaCampoTerritorio('tipologiaId');
|
||||
}
|
||||
|
||||
public function updatedConfini(): void
|
||||
{
|
||||
$this->salvaCampoTerritorio('confini');
|
||||
}
|
||||
|
||||
private function salvaCampoTerritorio(string $campo): void
|
||||
{
|
||||
// In creazione i campi si raccolgono e basta: li salva creaTerritorio().
|
||||
$territorio = $this->territorioCollegato();
|
||||
if (! $territorio) {
|
||||
return;
|
||||
}
|
||||
|
||||
$this->numero = trim($this->numero);
|
||||
|
||||
$regole = [
|
||||
'numero' => ['required', 'string', 'max:20', Rule::unique('territori', 'numero')->ignore($territorio->id)],
|
||||
'zonaId' => ['nullable', Rule::exists('zone', 'id')],
|
||||
'tipologiaId' => ['nullable', Rule::exists('tipologie', 'id')],
|
||||
'confini' => ['nullable', 'string', 'max:5000'],
|
||||
];
|
||||
|
||||
$this->validateOnly($campo, $regole, $this->messaggiTerritorio());
|
||||
|
||||
// Solo la colonna del campo cambiato: con un altro campo ancora non
|
||||
// valido a schermo, riscrivere tutto salverebbe anche quel valore.
|
||||
$colonna = ['numero' => 'numero', 'zonaId' => 'zona_id', 'tipologiaId' => 'tipologia_id', 'confini' => 'confini'][$campo];
|
||||
$territorio->update([$colonna => $this->valoriTerritorio()[$colonna]]);
|
||||
|
||||
$this->salvato($this->mappaAperta());
|
||||
}
|
||||
|
||||
private function valoriTerritorio(): array
|
||||
{
|
||||
return [
|
||||
'numero' => trim($this->numero),
|
||||
'zona_id' => $this->zonaId !== '' ? (int) $this->zonaId : null,
|
||||
'tipologia_id' => $this->tipologiaId !== '' ? (int) $this->tipologiaId : null,
|
||||
'confini' => trim($this->confini) !== '' ? trim($this->confini) : null,
|
||||
];
|
||||
}
|
||||
|
||||
private function messaggiTerritorio(): array
|
||||
{
|
||||
return [
|
||||
'numero.required' => 'Il territorio ha bisogno di un numero.',
|
||||
'numero.unique' => 'Esiste già un territorio con questo numero.',
|
||||
'numero.max' => 'Il numero può avere al massimo 20 caratteri.',
|
||||
'confini.max' => 'I confini possono avere al massimo 5000 caratteri.',
|
||||
];
|
||||
}
|
||||
|
||||
// ─── Zona e tipologia create sul posto ──────────────────────────────────
|
||||
|
||||
public function creaZona()
|
||||
public function creaZona(): void
|
||||
{
|
||||
$this->nuovaZona = trim($this->nuovaZona);
|
||||
$dati = $this->validate(
|
||||
['nuovaZona' => ['required', 'string', 'max:100', Rule::unique('zone', 'nome')]],
|
||||
[
|
||||
@@ -163,16 +409,17 @@ class PiantineEditor extends Component
|
||||
],
|
||||
);
|
||||
|
||||
$zona = Zona::create(['nome' => trim($dati['nuovaZona']), 'attivo' => true]);
|
||||
$zona = Zona::create(['nome' => $dati['nuovaZona'], 'attivo' => true]);
|
||||
|
||||
$this->zonaId = (string) $zona->id;
|
||||
$this->nuovaZona = '';
|
||||
|
||||
session()->flash('success', "Zona «{$zona->nome}» creata e selezionata.");
|
||||
$this->updatedZonaId();
|
||||
$this->avvisa("Zona «{$zona->nome}» creata e selezionata.");
|
||||
}
|
||||
|
||||
public function creaTipologia()
|
||||
public function creaTipologia(): void
|
||||
{
|
||||
$this->nuovaTipologia = trim($this->nuovaTipologia);
|
||||
$dati = $this->validate(
|
||||
['nuovaTipologia' => ['required', 'string', 'max:100', Rule::unique('tipologie', 'nome')]],
|
||||
[
|
||||
@@ -181,221 +428,155 @@ class PiantineEditor extends Component
|
||||
],
|
||||
);
|
||||
|
||||
$tipologia = Tipologia::create(['nome' => trim($dati['nuovaTipologia']), 'attivo' => true]);
|
||||
$tipologia = Tipologia::create(['nome' => $dati['nuovaTipologia'], 'attivo' => true]);
|
||||
|
||||
$this->tipologiaId = (string) $tipologia->id;
|
||||
$this->nuovaTipologia = '';
|
||||
|
||||
session()->flash('success', "Tipologia «{$tipologia->nome}» creata e selezionata.");
|
||||
$this->updatedTipologiaId();
|
||||
$this->avvisa("Tipologia «{$tipologia->nome}» creata e selezionata.");
|
||||
}
|
||||
|
||||
// ─── Salvataggio ────────────────────────────────────────────────────────
|
||||
// ─── Pubblicazione ed eliminazione ──────────────────────────────────────
|
||||
|
||||
public function salva()
|
||||
public function pubblica(): void
|
||||
{
|
||||
$mappa = $this->mappaId ? TerritorioMappa::find($this->mappaId) : null;
|
||||
|
||||
if (! $mappa && ! $this->geometriaInAttesa) {
|
||||
session()->flash('error', 'Disegna il poligono prima di salvare.');
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
$territorio = $this->salvaScheda($mappa);
|
||||
|
||||
// salvaScheda() torna false quando la validazione della scheda non
|
||||
// passa: in quel caso il messaggio è già a schermo e non si tocca nulla.
|
||||
if ($territorio === false) {
|
||||
return;
|
||||
}
|
||||
|
||||
$valori = [
|
||||
'territorio_id' => $territorio?->id,
|
||||
'nome' => trim($this->nome) !== '' ? trim($this->nome) : null,
|
||||
];
|
||||
|
||||
if ($this->geometriaInAttesa) {
|
||||
$valori['geojson'] = $this->geometriaInAttesa;
|
||||
}
|
||||
|
||||
if ($mappa) {
|
||||
$mappa->update($valori);
|
||||
} else {
|
||||
$mappa = TerritorioMappa::create($valori);
|
||||
$this->mappaId = $mappa->id;
|
||||
}
|
||||
|
||||
$this->geometriaInAttesa = null;
|
||||
|
||||
activity()->causedBy(auth()->user())->log('piantina_salvata');
|
||||
session()->flash('success', $mappa->fresh()->load('territorio')->etichetta() . ' salvata.');
|
||||
|
||||
$this->aggiornaMappaJs();
|
||||
}
|
||||
|
||||
/**
|
||||
* Crea o aggiorna il territorio della scheda.
|
||||
*
|
||||
* @return Territorio|null|false Il territorio collegato, null se la
|
||||
* piantina resta scollegata, false se la
|
||||
* scheda non è valida.
|
||||
*/
|
||||
private function salvaScheda(?TerritorioMappa $mappa): Territorio|null|false
|
||||
{
|
||||
if ($this->territorioScelto === '') {
|
||||
return null;
|
||||
}
|
||||
|
||||
$esistente = $this->territorioScelto === 'nuovo'
|
||||
? null
|
||||
: Territorio::find($this->territorioScelto);
|
||||
|
||||
if ($this->territorioScelto !== 'nuovo' && ! $esistente) {
|
||||
session()->flash('error', 'Il territorio scelto non esiste più.');
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
try {
|
||||
$this->validate(
|
||||
[
|
||||
'numero' => [
|
||||
'required', 'string', 'max:20',
|
||||
Rule::unique('territori', 'numero')->ignore($esistente?->id),
|
||||
],
|
||||
'zonaId' => ['nullable', Rule::exists('zone', 'id')],
|
||||
'tipologiaId' => ['nullable', Rule::exists('tipologie', 'id')],
|
||||
'confini' => ['nullable', 'string', 'max:5000'],
|
||||
],
|
||||
[
|
||||
'numero.required' => 'Il territorio ha bisogno di un numero.',
|
||||
'numero.unique' => 'Esiste già un territorio con questo numero.',
|
||||
],
|
||||
['numero' => 'numero'],
|
||||
);
|
||||
} catch (\Illuminate\Validation\ValidationException $e) {
|
||||
$this->pannelloAperto = true;
|
||||
throw $e;
|
||||
}
|
||||
|
||||
// Un territorio ha una piantina sola.
|
||||
if ($esistente) {
|
||||
$occupato = TerritorioMappa::where('territorio_id', $esistente->id)
|
||||
->when($mappa, fn ($q) => $q->where('id', '!=', $mappa->id))
|
||||
->exists();
|
||||
|
||||
if ($occupato) {
|
||||
session()->flash('error', "Il territorio {$esistente->numero} ha già una piantina: scollegala prima di assegnargli questa.");
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
$valori = [
|
||||
'numero' => trim($this->numero),
|
||||
'zona_id' => $this->zonaId !== '' ? (int) $this->zonaId : null,
|
||||
'tipologia_id' => $this->tipologiaId !== '' ? (int) $this->tipologiaId : null,
|
||||
'confini' => trim($this->confini) !== '' ? trim($this->confini) : null,
|
||||
];
|
||||
|
||||
if ($esistente) {
|
||||
$esistente->update($valori);
|
||||
return $esistente;
|
||||
}
|
||||
|
||||
$territorio = Territorio::create($valori + ['attivo' => true]);
|
||||
$this->territorioScelto = (string) $territorio->id;
|
||||
|
||||
activity()->causedBy(auth()->user())->performedOn($territorio)->log('territorio_creato_da_piantine');
|
||||
|
||||
return $territorio;
|
||||
}
|
||||
|
||||
// ─── Immagine ed eliminazione ───────────────────────────────────────────
|
||||
|
||||
public function generaImmagine(PiantinaRenderer $renderer)
|
||||
{
|
||||
$mappa = $this->mappaId ? TerritorioMappa::with('territorio')->find($this->mappaId) : null;
|
||||
$mappa = $this->mappaAperta();
|
||||
|
||||
if (! $mappa) {
|
||||
session()->flash('error', 'Salva la piantina prima di generarne l\'immagine.');
|
||||
return;
|
||||
}
|
||||
|
||||
if ($motivo = $mappa->motivoNonPubblicabile()) {
|
||||
$this->avvisaErrore($motivo);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
$renderer->render($mappa);
|
||||
} catch (\Throwable $e) {
|
||||
session()->flash('error', $e->getMessage());
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
session()->flash('success', "Immagine generata per {$mappa->etichetta()}.");
|
||||
$this->dispatch('pubblica-piantina', mappaId: $mappa->id)->to(Pubblicazione::class);
|
||||
}
|
||||
|
||||
public function elimina()
|
||||
#[On('piantina-pubblicata')]
|
||||
public function pubblicata(int $mappaId): void
|
||||
{
|
||||
$mappa = $this->mappaId ? TerritorioMappa::with('territorio')->find($this->mappaId) : null;
|
||||
$mappa = TerritorioMappa::with('territorio.zona')->find($mappaId);
|
||||
|
||||
if ($mappa) {
|
||||
$this->dispatch('piantina-aggiornata', piantina: $this->datiPiantina($mappa));
|
||||
}
|
||||
}
|
||||
|
||||
public function elimina(): void
|
||||
{
|
||||
$mappa = $this->mappaAperta();
|
||||
|
||||
if (! $mappa) {
|
||||
return;
|
||||
}
|
||||
|
||||
$etichetta = $mappa->etichetta();
|
||||
$id = $mappa->id;
|
||||
|
||||
if ($mappa->image_path) {
|
||||
Storage::disk('public')->delete($mappa->image_path);
|
||||
}
|
||||
$mappa->delete();
|
||||
|
||||
$this->nuova();
|
||||
session()->flash('success', "{$etichetta} eliminata.");
|
||||
$this->svuota();
|
||||
$this->dispatch('piantina-rimossa', mappaId: $id);
|
||||
$this->avvisa("{$etichetta} eliminata. Il territorio e il suo PDF restano com'erano.");
|
||||
}
|
||||
|
||||
// ─── Dati per la mappa ──────────────────────────────────────────────────
|
||||
|
||||
public function datiMappa(?PiantineArea $area = null): array
|
||||
/** Chiamata una volta dalla mappa all'avvio ($wire.datiMappa()). */
|
||||
public function datiMappa(PiantineArea $area): array
|
||||
{
|
||||
$area ??= app(PiantineArea::class);
|
||||
|
||||
$piantine = TerritorioMappa::with('territorio')->get()
|
||||
->filter(fn ($m) => $m->geometria() !== null)
|
||||
->map(fn ($m) => [
|
||||
'mappaId' => $m->id,
|
||||
'etichetta' => $m->etichetta(),
|
||||
'collegata' => $m->collegata(),
|
||||
'geometry' => $m->geometria(),
|
||||
])
|
||||
->values()
|
||||
->all();
|
||||
|
||||
return [
|
||||
'area' => $area->area(),
|
||||
'piantine' => $piantine,
|
||||
'piantine' => TerritorioMappa::with('territorio.zona')->get()
|
||||
->filter(fn (TerritorioMappa $m) => $m->geometria() !== null)
|
||||
->map(fn (TerritorioMappa $m) => $this->datiPiantina($m))
|
||||
->values()
|
||||
->all(),
|
||||
'selezionata' => $this->mappaId,
|
||||
];
|
||||
}
|
||||
|
||||
private function aggiornaMappaJs(bool $inquadra = false): void
|
||||
private function datiPiantina(TerritorioMappa $mappa): array
|
||||
{
|
||||
$this->dispatch('piantine-dati-aggiornati', dati: $this->datiMappa(), inquadra: $inquadra);
|
||||
return [
|
||||
'mappaId' => $mappa->id,
|
||||
'etichetta' => $mappa->etichetta(),
|
||||
'collegata' => $mappa->collegata(),
|
||||
'stato' => $mappa->stato(),
|
||||
'statoEtichetta' => $mappa->statoEtichetta(),
|
||||
'geometry' => $mappa->geometria(),
|
||||
];
|
||||
}
|
||||
|
||||
public function render(PiantineArea $area)
|
||||
/** Dopo ogni salvataggio automatico: ora in testata, mappa e indirizzo allineati. */
|
||||
private function salvato(?TerritorioMappa $mappa, bool $seleziona = false): void
|
||||
{
|
||||
$mappa = $this->mappaId ? TerritorioMappa::with('territorio')->find($this->mappaId) : null;
|
||||
if (! $mappa) {
|
||||
return;
|
||||
}
|
||||
|
||||
$mappa = $mappa->fresh(['territorio.zona']);
|
||||
$this->salvatoAlle = now()->format('H:i');
|
||||
|
||||
$this->dispatch('piantina-aggiornata', piantina: $this->datiPiantina($mappa));
|
||||
|
||||
if ($seleziona) {
|
||||
$this->dispatch('piantina-selezionata', mappaId: $mappa->id, inquadra: false);
|
||||
}
|
||||
|
||||
// La piantina aperta resta nell'indirizzo: ricaricando la pagina si
|
||||
// torna su questa e non su un editor vuoto.
|
||||
$this->dispatch('editor-indirizzo', url: route('piantine.editor', $mappa->id));
|
||||
}
|
||||
|
||||
private function mappaAperta(): ?TerritorioMappa
|
||||
{
|
||||
return $this->mappaId ? TerritorioMappa::with('territorio.zona')->find($this->mappaId) : null;
|
||||
}
|
||||
|
||||
private function territorioCollegato(): ?Territorio
|
||||
{
|
||||
if ($this->territorioScelto === '' || $this->territorioScelto === 'nuovo') {
|
||||
return null;
|
||||
}
|
||||
|
||||
$mappa = $this->mappaAperta();
|
||||
|
||||
return $mappa?->territorio;
|
||||
}
|
||||
|
||||
public function render()
|
||||
{
|
||||
$mappa = $this->mappaAperta();
|
||||
|
||||
// Nella tendina: i territori attivi senza piantina, più quello già
|
||||
// collegato anche se nel frattempo è stato disattivato o cestinato.
|
||||
$occupati = TerritorioMappa::whereNotNull('territorio_id')
|
||||
->when($mappa, fn ($q) => $q->whereKeyNot($mappa->id))
|
||||
->pluck('territorio_id');
|
||||
|
||||
$territori = Territorio::attivi()
|
||||
->whereNotIn('id', $occupati)
|
||||
->orderByRaw('LENGTH(numero), numero')
|
||||
->get(['id', 'numero', 'attivo', 'deleted_at']);
|
||||
|
||||
if ($mappa?->territorio && ! $territori->contains('id', $mappa->territorio_id)) {
|
||||
$territori->prepend($mappa->territorio);
|
||||
}
|
||||
|
||||
return view('livewire.piantine.piantine-editor', [
|
||||
'mappa' => $mappa,
|
||||
'areaCaricata' => $area->area() !== null,
|
||||
'datiMappaIniziali' => $this->datiMappa($area),
|
||||
'territori' => Territorio::attivi()
|
||||
->orderByRaw('LENGTH(numero), numero')
|
||||
->get(['id', 'numero']),
|
||||
'areaCaricata' => app(PiantineArea::class)->config()['kml_nome'] !== null,
|
||||
'territori' => $territori,
|
||||
'zone' => Zona::orderBy('nome')->get(['id', 'nome']),
|
||||
'tipologie' => Tipologia::orderBy('nome')->get(['id', 'nome']),
|
||||
'title' => 'Editor delle piantine',
|
||||
'title' => $mappa ? $mappa->etichetta() . ' — Editor delle piantine' : 'Editor delle piantine',
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user