Piantine staccate dai territori, editor a schermo intero, restyle
Le piantine non dipendono piu' da un territorio esistente: territorio_id e' nullable, la chiave esterna e' nullOnDelete invece di cascadeOnDelete, e `nome` fa da etichetta finche' il collegamento manca. Si disegna guardando le strade e si decide dopo di chi e' il disegno; se il territorio non c'e', lo si crea dall'editor con numero, zona, tipologia e confini — zona e tipologia comprese, create sul posto quando mancano. Il cambio di cascata chiude anche una perdita di dati silenziosa: ogni import XML svuota `territori` in blocco e finora si portava via tutte le piantine. Il disegno passa su /piantine/editor, a schermo intero con telaio proprio: su una mappa larga un terzo di schermo un confine si sbaglia, e finisce stampato. /piantine resta la gestione — area, generazione, collegamenti, storico. Cartolina S-12 reimpaginata: pagina 1 il modulo con la Localita' (che ora e' il nome della zona, non un campo duplicato) e i confini scritti nello spazio centrale, con il corpo del testo che si adatta alla lunghezza; pagina 2 la piantina sola al 98%. Aggiunta l'anteprima, che compone il PDF al volo senza toccare pdf_path ne' lo storico. Immagine: JPEG invece di PNG (0,9 MB contro 5 per territorio), composta alle tessere dello zoom piu' alto e ridotta con Lanczos, nelle proporzioni della pagina cosi' riempie il foglio invece di lasciare fasce bianche. Il tratto del confine e' espresso in pixel dell'immagine finale: si vede il confine e si legge la via che ci passa sotto. L'attribuzione OSM si dimensiona con l'immagine, come la ODbL richiede. Rimossa la rigenerazione massiva: job, stato in cache e interfaccia. Sistema visivo ripassato su tutta l'applicazione: le scale gray e indigo di Tailwind sono ridefinite nei token, cosi' le 37 viste si riallineano insieme invece di essere riscritte una per una. Grigi caldi, un accento solo con quattro significati, carattere servito dall'applicazione e non da Google Fonts, via il gradiente della testata. Aggiunto il link "salta al contenuto", che mancava. Corretto un guasto d'ambiente che bloccava TUTTI gli upload in sviluppo: dalla 1.26 il fastcgi_params di nginx passa HTTP_HOST come $host, che perde la porta, e ogni URL firmato smetteva di validare — l'endpoint di upload di Livewire rispondeva 401. 294 test verdi. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -11,17 +11,27 @@ use RuntimeException;
|
||||
use setasign\Fpdi\Fpdi;
|
||||
|
||||
/**
|
||||
* Compone il PDF del territorio sul modulo ufficiale S-12 e lo sostituisce
|
||||
* nel gestionale conservando la versione precedente.
|
||||
* Compone il PDF del territorio e lo sostituisce nel gestionale conservando
|
||||
* la versione precedente.
|
||||
*
|
||||
* Pagina 1: il modulo S-12 originale (resources/pdf/S-12_I.pdf) importato
|
||||
* com'è, con Località, numero e piantina sovrapposti negli spazi previsti.
|
||||
* Pagina 2: i confini scritti (campo `confini` del territorio).
|
||||
* Pagina 1 — la cartolina: il modulo ufficiale S-12 (resources/pdf/S-12_I.pdf,
|
||||
* 146 x 94,4 mm) importato com'è, con Località e numero sulle righe
|
||||
* punteggiate e i confini scritti nello spazio centrale.
|
||||
*
|
||||
* La "Località" del modulo è il nome della zona del territorio: è già lì, dice
|
||||
* la stessa cosa, e si aggiorna in un posto solo quando la congregazione
|
||||
* riorganizza il lavoro.
|
||||
*
|
||||
* Pagina 2 — la piantina, sola, al 98% della pagina. Il riquadro dell'S-12 è
|
||||
* grande sette centimetri: una mappa di quartiere lì dentro non si legge, e
|
||||
* chi percorre il territorio guarda quella, non il modulo.
|
||||
*/
|
||||
class PiantinaPdfService
|
||||
{
|
||||
/** Quanto della pagina occupa la piantina. */
|
||||
private const OCCUPAZIONE = 0.98;
|
||||
|
||||
public function __construct(
|
||||
private PiantineArea $area,
|
||||
private TerritorioThumbnailService $thumbnails,
|
||||
) {
|
||||
}
|
||||
@@ -41,6 +51,7 @@ class PiantinaPdfService
|
||||
[$imgPxW, $imgPxH] = $dimensioni;
|
||||
|
||||
$pdf = new Fpdi();
|
||||
$pdf->SetAutoPageBreak(false);
|
||||
$pdf->setSourceFile(resource_path('pdf/S-12_I.pdf'));
|
||||
$template = $pdf->importPage(1);
|
||||
$misure = $pdf->getTemplateSize($template);
|
||||
@@ -48,60 +59,120 @@ class PiantinaPdfService
|
||||
$w = $misure['width'];
|
||||
$h = $misure['height'];
|
||||
|
||||
// ── Pagina 1: il modulo ────────────────────────────────────────────
|
||||
$pdf->AddPage($misure['orientation'], [$w, $h]);
|
||||
$pdf->useTemplate($template);
|
||||
$pdf->SetTextColor(0, 0, 0);
|
||||
|
||||
// Intestazione: i valori si appoggiano sulle righe punteggiate del
|
||||
// modulo. Posizioni in proporzione alla pagina, tarate sull'S-12.
|
||||
$pdf->SetFont('Helvetica', 'B', 10);
|
||||
$pdf->SetTextColor(0, 0, 0);
|
||||
|
||||
// Tarato sull'S-12 reale: i valori si appoggiano alle righe
|
||||
// punteggiate senza coprire le etichette "Località" e "Terr. N.".
|
||||
$headerY = $h * 0.112;
|
||||
$pdf->SetXY($w * 0.155, $headerY);
|
||||
$pdf->Cell($w * 0.48, 5, $this->latin($this->area->localita()), 0, 0, 'L');
|
||||
$headerY = $h * 0.125;
|
||||
$pdf->SetXY($w * 0.185, $headerY);
|
||||
$pdf->Cell($w * 0.45, 5, $this->latin((string) $territorio->zona?->nome), 0, 0, 'L');
|
||||
|
||||
$pdf->SetXY($w * 0.875, $headerY);
|
||||
$pdf->Cell($w * 0.10, 5, $this->latin($territorio->numero), 0, 0, 'C');
|
||||
|
||||
// Piantina nello spazio centrale, adattata mantenendo le proporzioni:
|
||||
// sotto l'intestazione, sopra la dicitura "(Incollate qui sopra...)".
|
||||
$boxX = $w * 0.045;
|
||||
$boxY = $h * 0.175;
|
||||
$boxW = $w * 0.91;
|
||||
$boxH = $h * 0.565;
|
||||
$this->scriviConfini($pdf, $territorio, $w, $h);
|
||||
|
||||
// ── Pagina 2: la piantina ──────────────────────────────────────────
|
||||
$pdf->AddPage($misure['orientation'], [$w, $h]);
|
||||
|
||||
$boxW = $w * self::OCCUPAZIONE;
|
||||
$boxH = $h * self::OCCUPAZIONE;
|
||||
|
||||
$scala = min($boxW / $imgPxW, $boxH / $imgPxH);
|
||||
$imgW = $imgPxW * $scala;
|
||||
$imgH = $imgPxH * $scala;
|
||||
|
||||
$pdf->Image(
|
||||
$immagine,
|
||||
$boxX + ($boxW - $imgW) / 2,
|
||||
$boxY + ($boxH - $imgH) / 2,
|
||||
($w - $imgW) / 2,
|
||||
($h - $imgH) / 2,
|
||||
$imgW,
|
||||
$imgH,
|
||||
'PNG'
|
||||
);
|
||||
|
||||
// Pagina 2: i confini scritti.
|
||||
$pdf->AddPage($misure['orientation'], [$w, $h]);
|
||||
$pdf->SetFont('Helvetica', 'B', 13);
|
||||
$pdf->SetXY($w * 0.045, $h * 0.06);
|
||||
$pdf->Cell($w * 0.91, 7, $this->latin('Confini del territorio N. ' . $territorio->numero), 0, 2, 'C');
|
||||
|
||||
$pdf->SetFont('Helvetica', '', 11);
|
||||
$pdf->SetXY($w * 0.045, $h * 0.16);
|
||||
$confini = trim((string) $territorio->confini);
|
||||
$pdf->MultiCell(
|
||||
$w * 0.91,
|
||||
6,
|
||||
$this->latin($confini !== '' ? $confini : 'Confini non ancora descritti.')
|
||||
$this->tipoImmagine($mappa->image_path)
|
||||
);
|
||||
|
||||
return $pdf->Output('S');
|
||||
}
|
||||
|
||||
/**
|
||||
* I confini nello spazio che sul modulo è riservato alla piantina.
|
||||
*
|
||||
* Il corpo del testo si restringe finché non ci sta: i confini di un
|
||||
* territorio vanno da due righe a venti, e una misura fissa o lascerebbe
|
||||
* mezzo modulo vuoto o sborderebbe sulla dicitura stampata sotto.
|
||||
*/
|
||||
private function scriviConfini(Fpdi $pdf, Territorio $territorio, float $w, float $h): void
|
||||
{
|
||||
$testo = trim((string) $territorio->confini);
|
||||
|
||||
if ($testo === '') {
|
||||
$pdf->SetFont('Helvetica', 'I', 9);
|
||||
$pdf->SetTextColor(120, 120, 120);
|
||||
$pdf->SetXY($w * 0.06, $h * 0.42);
|
||||
$pdf->Cell($w * 0.88, 5, $this->latin('Confini non ancora descritti.'), 0, 0, 'C');
|
||||
$pdf->SetTextColor(0, 0, 0);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
$boxX = $w * 0.06;
|
||||
$boxY = $h * 0.20;
|
||||
$boxW = $w * 0.88;
|
||||
$boxH = $h * 0.53;
|
||||
|
||||
$righe = preg_split('/\R/', $testo) ?: [$testo];
|
||||
|
||||
foreach ([10, 9, 8, 7, 6, 5.5, 5] as $corpo) {
|
||||
$interlinea = $corpo * 0.44;
|
||||
$pdf->SetFont('Helvetica', '', $corpo);
|
||||
|
||||
if ($this->altezzaTesto($pdf, $righe, $boxW, $interlinea) <= $boxH) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
$pdf->SetXY($boxX, $boxY);
|
||||
foreach ($righe as $riga) {
|
||||
$riga = trim($riga);
|
||||
if ($riga === '') {
|
||||
$pdf->Ln($interlinea * 0.6);
|
||||
continue;
|
||||
}
|
||||
$pdf->SetX($boxX);
|
||||
$pdf->MultiCell($boxW, $interlinea, $this->latin($riga), 0, 'L');
|
||||
}
|
||||
}
|
||||
|
||||
/** Quanto verrebbe alto il blocco dei confini a questo corpo. */
|
||||
private function altezzaTesto(Fpdi $pdf, array $righe, float $larghezza, float $interlinea): float
|
||||
{
|
||||
$altezza = 0.0;
|
||||
|
||||
foreach ($righe as $riga) {
|
||||
$riga = trim($riga);
|
||||
if ($riga === '') {
|
||||
$altezza += $interlinea * 0.6;
|
||||
continue;
|
||||
}
|
||||
// GetStringWidth misura una riga sola: quante ne servono lo dice il
|
||||
// rapporto con la larghezza disponibile, arrotondato per eccesso.
|
||||
$larghezzaTesto = $pdf->GetStringWidth($this->latin($riga));
|
||||
$altezza += max(1, ceil($larghezzaTesto / $larghezza)) * $interlinea;
|
||||
}
|
||||
|
||||
return $altezza;
|
||||
}
|
||||
|
||||
/** FPDF vuole sapere il formato quando l'estensione non basta. */
|
||||
private function tipoImmagine(string $path): string
|
||||
{
|
||||
return strtolower(pathinfo($path, PATHINFO_EXTENSION)) === 'png' ? 'PNG' : 'JPEG';
|
||||
}
|
||||
|
||||
/**
|
||||
* Genera il PDF e lo rende quello ufficiale del territorio, archiviando
|
||||
* l'eventuale PDF precedente nello storico versioni.
|
||||
|
||||
@@ -8,9 +8,9 @@ use Illuminate\Support\Facades\Storage;
|
||||
use RuntimeException;
|
||||
|
||||
/**
|
||||
* Client del container `map-renderer`: gli passa la geometria di un
|
||||
* territorio, riceve il PNG ad alta definizione e lo archivia sul disco
|
||||
* pubblico accanto a PDF e miniature.
|
||||
* Client del container `map-renderer`: gli passa la geometria di una piantina,
|
||||
* riceve l'immagine ad alta definizione e la archivia sul disco pubblico
|
||||
* accanto a PDF e miniature.
|
||||
*/
|
||||
class PiantinaRenderer
|
||||
{
|
||||
@@ -19,14 +19,21 @@ class PiantinaRenderer
|
||||
$geometry = $mappa->geometria();
|
||||
|
||||
if ($geometry === null) {
|
||||
throw new RuntimeException('La geometria salvata per questo territorio non è leggibile: ridisegna il poligono.');
|
||||
throw new RuntimeException('La geometria salvata per questa piantina non è leggibile: ridisegna il poligono.');
|
||||
}
|
||||
|
||||
$formato = config('piantine.formato') === 'png' ? 'png' : 'jpeg';
|
||||
|
||||
$response = Http::timeout((int) config('piantine.renderer_timeout'))
|
||||
->post(rtrim((string) config('piantine.renderer_url'), '/') . '/render', [
|
||||
'geometry' => $geometry,
|
||||
'marginRatio' => (float) config('piantine.margin_ratio'),
|
||||
'maxSide' => (int) config('piantine.max_side'),
|
||||
'aspect' => (float) config('piantine.aspetto'),
|
||||
'strokeWidth' => (float) config('piantine.tratto'),
|
||||
'strokeOpacity' => (float) config('piantine.tratto_opacita'),
|
||||
'format' => $formato,
|
||||
'quality' => (int) config('piantine.qualita'),
|
||||
]);
|
||||
|
||||
if (! $response->successful()) {
|
||||
@@ -34,13 +41,21 @@ class PiantinaRenderer
|
||||
throw new RuntimeException('Il renderer delle mappe ha risposto con un errore: ' . $dettaglio);
|
||||
}
|
||||
|
||||
$png = $response->body();
|
||||
if ($png === '' || ! str_starts_with($png, "\x89PNG")) {
|
||||
throw new RuntimeException('Il renderer delle mappe non ha restituito un PNG valido.');
|
||||
$immagine = $response->body();
|
||||
|
||||
if (! $this->immagineValida($immagine, $formato)) {
|
||||
throw new RuntimeException('Il renderer delle mappe non ha restituito un\'immagine valida.');
|
||||
}
|
||||
|
||||
$path = 'territori-mappe/territorio-' . $mappa->territorio_id . '.png';
|
||||
Storage::disk('public')->put($path, $png);
|
||||
// Il vecchio file puo' avere un'estensione diversa da quella nuova (si
|
||||
// e' passati da PNG a JPEG): senza questa rimozione resterebbe sul
|
||||
// volume per sempre, senza che niente lo referenzi piu'.
|
||||
if ($mappa->image_path && $mappa->image_path !== $this->percorso($mappa, $formato)) {
|
||||
Storage::disk('public')->delete($mappa->image_path);
|
||||
}
|
||||
|
||||
$path = $this->percorso($mappa, $formato);
|
||||
Storage::disk('public')->put($path, $immagine);
|
||||
|
||||
$mappa->update([
|
||||
'image_path' => $path,
|
||||
@@ -49,4 +64,21 @@ class PiantinaRenderer
|
||||
|
||||
return $path;
|
||||
}
|
||||
|
||||
private function percorso(TerritorioMappa $mappa, string $formato): string
|
||||
{
|
||||
return 'territori-mappe/piantina-' . $mappa->id . '.' . ($formato === 'png' ? 'png' : 'jpg');
|
||||
}
|
||||
|
||||
/** I primi byte bastano a distinguere un'immagine da una pagina d'errore. */
|
||||
private function immagineValida(string $dati, string $formato): bool
|
||||
{
|
||||
if ($dati === '') {
|
||||
return false;
|
||||
}
|
||||
|
||||
return $formato === 'png'
|
||||
? str_starts_with($dati, "\x89PNG")
|
||||
: str_starts_with($dati, "\xFF\xD8\xFF");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,8 +10,12 @@ use RuntimeException;
|
||||
*
|
||||
* Vive su file (storage/app/piantine/), non su tabelle: c'è una sola area
|
||||
* attiva, caricare un KML nuovo la sostituisce e i poligoni già disegnati
|
||||
* restano al loro posto. Stando dentro storage/, entra nei backup completi
|
||||
* senza bisogno di altro.
|
||||
* restano al loro posto.
|
||||
*
|
||||
* ATTENZIONE: NON entra nel backup completo. BackupArchive impacchetta il solo
|
||||
* disco `public` (storage/app/public), e questa cartella gli sta accanto, non
|
||||
* dentro. Dopo un ripristino su volumi vuoti l'area va ricaricata a mano dal
|
||||
* KML originale — che quindi conviene conservare fuori di qui.
|
||||
*/
|
||||
class PiantineArea
|
||||
{
|
||||
@@ -64,33 +68,14 @@ class PiantineArea
|
||||
public function config(): array
|
||||
{
|
||||
if (! Storage::disk('local')->exists(self::FILE_CONFIG)) {
|
||||
return ['localita' => null, 'kml_nome' => null, 'aggiornato_il' => null];
|
||||
return ['kml_nome' => null, 'aggiornato_il' => null];
|
||||
}
|
||||
|
||||
$decoded = json_decode(Storage::disk('local')->get(self::FILE_CONFIG), true);
|
||||
|
||||
return is_array($decoded)
|
||||
? $decoded + ['localita' => null, 'kml_nome' => null, 'aggiornato_il' => null]
|
||||
: ['localita' => null, 'kml_nome' => null, 'aggiornato_il' => null];
|
||||
}
|
||||
|
||||
/** La "Località" stampata sull'intestazione del modulo S-12. */
|
||||
public function localita(): string
|
||||
{
|
||||
$config = $this->config();
|
||||
|
||||
if (! empty($config['localita'])) {
|
||||
return $config['localita'];
|
||||
}
|
||||
|
||||
return (string) \App\Models\Setting::getValue('congregazione_nome', '');
|
||||
}
|
||||
|
||||
public function impostaLocalita(?string $localita): void
|
||||
{
|
||||
$config = $this->config();
|
||||
$config['localita'] = $localita !== null && trim($localita) !== '' ? trim($localita) : null;
|
||||
$this->salvaConfig($config);
|
||||
? $decoded + ['kml_nome' => null, 'aggiornato_il' => null]
|
||||
: ['kml_nome' => null, 'aggiornato_il' => null];
|
||||
}
|
||||
|
||||
private function salvaConfig(array $config): void
|
||||
|
||||
@@ -1,152 +0,0 @@
|
||||
<?php
|
||||
|
||||
namespace App\Services\Piantine;
|
||||
|
||||
use Illuminate\Support\Facades\Cache;
|
||||
|
||||
/**
|
||||
* Stato della rigenerazione massiva delle piantine.
|
||||
*
|
||||
* Stessa impostazione di BackupOperationState e TerritorioPdfImportState:
|
||||
* la pagina segue il lavoro in coda interrogando questo stato, la barra si
|
||||
* muove su unità di lavoro completate davvero (territori renderizzati).
|
||||
* Un'operazione alla volta: due rigenerazioni parallele martellerebbero il
|
||||
* renderer e il tile server senza alcun beneficio.
|
||||
*/
|
||||
class PiantineOperationState
|
||||
{
|
||||
protected int $ttlSeconds = 86400;
|
||||
|
||||
private const MAX_LOG = 60;
|
||||
private const CHIAVE_CORRENTE = 'piantine-op:corrente';
|
||||
private const TTL_CORRENTE = 3600;
|
||||
|
||||
public function initialize(string $id, int $total, bool $anchePdf): array
|
||||
{
|
||||
$state = [
|
||||
'id' => $id,
|
||||
'status' => 'queued',
|
||||
'anche_pdf' => $anchePdf,
|
||||
'total' => $total,
|
||||
'processed' => 0,
|
||||
'falliti' => 0,
|
||||
'logs' => [],
|
||||
'error' => null,
|
||||
'started_at' => null,
|
||||
'finished_at' => null,
|
||||
];
|
||||
|
||||
$this->put($id, $state);
|
||||
Cache::put(self::CHIAVE_CORRENTE, $id, self::TTL_CORRENTE);
|
||||
|
||||
return $state;
|
||||
}
|
||||
|
||||
public function corrente(): ?string
|
||||
{
|
||||
$id = Cache::get(self::CHIAVE_CORRENTE);
|
||||
|
||||
if (! is_string($id) || $id === '') {
|
||||
return null;
|
||||
}
|
||||
|
||||
$stato = $this->get($id);
|
||||
|
||||
if ($stato === null || in_array($stato['status'] ?? '', ['completed', 'failed'], true)) {
|
||||
Cache::forget(self::CHIAVE_CORRENTE);
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
return $id;
|
||||
}
|
||||
|
||||
public function get(string $id): ?array
|
||||
{
|
||||
return Cache::get($this->key($id));
|
||||
}
|
||||
|
||||
public function put(string $id, array $state): void
|
||||
{
|
||||
Cache::put($this->key($id), $state, $this->ttlSeconds);
|
||||
}
|
||||
|
||||
public function update(string $id, callable $callback): void
|
||||
{
|
||||
$state = $this->get($id);
|
||||
|
||||
if (! $state) {
|
||||
return;
|
||||
}
|
||||
|
||||
$this->put($id, $callback($state) ?? $state);
|
||||
}
|
||||
|
||||
public function log(string $id, string $message): void
|
||||
{
|
||||
$this->update($id, function (array $state) use ($message) {
|
||||
$state['logs'][] = '[' . now()->format('H:i:s') . '] ' . $message;
|
||||
$state['logs'] = array_slice($state['logs'], -self::MAX_LOG);
|
||||
|
||||
return $state;
|
||||
});
|
||||
}
|
||||
|
||||
public function avanza(string $id, int $processed, int $falliti): void
|
||||
{
|
||||
$this->update($id, function (array $state) use ($processed, $falliti) {
|
||||
$state['processed'] = $processed;
|
||||
$state['falliti'] = $falliti;
|
||||
|
||||
return $state;
|
||||
});
|
||||
}
|
||||
|
||||
public function markRunning(string $id): void
|
||||
{
|
||||
$this->update($id, function (array $state) {
|
||||
$state['status'] = 'running';
|
||||
$state['started_at'] ??= now()->toDateTimeString();
|
||||
|
||||
return $state;
|
||||
});
|
||||
}
|
||||
|
||||
public function markCompleted(string $id): void
|
||||
{
|
||||
$this->update($id, function (array $state) {
|
||||
$state['status'] = 'completed';
|
||||
$state['finished_at'] = now()->toDateTimeString();
|
||||
|
||||
return $state;
|
||||
});
|
||||
|
||||
$this->liberaCorrente($id);
|
||||
}
|
||||
|
||||
public function markFailed(string $id, string $error): void
|
||||
{
|
||||
$this->update($id, function (array $state) use ($error) {
|
||||
$state['status'] = 'failed';
|
||||
$state['error'] = $error;
|
||||
$state['finished_at'] = now()->toDateTimeString();
|
||||
|
||||
return $state;
|
||||
});
|
||||
|
||||
$this->log($id, 'ERRORE: ' . $error);
|
||||
$this->liberaCorrente($id);
|
||||
}
|
||||
|
||||
private function liberaCorrente(string $id): void
|
||||
{
|
||||
if (Cache::get(self::CHIAVE_CORRENTE) === $id) {
|
||||
Cache::forget(self::CHIAVE_CORRENTE);
|
||||
}
|
||||
}
|
||||
|
||||
protected function key(string $id): string
|
||||
{
|
||||
return 'piantine-op:' . $id;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user