francesco/termanager2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

++ fix e controlli

Browse Source
This commit is contained in:
Francesco Picone
2026-07-30 17:05:39 +02:00
parent 712336d652
commit 440d63a6b9
54 changed files with 4921 additions and 1322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

379
app/Livewire/Settings/BackupManager.php
View File

@@ -3,64 +3,41 @@
namespace App\Livewire\Settings;
use App\Jobs\CreateBackupArchive;
use App\Jobs\ResetApplication;
use App\Livewire\Concerns\SegueOperazioneBackup;
use App\Services\BackupOperationState;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\RateLimiter;
use Livewire\Component;
/**
* Avvio e monitoraggio delle operazioni lunghe: backup, ripristino,
* azzeramento.
* Le due zone che si usano tutti i giorni: creare il pacchetto di backup e
* ripristinarlo.
*
* Il lavoro vero sta nei job; qui si avvia e si interroga lo stato. La barra
* mostra `processed/total` dell'operazione in corso, cioe' unita' di lavoro
* davvero completate — file finiti nell'archivio, file estratti, tabelle
* svuotate — non un'animazione a tempo.
* Il lavoro vero sta nei job; qui si avvia e si interroga lo stato. L'avanzamento
* e le righe di log non compaiono piu' in questa sezione: finiscono nella console
* unica agganciata in fondo alla pagina, che le riceve per eventi (vedi il trait
* SegueOperazioneBackup). Qui restano solo i comandi e l'esito.
*
* L'azzeramento sta in ZonaPericolosa, che e' un componente a se' perche' deve
* comparire in fondo alla pagina, dopo tutte le altre zone: dentro questa
* sezione finiva a meta' pagina, fra il ripristino e l'import.
*/
class BackupManager extends Component
{
/** Operazione seguita in questo momento; null quando non c'e' nulla in corso. */
public ?string $operationId = null;
public array $operazione = [];
/** Frase da digitare per sbloccare l'azzeramento. */
public const CONFERMA_AZZERAMENTO = 'AZZERA TUTTO';
/** Password sbagliate ammesse prima di bloccare l'azzeramento, e per quanto. */
private const TENTATIVI_PASSWORD = 5;
private const FINESTRA_TENTATIVI = 300;
public string $confermaReset = '';
/**
* Esiste solo per dare un nome agli errori del campo password: Livewire
* scarta dal messaggio di risposta ogni errore la cui chiave non
* corrisponda a una proprieta' del componente (SupportValidation::dehydrate),
* quindi senza questa riga "Password non corretta" non arriverebbe mai a
* schermo e il pulsante sembrerebbe non fare nulla.
*
* NON collegarla al campo con wire:model: la password viaggia come
* parametro di confermaAzzeramento() proprio per non finire nello
* snapshot, che Livewire rimanda al browser a ogni risposta. Qui resta
* sempre stringa vuota.
*/
public string $passwordConferma = '';
/** Messaggio mostrato in cima quando un avvio viene rifiutato. */
public string $erroreOperazione = '';
use SegueOperazioneBackup;
public function mount(): void
{
$this->authorize('settings.manage');
// Riaggancia un'operazione gia' in corso. Senza, ricaricare la pagina
// durante un backup lungo farebbe sparire la barra, e un azzeramento
// fermo in attesa di conferma diventerebbe irraggiungibile: nessuno
// potrebbe piu' ne' confermarlo ne' annullarlo.
$this->operationId = app(BackupOperationState::class)->corrente();
$this->aggiorna();
$this->agganciaOperazioneCorrente();
}
/**
* Backup e ripristino si raccontano da qui; l'azzeramento e' della zona
* pericolosa. Vedi SegueOperazioneBackup::tipiSeguiti().
*/
protected function tipiSeguiti(): array
{
return [BackupOperationState::TIPO_BACKUP, BackupOperationState::TIPO_RESTORE];
}
public function avviaBackup(): void
@@ -76,303 +53,55 @@ class BackupManager extends Component
CreateBackupArchive::dispatch($this->operationId, false);
$this->aggiorna();
$this->avvisaZonaPericolosa();
}
/**
* Vero se non c'e' gia' un'operazione in corso.
*
* Backup, ripristino e azzeramento lavorano tutti sullo stesso database e
* sullo stesso disco: farne partire due insieme — due schede, due
* amministratori — non li rallenta soltanto, li fa sovrascrivere a vicenda.
*/
private function postoLibero(): bool
{
$inCorso = app(BackupOperationState::class)->corrente();
if ($inCorso === null) {
$this->erroreOperazione = '';
return true;
}
// Si aggancia a quella in corso invece di limitarsi a rifiutare: chi ha
// premuto il pulsante vuole comunque vedere a che punto e'.
$this->operationId = $inCorso;
$this->aggiorna();
$this->erroreOperazione = 'C\'e\' gia\' un\'operazione in corso: attendi che finisca prima di avviarne un\'altra.';
return false;
}
/**
* Primo tempo dell'azzeramento: si costruisce il backup e lo si scarica.
* La cancellazione non parte da qui — serve il secondo tempo,
* confermaAzzeramento(), a valle del download.
*/
public function avviaAzzeramento(): void
{
$this->authorize('settings.manage');
$this->validate(
['confermaReset' => 'required|in:' . self::CONFERMA_AZZERAMENTO],
['confermaReset.in' => 'Scrivi esattamente "' . self::CONFERMA_AZZERAMENTO . '" per confermare.',
'confermaReset.required' => 'Scrivi "' . self::CONFERMA_AZZERAMENTO . '" per confermare.']
);
if (! $this->postoLibero()) {
return;
}
$this->confermaReset = '';
$this->operationId = $this->nuovaOperazione(BackupOperationState::TIPO_RESET);
CreateBackupArchive::dispatch($this->operationId, true);
$this->aggiorna();
}
/**
* Secondo tempo dell'azzeramento: parte solo su conferma esplicita, dopo
* che l'archivio e' stato servito.
*
* La conferma umana non e' un doppione del `wire:confirm` iniziale: e' il
* solo punto in cui si sa che il backup e' davvero sul computer di chi sta
* cancellando. Il server puo' verificare di averlo *spedito*
* (`servito_at`), non che sia arrivato: nginx bufferizza la risposta, il
* processo PHP la considera scritta e un download annullato dal browser
* resterebbe indistinguibile da uno riuscito. Chiedere all'operatore e'
* l'unico controllo che copre anche quel caso.
*/
public function confermaAzzeramento(string $password = ''): void
{
$this->authorize('settings.manage');
$this->aggiorna();
if (($this->operazione['fase'] ?? null) !== BackupOperationState::FASE_ATTESA_DOWNLOAD) {
$this->addError('confermaReset', 'Nessun azzeramento in attesa di conferma.');
return;
}
if (($this->operazione['result']['servito_at'] ?? null) === null) {
$this->addError('confermaReset', 'Scarica prima il backup: senza, l\'azzeramento non parte.');
return;
}
if (! $this->passwordConfermata($password)) {
return;
}
app(BackupOperationState::class)->update($this->operationId, function (array $state) {
$state['fase'] = 'Azzeramento in avvio';
$state['processed'] = 0;
$state['total'] = 0;
return $state;
});
ResetApplication::dispatch($this->operationId, (int) auth()->id());
$this->aggiorna();
}
/**
* Verifica la password dell'amministratore prima della cancellazione.
*
* A questo punto la sessione e' gia' autenticata, quindi la password non
* serve a stabilire *chi* sia: serve a stabilire che davanti allo schermo
* ci sia ancora quella persona. E' l'ultimo passo prima di
* un'operazione irreversibile, e una scheda lasciata aperta su una
* postazione condivisa e' lo scenario esatto contro cui protegge.
*
* La password arriva come parametro del metodo e non come proprieta' del
* componente: le proprieta' pubbliche di Livewire vengono serializzate
* nello snapshot e rispedite al browser a ogni risposta, e una password
* non ha motivo di fare quel viaggio di ritorno.
*/
private function passwordConfermata(string $password): bool
{
$utente = auth()->user();
$chiave = 'azzeramento-password:' . $utente->id;
// Senza un limite, la richiesta di password su una sessione dirottata
// sarebbe solo un rallentamento: si proverebbero le password comuni a
// raffica. Il blocco e' sull'azione, non sull'account, quindi nessuno
// resta chiuso fuori dall'applicazione.
if (RateLimiter::tooManyAttempts($chiave, self::TENTATIVI_PASSWORD)) {
$this->addError('passwordConferma', sprintf(
'Troppi tentativi. Riprova fra %d secondi.',
RateLimiter::availableIn($chiave)
));
return false;
}
if ($password === '') {
$this->addError('passwordConferma', 'Inserisci la tua password per confermare.');
return false;
}
if (! Hash::check($password, $utente->getAuthPassword())) {
RateLimiter::hit($chiave, self::FINESTRA_TENTATIVI);
$this->addError('passwordConferma', 'Password non corretta.');
return false;
}
RateLimiter::clear($chiave);
return true;
}
/**
* Annulla un azzeramento fermo in attesa di conferma. Il backup resta
* scaricabile: e' comunque un backup valido.
*/
public function annullaAzzeramento(): void
{
$this->authorize('settings.manage');
if (($this->operazione['fase'] ?? null) !== BackupOperationState::FASE_ATTESA_DOWNLOAD) {
return;
}
app(BackupOperationState::class)->markCompleted($this->operationId, [
'messaggio' => 'Azzeramento annullato. Il backup appena creato resta scaricabile.',
]);
// Da qui in poi e' un backup come un altro: la scheda mostra il
// pulsante di download, non piu' la conferma di cancellazione.
app(BackupOperationState::class)->update($this->operationId, function (array $state) {
$state['tipo'] = BackupOperationState::TIPO_BACKUP;
return $state;
});
$this->aggiorna();
}
/**
* Aggancia un'operazione avviata fuori da Livewire (il ripristino, che
* parte da un upload XHR e restituisce il suo id in JSON).
* Aggancia un'operazione avviata fuori da Livewire: il ripristino parte da un
* upload XHR e restituisce il proprio id in JSON.
*/
public function seguiOperazione(string $operationId): void
{
$this->authorize('settings.manage');
$this->operationId = $operationId;
$this->logSpediti = 0;
$this->aggiorna();
}
public function aggiorna(): void
{
if (! $this->operationId) {
return;
}
$stato = app(BackupOperationState::class)->get($this->operationId);
if (! $stato) {
$this->operationId = null;
$this->operazione = [];
return;
}
$this->operazione = $stato;
// Il download parte da solo appena l'archivio e' pronto: per il backup
// e' una comodita', per l'azzeramento e' il passaggio che sblocca la
// cancellazione, quindi non puo' dipendere da un clic.
if ($this->scaricaOra()) {
$this->dispatch('scarica-backup', url: route('backup.file', $this->operationId));
}
}
public function chiudi(): void
{
$this->operationId = null;
$this->operazione = [];
$this->avvisaZonaPericolosa();
}
/**
* True una volta sola per operazione: l'evento di download va emesso quando
* l'archivio compare, non a ogni poll successivo.
*/
private function scaricaOra(): bool
{
$pronto = ($this->operazione['result']['file'] ?? null) !== null;
$giaInviato = $this->operazione['result']['download_inviato'] ?? false;
if (! $pronto || $giaInviato) {
return false;
}
app(BackupOperationState::class)->update($this->operationId, function (array $state) {
$state['result']['download_inviato'] = true;
return $state;
});
$this->operazione['result']['download_inviato'] = true;
return true;
}
private function nuovaOperazione(string $tipo): string
{
$operationId = (string) \Illuminate\Support\Str::uuid();
$stato = app(BackupOperationState::class);
$stato->initialize($operationId, $tipo, 'In coda');
$stato->log($operationId, 'Operazione creata. In attesa del worker di coda.');
return $operationId;
}
/** Percentuale della fase corrente, 0-100. */
public function getPercentualeProperty(): int
{
$stato = $this->operazione['status'] ?? null;
if ($stato === 'completed') {
return 100;
}
$total = (int) ($this->operazione['total'] ?? 0);
if ($total <= 0) {
return 0;
}
$processed = (int) ($this->operazione['processed'] ?? 0);
return (int) min(100, round($processed / $total * 100));
}
/** Se true la pagina continua a interrogare lo stato. */
public function getInCorsoProperty(): bool
{
return $this->operationId !== null
&& in_array($this->operazione['status'] ?? '', ['queued', 'running'], true);
}
/**
* Ogni quanto reinterrogare lo stato.
* Il posto e' uno solo: la zona pericolosa deve sapere che e' occupato,
* altrimenti continuerebbe a offrire il proprio pulsante durante un backup o
* un ripristino.
*
* Mentre un job lavora servono aggiornamenti fitti, la barra deve muoversi.
* In attesa-download invece si aspetta una persona, che puo' metterci
* minuti: continuare a bussare ogni 750ms vorrebbe dire migliaia di
* richieste inutili se qualcuno lascia la scheda aperta e se ne va.
* L'evento e' indirizzato, non gridato: senza ->to() tornerebbe anche a
* questo componente, che si riaggancerebbe a un'operazione appena
* agganciata — una richiesta in piu' a ogni avvio, per niente.
*/
public function getIntervalloPollProperty(): string
private function avvisaZonaPericolosa(): void
{
return ($this->operazione['fase'] ?? null) === BackupOperationState::FASE_ATTESA_DOWNLOAD
? '5s'
: '750ms';
$this->dispatch('operazione-avviata')->to(ZonaPericolosa::class);
}
/**
* L'azzeramento avviato dalla zona pericolosa non passa da qui, ma occupa lo
* stesso posto: senza riagganciarsi, questa sezione resterebbe convinta che
* sia libero e offrirebbe il pulsante "Crea backup" durante una
* cancellazione.
*/
#[\Livewire\Attributes\On('operazione-avviata')]
public function agganciaAltrove(): void
{
$this->agganciaOperazioneCorrente();
}
/** Vero quando l'archivio di questa operazione e' scaricabile. */
public function getArchivioProntoProperty(): bool
{
return ($this->operazione['result']['file'] ?? null) !== null;
}
public function render()

68
app/Livewire/Settings/XmlExchange.php
View File

@@ -33,7 +33,15 @@ class XmlExchange extends Component
public array $pdfImportIssues = [];
public ?string $currentPdfImportId = null;
public string $pdfImportStatus = 'idle';
public string $pdfImportLogText = '';
/**
* Quante righe di log dell'import sono gia' state spedite alla console.
*
* La coda dell'import non ha tetto (un import di duemila PDF fa duemila
* righe): rispedirla intera a ogni poll significherebbe trascinarsi dietro
* l'intera cronologia dentro ogni risposta, una volta al secondo.
*/
public int $logPdfSpediti = 0;
public function mount(): void
{
@@ -95,7 +103,57 @@ class XmlExchange extends Component
$this->pdfImportStats = $state['stats'] ?? [];
$this->pdfImportLogs = $state['logs'] ?? [];
$this->pdfImportIssues = $state['issues'] ?? [];
$this->pdfImportLogText = implode(PHP_EOL, $this->pdfImportLogs);
$this->spedisciImportAllaConsole();
}
/**
* Manda alla console unica le righe nuove dell'import PDF.
*
* La console e' un componente Alpine fuori dal ciclo di Livewire: i suoi
* contenuti non possono essere ri-renderizzati dal server senza cancellare
* le righe scritte dal browser, quindi si comunica a eventi. E' lo stesso
* meccanismo di SegueOperazioneBackup, da cui questo componente non eredita
* perche' l'import PDF ha uno stato tutto suo (TerritorioPdfImportState) e
* non partecipa al posto unico: puo' girare mentre un backup lavora.
*/
protected function spedisciImportAllaConsole(): void
{
// Coda accorciata: e' un import nuovo, si riparte da capo.
if (count($this->pdfImportLogs) < $this->logPdfSpediti) {
$this->logPdfSpediti = 0;
}
$nuove = array_slice($this->pdfImportLogs, $this->logPdfSpediti);
$this->logPdfSpediti = count($this->pdfImportLogs);
$totale = (int) ($this->pdfImportStats['total'] ?? 0);
$fatti = (int) ($this->pdfImportStats['processed'] ?? 0);
$this->dispatch(
'console-operazione',
sorgente: 'import-pdf',
righe: array_values($nuove),
etichetta: 'Import PDF',
fase: $totale > 0 ? $fatti . ' / ' . $totale . ' file' : '',
percento: $this->percentualeImportPdf($fatti, $totale),
stato: $this->pdfImportStatus,
);
}
private function percentualeImportPdf(int $fatti, int $totale): int
{
if ($this->pdfImportStatus === 'completed') {
return 100;
}
return $totale > 0 ? (int) min(100, round($fatti / $totale * 100)) : 0;
}
/** Vero mentre l'import PDF e' in coda o in esecuzione. */
public function getImportPdfInCorsoProperty(): bool
{
return in_array($this->pdfImportStatus, ['queued', 'running'], true);
}
protected function dispatchPdfImport(string $importId, array $storedFiles, string $initialLog): void
@@ -108,9 +166,13 @@ class XmlExchange extends Component
$this->pdfImportStats = $state['stats'] ?? [];
$this->pdfImportLogs = $state['logs'] ?? [];
$this->pdfImportIssues = $state['issues'] ?? [];
// Import nuovo: il conto delle righe gia' raccontate riparte, altrimenti
// le prime righe di questo import verrebbero scambiate per quelle del
// precedente e non comparirebbero.
$this->logPdfSpediti = 0;
$this->refreshPdfImportStatus();
session()->flash('success', 'Import PDF avviato in background. I log si aggiorneranno automaticamente.');
session()->flash('success', 'Import PDF avviato in background. L\'avanzamento è nella console in fondo alla pagina.');
}
public function downloadImportLogPdf()

251
app/Livewire/Settings/ZonaPericolosa.php Normal file
View File

@@ -0,0 +1,251 @@
<?php
namespace App\Livewire\Settings;
use App\Jobs\CreateBackupArchive;
use App\Jobs\ResetApplication;
use App\Livewire\Concerns\SegueOperazioneBackup;
use App\Services\BackupOperationState;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\RateLimiter;
use Livewire\Component;
/**
* Azzeramento dell'applicazione: l'unica operazione irreversibile della pagina,
* e per questo l'ultima zona, dopo tutte le altre.
*
* E' un componente separato da BackupManager per una ragione di sola
* disposizione: la zona pericolosa deve stare in fondo alla pagina, mentre le
* sezioni di backup e ripristino stanno in cima. Rendendola dallo stesso
* componente finiva a meta' pagina, in mezzo alle sezioni di import, che e'
* l'ultimo posto in cui si vuole trovare un pulsante che cancella tutto.
*
* Lo stato dell'operazione resta condiviso con BackupManager attraverso
* BackupOperationState (il trait), quindi i due non hanno bisogno di parlarsi per
* restare coerenti: il posto unico e' uno solo per entrambi.
*
* L'azzeramento ha due tempi, separati dal download dell'archivio:
*
* 1. avviaAzzeramento() crea il backup e si ferma in attesa-download
* 2. confermaAzzeramento() cancella, solo su conferma umana e con la password
*
* Il primo tentativo faceva partire la cancellazione dalla coda dello
* streamDownload, "dopo l'ultimo byte": non funziona. Con fastcgi_buffering
* attivo (il default) nginx accetta l'intera risposta dal processo PHP, che
* prosegue anche se il browser ha chiuso la connessione al primo byte, quindi un
* download annullato azzerava lo stesso. Il server puo' verificare di aver
* *spedito* l'archivio, non che sia arrivato: quella verifica e' dell'operatore,
* e per questo la conferma e' umana.
*/
class ZonaPericolosa extends Component
{
use SegueOperazioneBackup;
/** Frase da digitare per sbloccare l'azzeramento. */
public const CONFERMA_AZZERAMENTO = 'AZZERA TUTTO';
/** Password sbagliate ammesse prima di bloccare l'azzeramento, e per quanto. */
private const TENTATIVI_PASSWORD = 5;
private const FINESTRA_TENTATIVI = 300;
public string $confermaReset = '';
/**
* Esiste solo per dare un nome agli errori del campo password: Livewire
* scarta dal messaggio di risposta ogni errore la cui chiave non
* corrisponda a una proprieta' del componente (SupportValidation::dehydrate),
* quindi senza questa riga "Password non corretta" non arriverebbe mai a
* schermo e il pulsante sembrerebbe non fare nulla.
*
* NON collegarla al campo con wire:model: la password viaggia come
* parametro di confermaAzzeramento() proprio per non finire nello
* snapshot, che Livewire rimanda al browser a ogni risposta. Qui resta
* sempre stringa vuota.
*/
public string $passwordConferma = '';
public function mount(): void
{
$this->authorize('settings.manage');
$this->agganciaOperazioneCorrente();
}
/**
* Solo l'azzeramento: backup e ripristino li racconta BackupManager. Vedi
* SegueOperazioneBackup::tipiSeguiti().
*/
protected function tipiSeguiti(): array
{
return [BackupOperationState::TIPO_RESET];
}
/**
* Primo tempo: si costruisce il backup e lo si scarica. La cancellazione non
* parte da qui.
*/
public function avviaAzzeramento(): void
{
$this->authorize('settings.manage');
$this->validate(
['confermaReset' => 'required|in:' . self::CONFERMA_AZZERAMENTO],
['confermaReset.in' => 'Scrivi esattamente "' . self::CONFERMA_AZZERAMENTO . '" per confermare.',
'confermaReset.required' => 'Scrivi "' . self::CONFERMA_AZZERAMENTO . '" per confermare.']
);
if (! $this->postoLibero()) {
return;
}
$this->confermaReset = '';
$this->operationId = $this->nuovaOperazione(BackupOperationState::TIPO_RESET);
CreateBackupArchive::dispatch($this->operationId, true);
$this->aggiorna();
// La sezione di backup deve sapere che il posto e' occupato, altrimenti
// continuerebbe a offrire il proprio pulsante durante l'azzeramento.
// Indirizzato e non gridato: senza ->to() l'evento tornerebbe anche qui.
$this->dispatch('operazione-avviata')->to(BackupManager::class);
}
/**
* Secondo tempo: parte solo su conferma esplicita, dopo che l'archivio e'
* stato servito.
*/
public function confermaAzzeramento(string $password = ''): void
{
$this->authorize('settings.manage');
$this->aggiorna();
if (! $this->attesaDownload) {
$this->addError('confermaReset', 'Nessun azzeramento in attesa di conferma.');
return;
}
if (($this->operazione['result']['servito_at'] ?? null) === null) {
$this->addError('confermaReset', 'Scarica prima il backup: senza, l\'azzeramento non parte.');
return;
}
if (! $this->passwordConfermata($password)) {
return;
}
app(BackupOperationState::class)->update($this->operationId, function (array $state) {
$state['fase'] = 'Azzeramento in avvio';
$state['processed'] = 0;
$state['total'] = 0;
return $state;
});
ResetApplication::dispatch($this->operationId, (int) auth()->id());
$this->aggiorna();
}
/**
* Verifica la password dell'amministratore prima della cancellazione.
*
* A questo punto la sessione e' gia' autenticata, quindi la password non
* serve a stabilire *chi* sia: serve a stabilire che davanti allo schermo
* ci sia ancora quella persona. E' l'ultimo passo prima di un'operazione
* irreversibile, e una scheda lasciata aperta su una postazione condivisa e'
* lo scenario esatto contro cui protegge.
*/
private function passwordConfermata(string $password): bool
{
$utente = auth()->user();
$chiave = 'azzeramento-password:' . $utente->id;
// Senza un limite, la richiesta di password su una sessione dirottata
// sarebbe solo un rallentamento: si proverebbero le password comuni a
// raffica. Il blocco e' sull'azione, non sull'account, quindi nessuno
// resta chiuso fuori dall'applicazione.
if (RateLimiter::tooManyAttempts($chiave, self::TENTATIVI_PASSWORD)) {
$this->addError('passwordConferma', sprintf(
'Troppi tentativi. Riprova fra %d secondi.',
RateLimiter::availableIn($chiave)
));
return false;
}
if ($password === '') {
$this->addError('passwordConferma', 'Inserisci la tua password per confermare.');
return false;
}
if (! Hash::check($password, $utente->getAuthPassword())) {
RateLimiter::hit($chiave, self::FINESTRA_TENTATIVI);
$this->addError('passwordConferma', 'Password non corretta.');
return false;
}
RateLimiter::clear($chiave);
return true;
}
/**
* Annulla un azzeramento fermo in attesa di conferma. Il backup resta
* scaricabile: e' comunque un backup valido.
*/
public function annullaAzzeramento(): void
{
$this->authorize('settings.manage');
if (! $this->attesaDownload) {
return;
}
app(BackupOperationState::class)->markCompleted($this->operationId, [
'messaggio' => 'Azzeramento annullato. Il backup appena creato resta scaricabile.',
]);
// Da qui in poi e' un backup come un altro: la sezione di backup mostra il
// pulsante di download, non piu' la conferma di cancellazione.
app(BackupOperationState::class)->update($this->operationId, function (array $state) {
$state['tipo'] = BackupOperationState::TIPO_BACKUP;
return $state;
});
$this->aggiorna();
$this->dispatch('operazione-avviata')->to(BackupManager::class);
}
/**
* Un azzeramento avviato altrove non esiste, ma il posto puo' essere occupato
* da un backup o da un ripristino: la zona deve saperlo per non offrire un
* pulsante che verrebbe rifiutato.
*/
#[\Livewire\Attributes\On('operazione-avviata')]
public function agganciaAltrove(): void
{
$this->agganciaOperazioneCorrente();
}
/**
* Vero quando questa zona sta seguendo un azzeramento (non un backup o un
* ripristino avviati altrove).
*/
public function getAzzeramentoInCorsoProperty(): bool
{
return $this->operationId !== null
&& ($this->operazione['tipo'] ?? null) === BackupOperationState::TIPO_RESET;
}
public function render()
{
return view('livewire.settings.zona-pericolosa');
}
}