Senza questo pezzo i nuovi flussi non sono raggiungibili in produzione.

Co-authored-by: Cursor <cursoragent@cursor.com>

app/Console/Commands/FestSalute.php

+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Cucina;
+use App\Models\Dispositivo;
+use App\Models\Endpoint;
+use App\Models\PrintJob;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Redis;
+use Illuminate\Support\Facades\Schema;
+
+class FestSalute extends Command
+{
+    protected $signature = 'fest:salute';
+
+    protected $description = 'Verifica Redis, code, stampe, endpoint e configurazione cassa/cucina';
+
+    private int $ko = 0;
+
+    private int $attenzione = 0;
+
+    public function handle(): int
+    {
+        $this->info('Fest — controllo salute');
+        $this->newLine();
+
+        $this->checkDatabase();
+        $this->checkMigrazioni();
+        $this->checkRedis();
+        $this->checkHorizon();
+        $this->checkCodaMail();
+        $this->checkMailConfig();
+        $this->checkEndpoint();
+        $this->checkCasse();
+        $this->checkCucine();
+        $this->checkPrintJobBloccati();
+
+        $this->newLine();
+        if ($this->ko > 0) {
+            $this->error("Esito: KO ({$this->ko} errori, {$this->attenzione} avvisi).");
+
+            return self::FAILURE;
+        }
+
+        if ($this->attenzione > 0) {
+            $this->warn("Esito: OK con avvisi ({$this->attenzione}). Il sistema è su, controlla le righe ATTENZIONE.");
+
+            return self::SUCCESS;
+        }
+
+        $this->info('Esito: OK. Controlli base superati.');
+
+        return self::SUCCESS;
+    }
+
+    private function checkDatabase(): void
+    {
+        try {
+            DB::connection()->getPdo();
+            $this->ok('Database', (string) DB::connection()->getDatabaseName());
+        } catch (\Throwable $e) {
+            $this->koCheck('Database', $e->getMessage());
+        }
+    }
+
+    private function checkMigrazioni(): void
+    {
+        try {
+            if (! Schema::hasTable('migrations')) {
+                $this->koCheck('Migrazioni', 'tabella migrations assente');
+
+                return;
+            }
+
+            $ran = DB::table('migrations')->pluck('migration')->all();
+            $files = collect(File::files(database_path('migrations')))
+                ->map(fn ($file) => pathinfo($file->getFilename(), PATHINFO_FILENAME));
+            $pending = $files->reject(fn (string $name) => in_array($name, $ran, true))->values();
+
+            if ($pending->isEmpty()) {
+                $this->ok('Migrazioni', 'nessuna in sospeso');
+
+                return;
+            }
+
+            $elenco = $pending->take(5)->implode(', ');
+            $extra = $pending->count() > 5 ? '…' : '';
+            $this->koCheck('Migrazioni', $pending->count().' in sospeso ('.$elenco.$extra.'). Esegui php artisan migrate');
+        } catch (\Throwable $e) {
+            $this->koCheck('Migrazioni', $e->getMessage());
+        }
+    }
+
+    private function checkRedis(): void
+    {
+        try {
+            Redis::connection()->ping();
+            $this->ok('Redis', 'risponde');
+        } catch (\Throwable $e) {
+            $this->koCheck('Redis', $e->getMessage());
+        }
+    }
+
+    private function checkHorizon(): void
+    {
+        if (! interface_exists(\Laravel\Horizon\Contracts\MasterSupervisorRepository::class)) {
+            $this->warnCheck('Horizon', 'pacchetto non disponibile: avvia php artisan queue:work redis');
+
+            return;
+        }
+
+        try {
+            $masters = app(\Laravel\Horizon\Contracts\MasterSupervisorRepository::class)->all();
+            $running = collect($masters)->contains(
+                fn ($master) => ($master->status ?? null) === 'running'
+            );
+
+            if ($running) {
+                $this->ok('Horizon', 'in esecuzione');
+
+                return;
+            }
+
+            $this->koCheck(
+                'Horizon',
+                'non in esecuzione. Avvia php artisan horizon (oppure queue:work redis) o stampe e conferma-tutte restano in coda'
+            );
+        } catch (\Throwable $e) {
+            $this->koCheck('Horizon', $e->getMessage());
+        }
+    }
+
+    private function checkCodaMail(): void
+    {
+        $connection = (string) config('queue.default');
+        if ($connection === 'redis') {
+            $this->ok('Coda mail', 'QUEUE_CONNECTION=redis (Horizon può processare le email)');
+
+            return;
+        }
+
+        if ($connection === 'sync') {
+            $this->koCheck('Coda mail', 'QUEUE_CONNECTION=sync: le mail partono in-process, rischio timeout su conferma tutte');
+
+            return;
+        }
+
+        $this->warnCheck(
+            'Coda mail',
+            'QUEUE_CONNECTION='.$connection.'. Horizon ascolta Redis: senza un worker su '.$connection.' le email prenotazioni non partono'
+        );
+    }
+
+    private function checkMailConfig(): void
+    {
+        $from = (string) config('mail.from.address');
+        $mailer = (string) config('mail.default');
+        if (! filled($from) || $from === 'hello@example.com') {
+            $this->warnCheck('Mail', 'mittente non configurato (mail.from.address)');
+
+            return;
+        }
+
+        $this->ok('Mail', 'mailer='.$mailer.', from='.$from);
+    }
+
+    private function checkEndpoint(): void
+    {
+        try {
+            $attivi = Endpoint::query()->where('status', Endpoint::ATTIVO)->get();
+            if ($attivi->isEmpty()) {
+                $this->warnCheck('Endpoint', 'nessun FestAgent attivo: le stampe non escono');
+
+                return;
+            }
+
+            $stale = $attivi->filter(function (Endpoint $endpoint) {
+                $hb = $endpoint->last_heartbeat;
+                if ($hb === null) {
+                    return true;
+                }
+
+                return $hb->lt(now()->subMinutes(5));
+            });
+
+            if ($stale->isNotEmpty()) {
+                $nomi = $stale->map(fn (Endpoint $e) => $e->label ?: '#'.$e->id)->take(5)->implode(', ');
+                $this->koCheck(
+                    'Endpoint',
+                    $stale->count().' attivi senza heartbeat recente ('.$nomi.'). Agent spento o rete?'
+                );
+
+                return;
+            }
+
+            $this->ok('Endpoint', $attivi->count().' attivi, heartbeat ok');
+        } catch (\Throwable $e) {
+            $this->koCheck('Endpoint', $e->getMessage());
+        }
+    }
+
+    private function checkCasse(): void
+    {
+        try {
+            $casse = Dispositivo::query()
+                ->whereIn('tipo', [Dispositivo::CASSA, Dispositivo::KIOSK, Dispositivo::CAMERIERE])
+                ->where('is_attivo', true)
+                ->get();
+
+            if ($casse->isEmpty()) {
+                $this->warnCheck('Casse', 'nessun punto vendita attivo');
+
+                return;
+            }
+
+            $senza = $casse->filter(fn (Dispositivo $d) => $d->stampante_dispositivo() === null);
+            if ($senza->isNotEmpty()) {
+                $nomi = $senza->map(fn (Dispositivo $d) => $d->nome ?: '#'.$d->id)->take(8)->implode(', ');
+                $this->koCheck('Casse', $senza->count().' senza stampante valida: '.$nomi);
+
+                return;
+            }
+
+            $this->ok('Casse', $casse->count().' attive con stampante');
+        } catch (\Throwable $e) {
+            $this->koCheck('Casse', $e->getMessage());
+        }
+    }
+
+    private function checkCucine(): void
+    {
+        try {
+            $cucine = Cucina::query()->where('is_attiva', true)->get();
+            if ($cucine->isEmpty()) {
+                $this->warnCheck('Cucine', 'nessuna cucina attiva');
+
+                return;
+            }
+
+            $senza = $cucine->filter(fn (Cucina $c) => $c->stampante_id === null);
+            if ($senza->isNotEmpty()) {
+                $nomi = $senza->map(fn (Cucina $c) => $c->nome ?: '#'.$c->id)->take(8)->implode(', ');
+                $this->koCheck('Cucine', $senza->count().' attive senza stampante: '.$nomi);
+
+                return;
+            }
+
+            $this->ok('Cucine', $cucine->count().' attive con stampante');
+        } catch (\Throwable $e) {
+            $this->koCheck('Cucine', $e->getMessage());
+        }
+    }
+
+    private function checkPrintJobBloccati(): void
+    {
+        try {
+            $limite = now()->subMinutes(10);
+            $inAttesa = PrintJob::query()
+                ->where('stato', PrintJob::STATO_IN_ATTESA)
+                ->where('created_at', '<', $limite)
+                ->count();
+            $inCoda = PrintJob::query()
+                ->where('stato', PrintJob::STATO_IN_CODA)
+                ->where('created_at', '<', $limite)
+                ->count();
+            $fallitiOggi = PrintJob::query()
+                ->where('stato', PrintJob::STATO_FALLITO)
+                ->whereDate('created_at', today())
+                ->count();
+
+            if ($inAttesa > 0 || $inCoda > 0) {
+                $this->koCheck(
+                    'PrintJob',
+                    "{$inAttesa} in_attesa da >10 min (worker Redis?), {$inCoda} in_coda da >10 min (agent?)"
+                );
+
+                return;
+            }
+
+            if ($fallitiOggi > 0) {
+                $this->warnCheck('PrintJob', $fallitiOggi.' falliti oggi');
+
+                return;
+            }
+
+            $this->ok('PrintJob', 'nessun job bloccato');
+        } catch (\Throwable $e) {
+            $this->koCheck('PrintJob', $e->getMessage());
+        }
+    }
+
+    private function ok(string $voce, string $dettaglio): void
+    {
+        $this->line('<info>[OK]</info> '.$voce.' — '.$dettaglio);
+    }
+
+    private function koCheck(string $voce, string $dettaglio): void
+    {
+        $this->ko++;
+        $this->line('<error>[KO]</error> '.$voce.' — '.$dettaglio);
+    }
+
+    private function warnCheck(string $voce, string $dettaglio): void
+    {
+        $this->attenzione++;
+        $this->line('<comment>[ATTENZIONE]</comment> '.$voce.' — '.$dettaglio);
+    }
+}

app/DataTables/AttivitaDataTableEditor.php

 use Yajra\DataTables\DataTablesEditor;
 use Illuminate\Http\Request;
 use Illuminate\Validation\ValidationException;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Storage;
 use Illuminate\Support\Str;
 use Illuminate\Http\JsonResponse;
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
     $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
+    $data['user_id'] = Auth::id();
+
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $this->garantisciQuestaAttivita($model);
     $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
+    unset($data['user_id']);
+
     return $data;
   }
 
-  public function created(Model $model, array $data): Model
+  public function deleting(Model $model, array $data): array
   {
-    return $model;
+    $this->garantisciQuestaAttivita($model);
+
+    return $data;
+  }
+
+  private function garantisciQuestaAttivita(Model $model): void
+  {
+    $user = Auth::user();
+    if ($user?->hasRole('superadmin')) {
+      return;
+    }
+
+    if (! $model instanceof Attivita || (int) $model->user_id !== (int) $user?->id) {
+      abort(404);
+    }
+  }
+
+  public function uploadRules(): array
+  {
+    $image = ['required', 'file', 'image', 'mimes:jpeg,png,jpg,gif,webp', 'max:5120'];
+
+    return [
+      'path_logo' => $image,
+      'path_icon' => $image,
+      'path_image' => $image,
+    ];
   }
 
   public function upload(Request $request): JsonResponse
   {
     $this->action = 'upload';
 
-    $field   = $request->input('uploadField');
-    $storage = Storage::disk($this->disk);
+    $field = $request->input('uploadField');
+    if (! $field || ! is_string($field)) {
+      $field = 'file';
+    }
 
     try {
-      $rules      = $this->uploadRules();
-      $fieldRules = ['upload' => data_get($rules, $field, [])];
+      $storage = Storage::disk($this->disk);
+      $rules = $this->uploadRules();
+      $fieldRules = ['upload' => $rules[$field] ?? $rules['path_image']];
 
       $this->validate($request, $fieldRules, $this->messages(), $this->attributes());
 
       $uploadedFile = $request->file('upload');
-      $filename     = $this->getUploadedFilename($field, $uploadedFile);
-      $id           = $storage->putFileAs($request->id, $uploadedFile, $filename);
+      if (! $uploadedFile instanceof UploadedFile) {
+        throw ValidationException::withMessages([
+          'upload' => 'File non valido.',
+        ]);
+      }
+
+      $directory = $this->resolveUploadDirectory($request);
+      $filename = $this->getUploadedFilename($field, $uploadedFile);
+      $id = $storage->putFileAs($directory, $uploadedFile, $filename);
+
+      if (! is_string($id)) {
+        throw ValidationException::withMessages([
+          'upload' => 'Impossibile salvare il file caricato.',
+        ]);
+      }
 
       if (method_exists($this, 'uploaded')) {
         $id = $this->uploaded($id);
 
       return response()->json([
         'action' => $this->action,
-        'data'   => [],
-        'files'  => [
+        'data' => [],
+        'files' => [
           'files' => [
             $id => [
-              'filename'      => $id,
+              'filename' => $id,
               'original_name' => $uploadedFile->getClientOriginalName(),
-              'size'          => $uploadedFile->getSize(),
-              'directory'     => $request->id,
-              'disk'          => $this->disk,
-              'url'           => $storage->url($id),
+              'size' => $uploadedFile->getSize(),
+              'directory' => $directory,
+              'disk' => $this->disk,
+              'url' => $storage->url($id),
             ],
           ],
         ],
       ]);
     } catch (ValidationException $exception) {
       return response()->json([
-        'action'      => $this->action,
-        'data'        => [],
+        'action' => $this->action,
+        'data' => [],
         'fieldErrors' => [
           [
-            'name'   => $field,
-            'status' => str_replace('upload', $field, $exception->errors()['upload'][0]),
+            'name' => $field,
+            'status' => str_replace('upload', $field, (string) ($exception->errors()['upload'][0] ?? 'Errore di validazione')),
           ],
         ],
       ]);
     }
   }
 
+  protected function resolveUploadDirectory(Request $request): string
+  {
+    $id = $request->input('id');
+    if ($id === null || $id === '' || ! is_numeric($id)) {
+      return 'tmp';
+    }
+
+    $attivita = Attivita::find((int) $id);
+    if (! $attivita) {
+      abort(404);
+    }
+
+    $this->garantisciQuestaAttivita($attivita);
+
+    return (string) $attivita->id;
+  }
+
+  protected function getUploadedFilename(string $field, UploadedFile $uploadedFile): string
+  {
+    $ext = $uploadedFile->getClientOriginalExtension();
+
+    return $field.'_'.time().'_'.Str::random(4).($ext !== '' ? '.'.$ext : '');
+  }
+
   public function messages(): array
   {
     return $this->messages;

app/DataTables/BachecaDataTable.php

      */
     public function query(Bacheca $model): QueryBuilder
     {
-        return $model->newQuery()->where('attivita_id', $this->attivita_id);
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
+            return $model->newQuery()->whereRaw('1 = 0');
+        }
+
+        return $model->newQuery()->where('attivita_id', $attivitaId);
     }
 
     /**

app/DataTables/BachecaDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Bacheca;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
+use Illuminate\Support\Facades\Session;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class BachecaDataTableEditor extends DataTablesEditor
 {
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
     $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
     $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
     return $data;
   }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
   public function messages(): array
   {
     return $this->messages;

app/DataTables/CategoriacontabileDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Categoriacontabile;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Facades\Session;
 use Illuminate\Validation\Rule;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class CategoriacontabileDataTableEditor extends DataTablesEditor
 {
       'nome'  => [
         'required',
         Rule::unique('categoria_contabile', 'nome')
-            ->where('attivita_id', $data['attivita_id'] ?? null),
+            ->where('attivita_id', Session::get('attivita_attuale')),
       ],
       'descrizione' => 'nullable',
       'is_attiva' => 'boolean',
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
     $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
     $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
     return $data;
   }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
   public function messages(): array
   {
     return $this->messages;

app/DataTables/ChiusuraServizioDataTable.php

      */
     public function query(ChiusuraServizio $model): QueryBuilder
     {
-        return $model->newQuery()->where('attivita_id', $this->attivita_id)->orderBy('chiusura_at', 'desc');
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
+            return $model->newQuery()->whereRaw('1 = 0');
+        }
+
+        return $model->newQuery()->where('attivita_id', $attivitaId)->orderBy('chiusura_at', 'desc');
     }
 
     /**

app/DataTables/ChiusuraServizioDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\ChiusuraServizio;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
+use Illuminate\Support\Facades\Session;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
 
 
 class ChiusuraServizioDataTableEditor extends DataTablesEditor
   public function createRules(): array
   {
     return [
-      'attivita_id'  => 'required',
       'chiusura_at' => 'required|date',
       'user_id' => 'required',
       'note' => 'nullable',
   public function editRules(Model $model): array
   {
     return [
-      'attivita_id'  => 'required',
       'chiusura_at' => 'required|date',
       'note' => 'nullable',
       'info' => 'nullable',
 
   public function creating(Model $model, array $data): array
   {
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
     return $data;
   }
   public function messages(): array

app/DataTables/ContenutoBachecaDataTable.php

      */
     public function query(ContenutoBacheca $model): QueryBuilder
     {
-        $model = $model->newQuery()->where('attivita_id', $this->attivita_id);
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
+            return $model->newQuery()->whereRaw('1 = 0');
+        }
+
+        $model = $model->newQuery()->where('attivita_id', $attivitaId);
         if($this->bacheca_id){
             return $model->join('bacheca_has_contenuto', 'contenuto_bacheca.id', '=', 'bacheca_has_contenuto.contenuto_id')->where('bacheca_has_contenuto.bacheca_id', $this->bacheca_id);
         }

app/DataTables/ContenutoBachecaDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\ContenutoBacheca;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
+use Illuminate\Support\Facades\Session;
 use Yajra\DataTables\DataTablesEditor;
 use Illuminate\Http\Request;
 use Illuminate\Validation\ValidationException;
 
   public function creating(Model $model, array $data): array
   {
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
 
     return $data;
   }
 
       $uploadedFile = $request->file('upload');
       $filename     = $this->getUploadedFilename($field, $uploadedFile);
-      $id           = $storage->putFileAs($request->id, $uploadedFile, $filename);
+      $rowId        = $request->id;
+      if ($rowId !== null && $rowId !== '' && is_numeric($rowId)) {
+        $contenuto = ContenutoBacheca::find((int) $rowId);
+        if (! $contenuto) {
+          abort(404);
+        }
+        AttivitaService::garantisciAttivita($contenuto->attivita_id);
+      }
+      $id           = $storage->putFileAs($rowId, $uploadedFile, $filename);
 
       if (method_exists($this, 'uploaded')) {
         $id = $this->uploaded($id);

app/DataTables/CucinaDataTable.php

      */
     public function query(Cucina $model): QueryBuilder
     {
-        if($this->attivita_id){
-            return $model->newQuery()->where('attivita_id', $this->attivita_id)->orderBy('nome', 'asc');
-        }else{
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
             return $model->newQuery()->whereRaw('1 = 0');
         }
+
+        return $model->newQuery()->where('attivita_id', $attivitaId)->orderBy('nome', 'asc');
     }
 
     /**
                         Editor::make()
                         ->ajax(route('cucina.store'))
                         ->fields([
-                          Fields\Hidden::make('attivita_id')->label('Attività')->default($this->attivita_id),
+                          Fields\Hidden::make('attivita_id')->label('Attività')->default((int) $this->attivita_id),
                           Fields\Boolean::make('is_attiva')->label('Attiva')->default(true),  
                           Fields\Text::make('nome')->label('Nome'),
                           Fields\Text::make('descrizione')->label('Descrizione'),
-                          Fields\Select2::make('stampante_id')->label('Stampante')->options(Dispositivo::where('tipo', Dispositivo::STAMPANTE)->pluck('id', 'nome')),
+                          Fields\Select2::make('stampante_id')->label('Stampante')->options(Dispositivo::where('tipo', Dispositivo::STAMPANTE)->where('attivita_id', (int) $this->attivita_id)->pluck('id', 'nome')),
                           Fields\Text::make('colore')->label('Colore')->set('attr', ['type' => 'color']),
                           Fields\Boolean::make('coperto_come_piatto')->label('Ogni piatto ordinato corrisponde ad un coperto'),  
+                          Fields\Boolean::make('stampa_ritiro')->label('Stampa biglietto per ritiro ordine'),
                             // Fields\Image::make('immagine')->label('Immagine'),
                             // Fields\Select2::make('cucina_id')->label('Cucina')->options(Cucina::where('is_attiva', true)->pluck('id', 'nome')),
                         ])
         Column::make('badge_colore')->title('Cucina')->addClass('text-left')->responsivePriority(1),
         Column::computed('piatti_count')->title('Piatti')->addClass('text-center'),
         Column::make('coperto_come_piatto')->visible(false),
+        Column::make('stampa_ritiro')->visible(false),
         Column::computed('action')
         ->title('')
         ->exportable(false)
             Column::make('stampante_id')->data('stampante_display')->title('Stampante')->addClass('text-center'),
             // Column::make('cucina_id')->data('cucina_id_display')->title('Cucina')->addClass('text-center'),
             Column::make('coperto_come_piatto')->visible(false),
+            Column::make('stampa_ritiro')->visible(false),
             Column::make('action')
             ->title('')
             ->exportable(false)

app/DataTables/CucinaDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Cucina;
+use App\Models\Dispositivo;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
+use Illuminate\Support\Facades\Session;
 
 class CucinaDataTableEditor extends DataTablesEditor
 {
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $this->garantisciStampanteDiQuestaAttivita($data['stampante_id'] ?? null, $data['attivita_id']);
+
     $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
-    
     $data['info']['coperto_come_piatto'] = filter_var($data['coperto_come_piatto'] ?? false, FILTER_VALIDATE_BOOLEAN);
-    $data['info']['colore'] = $data['colore'];
+    $data['info']['stampa_ritiro'] = filter_var($data['stampa_ritiro'] ?? false, FILTER_VALIDATE_BOOLEAN);
+    $data['info']['colore'] = $data['colore'] ?? null;
 
-    // $data['info']['coperto_come_piatto'] = isset($data['coperto_come_piatto']) ? true : false;
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $this->garantisciStampanteDiQuestaAttivita($data['stampante_id'] ?? $model->stampante_id, $model->attivita_id);
+
     $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
-    $data['info']['colore'] = $data['colore'];
+    $data['info']['colore'] = $data['colore'] ?? ($model->info['colore'] ?? null);
     $data['info']['coperto_come_piatto'] = filter_var($data['coperto_come_piatto'] ?? false, FILTER_VALIDATE_BOOLEAN);
+    $data['info']['stampa_ritiro'] = filter_var($data['stampa_ritiro'] ?? false, FILTER_VALIDATE_BOOLEAN);
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
 
     return $data;
   }
+
+  private function garantisciStampanteDiQuestaAttivita($stampanteId, $attivitaId): void
+  {
+    if (! $stampanteId) {
+      return;
+    }
+
+    $stampante = Dispositivo::find($stampanteId);
+    if (
+      ! $stampante
+      || (int) $stampante->attivita_id !== (int) $attivitaId
+      || $stampante->tipo !== Dispositivo::STAMPANTE
+    ) {
+      abort(404);
+    }
+  }
   public function messages(): array
   {
     return $this->messages;

app/DataTables/CuponDataTable.php

+<?php
+
+namespace App\DataTables;
+
+use App\Models\Cupon;
+use Illuminate\Database\Eloquent\Builder as QueryBuilder;
+use Yajra\DataTables\EloquentDataTable;
+use Yajra\DataTables\Html\Builder as HtmlBuilder;
+use Yajra\DataTables\Html\Button;
+use Yajra\DataTables\Html\Column;
+use Yajra\DataTables\Html\Editor\Editor;
+use Yajra\DataTables\Html\Editor\Fields;
+use Yajra\DataTables\Services\DataTable;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Str;
+
+
+class CuponDataTable extends DataTable
+{
+
+ public function __construct()
+ {
+    $this->dataTableVariable = 'dataTable_cupon';
+ }
+    /**
+     * Build the DataTable class.
+     *
+     * @param QueryBuilder<Cupon> $query Results from query() method.
+     */
+    public function dataTable(QueryBuilder $query): EloquentDataTable
+    {
+        return (new EloquentDataTable($query))
+            ->addColumn('action', function ($entity) {
+                return view('cupon.menu', compact('entity'));
+            })
+            ->editColumn('importo', function ($entity) {
+                return '€ ' . number_format($entity->importo, 2, ',', '.');
+            })
+            ->editColumn('validita_display', function ($entity) {
+                if($entity->validita_da->isSameDay($entity->validita_a)){
+                    return $entity->validita_da->format('d/m/Y');
+                }else{
+                    return $entity->validita_da->format('d/m/Y') . ' - ' . $entity->validita_a->format('d/m/Y');
+                }   
+            })
+            ->addColumn('stato_display', function ($entity) {
+                return view('cupon.stato', ['stato' => $entity->stato]);
+            })
+            ->addColumn('codice_display', function ($entity) {
+                return view('cupon.stato', ['codice' => $entity->codice]);
+            })
+            ->setRowId('id');
+    }
+
+    /**
+     * Get the query source of dataTable.
+     *
+     * @return QueryBuilder<Cupon>
+     */
+    public function query(Cupon $model): QueryBuilder
+    {
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
+            return $model->newQuery()->whereRaw('1 = 0');
+        }
+
+        return $model->newQuery()->where('attivita_id', $attivitaId);
+    }
+
+    /**
+     * Optional method if you want to use the html builder.
+     */
+    public function html(): HtmlBuilder
+    {
+        $buttons = [];
+
+        if(Auth::user()->can('create-cupon')){
+            array_push($buttons, Button::make('create')
+            ->editor('editor')
+            ->formTitle('Crea nuovo cupon')
+            ->className('btn btn-sm btn-primary mb-4 text-white')
+            ->text('<i class="fas fa-plus "></i> Nuovo cupon')
+            );
+        
+
+            array_push($buttons, Button::raw('generaBatch')
+            ->className('btn btn-sm btn-primary mb-4 text-white')
+            ->text('<i class="fas fa-plus "></i> massivo')
+            ->action("generaBatchCupon()")
+            );
+
+            // array_push($buttons, Button::raw('reportCupon')
+            // ->className('btn btn-sm btn-primary mb-4 text-white')
+            // ->text('<i class="fas fa-file-alt "></i> Report cupon')
+            // ->action("reportCupon()")
+            // );
+            
+            array_push($buttons, Button::raw('stampaCupon')
+            ->className('btn btn-sm btn-primary mb-4 text-white')
+            ->text('<i class="fas fa-file-alt "></i> Stampa cupon')
+            ->action("window.location.href='".route('cupon.stampa')."'")
+            );
+        }
+
+        return $this->builder()
+                    ->setTableId($this->dataTableVariable)
+                    ->columns($this->getColumns())
+                    ->minifiedAjax()
+                    ->orderBy(1)
+                    ->selectStyleSingle()
+                    ->buttons($buttons)
+                    ->initComplete("function(settings, json){
+                        initComplete_cupon();
+                    }")
+                    ->language(asset('assets/Italian.json'))
+                    ->dom(count($buttons)==0?'rtip':'Bfrtip')
+                    ->editor(
+                        Editor::make()->fields([
+                        Fields\Hidden::make('attivita_id')->label('Attività')->default((int) $this->attivita_id),
+                        Fields\Hidden::make('stato')->label('Stato')->default(Cupon::GENERATO),
+                        Fields\Hidden::make('codice')->label('Codice'),
+                        Fields\Number::make('importo')->label('Importo')->required(),
+                        Fields\Text::make('nominativo')->label('Nominativo')->required(),
+                        Fields\Text::make('email')->label('Email'),
+                        Fields\Date::make('validita_da')->label('Validità da')->required(),
+                        Fields\Date::make('validita_a')->label('Validità a')->required(),
+                    ]));
+    }
+
+    /**
+     * Get the dataTable columns definition.
+     */
+    public function getColumns(): array
+    {
+        return [
+            Column::make('id'),
+            Column::make('codice_display')->title('Codice'),
+            Column::make('stato_display'),
+            Column::make('importo')->title('Importo'),
+            Column::make('nominativo')->title('Nominativo'),
+            // Column::make('email'),
+            Column::make('validita_display')->title('Validità'),
+            Column::computed('action')
+                  ->title('Azioni')
+                  ->exportable(false)
+                  ->printable(false)
+                  ->width(60)
+                  ->addClass('text-center'),
+        ];
+    }
+
+    /**
+     * Get the filename for export.
+     */
+    protected function filename(): string
+    {
+        return 'Cupon_' . date('YmdHis');
+    }
+}

app/DataTables/CuponDataTableEditor.php

+<?php
+
+namespace App\DataTables;
+
+use App\Models\Cupon;
+use App\Services\Attivita\AttivitaService;
+use Illuminate\Database\Eloquent\Model;
+use Yajra\DataTables\DataTablesEditor;
+use Illuminate\Support\Facades\Session;
+
+class CuponDataTableEditor extends DataTablesEditor
+{
+  protected $model = Cupon::class;
+  // protected $uploadDir = '';
+  // protected $disk = 'modelliRicevute';
+
+  protected $messages = [
+    'codice.required' => 'Il codice è richiesto',
+    'codice.unique' => 'Il codice deve essere unico',
+    'validita_a.after_or_equal' => 'La validità a deve essere dopo la validità da',
+    'validita_da.date' => 'La validità da deve essere una data valida',
+    'validita_a.date' => 'La validità a deve essere una data valida',
+    'importo.numeric' => 'L\'importo deve essere un numero',
+    'importo.min' => 'L\'importo deve essere maggiore di 0',
+    'nominativo.string' => 'Il nominativo deve essere una stringa',
+    'nominativo.max' => 'Il nominativo deve essere massimo 255 caratteri',
+    'email.email' => 'L\'email deve essere una email valida',
+  ];
+
+  /**
+  * Get create action validation rules.
+  *
+  * @return array
+  */
+  public function createRules(): array
+  {
+    return [
+      // 'codice'  => 'required|unique:cupon,codice',
+      'importo' => 'nullable|numeric|min:0',
+      'nominativo' => 'nullable|string|max:255',
+      'email' => 'nullable|email|max:255',
+      'validita_da' => 'nullable|date',
+      'validita_a' => 'nullable|date|after_or_equal:validita_da',
+    ];
+  }
+
+  public function createMessages(): array{
+    return $this->messages;
+  }
+
+  /**
+  * Get edit action validation rules.
+  *
+  * @param Model $model
+  * @return array
+  */
+  public function editRules(Model $model): array
+  {
+    return [
+      'codice'  => 'required|unique:cupon,codice,' . $model->id,
+      'importo' => 'nullable|numeric|min:0',
+      'nominativo' => 'nullable|string|max:255',
+      'email' => 'nullable|email|max:255',
+      'validita_da' => 'nullable|date',
+      'validita_a' => 'nullable|date|after_or_equal:validita_da',
+ 
+    ];
+  }
+
+  public function editMessages(): array{
+    return $this->messages;
+  }
+
+  /**
+  * Get remove action validation rules.
+  *
+  * @param Model $model
+  * @return array
+  */
+  public function removeRules(Model $model): array
+  {
+    return [];
+  }
+
+  public function creating(Model $model, array $data): array
+  {
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $data['stato'] = Cupon::GENERATO;
+    if(!isset($data['codice']) || empty($data['codice'])){
+      $data['codice'] = app('App\Http\Controllers\CuponController')->generaCodiceCupon();
+    }
+
+    return $data;
+  }
+
+  public function updating(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
+  public function messages(): array
+  {
+    return $this->messages;
+  }
+
+
+}

app/DataTables/DispositivoDataTable.php

 
 class DispositivoDataTable extends DataTable
 {
+    public ?int $attivita_id = null;
+
     public function __construct()
     {
         $this->dataTableVariable = 'dataTable_dispositivo';
      */
     public function query(Dispositivo $model): QueryBuilder
     {
-        return $model->newQuery();
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
+            return $model->newQuery()->whereRaw('1 = 0');
+        }
+
+        return $model->newQuery()->where('attivita_id', $attivitaId);
     }
 
     /**
                     ->editor(
                         Editor::make()
                             ->fields([
-                                Fields\Hidden::make('attivita_id')->label('Attività')->default($this->attivita_id),
+                                Fields\Hidden::make('attivita_id')->label('Attività')->default((int) $this->attivita_id),
                                 Fields\Hidden::make('endpoint_id')->label('Endpoint ID'),
                                 Fields\Text::make('nome')->label('Nome'),
                                 Fields\Select2::make('tipo')->label('Tipo')->options(Dispositivo::getTipoDispositivo()->pluck('value', 'label')),

app/DataTables/DispositivoDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Dispositivo;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
+use Illuminate\Support\Facades\Session;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class DispositivoDataTableEditor extends DataTablesEditor
 {
     return [
       'nome'  => 'required',
       'tipo' => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
       'licenza' => 'nullable',
       'url_stampante' => 'nullable',
       'ubicazione' => 'nullable',
     return [
       'nome'  => 'required',
       'tipo' => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
       'licenza' => 'nullable',
       'url_stampante' => 'nullable',
       'ubicazione' => 'nullable',
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
-    $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
-    $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
     return $data;
   }
   public function messages(): array

app/DataTables/EndpointDataTableEditor.php

 use Illuminate\Validation\ValidationException;
 use Illuminate\Support\Facades\Storage;
 use Illuminate\Support\Str;
+use App\Services\Attivita\AttivitaService;
+use Illuminate\Support\Facades\Session;
 
 class EndpointDataTableEditor extends DataTablesEditor
 {
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data = $this->senzaSegreti($data);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    $data = $this->senzaSegreti($data);
+    unset($data['attivita_id']);
+
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
+
+  private function senzaSegreti(array $data): array
+  {
+    unset($data['token'], $data['product_key'], $data['secret'], $data['deeplink_token']);
+
     return $data;
   }
 

app/DataTables/EventoDataTable.php

             ->addColumn('stato_display', function($entity){
               return view('_partials.available', ['available' => $entity->is_attivo]);
             })
-            ->addColumn('data_inizio_display', function($entity){
-              return Carbon::parse($entity->data_inizio)->format('d/m/Y');
+            // ->addColumn('data_inizio_display', function($entity){
+            //   return Carbon::parse($entity->data_inizio)->format('d/m/Y');
+            // })
+            // ->addColumn('data_fine_display', function($entity){
+            //   return Carbon::parse($entity->data_fine)->format('d/m/Y');
+            // })
+            // ->addColumn('prezzo_display', function($entity){
+            //   return '€ ' . number_format($entity->prezzo, 2, ',', '.');
+            // })
+            // ->addColumn('apertura_prenotazione_display', function($entity){
+            //   return Carbon::parse($entity->apertura_prenotazione)->format('d/m/Y H:i');
+            // })
+            // ->addColumn('chiusura_prenotazione_display', function($entity){
+            //   return Carbon::parse($entity->chiusura_prenotazione)->format('d/m/Y H:i');
+            // })
+            // ->addColumn('periodo_evento_display', function($entity){
+            //   return Carbon::parse($entity->data_inizio)->format('d/m/Y') . ' - ' . Carbon::parse($entity->data_fine)->format('d/m/Y');
+            // })
+            // ->addColumn('periodo_prenotazioni_display', function($entity){
+            //   return Carbon::parse($entity->apertura_prenotazione)->format('d/m/Y') . ' - ' . Carbon::parse($entity->chiusura_prenotazione)->format('d/m/Y');
+            // })
+            // ->addColumn('prezzo_fisso_display', function($entity){
+            //   return view('_partials.available', ['available' => $entity->prezzo_fisso]);
+            // })
+            ->addColumn('posti_prenotati_confermati', function($entity){
+              return $entity->getCopertiConfermati();
             })
-            ->addColumn('data_fine_display', function($entity){
-              return Carbon::parse($entity->data_fine)->format('d/m/Y');
+            ->addColumn('posti_prenotati_non_confermati', function($entity){
+              return $entity->getPostiNonConfermati();
             })
-            ->addColumn('prezzo_display', function($entity){
-              return '€ ' . number_format($entity->prezzo, 2, ',', '.');
-            })
-            ->addColumn('apertura_prenotazione_display', function($entity){
-              return Carbon::parse($entity->apertura_prenotazione)->format('d/m/Y H:i');
-            })
-            ->addColumn('chiusura_prenotazione_display', function($entity){
-              return Carbon::parse($entity->chiusura_prenotazione)->format('d/m/Y H:i');
-            })
-            ->addColumn('periodo_evento_display', function($entity){
-              return Carbon::parse($entity->data_inizio)->format('d/m/Y') . ' - ' . Carbon::parse($entity->data_fine)->format('d/m/Y');
-            })
-            ->addColumn('periodo_prenotazioni_display', function($entity){
-              return Carbon::parse($entity->apertura_prenotazione)->format('d/m/Y') . ' - ' . Carbon::parse($entity->chiusura_prenotazione)->format('d/m/Y');
-            })
-            ->addColumn('prezzo_fisso_display', function($entity){
-              return view('_partials.available', ['available' => $entity->prezzo_fisso]);
+            ->addColumn('posti_rimasti', function($entity){
+              return $entity->posti - $entity->getCopertiConfermati() - $entity->getPostiNonConfermati();
             })
             ->setRowId('id');
     }
      */
     public function query(Evento $model): QueryBuilder
     {
-        return $model->newQuery();
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
+            return $model->newQuery()->whereRaw('1 = 0');
+        }
+
+        return $model->newQuery()->where('attivita_id', $attivitaId);
     }
 
     /**
     {
         $buttons = [];
         if(Auth::user()->can('create-evento')){
-            array_push($buttons, Button::make('create')
-                ->editor('editor')
+
+            // array_push($buttons, Button::make('create')
+            //     ->editor('editor')
+            //     ->className('btn btn-sm btn-primary mb-4')
+            //     ->formTitle('Crea nuovo evento')
+            //     ->formButtons([
+            //         Button::raw('Annulla')
+            //             ->className('btn btn-secondary ml-2')
+            //             ->actionClose(),
+            //         Button::raw('Salva')
+            //             ->className('btn btn-success ml-2')
+            //             ->actionHandler('create')
+            //     ])
+            //     ->text('<i class="fas fa-plus"></i> Nuovo evento'));
+
+            array_push($buttons, Button::raw('nuovoEvento')
                 ->className('btn btn-sm btn-primary mb-4')
-                ->formTitle('Crea nuovo evento')
-                ->formButtons([
-                    Button::raw('Annulla')
-                        ->className('btn btn-secondary ml-2')
-                        ->actionClose(),
-                    Button::raw('Salva')
-                        ->className('btn btn-success ml-2')
-                        ->actionHandler('create')
-                ])
-                ->text('<i class="fas fa-plus"></i> Nuovo evento'));
+                ->text('<i class="fas fa-plus"></i> Nuovo evento')
+                ->action("nuovoEvento()"));
         }
         return $this->builder()
                     ->setTableId($this->dataTableVariable)
         return [
             Column::make('id')->title('ID')->width('10%')->visible(false),
             Column::make('stato')->data('stato_display')->title('Stato')->addClass('text-center')->responsivePriority(1)->width('10%'),
-            Column::make('nome')->title('Nome')->responsivePriority(1),
+            Column::make('nome')->title('Titolo')->responsivePriority(1),
+            Column::make('posti')->title('Posti')->responsivePriority(2),
+            Column::computed('posti_prenotati_non_confermati')->title('NON confermati')->responsivePriority(2)->addClass('text-center text-warning'),
+            Column::computed('posti_prenotati_confermati')->title('Confermati')->responsivePriority(2)->addClass('text-center text-success'),
+            Column::computed('posti_rimasti')->title('Rimasti')->responsivePriority(2)->addClass('text-center'),
             // Column::make('descrizione')->title('Descrizione'),
-            Column::computed('periodo_evento_display')->title('Periodo evento')->responsivePriority(2),
-            Column::computed('periodo_prenotazioni_display')->title('Periodo prenotazioni')->responsivePriority(2),
-            Column::make('data_inizio')->title('Data inizio')->data('data_inizio_display')->visible(false)->responsivePriority(2),
-            Column::make('data_fine')->title('Data fine')->data('data_fine_display')->visible(false)->responsivePriority(2),
-            Column::make('apertura_prenotazione')->title('Apertura prenotazione')->data('apertura_prenotazione_display')->visible(false)->responsivePriority(2),
-            Column::make('chiusura_prenotazione')->title('Chiusura prenotazione')->data('chiusura_prenotazione_display')->visible(false)->responsivePriority(2),
-            Column::make('prezzo_fisso')->title('Prezzo fisso')->data('prezzo_fisso_display')->addClass('text-center')->responsivePriority(2),
-            Column::make('prezzo')->title('Prezzo')->data('prezzo_display')->addClass('text-center')->responsivePriority(2),
-            Column::make('note')->title('Note')->visible(false)->responsivePriority(2),
+            // Column::computed('periodo_evento_display')->title('Periodo evento')->responsivePriority(2),
+            // Column::computed('periodo_prenotazioni_display')->title('Periodo prenotazioni')->responsivePriority(2),
+            // Column::make('data_inizio')->title('Data inizio')->data('data_inizio_display')->visible(false)->responsivePriority(2),
+            // Column::make('data_fine')->title('Data fine')->data('data_fine_display')->visible(false)->responsivePriority(2),
+            // Column::make('apertura_prenotazione')->title('Apertura prenotazione')->data('apertura_prenotazione_display')->visible(false)->responsivePriority(2),
+            // Column::make('chiusura_prenotazione')->title('Chiusura prenotazione')->data('chiusura_prenotazione_display')->visible(false)->responsivePriority(2),
+            // Column::make('prezzo_fisso')->title('Prezzo fisso')->data('prezzo_fisso_display')->addClass('text-center')->responsivePriority(2),
+            // Column::make('prezzo')->title('Prezzo')->data('prezzo_display')->addClass('text-center')->responsivePriority(2),
+            // Column::make('note')->title('Note')->visible(false)->responsivePriority(2),
             Column::computed('action')
                   ->title('')
                   ->exportable(false)

app/DataTables/EventoDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Evento;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\UploadedFile;
 use Yajra\DataTables\DataTablesEditor;
 use Illuminate\Http\Request;
 use Illuminate\Validation\ValidationException;
+use Illuminate\Support\Facades\Session;
 use Illuminate\Support\Facades\Storage;
 use Illuminate\Support\Str;
 
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
     return $data;
   }
 
   {
     $id = $request->input('id');
     if ($id !== null && $id !== '' && is_numeric($id)) {
+      $evento = Evento::find((int) $id);
+      if (! $evento) {
+        abort(404);
+      }
+      AttivitaService::garantisciAttivita($evento->attivita_id);
+
       return $this->uploadDir.'/'.(int) $id;
     }
 
-    return $this->uploadDir; //$this->uploadDir.'/tmp';
+    AttivitaService::garantisciAttivita(Session::get('attivita_attuale'));
+
+    return $this->uploadDir;
   }
 
   protected function getUploadedFilename(string $field, UploadedFile $uploadedFile): string

app/DataTables/EventoFormDataTableEditor.php

 
 namespace App\DataTables;
 
+use App\Models\Evento;
 use App\Models\EventoForm;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class EventoFormDataTableEditor extends DataTablesEditor
 {
   public function creating(Model $model, array $data): array
   {
     $eventoId = request()->query('evento_id') ?? request()->input('evento_id');
-    if ($eventoId) {
-      $data['evento_id'] = (int) $eventoId;
+    $evento = Evento::find($eventoId);
+    if (! $evento) {
+      abort(404);
     }
+    AttivitaService::garantisciEventoDiQuestaAttivita($evento);
+    $data['evento_id'] = (int) $evento->id;
 
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciEventoDiQuestaAttivita($model->evento);
+    unset($data['evento_id']);
+
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciEventoDiQuestaAttivita($model->evento);
+
     return $data;
   }
   public function messages(): array

app/DataTables/FatturaDataTable.php

      */
     public function query(Fattura $model): QueryBuilder
     {
-        return $model->newQuery();
+        if (Auth::user()?->hasRole('superadmin')) {
+            return $model->newQuery();
+        }
+
+        return $model->newQuery()->where('user_id', Auth::id());
     }
 
     /**

app/DataTables/FatturaDataTableEditor.php

 
 use App\Models\Fattura;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
+use Illuminate\Support\Facades\Auth;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class FatturaDataTableEditor extends DataTablesEditor
 {
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['user_id'] = Auth::id();
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    if (! Auth::user()?->hasRole('superadmin') && (int) $model->user_id !== (int) Auth::id()) {
+      abort(404);
+    }
+    unset($data['user_id']);
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    if (! Auth::user()?->hasRole('superadmin') && (int) $model->user_id !== (int) Auth::id()) {
+      abort(404);
+    }
+
     return $data;
   }
   public function messages(): array

app/DataTables/FornitoreDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Fornitore;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
+use Illuminate\Support\Facades\Session;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class FornitoreDataTableEditor extends DataTablesEditor
 {
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
     return $data;
   }
   public function messages(): array

app/DataTables/ImpostazioniDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Impostazioni;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
+use Illuminate\Support\Facades\Session;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class ImpostazioniDataTableEditor extends DataTablesEditor
 {
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // $data['valore'] = $data['valore'] == 'true' ? true : false;
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
     return $data;
   }
   public function messages(): array

app/DataTables/MetodoPagamentoDataTable.php

 
 class MetodoPagamentoDataTable extends DataTable
 {
+    public ?int $attivita_id = null;
+
     public function __construct()
     {
         $this->dataTableVariable = 'dataTable_metodo_pagamento';
      */
     public function query(MetodoPagamento $model): QueryBuilder
     {
-        if($this->attivita_id){
-            return $model->newQuery()->where('attivita_id', $this->attivita_id)->orderBy('nome', 'asc');
-        }else{
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
             return $model->newQuery()->whereRaw('1 = 0');
         }
+
+        return $model->newQuery()->where('attivita_id', $attivitaId)->orderBy('nome', 'asc');
     }
 
     /**
                     ->editor(
                         Editor::make()
                             ->fields([
-                                Fields\Hidden::make('attivita_id')->label('Attività')->default($this->attivita_id),
+                                Fields\Hidden::make('attivita_id')->label('Attività')->default((int) $this->attivita_id),
                                 Fields\Boolean::make('is_attivo')->label('Attivo')->default(true),
                                 Fields\Select2::make('tipo')->label('Tipo')->options(MetodoPagamento::getTipiPagamento()->sortBy('label')->pluck('value' ,'label')),
                                 Fields\Text::make('nome')->label('Nome'),

app/DataTables/MetodoPagamentoDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\MetodoPagamento;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
+use Illuminate\Support\Facades\Session;
 
 class  MetodoPagamentoDataTableEditor extends DataTablesEditor
 {
     return [
       'nome'  => 'required',
       'tipo' => 'required|in:'.MetodoPagamento::getTipiPagamento()->pluck('value')->implode(','),
-      'attivita_id' => 'required|exists:attivita,id',
       // 'is_attivo' => 'boolean',
       // 'is_pubblico' => 'boolean',
       'key' => 'nullable',
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
     $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     $data['is_pubblico'] = isset($data['is_pubblico']) ? true : false;
     return $data;
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
     $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     $data['is_pubblico'] = isset($data['is_pubblico']) ? true : false;
     return $data;
   }
 
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
+
   public function messages(): array
   {
     return $this->messages;

app/DataTables/MonitorDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Dispositivo;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
+use Illuminate\Support\Facades\Session;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class MonitorDataTableEditor extends DataTablesEditor
 {
     return [
       'nome'  => 'required',
       'tipo' => 'required|in:'.Dispositivo::MONITOR,
-      'attivita_id' => 'required|exists:attivita,id',
       'licenza' => 'nullable',
       'url_stampante' => 'nullable',
       'ubicazione' => 'nullable',
     return [
       'nome'  => 'required',
       'tipo' => 'required|in:'.Dispositivo::MONITOR,
-      'attivita_id' => 'required|exists:attivita,id',
       'licenza' => 'nullable',
       'url_stampante' => 'nullable',
       'ubicazione' => 'nullable',
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
-    $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $data['tipo'] = Dispositivo::MONITOR;
+    $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
-    $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $data['tipo'] = Dispositivo::MONITOR;
+    $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
     return $data;
   }
   public function messages(): array

app/DataTables/OperatoreDataTable.php

 
 class OperatoreDataTable extends DataTable
 {
+    public ?int $attivita_id = null;
+
     public function __construct()
     {
         $this->dataTableVariable = 'dataTable_operatore';

app/DataTables/OperatoreDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Operatore;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
-use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
+use Illuminate\Support\Facades\Session;
 use Illuminate\Support\Str;
-use Illuminate\Support\Facades\Hash;
+use Yajra\DataTables\DataTablesEditor;
 
 class OperatoreDataTableEditor extends DataTablesEditor
 {
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
     $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     if(!isset($data['password'])){
       $data['password'] = Str::random(8);
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
     $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     $data['username'] = $this->createUsername($data);
     return $data;
   }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
   public function messages(): array
   {
     return $this->messages;

app/DataTables/OpzioneFormDataTableEditor.php

 
 namespace App\DataTables;
 
+use App\Models\EventoForm;
 use App\Models\OpzioneForm;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
 use Yajra\DataTables\DataTablesEditor;
 
 
     public function creating(Model $model, array $data): array
     {
-        $efId = request()->query('evento_form_id') ?? request()->input('evento_form_id');
-        if ($efId) {
-            $data['evento_form_id'] = (int) $efId;
-        }
+        $form = $this->garantisciFormDiQuestaAttivita(
+            request()->query('evento_form_id') ?? request()->input('evento_form_id') ?? ($data['evento_form_id'] ?? null)
+        );
+        $data['evento_form_id'] = (int) $form->id;
+
+        return $data;
+    }
+
+    public function updating(Model $model, array $data): array
+    {
+        $this->garantisciFormDiQuestaAttivita($model->evento_form_id);
+        unset($data['evento_form_id']);
+
+        return $data;
+    }
+
+    public function deleting(Model $model, array $data): array
+    {
+        $this->garantisciFormDiQuestaAttivita($model->evento_form_id);
 
         return $data;
     }
+
+    private function garantisciFormDiQuestaAttivita($formId): EventoForm
+    {
+        $form = EventoForm::find($formId);
+        if (! $form) {
+            abort(404);
+        }
+        AttivitaService::garantisciEventoDiQuestaAttivita($form->evento);
+
+        return $form;
+    }
 }

app/DataTables/OrdineDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Ordine;
+use App\Models\Prenotazione;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
+use App\Services\Attivita\AttivitaService;
+use Illuminate\Support\Facades\Session;
 
 class OrdineDataTableEditor extends DataTablesEditor
 {
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $this->garantisciPrenotazioneDiQuestaAttivita($data['prenotazione_id'] ?? null, $data['attivita_id']);
+
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $this->garantisciPrenotazioneDiQuestaAttivita($data['prenotazione_id'] ?? $model->prenotazione_id, $model->attivita_id);
+
     return $data;
   }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
+
+  private function garantisciPrenotazioneDiQuestaAttivita($prenotazioneId, $attivitaId): void
+  {
+    if (! $prenotazioneId) {
+      return;
+    }
+
+    $prenotazione = Prenotazione::with('evento')->find($prenotazioneId);
+    if (! $prenotazione || (int) $prenotazione->evento?->attivita_id !== (int) $attivitaId) {
+      abort(404);
+    }
+  }
   public function messages(): array
   {
     return $this->messages;

app/DataTables/PagamentoDataTable.php

 namespace App\DataTables;
 
 use App\Models\Pagamento;
-use App\Models\Ordine;
-use App\Models\Prenotazione;
 use App\Models\MetodoPagamento;
-use App\Models\Attivita;
 use Illuminate\Database\Eloquent\Builder as QueryBuilder;
 use Yajra\DataTables\EloquentDataTable;
 use Yajra\DataTables\Html\Builder as HtmlBuilder;
      */
     public function query(Pagamento $model): QueryBuilder
     {
-        if($this->attivita_id){
-            return $model->newQuery()->where('attivita_id', $this->attivita_id)->orderBy('created_at', 'desc');
-        }else{
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
             return $model->newQuery()->whereRaw('1 = 0')->orderBy('created_at', 'desc');
         }
+
+        return $model->newQuery()->where('attivita_id', $attivitaId)->orderBy('created_at', 'desc');
     }
 
     /**
                     ->editor(
                         Editor::make()
                             ->fields([
-                                Fields\Text::make('attivita_id')->label('Attività')->options(Attivita::all()->pluck('nome', 'id')),
-                                Fields\Select2::make('ordine_id')->label('Ordine')->options(Ordine::all()->pluck('id', 'nome')),
-                                Fields\Select2::make('prenotazione_id')->label('Prenotazione')->options(Prenotazione::all()->pluck('id', 'nome')),
+                                Fields\Hidden::make('attivita_id')->default((int) $this->attivita_id),
+                                Fields\Hidden::make('ordine_id'),
+                                Fields\Hidden::make('prenotazione_id'),
                                 Fields\Text::make('importo')->label('Importo'),
                                 Fields\Text::make('causale')->label('Causale'),
                                 Fields\Select2::make('stato')->label('Stato')->options(Pagamento::getStati()->pluck('value', 'label')),
-                                Fields\Select2::make('metodo_pagamento_id')->label('Metodo pagamento')->options(MetodoPagamento::all()->pluck('id', 'nome')),
+                                Fields\Select2::make('metodo_pagamento_id')->label('Metodo pagamento')->options(MetodoPagamento::where('attivita_id', (int) $this->attivita_id)->where('is_attivo', true)->pluck('id' , 'nome')),
                                 Fields\Text::make('note')->label('Note'),
-                                Fields\Text::make('info')->label('Info'),
+                                // Fields\Text::make('info')->label('Info'),
                             ])
                     )
                     ->initComplete("function(settings, json){
             Column::make('prenotazione_id')->title('Prenotazione')->data('prenotazione_id_display'),
             Column::make('importo')->title('Importo')->data('importo_display'),
             Column::make('causale')->title('Causale'),
-            Column::make('metodo_pagamento_id')->title('Metodo pagamento')->data('metodo_pagamento_id_display'),
+            Column::make('metodo_pagamento_id')->visible(false)->width('10%'),
+            Column::make('metodo_pagamento_id_display')->title('Metodo pagamento')->data('metodo_pagamento_id_display'),
             Column::make('note')->title('Note'),
             Column::computed('action')
                   ->title('')

app/DataTables/PagamentoDataTableEditor.php

+<?php
+
+namespace App\DataTables;
+
+use App\Models\Ordine;
+use App\Models\Pagamento;
+use App\Models\Prenotazione;
+use App\Models\MetodoPagamento;
+use App\Services\Attivita\AttivitaService;
+use Illuminate\Database\Eloquent\Model;
+use Yajra\DataTables\DataTablesEditor;
+use Illuminate\Support\Facades\Session;
+
+class PagamentoDataTableEditor extends DataTablesEditor
+{
+  protected $model = Pagamento::class;
+
+  protected $messages = [
+    'attivita_id.required' => 'L\'attività è richiesta',
+    'ordine_id.required' => 'L\'ordine è richiesto',
+    'prenotazione_id.required' => 'La prenotazione è richiesta',
+    'importo.required' => 'L\'importo è richiesto',
+    'causale.required' => 'La causale è richiesta',
+    'stato.required' => 'Lo stato è richiesto',
+    'metodo_pagamento_id.required' => 'Il metodo di pagamento è richiesto',
+    'note.required' => 'La note è richiesta',
+    'info.required' => 'L\'info è richiesta',
+  ];
+
+  /**
+  * Get create action validation rules.
+  *
+  * @return array
+  */
+  public function createRules(): array
+  {
+    return [
+      'ordine_id' => 'required|exists:ordine,id',
+      'prenotazione_id' => 'nullable|exists:prenotazione,id',
+      'importo' => 'required|numeric',
+      'causale' => 'required|string',
+      'stato' => 'required|string',
+      'metodo_pagamento_id' => 'required|exists:metodo_pagamento,id',
+      'note' => 'nullable',
+      'info' => 'nullable',
+    ];
+  }
+
+  public function createMessages(): array{
+    return $this->messages;
+  }
+
+  /**
+  * Get edit action validation rules.
+  *
+  * @param Model $model
+  * @return array
+  */
+  public function editRules(Model $model): array
+  {
+    return [
+      'ordine_id' => 'required|exists:ordine,id',
+      'prenotazione_id' => 'nullable|exists:prenotazione,id',
+      'importo' => 'required|numeric',
+      'causale' => 'required|string',
+      'stato' => 'required|string',
+      'metodo_pagamento_id' => 'required|exists:metodo_pagamento,id',
+      'note' => 'nullable',
+      'info' => 'nullable',
+    ];
+  }
+
+  public function editMessages(): array{
+    return $this->messages;
+  }
+
+  /**
+  * Get remove action validation rules.
+  *
+  * @param Model $model
+  * @return array
+  */
+  public function removeRules(Model $model): array
+  {
+    return [];
+  }
+
+  public function creating(Model $model, array $data): array
+  {
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $this->garantisciRelazioniDiQuestaAttivita($data, $data['attivita_id']);
+
+    return $data;
+  }
+
+  public function updating(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $this->garantisciRelazioniDiQuestaAttivita($data, $model->attivita_id, $model);
+
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
+
+  public function messages(): array
+  {
+    return $this->messages;
+  }
+
+  private function garantisciRelazioniDiQuestaAttivita(array $data, $attivitaId, ?Model $model = null): void
+  {
+    $ordineId = $data['ordine_id'] ?? $model?->ordine_id;
+    $ordine = Ordine::find($ordineId);
+    if (! $ordine || (int) $ordine->attivita_id !== (int) $attivitaId) {
+      abort(404);
+    }
+
+    $prenotazioneId = $data['prenotazione_id'] ?? $model?->prenotazione_id;
+    if ($prenotazioneId) {
+      $prenotazione = Prenotazione::with('evento')->find($prenotazioneId);
+      if (! $prenotazione || (int) $prenotazione->evento?->attivita_id !== (int) $attivitaId) {
+        abort(404);
+      }
+    }
+
+    $metodoId = $data['metodo_pagamento_id'] ?? $model?->metodo_pagamento_id;
+    $metodo = MetodoPagamento::find($metodoId);
+    if (! $metodo || (int) $metodo->attivita_id !== (int) $attivitaId) {
+      abort(404);
+    }
+  }
+
+}

app/DataTables/PiattoDataTable.php

      */
     public function query(Piatto $model): QueryBuilder
     {
-        if($this->attivita_id !== null){
-            $model = $model->newQuery()->where('attivita_id', $this->attivita_id);
-            
-            if (isset($this->cucina_id)) {
-                return $model->where('cucina_id', $this->cucina_id)
-                    ->with('cucina', 'elencoAllergeni');
-            }
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
+            return $model->newQuery()->whereRaw('1 = 0');
+        }
 
-            return $model->with('cucina', 'elencoAllergeni');
+        $model = $model->newQuery()->where('attivita_id', $attivitaId);
 
-        }else{
-            return $model->newQuery()->whereRaw('1 = 0');
+        if (isset($this->cucina_id)) {
+            return $model->where('cucina_id', $this->cucina_id)
+                ->with('cucina', 'elencoAllergeni');
         }
+
+        return $model->with('cucina', 'elencoAllergeni');
     }
 
     /**
                 Editor::make()
                     ->ajax(route('piatto.store'))
                     ->fields([
-                        Fields\Hidden::make('attivita_id')->label('Attività')->default($this->attivita_id),
+                        Fields\Hidden::make('attivita_id')->label('Attività')->default((int) $this->attivita_id),
                         Fields\Text::make('nome')->label('Nome'),
                         Fields\Text::make('descrizione')->label('Descrizione'),
                         Fields\Select2::make('cucina_id')->label('cucina')
-                        ->options(Cucina::where('is_attiva', true)->where('attivita_id', $this->attivita_id)->pluck('id', 'nome'))
+                        ->options(Cucina::where('is_attiva', true)->where('attivita_id', (int) $this->attivita_id)->pluck('id', 'nome'))
                         ->default(isset($this->cucina_id) ? $this->cucina_id : ''),
                         Fields\Text::make('prezzo')->label('Prezzo (€)'),
                         // Fields\Image::make('immagine')->label('Immagine'),

app/DataTables/PiattoDataTableEditor.php

 
 namespace App\DataTables;
 
+use App\Models\Cucina;
 use App\Models\Piatto;
 use App\Models\PiattoHasAllergene;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
+use Illuminate\Support\Facades\Session;
 
 class PiattoDataTableEditor extends DataTablesEditor
 {
 
   public function creating(Model $model, array $data): array
   {
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $this->garantisciCucinaDiQuestaAttivita($data['cucina_id'] ?? null, $data['attivita_id']);
+
     // L'Editor manda `allergeni` come array di ID selezionati:
     // salviamo la relazione nella pivot `piatto_allergene`, non nella colonna `piatto.allergeni`.
     $data['_allergeni_ids'] = $this->normalizeAllergeniIds($data['allergeni'] ?? null);
 
     $data['bacheca_id'] = isset($data['bacheca_id']) ? true : false;
     $data['in_evidenza'] = isset($data['in_evidenza']) ? true : false;
-    $data['disponibile'] = isset($data['disponibile']) ? true : false;
+    $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $this->garantisciCucinaDiQuestaAttivita($data['cucina_id'] ?? $model->cucina_id, $model->attivita_id);
+
     $data['_allergeni_ids'] = $this->normalizeAllergeniIds($data['allergeni'] ?? null);
     unset($data['allergeni']);
 
     $data['bacheca_id'] = isset($data['bacheca_id']) ? true : false;
     $data['in_evidenza'] = isset($data['in_evidenza']) ? true : false;
-    $data['disponibile'] = isset($data['disponibile']) ? true : false;
+    $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
 
     return $data;
   }
 
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
+
+  private function garantisciCucinaDiQuestaAttivita($cucinaId, $attivitaId): void
+  {
+    $cucina = Cucina::find($cucinaId);
+    if (! $cucina || (int) $cucina->attivita_id !== (int) $attivitaId) {
+      abort(404);
+    }
+  }
+
   protected function normalizeAllergeniIds(null|array|string $value): array
   {
     if (is_null($value)) {

app/DataTables/PrenotazioneDataTable.php

             ->addColumn('stato_display', function($entity){
               return view('prenotazione._partials.stato-prenotazione', ['stato' => $entity->stato??'']);
             })
+            ->addColumn('confermata', function($entity){
+              return view('_partials.available', ['available' => $entity->confermata]);
+            })
             ->setRowId('id');
     }
 
      */
     public function query(Prenotazione $model): QueryBuilder
     {
-        if(isset($this->evento_id)){
-            return $model->newQuery()->where('evento_id', $this->evento_id);
+        $attivitaId = (int) session('attivita_attuale');
+        $query = $model->newQuery()->whereHas('evento', function ($q) use ($attivitaId) {
+            $q->where('attivita_id', $attivitaId);
+        });
+
+        if (isset($this->evento_id)) {
+            $query->where('evento_id', $this->evento_id);
         }
-        return $model->newQuery();
+
+        return $query;
     }
 
     /**
     public function html(): HtmlBuilder
     {
         $titoloPrenotazioni = 'Prenotazione';
-        if(isset($this->evento_id)){
-            $titoloPrenotazioni = 'Prenota per ' . Evento::find($this->evento_id)->nome;
-        }
+
         $buttons = [];
         if(Auth::user()->can('create-prenotazione')){
-            array_push($buttons, Button::make('create')
-                ->editor('editor')
-                ->className('btn btn-sm btn-primary mb-4')
-                ->formTitle('Crea nuovo prenotazione')
-                ->formButtons([
-                    Button::raw('Annulla')
-                        ->className('btn btn-secondary ml-2')
-                        ->actionClose(),
-                    Button::raw('Salva')
-                        ->className('btn btn-success ml-2')
-                        ->actionHandler('create')
-                ])
-                ->text('<i class="fas fa-plus"></i> ' . $titoloPrenotazioni));
+            $nuovaUrl = isset($this->evento_id)
+                ? route('prenotazione.nuova', ['evento_id' => $this->evento_id])
+                : route('prenotazione.nuova');
+
+            array_push($buttons, Button::raw()
+                ->className('btn btn-sm btn-primary mb-4 text-white')
+                ->action('window.location.href = '.json_encode($nuovaUrl))
+                ->text('<i class="fas fa-plus"></i> Prenotazione'));
+            if($this->evento_id){
+                array_push($buttons, Button::raw('Conferma tutte le prenotazioni')
+                    ->className('btn btn-sm btn-primary mb-4 text-white')
+                        ->action('confermaTuttePrenotazioni()')
+                        ->text('<i class="fas fa-check"></i> Conferma tutte le prenotazioni')
+                    );
+            }
+
         };
 
-        if(Auth::user()->can('edit-prenotazione') || Auth::user()->can('segna-presenza-prenotazione')){
-            array_push($buttons, Button::raw('Appello')
-                ->className('btn btn-sm btn-warning mb-4')
-                ->action('appelloPrenotazioni')
-            );
-        }
+        // if(Auth::user()->can('edit-prenotazione') || Auth::user()->can('segna-presenza-prenotazione')){
+        //     array_push($buttons, Button::raw('Appello')
+        //         ->className('btn btn-sm btn-warning mb-4')
+        //         ->action('appelloPrenotazioni')
+        //     );
+        // }
 
         if(Auth::user()->can('report-prenotazione') || Auth::user()->can('segna-presenza-prenotazione')){
+            if($this->evento_id){
             array_push($buttons, Button::raw('Report')
-                ->className('btn btn-sm btn-success mb-4')
-                ->action('reportPrenotazioni()')
-                ->text('<i class="fas fa-file-alt"></i> Report')
-            );
+                ->className('btn btn-sm btn-primary mb-4 text-white')
+                    ->action('reportPrenotazioni()')
+                    ->text('<i class="fas fa-file-alt"></i> Report')
+                );
+            }
         }
 
 
         Fields\Text::make('email')->label('Email'),
         Fields\Text::make('telefono')->label('Telefono'),
         Fields\Select2::make('evento_id')->label('Evento')
-        ->options(Evento::where('is_attivo', true)->pluck('id', 'nome'))
+        ->options(Evento::where('attivita_id', session('attivita_attuale'))->orderBy('nome')->pluck('id', 'nome'))
         ->default(isset($this->evento_id) ? $this->evento_id : ''),
-        Fields\Select2::make('cucina_id')->label('Cucina')->options(Cucina::all()->pluck('id', 'nome')),
+        Fields\Select2::make('cucina_id')->label('Cucina')->options(Cucina::where('attivita_id', session('attivita_attuale'))->orderBy('nome')->pluck('id', 'nome')),
         Fields\Select2::make('stato')->label('Stato')->options(Prenotazione::getStati()->pluck('value', 'label'))->default(Prenotazione::STATO_INVIATA) ,
+        Fields\Boolean::make('confermata')->label('Confermata')->default(false),
         Fields\Text::make('note')->label('Note'),
         Fields\Text::make('codice')->label('Codice'),
         Fields\Text::make('stato_pagamento')->label('Stato pagamento'),
         return [
             Column::make('id')->title('ID')->width('10%')->visible(false)->responsivePriority(1)->width('10%'),
             Column::make('stato')->data('stato_display')->title('Stato')->searchable(true)->filter(true)->responsivePriority(1),
+            Column::make('confermata')->addClass('text-center')->title('Confermata')->responsivePriority(1),
             Column::make('codice')->title('Codice')->responsivePriority(1),
             Column::make('cognome')->title('Cognome')->responsivePriority(2),
             Column::make('nome')->title('Nome'),
             Column::make('email')->title('Email'),
             Column::make('telefono')->title('Telefono'),
             Column::make('evento_id_display')->title('Evento'),
-            Column::make('cucina_id_display')->title('Cucina'),
-            Column::make('note')->title('Note'),
+            // Column::make('cucina_id_display')->title('Cucina'),
+            // Column::make('note')->title('Note'),
             Column::computed('action')
                   ->title('')
                   ->exportable(false)

app/DataTables/PrenotazioneDataTableEditor.php

 
 namespace App\DataTables;
 
+use App\Models\Cucina;
+use App\Models\Evento;
 use App\Models\Prenotazione;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class PrenotazioneDataTableEditor extends DataTablesEditor
 {
   protected $model = Prenotazione::class;
-  // protected $uploadDir = '';
-  // protected $disk = 'modelliRicevute';
 
   protected $messages = [
     'nome.required' => 'Il nome è richiesto',
     'telefono.required' => 'Il telefono è richiesto',
     'evento_id.required' => 'L\'evento è richiesto',
     'cucina_id.required' => 'La cucina è richiesta',
-    'stato.required' => 'Il stato è richiesto',
+    'stato.required' => 'Lo stato è richiesto',
     'note.required' => 'La note è richiesta',
   ];
 
       'email' => 'nullable|email',
       'telefono' => 'nullable',
       'evento_id' => 'required|exists:evento,id',
-      'cucina_id' => 'required|exists:cucina,id',
+      'cucina_id' => 'nullable|exists:cucina,id',
       'stato' => 'nullable|string',
+      'confermata' => 'nullable|boolean',
       'note' => 'nullable',
       'codice' => 'required|unique:prenotazione,codice',
       'stato_pagamento' => 'nullable|string',
       'email' => 'nullable|email',
       'telefono' => 'nullable',
       'evento_id' => 'required|exists:evento,id',
-      'cucina_id' => 'required|exists:cucina,id',
+      'cucina_id' => 'nullable|exists:cucina,id',
       'stato' => 'nullable|string',
+      'confermata' => 'nullable|boolean',
       'note' => 'nullable',
-      'codice' => 'required|unique:prenotazione,codice',
+      'codice' => 'required|unique:prenotazione,codice,'.$model->getKey(),
     ];
   }
 
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $evento = $this->eventoDiQuestaAttivita($data['evento_id'] ?? null);
+    $this->garantisciCucinaDiQuestaAttivita($data['cucina_id'] ?? null, $evento->attivita_id);
+
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $this->eventoDiQuestaAttivita($model->evento_id);
+    $evento = $this->eventoDiQuestaAttivita($data['evento_id'] ?? $model->evento_id);
+    $this->garantisciCucinaDiQuestaAttivita($data['cucina_id'] ?? $model->cucina_id, $evento->attivita_id);
+
     return $data;
   }
+
+  public function deleting(Model $model, array $data): array
+  {
+    $this->eventoDiQuestaAttivita($model->evento_id);
+
+    return $data;
+  }
+
+  private function eventoDiQuestaAttivita($eventoId): Evento
+  {
+    $evento = Evento::find($eventoId);
+    if (! $evento) {
+      abort(404);
+    }
+    AttivitaService::garantisciEventoDiQuestaAttivita($evento);
+
+    return $evento;
+  }
+
+  private function garantisciCucinaDiQuestaAttivita($cucinaId, $attivitaId): void
+  {
+    if (! $cucinaId) {
+      return;
+    }
+
+    $cucina = Cucina::find($cucinaId);
+    if (! $cucina || (int) $cucina->attivita_id !== (int) $attivitaId) {
+      abort(404);
+    }
+  }
+
   public function messages(): array
   {
     return $this->messages;

app/DataTables/PrenotazioneTavoloDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\PrenotazioneTavolo;
+use App\Models\Tavolo;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
+use Illuminate\Support\Facades\Session;
 
 class PrenotazioneTavoloDataTableEditor extends DataTablesEditor
 {
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $this->garantisciTavoloDiQuestaAttivita($data['tavolo_id'] ?? null, $data['attivita_id']);
+
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $this->garantisciTavoloDiQuestaAttivita($data['tavolo_id'] ?? $model->tavolo_id, $model->attivita_id);
+
     return $data;
   }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
+
+  private function garantisciTavoloDiQuestaAttivita($tavoloId, $attivitaId): void
+  {
+    if (! $tavoloId) {
+      return;
+    }
+
+    $tavolo = Tavolo::find($tavoloId);
+    if (! $tavolo || (int) $tavolo->attivita_id !== (int) $attivitaId) {
+      abort(404);
+    }
+  }
   public function messages(): array
   {
     return $this->messages;

app/DataTables/PrimaNotaDataTable.php

      */
     public function query(PrimaNota $model): QueryBuilder
     {
-        if (!$this->attivita_id) {
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
             return $model->newQuery()->whereRaw('1 = 0');
         }
 
         return $model->newQuery()
-            ->where('attivita_id', $this->attivita_id)
+            ->with('pagamento')
+            ->where('attivita_id', $attivitaId)
             ->conFiltriIndice()
             ->orderBy('created_at', 'desc');
     }
                     ->editor(
                         Editor::make()
                             ->fields([
-                                Fields\Hidden::make('attivita_id')->default($this->attivita_id),
+                                Fields\Hidden::make('attivita_id')->default((int) $this->attivita_id),
                                 Fields\Select2::make('tipo_movimento')->label('Tipo movimento')->options(PrimaNota::getTipiMovimento()->pluck('value', 'label')),
-                                Fields\Select2::make('categoria_contabile_id')->label('Categoria contabile')->options(\App\Models\Categoriacontabile::where('is_attiva', true)->pluck('id', 'nome')),
+                                Fields\Select2::make('categoria_contabile_id')->label('Categoria contabile')->options(\App\Models\Categoriacontabile::where('attivita_id', (int) $this->attivita_id)->where('is_attiva', true)->pluck('id', 'nome')),
+                                Fields\Select2::make('pagamento_id')->label('Pagamento')->options(Pagamento::where('attivita_id', (int) $this->attivita_id)->pluck('id', 'causale')),
                                 Fields\Text::make('importo')->label('Importo'),
                                 Fields\Text::make('causale')->label('Causale'),
                                 Fields\Text::make('riferimento')->label('Riferimento'),
                                 Fields\Select2::make('evento_id')
                                 ->label('Evento')
                                 ->options(
-                                    collect(['Nessun evento' => ''])->merge(Evento::all()->pluck('id', 'nome'))->toArray()
+                                    collect(['Nessun evento' => ''])->merge(Evento::where('attivita_id', (int) $this->attivita_id)->pluck('id', 'nome'))->toArray()
                                 ),
                                 Fields\Select2::make('fornitore_id')
                                 ->label('Fornitore')
                                 ->options(
-                                    collect(['Nessun fornitore' => ''])->merge(Fornitore::all()->pluck('id', 'nome'))->toArray()
+                                    collect(['Nessun fornitore' => ''])->merge(Fornitore::where('attivita_id', (int) $this->attivita_id)->pluck('id', 'nome'))->toArray()
                                 ),
                                 
                                 // Fields\Checkbox::make('tipo_movimento')->label('Tipo movimento')->options(PrimaNota::getTipiMovimento()->pluck('value', 'label')),

app/DataTables/PrimaNotaDataTableEditor.php

 
 namespace App\DataTables;
 
+use App\Models\Categoriacontabile;
+use App\Models\Evento;
+use App\Models\Fornitore;
+use App\Models\Ordine;
+use App\Models\Pagamento;
+use App\Models\Prenotazione;
 use App\Models\PrimaNota;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
+use Illuminate\Support\Facades\Session;
 
 class PrimaNotaDataTableEditor extends DataTablesEditor
 {
   protected $model = PrimaNota::class;
-  // protected $uploadDir = '';
-  // protected $disk = 'modelliRicevute';
 
   protected $messages = [
     'riferimento.required' => 'Il riferimento è richiesto',
     'importo.required' => 'L\'importo è richiesto',
     'tipo_movimento.required' => 'Il tipo movimento è richiesto',
     'causale.required' => 'La causale è richiesta',
-    'stato.required' => 'Il stato è richiesto',
+    'stato.required' => 'Lo stato è richiesto',
     'categoria_contabile_id.required' => 'La categoria contabile è richiesta',
   ];
 
   public function createRules(): array
   {
     return [
-      'attivita_id' => 'required|exists:attivita,id',
       'pagamento_id' => 'nullable|exists:pagamento,id',
       'ordine_id' => 'nullable|exists:ordine,id',
       'prenotazione_id' => 'nullable|exists:prenotazione,id',
       'fornitore_id' => 'nullable|exists:fornitore,id',
       'riferimento' => 'nullable|string',
       'importo' => 'required|numeric',
-      'tipo_movimento' => 'required|string',   
+      'tipo_movimento' => 'required|string',
       'causale' => 'required|string',
       'categoria_contabile_id' => 'required|exists:categoria_contabile,id',
-      // 'stato' => 'nullable|string',
-      // 'note' => 'nullable|string',
-      // 'codice' => 'nullable|string',
       'stato_pagamento' => 'nullable|string',
       'metodo_pagamento' => 'nullable|string',
     ];
   public function editRules(Model $model): array
   {
     return [
-      'attivita_id' => 'required|exists:attivita,id',
       'pagamento_id' => 'nullable|exists:pagamento,id',
       'ordine_id' => 'nullable|exists:ordine,id',
       'prenotazione_id' => 'nullable|exists:prenotazione,id',
       'fornitore_id' => 'nullable|exists:fornitore,id',
       'riferimento' => 'nullable|string',
       'importo' => 'required|numeric',
-      'tipo_movimento' => 'required|string',   
+      'tipo_movimento' => 'required|string',
       'causale' => 'required|string',
       'stato' => 'nullable|string',
       'categoria_contabile_id' => 'required|exists:categoria_contabile,id',
-      // 'note' => 'nullable|string',
-      // 'codice' => 'nullable|string',
       'stato_pagamento' => 'nullable|string',
       'metodo_pagamento' => 'nullable|string',
     ];
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $this->garantisciRelazioniDiQuestaAttivita($data, $data['attivita_id']);
+
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $this->garantisciRelazioniDiQuestaAttivita($data, $model->attivita_id, $model);
+
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
     return $data;
   }
+
   public function messages(): array
   {
     return $this->messages;
   }
 
+  private function garantisciRelazioniDiQuestaAttivita(array $data, $attivitaId, ?Model $model = null): void
+  {
+    $this->garantisciStessoTenant($data['pagamento_id'] ?? $model?->pagamento_id, Pagamento::class, $attivitaId);
+    $this->garantisciStessoTenant($data['ordine_id'] ?? $model?->ordine_id, Ordine::class, $attivitaId);
+    $this->garantisciStessoTenant($data['evento_id'] ?? $model?->evento_id, Evento::class, $attivitaId);
+    $this->garantisciStessoTenant($data['fornitore_id'] ?? $model?->fornitore_id, Fornitore::class, $attivitaId);
+    $this->garantisciStessoTenant($data['categoria_contabile_id'] ?? $model?->categoria_contabile_id, Categoriacontabile::class, $attivitaId);
+
+    $prenotazioneId = $data['prenotazione_id'] ?? $model?->prenotazione_id;
+    if ($prenotazioneId) {
+      $prenotazione = Prenotazione::with('evento')->find($prenotazioneId);
+      if (! $prenotazione || (int) $prenotazione->evento?->attivita_id !== (int) $attivitaId) {
+        abort(404);
+      }
+    }
+  }
+
+  private function garantisciStessoTenant($id, string $class, $attivitaId): void
+  {
+    if (! $id) {
+      return;
+    }
+
+    $record = $class::find($id);
+    if (! $record || (int) $record->attivita_id !== (int) $attivitaId) {
+      abort(404);
+    }
+  }
+
 }

app/DataTables/PrintJobDataTable.php

      */
     public function query(PrintJob $model): QueryBuilder
     {
-        return $model->newQuery()->orderBy('created_at', 'desc');
+        $attivitaId = (int) session('attivita_attuale');
+        if ($attivitaId <= 0) {
+            return $model->newQuery()->whereRaw('1 = 0');
+        }
+
+        return $model->newQuery()
+            ->where(function ($q) use ($attivitaId) {
+                $q->whereHas('dispositivo', function ($d) use ($attivitaId) {
+                    $d->where('attivita_id', $attivitaId);
+                })->orWhereHas('stampante', function ($d) use ($attivitaId) {
+                    $d->where('attivita_id', $attivitaId);
+                })->orWhereHas('ordine', function ($o) use ($attivitaId) {
+                    $o->where('attivita_id', $attivitaId);
+                });
+            })
+            ->orderBy('created_at', 'desc');
     }
 
     /**

app/DataTables/PuntoOperatoreDataTable.php

 
 class PuntoOperatoreDataTable extends DataTable
 {
+    public ?int $attivita_id = null;
+
     public function __construct()
     {
         $this->dataTableVariable = 'dataTable_punto_operatore';
      */
     public function query(Dispositivo $model): QueryBuilder
     {
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
+            return $model->newQuery()->whereRaw('1 = 0');
+        }
+
         return $model->newQuery()
         ->where('tipo', Dispositivo::OPERATORE)
-        ->where('attivita_id', $this->attivita_id);
+        ->where('attivita_id', $attivitaId);
     }
 
     /**

app/DataTables/PuntoOperatoreDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Dispositivo;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Facades\Session;
 use Yajra\DataTables\DataTablesEditor;
-use Auth;
 
 class PuntoOperatoreDataTableEditor extends DataTablesEditor
 {
   {
     return [
       'nome'  => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
-      'tipo' => 'required',
+      'tipo' => 'required|in:'.Dispositivo::OPERATORE,
       'licenza' => 'nullable',
       'url_stampante' => 'nullable',
       'ubicazione' => 'nullable',
   {
     return [
       'nome'  => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
-      'tipo' => 'required',
+      'tipo' => 'required|in:'.Dispositivo::OPERATORE,
       'licenza' => 'nullable',
       'url_stampante' => 'nullable',
       'ubicazione' => 'nullable',
 
   public function creating(Model $model, array $data): array
   {
-    // L'Editor manda `allergeni` come array di ID selezionati:
-    // salviamo la relazione nella pivot `piatto_allergene`, non nella colonna `piatto.allergeni`.
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $data['tipo'] = Dispositivo::OPERATORE;
     $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $data['tipo'] = Dispositivo::OPERATORE;
     $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     return $data;
   }
 
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
+
   public function saved(Model $model, array $data): Model
   {
     return $model;

app/DataTables/PuntoVenditaDataTable.php

 
 class PuntoVenditaDataTable extends DataTable
 {
+    public ?int $attivita_id = null;
+
     public function __construct()
     {
         $this->dataTableVariable = 'dataTable_punto_vendita';
      */
     public function query(Dispositivo $model): QueryBuilder
     {
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
+            return $model->newQuery()->whereRaw('1 = 0');
+        }
+
         return $model->newQuery()
         ->whereIn('tipo', [Dispositivo::KIOSK, Dispositivo::CASSA , Dispositivo::CAMERIERE])
-        ->where('attivita_id', $this->attivita_id);
+        ->where('attivita_id', $attivitaId);
     }
 
     /**

app/DataTables/PuntoVenditaDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Dispositivo;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
+use Illuminate\Support\Facades\Session;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class PuntoVenditaDataTableEditor extends DataTablesEditor
 {
   {
     return [
       'nome'  => 'required',
-      'tipo' => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
+      'tipo' => 'required|in:'.implode(',', [Dispositivo::CASSA, Dispositivo::KIOSK, Dispositivo::CAMERIERE]),
       'licenza' => 'nullable',
       'url_stampante' => 'nullable',
       'ubicazione' => 'nullable',
   {
     return [
       'nome'  => 'required',
-      'tipo' => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
+      'tipo' => 'required|in:'.implode(',', [Dispositivo::CASSA, Dispositivo::KIOSK, Dispositivo::CAMERIERE]),
       'licenza' => 'nullable',
       'url_stampante' => 'nullable',
       'ubicazione' => 'nullable',
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
-    $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
-    $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
     return $data;
   }
   public function messages(): array

app/DataTables/RigaFatturazioneDataTable.php

     {
         return (new EloquentDataTable($query))
             ->addColumn('action', function ($entity) {
-                return view('fatturazione.menu',['entity' => $entity]);
+                return view('fatturazione.menu', ['entity' => $entity]);
             })
             ->addColumn('attivita_id', function ($entity) {
-                return $entity->attivita->nome??'ND';
+                return $entity->attivita->nome ?? 'ND';
+            })
+            ->filterColumn('attivita_id', function ($query, $keyword) {
+                $query->whereHas('attivita', function ($q) use ($keyword) {
+                    $q->where('nome', 'like', "%{$keyword}%");
+                });
             })
             ->addColumn('dispositivo_id', function ($entity) {
-                return $entity->dispositivo->nome??'ND';
+                return $entity->dispositivo->nome ?? 'ND';
+            })
+            ->filterColumn('dispositivo_id', function ($query, $keyword) {
+                $query->whereHas('dispositivo', function ($q) use ($keyword) {
+                    $q->where('nome', 'like', "%{$keyword}%");
+                });
             })
             ->addColumn('prezzo', function ($entity) {
                 return number_format($entity->prezzo, 2, ',', '.') . ' €';
             })
+            ->filterColumn('prezzo', function ($query, $keyword) {
+                $normalized = str_replace(['€', ' ', ','], ['', '', '.'], $keyword);
+                $query->where('prezzo', 'like', "%{$normalized}%");
+            })
             ->addColumn('stato_display', function ($entity) {
-                return view('fatturazione.stato',['entity' => $entity]);
+                return view('fatturazione.stato', ['entity' => $entity]);
+            })
+            ->filterColumn('stato', function ($query, $keyword) {
+                $query->where('stato', 'like', "%{$keyword}%");
             })
             ->addColumn('listino_prezzi_display', function ($entity) {
                 return optional($entity->listinoPrezzi)->label;
             })
-            ->rawColumns(['note'])
+            // La colonna HTML si chiama listino_prezzi_id (name), non listino_prezzi_display
+            ->filterColumn('listino_prezzi_id', function ($query, $keyword) {
+                $query->whereHas('listinoPrezzi', function ($q) use ($keyword) {
+                    $q->where('label', 'like', "%{$keyword}%")
+                        ->orWhere('descrizione', 'like', "%{$keyword}%");
+                });
+            })
+            ->addColumn('note_display', function ($entity) {
+                return $entity->note;
+            })
+            ->filterColumn('note_display', function ($query, $keyword) {
+                $query->where('note', 'like', "%{$keyword}%");
+            })
+            ->rawColumns(['action', 'stato_display', 'note_display'])
             ->setRowId('id');
     }
 
      */
     public function query(RigaFatturazione $model): QueryBuilder
     {
-        $query = $model->newQuery()->orderBy('created_at', 'desc');
+        $query = $model->newQuery()
+            ->with(['attivita', 'dispositivo', 'listinoPrezzi'])
+            ->orderBy('created_at', 'desc');
 
-        if(!$this->tutti_i_consumi){
+        if (! $this->tutti_i_consumi) {
             $query->whereIn('stato', [RigaFatturazione::GRATUITO, RigaFatturazione::REGISTRATO]);
         }
-        if($this->superadmin){
+
+        if ($this->superadmin) {
             return $query;
-            }
-            
-            if($this->user_id){
-                $query->where('user_id', $this->user_id);
-            }
-            if($this->attivita_id){
-                $query->where('attivita_id', $this->attivita_id);
-            }
+        }
+
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
+            return $query->whereRaw('1 = 0');
+        }
 
-        return $query;
+        return $query->where('attivita_id', $attivitaId);
     }
 
     /**
      */
     public function getColumns(): array
     {
-        return [
-            Column::make('id'),
-            Column::make('fattura_id')->title('Fattura'),
-            Column::make('attivita_id')->title('Attività')->searchable(true)->searchPanes(['show' => true]),
-            Column::make('dispositivo_id')->title('Dispositivo')->searchPanes(['show' => true]),
-            Column::make('tipo')->title('Tipo'),
-            Column::make('qta')->title('Qta'),
-            Column::make('ordini')->title('Ordini'),
-            Column::make('listino_prezzi_id')->title('Listino prezzi')->data('listino_prezzi_display'),
-            Column::make('prezzo'),
-            Column::make('stato')->data('stato_display'),
-            Column::make('note'),
+        $columns = [
+            Column::make('id')->searchable(true),
+            Column::make('fattura_id')->title('Fattura')->responsivePriority(2)->width('10%'),
+            Column::make('attivita_id')->title('Attività')->searchable(true),
+            Column::make('dispositivo_id')->title('Dispositivo')->responsivePriority(2)->width('10%')->searchable(true),
+            Column::make('tipo')->title('Tipo')->searchable(true),
+            Column::make('qta')->title('Qta')->searchable(true),
+            Column::make('ordini')->title('Ordini')->searchable(true),
+            Column::make('listino_prezzi_id')->title('Listino prezzi')->data('listino_prezzi_display')->name('listino_prezzi_id')->searchable(true),
+            Column::make('prezzo')->title('Prezzo')->responsivePriority(1)->width('15%')->searchable(true),
+            Column::make('stato')->data('stato_display')->name('stato')->searchable(true),
+            Column::make('note_display')->title('Note')->responsivePriority(2)->searchable(true),
         ];
 
-        if(Auth::user()->hasRole('superadmin')){
-            array_push($columns,
-            Column::make('action')
-                  ->title('')
-                  ->addClass('text-center')
-                  ->exportable(false)
-                  ->printable(false)
-                  ->width(60)
-                  ->addClass('text-center'),
-            );
+        if (Auth::user()->hasRole('superadmin')) {
+            $columns[] = Column::make('action')
+                ->title('')
+                ->exportable(false)
+                ->printable(false)
+                ->searchable(false)
+                ->orderable(false)
+                ->width(60)
+                ->addClass('text-center');
         }
+
         return $columns;
     }
 

app/DataTables/RigaFatturazioneDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\RigaFatturazione;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
-use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Session;
 use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
+use Yajra\DataTables\DataTablesEditor;
 
 class RigaFatturazioneDataTableEditor extends DataTablesEditor
 {
   protected $model = RigaFatturazione::class;
-  // protected $uploadDir = '';
-  // protected $disk = 'modelliRicevute';
 
   protected $messages = [
     'attivita_id.required' => 'L\'attività è richiesta',
     'listino_prezzi_id.required' => 'Il listino prezzi è richiesto',
   ];
 
-  /**
-  * Get create action validation rules.
-  *
-  * @return array
-  */
   public function createRules(): array
   {
     return [
-      'attivita_id'  => 'required',
       'qta' => 'required',
-      // 'prezzo' => 'required',
-      // 'tipo' => 'required',
       'listino_prezzi_id' => 'required',
     ];
   }
 
-  public function createMessages(): array{
+  public function createMessages(): array
+  {
     return $this->messages;
   }
 
-  /**
-  * Get edit action validation rules.
-  *
-  * @param Model $model
-  * @return array
-  */
   public function editRules(Model $model): array
   {
     return [
-      'attivita_id'  => 'required',
       'qta' => 'required',
-      // 'prezzo' => 'required',
-      // 'tipo' => 'required',
       'listino_prezzi_id' => 'required',
     ];
   }
 
-  public function editMessages(): array{
+  public function editMessages(): array
+  {
     return $this->messages;
   }
 
-  /**
-  * Get remove action validation rules.
-  *
-  * @param Model $model
-  * @return array
-  */
   public function removeRules(Model $model): array
   {
     return [];
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
-   $listinoPrezzi = \App\Models\ListinoPrezzi::find($data['listino_prezzi_id']);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $data['user_id'] = Auth::id();
+    $listinoPrezzi = \App\Models\ListinoPrezzi::find($data['listino_prezzi_id']);
     $data['prezzo'] = $listinoPrezzi->prezzo;
     $data['tipo'] = $listinoPrezzi->categoria;
+
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    $this->assertModificabile($model);
+    unset($data['attivita_id'], $data['stato'], $data['ordini'], $data['metadata'], $data['fattura_id']);
+
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    $this->assertModificabile($model);
+
     return $data;
   }
+
   public function messages(): array
   {
     return $this->messages;
   }
 
+  private function assertModificabile(Model $model): void
+  {
+    if (! $model instanceof RigaFatturazione || ! $model->isModificabile()) {
+      throw ValidationException::withMessages([
+        'stato' => 'Solo le righe in stato gratuito possono essere modificate o eliminate.',
+      ]);
+    }
+  }
 }

app/DataTables/StampanteDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Dispositivo;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
+use Illuminate\Support\Facades\Session;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class StampanteDataTableEditor extends DataTablesEditor
 {
   {
     return [
       'nome'  => 'required',
-      'tipo' => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
+      'tipo' => 'required|in:'.Dispositivo::STAMPANTE,
       'licenza' => 'nullable',
       'url_stampante' => 'nullable',
       'ubicazione' => 'nullable',
   {
     return [
       'nome'  => 'required',
-      'tipo' => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
+      'tipo' => 'required|in:'.Dispositivo::STAMPANTE,
       'licenza' => 'nullable',
       'url_stampante' => 'nullable',
       'ubicazione' => 'nullable',
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
-    $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $data['tipo'] = Dispositivo::STAMPANTE;
+    $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
-    $data['is_attiva'] = isset($data['is_attiva']) ? true : false;
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $data['tipo'] = Dispositivo::STAMPANTE;
+    $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
+    return $data;
+  }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
     return $data;
   }
   public function messages(): array

app/DataTables/TavoloDataTable.php

 
 class TavoloDataTable extends DataTable
 {
+    public ?int $attivita_id = null;
+
     public function __construct(){
         $this->dataTableVariable = 'dataTable_tavolo';
     }
      */
     public function query(Tavolo $model): QueryBuilder
     {
-        if($this->attivita_id){
-            return $model->newQuery()->where('attivita_id', $this->attivita_id);
-        }else{
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
             return $model->newQuery()->whereRaw('1 = 0');
         }
+
+        return $model->newQuery()->where('attivita_id', $attivitaId);
     }
 
     /**
                     ->editor(
                         Editor::make()
                             ->fields([
-                                Fields\Hidden::make('attivita_id')->label('Attività')->default($this->attivita_id),
+                                Fields\Hidden::make('attivita_id')->label('Attività')->default((int) $this->attivita_id),
                                 Fields\Text::make('label')->label('Label'),
                                 Fields\Text::make('posti')->label('Posti'),
                                 Fields\Text::make('ubicazione')->label('Ubicazione'),

app/DataTables/TavoloDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Tavolo;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
+use Illuminate\Support\Facades\Session;
 
 class TavoloDataTableEditor extends DataTablesEditor
 {
   {
     return [
       'label'  => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
       'posti' => 'nullable|numeric|min:0',
       'ubicazione' => 'nullable',
       'is_attivo' => 'boolean',
   {
     return [
       'label'  => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
       'posti' => 'nullable|numeric|min:0',
       'ubicazione' => 'nullable',
       'is_attivo' => 'boolean',
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
     $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
     $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     return $data;
   }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
   public function messages(): array
   {
     return $this->messages;

app/DataTables/TestiDataTableEditor.php

 namespace App\DataTables;
 
 use App\Models\Testi;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
+use Illuminate\Support\Facades\Session;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
 
 class TestiDataTableEditor extends DataTablesEditor
 {
   {
     return [
       'titolo'  => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
       'descrizione' => 'nullable',
       'testo' => 'nullable',
       'ambiente' => 'nullable',
   {
     return [
       'titolo'  => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
       'descrizione' => 'nullable',
       'testo' => 'nullable',
       'ambiente' => 'nullable',
 
   public function creating(Model $model, array $data): array
   {
-    // $model->roles()->sync([$data['ruolo_id']]);
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
     $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     return $data;
   }
 
   public function updating(Model $model, array $data): array
   {
-    // dd($data['ruolo']);
-    // $model->roles()->sync([$data['ruolo_id']]);
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
     $data['is_attivo'] = isset($data['is_attivo']) ? true : false;
     return $data;
   }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
   public function messages(): array
   {
     return $this->messages;

app/DataTables/VariantePiattoDataTable.php

      */
     public function query(VariantePiatto $model): QueryBuilder
     {
-        $query = $model->newQuery()->where('attivita_id', $this->attivita_id);
+        $attivitaId = (int) $this->attivita_id;
+        if ($attivitaId <= 0) {
+            return $model->newQuery()->whereRaw('1 = 0');
+        }
+
+        $query = $model->newQuery()->where('attivita_id', $attivitaId);
         if (isset($this->cucina_id)) {
             $query->where('cucina_id', $this->cucina_id);
         }
                     ->editor(Editor::make()
                         ->ajax(route('variante-piatto.store'))
                         ->fields([
-                            Fields\Hidden::make('attivita_id')->label('Attività')->default($this->attivita_id),
+                            Fields\Hidden::make('attivita_id')->label('Attività')->default((int) $this->attivita_id),
                             Fields\Text::make('label')->label('Nome'),
                             Fields\Text::make('prezzo')->label('Prezzo'),
-                            Fields\Select2::make('piatto_id')->label('Associa al Piatto')->options(Piatto::where('attivita_id', $this->attivita_id)->pluck('id', 'nome')),
-                            Fields\Select2::make('cucina_id')->label('Associa alla Cucina')->options(Cucina::where('attivita_id', $this->attivita_id)->pluck('id', 'nome'))->default($this->cucina_id),
-                            Fields\Checkbox::make('is_attivo')->label('Attiva')->default(true),
+                            Fields\Select2::make('piatto_id')->label('Associa al Piatto')->options(Piatto::where('attivita_id', (int) $this->attivita_id)->pluck('id', 'nome')),
+                            Fields\Select2::make('cucina_id')->label('Associa alla Cucina')->options(Cucina::where('attivita_id', (int) $this->attivita_id)->pluck('id', 'nome'))->default($this->cucina_id),
+                            Fields\Boolean::make('is_attivo')->label('Attiva')->default(true),
                         ])
                     )
                     ->language(asset('assets/Italian.json'))

app/DataTables/VariantePiattoDataTableEditor.php

 
 namespace App\DataTables;
 
+use App\Models\Cucina;
+use App\Models\Piatto;
 use App\Models\VariantePiatto;
+use App\Services\Attivita\AttivitaService;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Validation\Rule;
 use Yajra\DataTables\DataTablesEditor;
-use Illuminate\Http\Request;
-use Illuminate\Validation\ValidationException;
-use Storage;
-use Illuminate\Support\Str;
+use Illuminate\Support\Facades\Session;
 
 class VariantePiattoDataTableEditor extends DataTablesEditor
 {
   {
     return [
       'label'  => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
       'prezzo' => 'required',
-      'is_attivo' => 'boolean',
       'piatto_id' => 'nullable|exists:piatto,id',
       'cucina_id' => 'required|exists:cucina,id',
     ];
   {
     return [
       'label'  => 'required',
-      'attivita_id' => 'required|exists:attivita,id',
       'prezzo' => 'required',
-      'is_attivo' => 'boolean',
       'piatto_id' => 'nullable|exists:piatto,id',
       'cucina_id' => 'required|exists:cucina,id',
     ];
 
   public function creating(Model $model, array $data): array
   {
+    $data['attivita_id'] = Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($data['attivita_id']);
+    $this->garantisciRelazioniDiQuestaAttivita($data, $data['attivita_id']);
+
     $data['is_attivo'] = array_key_exists('is_attivo', $data)
       ? filter_var($data['is_attivo'], FILTER_VALIDATE_BOOLEAN)
       : true;
 
   public function updating(Model $model, array $data): array
   {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+    unset($data['attivita_id']);
+    $this->garantisciRelazioniDiQuestaAttivita($data, $model->attivita_id, $model);
+
     if (array_key_exists('is_attivo', $data)) {
       $data['is_attivo'] = filter_var($data['is_attivo'], FILTER_VALIDATE_BOOLEAN);
     }
     return $data;
   }
+
+  public function deleting(Model $model, array $data): array
+  {
+    AttivitaService::garantisciAttivita($model->attivita_id);
+
+    return $data;
+  }
+
+  private function garantisciRelazioniDiQuestaAttivita(array $data, $attivitaId, ?Model $model = null): void
+  {
+    $cucinaId = $data['cucina_id'] ?? $model?->cucina_id;
+    $cucina = Cucina::find($cucinaId);
+    if (! $cucina || (int) $cucina->attivita_id !== (int) $attivitaId) {
+      abort(404);
+    }
+
+    $piattoId = $data['piatto_id'] ?? $model?->piatto_id;
+    if ($piattoId) {
+      $piatto = Piatto::find($piattoId);
+      if (! $piatto || (int) $piatto->attivita_id !== (int) $attivitaId) {
+        abort(404);
+      }
+    }
+  }
   public function messages(): array
   {
     return $this->messages;

app/Http/Controllers/AllergeneController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Allergene;
 use App\DataTables\AllergeneDataTable;

app/Http/Controllers/AsportoController.php

 namespace App\Http\Controllers;
 
 use Illuminate\Http\Request;
+use Illuminate\Routing\Controllers\Middleware;
 use App\Models\Asporto;
 use Illuminate\Support\Collection;
 
         'view-asporto' => 'Visualizza asporto',
     ];
 
+    public static function middleware(): array
+    {
+        return [
+            new Middleware('permission:view-asporto', only: [
+                'index', 'dashboard', 'dashboard_slot',
+                'preparazione', 'completaPreparazione',
+                'chiamata', 'completaChiamata',
+                'ritiro', 'completaRitiro', 'sync',
+            ]),
+        ];
+    }
+
     public function index(Request $request)
     {
 

app/Http/Controllers/AttivitaController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Attivita;
+use App\Models\Evento;
 use App\DataTables\AttivitaDataTable;
 use App\DataTables\AttivitaDataTableEditor;
 use Illuminate\Support\Facades\Auth;
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-attivita', only: ['index']),
+            new Middleware('permission:view-attivita', only: ['index', 'show']),
+            new Middleware('permission:select-attivita', only: ['select']),
             new Middleware('permission:create-attivita|edit-attivita|delete-attivita', only: ['store', 'update', 'destroy']),
         ];
     }
 
     public function show($attivita_id)
     {
-        $attivita = Attivita::with([
+        $attivita = Attivita::find($attivita_id);
+        $user = Auth::user();
+        $isSuperadmin = $user?->hasRole('superadmin');
+        $isOwner = $attivita && (int) $attivita->user_id === (int) $user->id;
+
+        if (! $attivita || (! $isSuperadmin && ! $isOwner)) {
+            abort(404);
+        }
+
+        $attivita->load([
             'dispositivi',
             'eventi',
             'prenotazioni',
             'piatti',
             'fornitori',
-        ])->find($attivita_id);
+        ]);
 
         return view('attivita.show', ['attivita' => $attivita]);
     }
     public function select(Request $request)
     {
         $request->validate([
-            'attivita_id' => 'required|exists:attivita,id',
+            'attivita_id' => 'required|integer',
         ]);
-        Session::put('attivita_attuale', $request->attivita_id);
+
+        $attivita = Attivita::find($request->attivita_id);
+        $user = Auth::user();
+        $isSuperadmin = $user?->hasRole('superadmin');
+        $isOwner = $attivita && (int) $attivita->user_id === (int) $user->id;
+
+        if (! $attivita || (! $isSuperadmin && ! $isOwner)) {
+            abort(404);
+        }
+
+        if (! $attivita->is_attiva) {
+            return redirect()->route('attivita.index')->with('error', 'Attività non attiva');
+        }
+
+        Session::put('attivita_attuale', (int) $attivita->id);
+
         return redirect()->route('dashboard')->with('success', 'Attività selezionata con successo');
     }
 
         ]);
     }
 
-    public function show_public(Request $request)
+    public function show_public($slug)
     {
-        $attivita = Attivita::find($request->attivita_id);
-        if(!$attivita) {
+        $attivita = Attivita::where('slug', $slug)->first();
+        if (! $attivita) {
             return redirect()->route('welcome')->with('error', 'Attività non trovata');
         }
-        return view('attivita.public.show', ['attivita' => $attivita]);
+
+        $eventiPubblici = Evento::pubblici($attivita->id)
+            ->orderBy('data_inizio')
+            ->orderBy('id')
+            ->get();
+
+        return view('attivita.public.show', [
+            'attivita' => $attivita,
+            'eventiPubblici' => $eventiPubblici,
+        ]);
     }
 }

app/Http/Controllers/BachecaController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Bacheca;
 use App\DataTables\BachecaDataTable;
 use Illuminate\Support\Facades\Auth;
 use App\DataTables\ContenutoBachecaDataTable;
 use Illuminate\Support\Facades\Session;
+use App\Services\Attivita\AttivitaService;
 
 class BachecaController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-bacheca', only: ['index']),
+            new Middleware('permission:view-bacheca', only: ['index', 'show']),
             new Middleware('permission:create-bacheca|edit-bacheca|delete-bacheca', only: ['store', 'update', 'destroy']),
         ];
     }
     public function show(ContenutoBachecaDataTable $datatable, Request $request)
     {
         $bacheca = Bacheca::find($request->get('bacheca_id'));
+        if (! $bacheca) {
+            abort(404);
+        }
+        AttivitaService::garantisciAttivita($bacheca->attivita_id);
+        $datatable->attivita_id = Session::get('attivita_attuale');
         $datatable->bacheca_id = $bacheca->id;
         return $datatable->render('bacheca.show', ['bacheca' => $bacheca]);
     }

app/Http/Controllers/BachecaHasContenutoController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\BachecaHasContenuto;
 use App\Models\Bacheca;
 use App\Models\ContenutoBacheca;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Session;
+use App\Services\Attivita\AttivitaService;
 
 class BachecaHasContenutoController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-bacheca_has_contenuto', only: ['index']),
-            new Middleware('permission:create-bacheca_has_contenuto|edit-bacheca_has_contenuto|delete-bacheca_has_contenuto', only: ['store', 'update', 'destroy']),
+            new Middleware('permission:view-bacheca_has_contenuto', only: ['index', 'associa_contenuto']),
+            new Middleware('permission:create-bacheca_has_contenuto|edit-bacheca_has_contenuto|delete-bacheca_has_contenuto', only: ['store', 'update', 'destroy', 'associa_contenuto_bacheca']),
         ];
     }
     
 
     public function associa_contenuto(Request $request)
     {
-        $contenuti = ContenutoBacheca::all();
+        $attivitaId = Session::get('attivita_attuale');
+        AttivitaService::garantisciAttivita($attivitaId);
+        $contenuti = ContenutoBacheca::query()->where('attivita_id', $attivitaId)->get();
         return view('contenuto_bacheca.associa_contenuto', ['contenuti' => $contenuti]);
     }
 
         
         $bacheca = Bacheca::find($request->bacheca_id);
         $contenuto = ContenutoBacheca::find($request->contenuto_id);
-        
+        if (! $bacheca || ! $contenuto) {
+            abort(404);
+        }
+        AttivitaService::garantisciAttivita($bacheca->attivita_id);
+        AttivitaService::garantisciAttivita($contenuto->attivita_id);
+
         $bacheca->contenuti()->attach($contenuto);
         
         return response()->json(['message' => 'Contenuto associato con successo']);

app/Http/Controllers/BilancioController.php

     public function oggi(Request $request, BilancioServizioService $bilancioServizio)
     {
         $attivitaId = (int) session()->get('attivita_attuale');
+        if ($attivitaId <= 0 && ! auth()->user()?->hasRole('superadmin')) {
+            $attivitaId = -1;
+        }
         $attivita = Attivita::find($attivitaId);
         $period = $bilancioServizio->currentPeriod($attivitaId);
         $periodStart = $period['start'];
     public function index(Request $request, BilancioServizioService $bilancioServizio)
     {
         $attivitaId = (int) session()->get('attivita_attuale');
+        if ($attivitaId <= 0 && ! auth()->user()?->hasRole('superadmin')) {
+            $attivitaId = -1;
+        }
         $attivita = Attivita::find($attivitaId);
 
         $year = (int) $request->get('anno', now()->year);
             ->get();
 
         $movimenti = $movimentiCollection->map(function ($movimento) {
-            $tipoRaw = strtolower((string) ($movimento->tipo_movimento ?? ''));
-            $isUscita = $tipoRaw === 'uscita' || ((float) ($movimento->importo ?? 0)) < 0;
-
             return [
                 'data' => $movimento->created_at,
-                'tipo' => $isUscita ? 'uscita' : 'entrata',
+                'tipo' => $movimento->tipoPerAggregazione(),
                 'importo' => abs((float) ($movimento->importo ?? 0)),
                 'pagamento_id' => (int) ($movimento->pagamento_id ?? 0),
                 'fornitore_id' => (int) ($movimento->fornitore_id ?? 0),
 
         $ricaviTotali = (float) $movimenti->where('tipo', 'entrata')->sum('importo');
         $costiTotali = (float) $movimenti->where('tipo', 'uscita')->sum('importo');
+        $importoNonContabilizzato = (float) $movimenti->where('tipo', 'no_contabile')->sum('importo');
+        $movimentiNonContabilizzatiCount = (int) $movimenti->where('tipo', 'no_contabile')->count();
 
         // Fallback per ricavi se la prima nota non contiene entrate.
         $pagamentiCollection = Pagamento::query()
                 $query->where('attivita_id', $attivitaId);
             })
             ->whereBetween('created_at', [$yearStart, $yearEnd])
+            ->perIncasso()
             ->orderBy('created_at')
             ->get();
 
                 continue;
             }
             $row = $mesiBase->get($monthKey);
+            if ($movimento['tipo'] === 'no_contabile') {
+                continue;
+            }
             if ($movimento['tipo'] === 'entrata') {
                 $row['ricavi'] += $movimento['importo'];
             } else {
             'costiTotali' => $costiTotali,
             'saldoTotale' => $saldo,
             'movimentiCount' => $movimenti->count(),
+            'importoNonContabilizzato' => $importoNonContabilizzato,
+            'movimentiNonContabilizzatiCount' => $movimentiNonContabilizzatiCount,
             'andamentoMensile' => $andamentoMensile,
             'costiRows' => $costiRows,
             'ricaviRows' => $ricaviRows,

app/Http/Controllers/CarrelloController.php

 namespace App\Http\Controllers;
 
 use Illuminate\Http\Request;
+use Illuminate\Routing\Controllers\Middleware;
 use App\Models\Ordine;
-use App\Models\PuntoVendita;
+// use App\Models\PuntoVendita;
 use App\Models\Attivita;
 use App\Models\Dispositivo;
 use App\Models\Pagamento;
 use Illuminate\Support\Facades\Session;
 use App\Http\Controllers\PagamentoController;
 use App\Services\Carrello\CarrelloService;
+use App\Services\Attivita\AttivitaService;
 
 class CarrelloController extends Controller
 {
-
     private CarrelloService $carrelloService;
 
+    public static function middleware(): array
+    {
+        return [
+            new Middleware('permission:view-punto_vendita', only: [
+                'index', 'list', 'totale', 'checkout',
+                'aumenta', 'diminuisci', 'elimina', 'aggiorna_nota', 'azzera',
+                'aggiungi_variante', 'elimina_variante', 'aggiorna_info', 'paga_ordine',
+            ]),
+        ];
+    }
+
     public function __construct(CarrelloService $carrelloService)
     {
         $this->carrelloService = $carrelloService;
     }
 
-    public function index(){
-        // return Ordine::all();
-        return Ordine::where('stato', Ordine::CARRELLO)->get();
-    }
+    public function index()
+    {
+        [$attivitaId, $dispositivoId] = $this->carrelloService->contestoCassa();
 
+        return Ordine::where('stato', Ordine::CARRELLO)
+            ->where('attivita_id', $attivitaId)
+            ->where('dispositivo_id', $dispositivoId)
+            ->get();
+    }
 
-    public function list(Request $request, RigaOrdineDataTable $dataTable){
+    public function list(Request $request, RigaOrdineDataTable $dataTable)
+    {
+        [$attivitaId, $dispositivoId] = $this->carrelloService->contestoCassa();
         $ordine = Ordine::where([
-            'stato' => Ordine::CARRELLO, 
-            'dispositivo_id' => Session::get('dispositivo_id') || $request->dispositivo_id,
-            'attivita_id' => Session::get('attivita_id') || $request->attivita_id,
+            'stato' => Ordine::CARRELLO,
+            'dispositivo_id' => $dispositivoId,
+            'attivita_id' => $attivitaId,
         ])->orderBy('created_at', 'desc')->first();
-    // dd($ordine->count());
+
         return $dataTable->render('punto_vendita.cassa._partials.carrello.index', ['ordine' => $ordine]);
     }
 
-
-    public function aumenta(Request $request){
+    public function aumenta(Request $request)
+    {
         $request->validate([
             'ordine_id' => 'nullable|integer',
             'piatto_id' => 'required|integer|exists:piatto,id',
-            'dispositivo_id' => 'required|integer|exists:dispositivo,id',
-            'attivita_id' => 'nullable|integer|exists:attivita,id',
             'riga_ordine_id' => 'nullable|integer|exists:riga_ordine,id',
         ]);
-       
-       $result = $this->carrelloService->aumentaQuantita($request->dispositivo_id, $request->attivita_id, $request->ordine_id, $request->piatto_id, $request->riga_ordine_id);
-       $carrello = $result['ordine'];
-       $riga = $result['riga'];
 
-       return response()->json([
-           'success' => true,
-           'message' => 'Quantità aumentata',
-           'ordine_id' => $carrello->id,
-           'data' => $riga,
-       ]);
+        $result = $this->carrelloService->aumentaQuantita(
+            $request->filled('ordine_id') ? (int) $request->ordine_id : null,
+            (int) $request->piatto_id,
+            $request->filled('riga_ordine_id') ? (int) $request->riga_ordine_id : null
+        );
+        $carrello = $result['ordine'];
+        $riga = $result['riga'];
+
+        return response()->json([
+            'success' => true,
+            'message' => 'Quantità aumentata',
+            'ordine_id' => $carrello->id,
+            'data' => $riga,
+        ]);
 
 
         // Tolleranza su ordine_id stale: se non e` valido, usa/crea il carrello corrente per dispositivo+attivita.
         // // }
     }
 
-    public function totale(Request $request){
-        $ordine = Ordine::find($request->ordine_id);
-        if ($ordine == null){ 
+    public function totale(Request $request)
+    {
+        if (! $request->filled('ordine_id')) {
             return response()->json([
                 'success' => true,
                 'message' => 'Totale carrello',
                 'quantita_totale' => 0,
             ]);
         }
+
+        $ordine = $this->carrelloService->carrelloDiQuestaCassa((int) $request->ordine_id);
         // dd([$ordine->prezzo , $request->all()]);
         if($ordine->prezzo == null || $ordine->prezzo == 0){
             if($ordine->righe_ordine->count() >0){
             'quantita_totale' => $quantitaTotale,
         ]);
     }
-    public function aggiorna_info(Request $request){
-        $ordine = Ordine::find($request->ordine_id);
-        if($ordine == null){
-            return response()->json([
-                'success' => false,
-                'message' => 'Ordine non trovato',
-                'data' => null,
-            ]);
-        }
+    public function aggiorna_info(Request $request)
+    {
+        $request->validate([
+            'ordine_id' => 'required|integer',
+        ]);
+        $ordine = $this->carrelloService->carrelloDiQuestaCassa((int) $request->ordine_id);
         $info = is_array($ordine->info) ? $ordine->info : [];
         $info['cliente'] = $request->cliente;
         $info['tavolo'] = $request->tavolo;
     }
 
 
-    public function checkout(Request $request){
-        // $ordineA = Ordine::where([
-        //     'stato' => Ordine::CARRELLO, 
-        //     // 'dispositivo_id' => Session::get('dispositivo_id') || $request->dispositivo_id,
-        //     'attivita_id' => Session::get('attivita_id') || $request->attivita_id,
-        // ])->orderBy('created_at', 'desc')->first();
-        $ordine = Ordine::find($request->ordine_id);
-        if($ordine == null){
-            return  response()->json([
-                'success' => false,
-                'message' => 'Ordine non trovato',
-                'data' => null,
-                'ordineA' => $ordineA,
-                'ordineB' => $ordineB,
-                // 'ordineA->id == ordineB->id' => $ordineA->id == $ordineB->id,
-            ]);
-        }
+    public function checkout(Request $request)
+    {
+        $ordine = $this->carrelloService->carrelloDiQuestaCassa((int) $request->ordine_id);
 
         $ordine->prezzo = $ordine->righe_ordine->sum('prezzo');
         // $ordine->stato = Ordine::CHECKOUT;
     }
 
     public function paga_ordine(Request $request){
+
         
-        if(!$request->filled('tag_id') && MetodoPagamento::find($request->metodo_pagamento_id)->tipo == MetodoPagamento::SEGRESTA_WALLET){
-            return back()->with('error', 'Tag ID obbligatorio per il metodo di pagamento Segresta Wallet');
+        $ordine = $this->carrelloService->carrelloDiQuestaCassa((int) $request->ordine_id);
+
+        $attivitaId = (int) (session('attivita_attuale') ?: session('attivita_id'));
+        $dispositivoId = (int) session('dispositivo_id');
+
+
+        if ($ordine->stato !== Ordine::CARRELLO) {
+            return redirect()->route('punto-vendita.show', ['punto_vendita_id' => $ordine->dispositivo_id , 'vista' => $request->vista])->with('error', 'Questo ordine non è più un carrello');
         }
-        
-        $ordine = Ordine::find($request->ordine_id);
-        if($ordine == null){
-            return response()->json([
-                'success' => false,
-                'message' => 'Ordine non trovato',
-                'data' => null,
-            ]);
+
+        $metodo = MetodoPagamento::where('id', $request->metodo_pagamento_id)
+                ->where('attivita_id', $attivitaId)
+                ->where('is_attivo', true)
+                ->first();
+        if (! $metodo) {
+            return back()->with('error', 'Metodo di pagamento non valido');
+        }
+
+                
+        if(!$request->filled('tag_id') && $metodo->tipo == MetodoPagamento::SEGRESTA_WALLET){
+            return back()->with('error', 'Tag ID obbligatorio per il metodo di pagamento Segresta Wallet');
         }
+
         $pagamento = Pagamento::create([
-            'attivita_id' => session('attivita_id'), //$request->attivita_id,
-            'dispositivo_id' => $request->dispositivo_id,
+            'attivita_id' => $attivitaId,
+            'dispositivo_id' => $dispositivoId,
             'ordine_id' => $ordine->id,
             'metodo_pagamento_id' => $request->metodo_pagamento_id,
             'tipo' => $request->tipo,
                     $ordine->update(['stato' => Ordine::PAGATO]);
                     return redirect()->route('punto-vendita.show', ['punto_vendita_id' => $ordine->dispositivo_id , 'vista' => $request->vista])->with('success', 'Pagamento con contanti riuscito. ->'.$pagamento->metodo_pagamento->tipo);
                 }else{
+                    $pagamento->stato = Pagamento::ERRORE;
+                    $pagamento->save();
+
                     $ordine->stato = Ordine::CARRELLO;
                     $ordine->save();
                     return back()->with('error', 'Pagamento con contanti non riuscito. '.$pagamentoResult['message']);
                 // $pagamento->save();
                 // return redirect()->route('punto-vendita.show', ['punto_vendita_id' => $ordine->dispositivo_id])->with('success', 'Pagamento con bonifico riuscito.');
                 
+                $pagamento->stato = Pagamento::ERRORE;
+                $pagamento->save();
+
                 $ordine->stato = Ordine::CARRELLO;
                     $ordine->save();
                     return back()->with('error', 'METODO PAGAMENTO NON DISPONIBILE. ');
                 // $pagamento->update(['stato' , Pagamento::PAGATO]);
                 // $pagamento->save();
                 // return redirect()->route('punto-vendita.show', ['punto_vendita_id' => $ordine->dispositivo_id])->with('success', 'Pagamento con paypal riuscito.');
-                
+                $pagamento->stato = Pagamento::ERRORE;
+                $pagamento->save();
+
                 $ordine->stato = Ordine::CARRELLO;
                     $ordine->save();
                     return back()->with('error', 'METODO PAGAMENTO NON DISPONIBILE. ');
                 // $pagamento->update(['stato' , Pagamento::PAGATO]);
                 // $pagamento->save();
                 // return redirect()->route('punto-vendita.show', ['punto_vendita_id' => $ordine->dispositivo_id])->with('success', 'Pagamento con carta di debito riuscito.');
-                
+                $pagamento->stato = Pagamento::ERRORE;
+                $pagamento->save();
+
                 $ordine->stato = Ordine::CARRELLO;
                     $ordine->save();
                     return back()->with('error', 'METODO PAGAMENTO NON DISPONIBILE. ');
 
                 break;
             case MetodoPagamento::CUPON:
-                $pagamentoResult = app('\App\Services\Paga\Cupon')->paga($pagamento);
+                $pagamentoResult = app('\App\Services\Paga\PagaCupon')->paga($pagamento, $request->cupon_codice);
                 
                 if($pagamentoResult['result'] === true){
                     $ordine->update(['stato' => Ordine::PAGATO]);
                     return redirect()->route('punto-vendita.show', ['punto_vendita_id' => $ordine->dispositivo_id])->with('success', 'Pagamento con cupon riuscito.');
                 }else{
+                    $pagamento->stato = Pagamento::ERRORE;
+                    $pagamento->save();
+
                     $ordine->stato = Ordine::CARRELLO;
                     $ordine->save();
                     return back()->with('error', 'Pagamento con cupon non riuscito. '.$pagamentoResult['message']);
                 
                 if($pagamentoResult['result'] === true){
                     $pagamento->update(['stato' => Pagamento::PAGATO]);
-                    $pagamento->save();
+                    $ordine->update(['stato' => Ordine::PAGATO]);
+
                     return redirect()->route('punto-vendita.show', ['punto_vendita_id' => $ordine->dispositivo_id])->with('success', 'Pagamento con wallet riuscito.');
                 }else{
                     $pagamento->stato = Pagamento::ERRORE;
                     // $pagamento->update(['stato' , Pagamento::PAGATO]);
                     // $pagamento->save();
                     // return redirect()->route('punto-vendita.show', ['punto_vendita_id' => $ordine->dispositivo_id])->with('success', 'Pagamento con apple pay riuscito.');
-                    
+                    $pagamento->stato = Pagamento::ERRORE;
+                    $pagamento->save();
+
                     $ordine->stato = Ordine::CARRELLO;
                     $ordine->save();
                     return back()->with('error', 'METODO PAGAMENTO NON DISPONIBILE. ');
                 // $pagamento->update(['stato' , Pagamento::PAGATO]);
                 // $pagamento->save();
                 // return redirect()->route('punto-vendita.show', ['punto_vendita_id' => $ordine->dispositivo_id])->with('success', 'Pagamento con google pay riuscito.');
-                
+                $pagamento->stato = Pagamento::ERRORE;
+                $pagamento->save();
+
                 $ordine->stato = Ordine::CARRELLO;
                     $ordine->save();
                     return back()->with('error', 'METODO PAGAMENTO NON DISPONIBILE. ');
                     $ordine->update(['stato' => Ordine::PAGATO]);
                     return redirect()->route('punto-vendita.show', ['punto_vendita_id' => $ordine->dispositivo_id])->with('success', 'Pagamento con contanti riuscito. ->'.$pagamento->metodo_pagamento->tipo);
                 }else{
+                    $pagamento->stato = Pagamento::ERRORE;
+                    $pagamento->save();
+
                     $ordine->stato = Ordine::CARRELLO;
                     $ordine->save();
                     return back()->with('error', 'Pagamento con contanti non riuscito. '.$pagamentoResult['message']);
                 }
+                break;
 
             case MetodoPagamento::STAFF:
                 $pagamentoResult = app('\App\Services\Paga\Staff')->paga($pagamento);
                     $ordine->update(['stato' => Ordine::PAGATO]);
                     return redirect()->route('punto-vendita.show', ['punto_vendita_id' => $ordine->dispositivo_id])->with('success', 'Pagamento con staff riuscito.');
                 }else{
+                    $pagamento->stato = Pagamento::ERRORE;
+                    $pagamento->save();
+
                     $ordine->stato = Ordine::CARRELLO;
                     $ordine->save();
                     return back()->with('error', 'Pagamento con staff non riuscito. '.$pagamentoResult['message']);

app/Http/Controllers/CategoriaContabileController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Categoriacontabile;
 use App\DataTables\CategoriacontabileDataTable;

app/Http/Controllers/ChiusuraServizioController.php

 use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Session;
+use App\Services\Attivita\AttivitaService;
 
 class ChiusuraServizioController extends Controller
 {
       return redirect()->back()->with('error', 'Non autorizzato');
     }
 
-    $attivitaId = (int) ($request->input('attivita_id') ?: Session::get('attivita_attuale'));
+    $attivitaId = (int) Session::get('attivita_attuale');
+    AttivitaService::garantisciAttivita($attivitaId);
     $attivita = Attivita::find($attivitaId);
     if (!$attivita) {
       return redirect()->back()->with('error', 'Attività non trovata');

app/Http/Controllers/ConsultaController.php

 
 namespace App\Http\Controllers;
 
+use App\Models\EventoForm;
 use App\Models\Ordine;
 use App\Models\Prenotazione;
+use App\Models\PrenotazioneRisposta;
+use App\Notifications\PrenotazioneLinkModifica;
+use App\Services\Prenotazione\AccessoModificaCliente;
 use Endroid\QrCode\Builder\Builder;
 use Endroid\QrCode\Color\Color;
 use Endroid\QrCode\Writer\SvgWriter;
 use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Notification;
+use Illuminate\Support\Facades\Validator;
 
 class ConsultaController extends Controller
 {
 
     public function scontrino_show(Request $request)
     {
-        $ordine = Ordine::find($request->route('ordine_id'));
-        // dd($ordine);
-        if (!$ordine) {
+        $ordine = Ordine::where('codice', $request->route('ordine_codice'))->first();
+        if (! $ordine) {
             return redirect()->route('consulta.index')->with('error', 'Ordine non trovato');
         }
+
         return view('consulta.scontrino.show', compact('ordine'));
     }
-    
+
     public function comanda_show(Request $request)
     {
-        $ordine = Ordine::find($request->route('ordine_id'));
-        if (!$ordine) {
+        $ordine = Ordine::where('codice', $request->route('ordine_codice'))->first();
+        if (! $ordine) {
             return redirect()->route('consulta.index')->with('error', 'Ordine non trovato');
         }
+
         return view('consulta.comanda.show', compact('ordine'));
     }
+
     public function prenotazione_show(Request $request)
     {
+        $prenotazione = $this->trovaPrenotazionePerCodice($request->route('codice'));
+        if (! $prenotazione) {
+            return redirect()->route('welcome')->with('error', 'Prenotazione non trovata');
+        }
+
+        return view('consulta.prenotazione.show', [
+            'prenotazione' => $prenotazione,
+            'codiceQrSvg' => $this->qrSvg($prenotazione),
+            'puoModificare' => (bool) $prenotazione->evento?->clientePuoModificareQuestaPrenotazione($prenotazione),
+            'puoAnnullare' => (bool) $prenotazione->evento?->clientePuoAnnullareQuestaPrenotazione($prenotazione),
+        ]);
+    }
+
+    public function prenotazione_calendario(Request $request, \App\Services\Calendario\CreaIcsPrenotazione $ics)
+    {
+        $request->validate([
+            'codice' => 'required|string',
+        ]);
+
         $prenotazione = Prenotazione::query()
+            ->with(['evento.attivita'])
+            ->where('codice', $request->get('codice'))
+            ->first();
+
+        if (! $prenotazione) {
+            return redirect()->route('consulta.index')->with('error', 'Prenotazione non trovata');
+        }
+
+        $contenuto = $ics->contenuto($prenotazione);
+        if (! $contenuto) {
+            return redirect()
+                ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+                ->with('error', 'Calendario non disponibile per questa prenotazione');
+        }
+
+        return response($contenuto, 200, [
+            'Content-Type' => 'text/calendar; charset=utf-8',
+            'Content-Disposition' => 'attachment; filename="'.$ics->nomeFile($prenotazione).'"',
+        ]);
+    }
+
+    /**
+     * Da consulta: invia email con magic link (modifica o annulla).
+     */
+    public function prenotazione_richiedi_modifica(Request $request, AccessoModificaCliente $accesso)
+    {
+        $data = $request->validate([
+            'codice' => 'required|string',
+            'azione' => 'required|in:modifica,annulla',
+        ]);
+
+        $prenotazione = $this->trovaPrenotazionePerCodice($data['codice']);
+        if (! $prenotazione) {
+            return redirect()->route('consulta.index')->with('error', 'Prenotazione non trovata');
+        }
+
+        $azione = $data['azione'];
+        if (! $accesso->puoRichiedereLink($prenotazione, $azione)) {
+            return redirect()
+                ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+                ->with('error', 'Questa operazione non è più disponibile per la prenotazione.');
+        }
+
+        if (! filled($prenotazione->email)) {
+            return redirect()
+                ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+                ->with('error', 'Nessuna email associata a questa prenotazione.');
+        }
+
+        if (! $accesso->puoInviareOra($prenotazione, $azione)) {
+            return redirect()
+                ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+                ->with('error', 'Abbiamo già inviato un link. Controlla la posta o riprova tra un minuto.');
+        }
+
+        $url = $accesso->urlFirmato($prenotazione, $azione);
+        $emailMask = $accesso->mascheraEmail($prenotazione->email);
+
+        Notification::route('mail', $prenotazione->email)
+            ->notify(new PrenotazioneLinkModifica($prenotazione, $azione, $url));
+
+        $msg = $azione === 'annulla'
+            ? 'Ti abbiamo inviato un’email a '.$emailMask.' con il link per annullare (valido '.AccessoModificaCliente::MINUTI_LINK.' minuti). Controlla anche lo spam.'
+            : 'Ti abbiamo inviato un’email a '.$emailMask.' con il link per modificare (valido '.AccessoModificaCliente::MINUTI_LINK.' minuti). Controlla anche lo spam.';
+
+        return redirect()
+            ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+            ->with('success', $msg);
+    }
+
+    /**
+     * Entrypoint magic link firmato (monouso) → avvia sessione 15 min.
+     */
+    public function prenotazione_modifica_apri(Request $request, AccessoModificaCliente $accesso)
+    {
+        if (! $request->hasValidSignature()) {
+            return redirect()
+                ->route('consulta.index')
+                ->with('error', 'Link non valido o scaduto. Richiedine uno nuovo dalla scheda prenotazione.');
+        }
+
+        $codice = (string) $request->query('codice', '');
+        $azione = (string) $request->query('azione', 'modifica');
+
+        $prenotazione = $this->trovaPrenotazionePerCodice($codice);
+        if (! $prenotazione) {
+            return redirect()->route('consulta.index')->with('error', 'Prenotazione non trovata');
+        }
+
+        if (! $accesso->puoRichiedereLink($prenotazione, $azione)) {
+            return redirect()
+                ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+                ->with('error', 'Questa operazione non è più disponibile.');
+        }
+
+        if (! $accesso->consumaLink($request)) {
+            return redirect()
+                ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+                ->with('error', 'Questo link è già stato usato. Richiedine uno nuovo se serve.');
+        }
+
+        $accesso->avviaSessione($prenotazione, $azione);
+
+        return $azione === 'annulla'
+            ? redirect()->route('consulta.prenotazione.annulla.form')
+            : redirect()->route('consulta.prenotazione.modifica.form');
+    }
+
+    public function prenotazione_modifica_form(AccessoModificaCliente $accesso)
+    {
+        $prenotazione = $this->prenotazioneDaSessione($accesso, 'modifica');
+        if (! $prenotazione) {
+            return redirect()->route('consulta.index')->with('error', 'Sessione di modifica scaduta. Richiedi un nuovo link.');
+        }
+
+        if (! $accesso->puoRichiedereLink($prenotazione, 'modifica')) {
+            $accesso->chiudiSessione();
+
+            return redirect()
+                ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+                ->with('error', 'La modifica non è più disponibile.');
+        }
+
+        $risposte = $this->rispostePerForm($prenotazione);
+
+        return view('consulta.prenotazione.modifica', [
+            'prenotazione' => $prenotazione,
+            'evento' => $prenotazione->evento,
+            'risposte' => $risposte,
+            'minutiSessione' => AccessoModificaCliente::MINUTI_LINK,
+        ]);
+    }
+
+    public function prenotazione_modifica_salva(Request $request, AccessoModificaCliente $accesso)
+    {
+        $prenotazione = $this->prenotazioneDaSessione($accesso, 'modifica');
+        if (! $prenotazione || ! $prenotazione->evento) {
+            return redirect()->route('consulta.index')->with('error', 'Sessione di modifica scaduta.');
+        }
+
+        $evento = $prenotazione->evento;
+        if (! $accesso->puoRichiedereLink($prenotazione, 'modifica')) {
+            $accesso->chiudiSessione();
+
+            return redirect()
+                ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+                ->with('error', 'La modifica non è più disponibile.');
+        }
+
+        $nPersone = max(1, (int) $request->input('numero_persone', 1));
+        $user = null;
+
+        $rules = [
+            'nome' => 'required|string|max:255',
+            'cognome' => 'required|string|max:255',
+            'telefono' => 'nullable|string|max:50',
+            'note' => 'nullable|string|max:2000',
+            'numero_persone' => 'required|integer|min:1|max:100',
+        ];
+
+        $campiVisibili = $evento->form->filter(fn ($campo) => $campo->isVisibileAlCliente($user));
+
+        foreach ($campiVisibili as $campo) {
+            $key = 'prenotazione_risposta_'.$campo->id;
+            $obbligatoria = (bool) $campo->obbligatoria;
+
+            if ($campo->per_coperto) {
+                $rules[$key] = $obbligatoria ? 'required|array|size:'.$nPersone : 'nullable|array';
+                for ($i = 0; $i < $nPersone; $i++) {
+                    if ($campo->tipo === EventoForm::MULTISELEZIONE) {
+                        $rules[$key.'.'.$i] = $obbligatoria ? 'required|array|min:1' : 'nullable|array';
+                    } elseif ($campo->tipo === EventoForm::CHECKBOX) {
+                        $rules[$key.'.'.$i] = $obbligatoria ? 'required|in:1' : 'nullable';
+                    } else {
+                        $rules[$key.'.'.$i] = $obbligatoria ? 'required' : 'nullable';
+                    }
+                }
+            } elseif ($campo->tipo === EventoForm::MULTISELEZIONE) {
+                $rules[$key] = $obbligatoria ? 'required|array|min:1' : 'nullable|array';
+            } elseif ($campo->tipo === EventoForm::CHECKBOX) {
+                $rules[$key] = $obbligatoria ? 'required|in:1' : 'nullable';
+            } else {
+                $rules[$key] = $obbligatoria ? 'required' : 'nullable';
+            }
+        }
+
+        $validator = Validator::make($request->all(), $rules);
+        if ($validator->fails()) {
+            return redirect()
+                ->route('consulta.prenotazione.modifica.form')
+                ->withErrors($validator)
+                ->withInput()
+                ->with('error', $validator->errors()->first());
+        }
+
+        $eraConfermata = $prenotazione->stato === Prenotazione::STATO_CONFERMATA
+            || (bool) $prenotazione->confermata;
+
+        $prenotazione->fill($request->only(['nome', 'cognome', 'telefono', 'note']));
+        $prenotazione->numero_persone = $nPersone;
+        // Email non modificabile dal cliente.
+
+        if ($eraConfermata && $evento->clienteModificaSeConfermata()) {
+            $prenotazione->stato = Prenotazione::STATO_INVIATA;
+            $prenotazione->confermata = false;
+        }
+
+        $prenotazione->save();
+
+        $seenFormIds = [];
+        foreach ($campiVisibili as $campo) {
+            $value = $request->input('prenotazione_risposta_'.$campo->id);
+            if (is_array($value)) {
+                $value = json_encode(array_values($value), JSON_UNESCAPED_UNICODE);
+            }
+
+            if ($value === null || $value === '') {
+                continue;
+            }
+
+            PrenotazioneRisposta::updateOrCreate(
+                [
+                    'prenotazione_id' => $prenotazione->id,
+                    'evento_form_id' => $campo->id,
+                ],
+                ['risposta' => (string) $value]
+            );
+            $seenFormIds[] = $campo->id;
+        }
+
+        $visibleIds = $campiVisibili->pluck('id')->all();
+        if ($visibleIds !== []) {
+            $prenotazione->risposte()
+                ->whereIn('evento_form_id', $visibleIds)
+                ->when(
+                    $seenFormIds !== [],
+                    fn ($q) => $q->whereNotIn('evento_form_id', $seenFormIds),
+                    fn ($q) => $q
+                )
+                ->delete();
+        }
+
+        $accesso->chiudiSessione();
+
+        $msg = 'Prenotazione aggiornata.';
+        if ($eraConfermata && $prenotazione->stato === Prenotazione::STATO_INVIATA) {
+            $msg .= ' È tornata in attesa di conferma da parte degli organizzatori.';
+        }
+
+        return redirect()
+            ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+            ->with('success', $msg);
+    }
+
+    public function prenotazione_annulla_form(AccessoModificaCliente $accesso)
+    {
+        $prenotazione = $this->prenotazioneDaSessione($accesso, 'annulla');
+        if (! $prenotazione) {
+            return redirect()->route('consulta.index')->with('error', 'Sessione scaduta. Richiedi un nuovo link.');
+        }
+
+        if (! $accesso->puoRichiedereLink($prenotazione, 'annulla')) {
+            $accesso->chiudiSessione();
+
+            return redirect()
+                ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+                ->with('error', 'L’annullamento non è più disponibile.');
+        }
+
+        return view('consulta.prenotazione.annulla', [
+            'prenotazione' => $prenotazione,
+            'evento' => $prenotazione->evento,
+            'minutiSessione' => AccessoModificaCliente::MINUTI_LINK,
+        ]);
+    }
+
+    public function prenotazione_annulla_conferma(Request $request, AccessoModificaCliente $accesso)
+    {
+        $prenotazione = $this->prenotazioneDaSessione($accesso, 'annulla');
+        if (! $prenotazione) {
+            return redirect()->route('consulta.index')->with('error', 'Sessione scaduta.');
+        }
+
+        if (! $accesso->puoRichiedereLink($prenotazione, 'annulla')) {
+            $accesso->chiudiSessione();
+
+            return redirect()
+                ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+                ->with('error', 'L’annullamento non è più disponibile.');
+        }
+
+        $request->validate([
+            'conferma' => 'accepted',
+        ], [
+            'conferma.accepted' => 'Conferma di voler annullare la prenotazione.',
+        ]);
+
+        $prenotazione->stato = Prenotazione::STATO_CANCELLATA;
+        $prenotazione->confermata = false;
+        $prenotazione->save();
+
+        $accesso->chiudiSessione();
+
+        return redirect()
+            ->route('consulta.prenotazione.show', ['codice' => $prenotazione->codice])
+            ->with('success', 'Prenotazione annullata.');
+    }
+
+    private function trovaPrenotazionePerCodice(?string $codice): ?Prenotazione
+    {
+        if (! filled($codice)) {
+            return null;
+        }
+
+        return Prenotazione::query()
             ->with([
                 'risposte',
+                'evento.attivita',
                 'evento.form' => function ($q) {
-                    $q->orderBy('ordine_visualizzazione')->with('opzioni_form');
+                    $q->orderBy('ordine_visualizzazione')->with(['opzioni_form' => function ($oq) {
+                        $oq->orderBy('ordine')->orderBy('id');
+                    }]);
                 },
             ])
-            ->where('codice', $request->get('codice'))
+            ->where('codice', $codice)
             ->first();
-        if (!$prenotazione) {
-            return redirect()->route('consulta.index')->with('error', 'Prenotazione non trovata');
+    }
+
+    private function prenotazioneDaSessione(AccessoModificaCliente $accesso, string $azione): ?Prenotazione
+    {
+        if (! $accesso->sessioneValida(azione: $azione)) {
+            return null;
         }
 
+        $codice = $accesso->codiceSessione();
+
+        return $this->trovaPrenotazionePerCodice($codice);
+    }
+
+    private function rispostePerForm(Prenotazione $prenotazione): array
+    {
+        $risposte = [];
+        foreach ($prenotazione->risposte as $r) {
+            $decoded = json_decode((string) $r->risposta, true);
+            $risposte[$r->evento_form_id] = (json_last_error() === JSON_ERROR_NONE && is_array($decoded))
+                ? $decoded
+                : $r->risposta;
+        }
+
+        return $risposte;
+    }
+
+    private function qrSvg(Prenotazione $prenotazione): string
+    {
         $qrBuilder = new Builder(
             writer: new SvgWriter(),
             writerOptions: [
             ],
         );
 
-        $codiceQrSvg = $qrBuilder->build(
+        return $qrBuilder->build(
             data: (string) $prenotazione->codice,
             size: 168,
             margin: 4,
             foregroundColor: new Color(21, 38, 92),
-            // class: 'bg-primary',
-            // backgroundColor: new Color(245, 130, 32),
         )->getString();
-
-        return view('consulta.prenotazione.show', [
-            'prenotazione' => $prenotazione,
-            'codiceQrSvg' => $codiceQrSvg,
-        ]);
     }
 }

app/Http/Controllers/ContenutoBachecaController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\ContenutoBacheca;
 use App\DataTables\ContenutoBachecaDataTable;
 use App\DataTables\ContenutoBachecaDataTableEditor;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Session;
+use App\Services\Attivita\AttivitaService;
 
 class ContenutoBachecaController extends Controller
 {
     public function show(Request $request)
     {
         $contenuto_bacheca = ContenutoBacheca::find($request->get('contenuto_bacheca_id'));
+        if (! $contenuto_bacheca) {
+            abort(404);
+        }
+        AttivitaService::garantisciAttivita($contenuto_bacheca->attivita_id);
         return view('contenuto_bacheca.show', ['contenuto_bacheca' => $contenuto_bacheca]);
     }
     

app/Http/Controllers/Controller.php

 
 namespace App\Http\Controllers;
 
-abstract class Controller
+use Illuminate\Routing\Controllers\HasMiddleware;
+
+abstract class Controller implements HasMiddleware
 {
-  //
-}
+    /**
+     * Laravel 12 applica il middleware dei controller solo se la classe
+     * implementa HasMiddleware. I figli possono sovrascrivere questo metodo.
+     *
+     * @return array<int, \Illuminate\Routing\Controllers\Middleware|\Closure|string>
+     */
+    public static function middleware(): array
+    {
+        return [];
+    }
+}

app/Http/Controllers/CucinaController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Cucina;
 use App\DataTables\CucinaDataTable;
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-cucina', only: ['index']),
+            new Middleware('permission:view-cucina', only: ['index', 'dashboard']),
             new Middleware('permission:create-cucina|edit-cucina|delete-cucina', only: ['store', 'update', 'destroy']),
         ];
     }

app/Http/Controllers/CuponController.php

+<?php
+
+namespace App\Http\Controllers;
+
+
+use Illuminate\Routing\Controllers\Middleware;
+use Illuminate\Http\Request;
+use App\Models\Cupon;
+use App\DataTables\CuponDataTable;
+use App\DataTables\CuponDataTableEditor;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Session;
+use Illuminate\Support\Facades\Storage;
+use Barryvdh\DomPDF\Facade\Pdf;
+use Illuminate\Support\Str;
+use App\Models\Attivita;
+use App\Models\Dispositivo;
+use App\Models\PrintJob;
+use App\Jobs\ElaboraJobStampa;
+use App\Services\Attivita\AttivitaService;
+use App\Models\Ordine;
+use Carbon\Carbon;
+
+class CuponController extends Controller
+{
+
+    public static $permission_group = "Cupon";
+    public static $permissions = [
+        'view-cupon' => 'Vedi',
+        'create-cupon' => 'Crea',
+        'edit-cupon' => 'Modifica',
+        'delete-cupon' => 'Elimina',
+    ];
+     
+    public static function middleware(): array
+    {
+        return [
+            new Middleware('permission:view-cupon', only: ['index', 'stampaCupon', 'pdfCupon', 'pdfCuponPersonalizzato', 'checklistCupon']),
+            new Middleware('permission:view-cupon|view-punto_vendita', only: ['check']),
+            new Middleware('permission:create-cupon|edit-cupon|delete-cupon', only: ['store', 'update', 'destroy', 'generaBatch', 'uploadCuponTemplate', 'printCupon']),
+        ];
+    }
+
+    public function index(CuponDataTable $dataTable)
+    {
+        $dataTable->attivita_id = Session::get('attivita_attuale');
+        return $dataTable->render('cupon.index');
+    }
+
+    public function stampaCupon(Request $request)
+    {
+        $attivitaId = Session::get('attivita_attuale');
+        $cupons = Cupon::where('attivita_id', $attivitaId)->orderBy('id', 'desc')->get();
+        $stampanti = Dispositivo::where('attivita_id', $attivitaId)
+            ->where('tipo', Dispositivo::STAMPANTE)
+            ->where('is_attivo', true)
+            ->orderBy('nome')
+            ->get();
+
+        return view('cupon.stampa-cupon', compact('cupons', 'stampanti'));
+    }
+
+
+    public function pdfCupon(Request $request)
+    {
+        $cupons = $this->cuponsSelezionati($request);
+
+        return Pdf::loadView('cupon.pdf', [
+            'cupons' => $cupons,
+            'nomeAttivita' => Attivita::find(Session::get('attivita_attuale'))?->nome ?? '',
+        ])->setPaper('a4', 'portrait')->download('cupon.pdf');
+    }
+
+    public function pdfCuponPersonalizzato(Request $request)
+    {
+        $attivitaId = Session::get('attivita_attuale');
+        $cupons = $this->cuponsSelezionati($request);
+
+        return Pdf::loadView('cupon.pdf-personalizzato', [
+            'cupons' => $cupons,
+            'templatePath' => Storage::disk('templateCupon')->path($attivitaId.'/template.png'),
+            'layout' => [
+              'show_importo' => false,
+              'show_nominativo' => false,
+              'show_validita' => false,
+              'codice' => [
+                'top' => '18mm',
+                'left' => '12mm',
+                'font_size' => '18pt',
+              ],
+            ],
+          ])->setPaper('a4', 'portrait')->download('cupon.pdf-personalizzato');
+    }
+
+    public function uploadCuponTemplate(Request $request)
+    {
+        $request->validate([
+            'template' => 'required|image|mimes:png,jpg,jpeg,webp|max:5120',
+        ]);
+        $attivitaId = Session::get('attivita_attuale');
+        AttivitaService::garantisciAttivita($attivitaId);
+        $path = $attivitaId.'/template.png';
+        // sovrascrive sempre lo stesso file
+        Storage::disk('templateCupon')->put(
+            $path,
+            file_get_contents($request->file('template')->getRealPath())
+        );
+        return response()->json([
+            'success' => true,
+            'message' => 'Grafica salvata.',
+            'url' => Storage::disk('templateCupon')->url($path),
+        ]);
+    }
+    
+
+    public function store(CuponDataTableEditor $editor)
+    {
+        $request = request();
+        $input = $request->all();
+        if($request->has('action')){
+          switch($input['action']){
+            case 'create':
+              if(!Auth::user()->can('create-cupon')) return;
+              break;
+            case 'edit':
+              if(!Auth::user()->can('edit-cupon')) return;
+              break;
+            case 'remove':
+              if(!Auth::user()->can('delete-cupon')) return;
+              break;
+          }
+        }
+        return $editor->process($request);
+    }
+
+    public function generaBatch(Request $request)
+    {
+        AttivitaService::garantisciAttivita(Session::get('attivita_attuale'));
+        
+        switch($request->modo){
+            case 'file':
+                //colonne CSV: nominativo,importo,validita_da,validita_a,email
+
+                $file = $request->file('file')->getRealPath();
+                $fileOpen = fopen($file, 'r');
+                fgetcsv($fileOpen, 0, ','); // scarta nominativo,importo,validita_da,validita_a
+                while (($line = fgetcsv($fileOpen, 0, ',')) !== false) {
+                    $this->generaCupon([
+                        'importo' => doubleval($line[1])?? $request->importo,
+                        'validita_da' => Carbon::parse($line[2])?? $request->validita_da,
+                        'validita_a' => Carbon::parse($line[3])?? $request->validita_a,
+                        'nominativo' => $line[0]?? '',
+                        'email' => $line[4]?? '',
+                    ]);
+                                };
+                break;
+            case 'numerati':
+                
+                for($i = $request->da; $i <= $request->a; $i++){
+                    $this->generaCupon([
+                        'importo' => $request->importo,
+                        'validita_da' => Carbon::parse($request->validita_da),
+                        'validita_a' => Carbon::parse($request->validita_a),
+                        'nominativo' => $request->nominativo?? '',
+                        'email' => $request->email?? '',
+                    ]);
+                }
+                break;
+        }
+
+        return redirect()->route('cupon.index')->with('success', 'Cupon generati con successo');
+    }
+
+    public function check(Request $request)
+    {
+        $cupon = Cupon::where('codice', $request->cupon_codice)->where('attivita_id', session('attivita_attuale'))->first();
+        if($cupon){
+            // Marca come scaduto se la data di fine validità è passata
+            if($cupon->stato == Cupon::GENERATO && $cupon->validita_a < Carbon::today()){
+                $cupon->stato = Cupon::SCADUTO;
+                $cupon->save();
+            }
+
+            // Cupon non ancora valido (troppo presto)
+            if($cupon->stato == Cupon::GENERATO && $cupon->validita_da->startOfDay() > Carbon::today()){
+                return response()->json(['success' => false, 'message' => 'Cupon non ancora valido', 'validita_da' => $cupon->validita_da->format('d/m/Y')]);
+            }
+
+            $ordine = Ordine::find($request->ordine_id);
+            if (! $ordine || (int) $ordine->attivita_id !== (int) session('attivita_attuale')) {
+                return response()->json(['success' => false, 'message' => 'Ordine non trovato']);
+            }
+
+
+        switch($cupon->stato){
+            case Cupon::GENERATO:
+                $importoValido = null;
+                $message = null;
+
+                if(!$this->checkImporto($cupon, $ordine->prezzo)){
+                    $success = false;
+                    $importoValido = false;
+                    $message = 'Importo del cupon non sufficiente.';
+                }else{
+                    $success = true;
+                    $importoValido = true;
+                    $message = 'Cupon utilizzabile';
+                }
+
+                return response()->json([
+                    'success'    => $success,
+                    'message'    => $message,
+                    'importo'    => $cupon->importo,
+                    'nominativo' => $cupon->nominativo,
+                    'validita_da' => $cupon->validita_da?->format('d/m/Y'),
+                    'validita_a'  => $cupon->validita_a?->format('d/m/Y'),
+                    'oggi' => $oggi = $cupon->validita_da->isSameDay($cupon->validita_a) && $cupon->validita_da->isSameDay(Carbon::today()),
+                ]);
+            case Cupon::USATO:
+                return response()->json(['success' => false, 'message' => 'Cupon già utilizzato']);
+            case Cupon::SCADUTO:
+                return response()->json(['success' => false, 'message' => 'Cupon scaduto', 'validita_a' => $cupon->validita_a?->format('d/m/Y')]);
+            default:
+                return response()->json(['success' => false, 'message' => 'Cupon non trovato']);
+        }
+        }else{
+            return response()->json(['success' => false, 'message' => 'Cupon non trovato']);
+        }
+    }
+
+    public function printCupon(Request $request)
+    {
+        $request->validate([
+            'ids' => 'required|array|min:1',
+            'ids.*' => 'integer',
+            'stampante_id' => 'required|integer|exists:dispositivo,id',
+        ]);
+
+        $attivitaId = Session::get('attivita_attuale');
+        $ids = $request->input('ids', []);
+
+        $stampante = Dispositivo::where('id', $request->stampante_id)
+            ->where('attivita_id', $attivitaId)
+            ->where('tipo', Dispositivo::STAMPANTE)
+            ->first();
+
+        if (! $stampante) {
+            return response()->json([
+                'success' => false,
+                'message' => 'Stampante non valida per questa attività.',
+            ], 422);
+        }
+
+        $cupons = Cupon::where('attivita_id', $attivitaId)
+            ->whereIn('id', $ids)
+            ->get();
+
+        if ($cupons->count() !== count($ids)) {
+            return response()->json([
+                'success' => false,
+                'message' => 'Alcuni cupon selezionati non esistono o non appartengono all\'attività corrente.',
+            ], 422);
+        }
+
+        foreach ($cupons as $cupon) {
+            $printJob = new PrintJob();
+            $printJob->fill([
+                'printable_id' => $cupon->id,
+                'tipo' => PrintJob::TIPO_CUPON,
+                'stampante_id' => $stampante->id,
+                'stato' => PrintJob::STATO_IN_ATTESA,
+                'payload' => null,
+            ]);
+            $printJob->save();
+            ElaboraJobStampa::dispatch($printJob->id);
+        }
+
+        return response()->json([
+            'success' => true,
+            'message' => 'Stampa inviata: '.$cupons->count().' cupon in coda.',
+            'count' => $cupons->count(),
+        ]);
+    }
+
+    public function checklistCupon(Request $request)
+    {
+        $attivitaId = Session::get('attivita_attuale');
+        $cupons = $this->cuponsSelezionati($request);
+
+        $stati = Cupon::getStati();
+        $statoKey = $request->input('stato');
+        $statoLabel = $statoKey
+            ? ($stati[$statoKey]['label'] ?? $statoKey)
+            : 'Tutti';
+
+        $filtri = [
+            'Codice' => $request->filled('codice') ? strtoupper($request->input('codice')) : '—',
+            'Solo validi oggi' => $request->boolean('oggi') ? 'Sì' : 'No',
+            'Validità da' => $request->filled('validita_da')
+                ? Carbon::parse($request->input('validita_da'))->format('d/m/Y')
+                : '—',
+            'Validità a' => $request->filled('validita_a')
+                ? Carbon::parse($request->input('validita_a'))->format('d/m/Y')
+                : '—',
+            'Stato' => $statoLabel,
+            'Tag' => $request->filled('tag') ? $request->input('tag') : '—',
+            'Limite' => $request->filled('limite') ? $request->input('limite') : '—',
+        ];
+
+        return Pdf::loadView('cupon.checklist', [
+            'cupons' => $cupons,
+            'nomeAttivita' => Attivita::find($attivitaId)?->nome ?? '',
+            'filtri' => $filtri,
+            'generatoIl' => Carbon::now()->format('d/m/Y H:i'),
+            'totale' => $cupons->count(),
+            'stati' => $stati,
+        ])->setPaper('a4', 'portrait')->download('checklist-cupon.pdf');
+    }
+
+    /**
+     * Cupon selezionati da ids[] (stampa PDF / checklist), scoped all'attività corrente.
+     */
+    private function cuponsSelezionati(Request $request)
+    {
+        $ids = array_values(array_filter((array) $request->input('ids', [])));
+        if (empty($ids)) {
+            abort(422, 'Nessun cupon selezionato.');
+        }
+
+        $cupons = Cupon::where('attivita_id', Session::get('attivita_attuale'))
+            ->whereIn('id', $ids)
+            ->orderBy('codice')
+            ->get();
+
+        if ($cupons->isEmpty()) {
+            abort(404, 'Nessun cupon trovato.');
+        }
+
+        return $cupons;
+    }
+
+//PRIVATE
+    private function generaCupon($data)
+    {
+        $codice = $this->generaCodiceCupon();
+        while (Cupon::where('codice', $codice)->exists()) {
+            $codice = $this->generaCodiceCupon();
+        }
+
+        Cupon::create([
+            'attivita_id' => Session::get('attivita_attuale'),
+            'codice' => $codice,
+            'importo' => $data['importo'],
+            'validita_da' => $data['validita_da'],
+            'validita_a' => $data['validita_a'],
+            'stato' => Cupon::GENERATO,
+            'nominativo' => $data['nominativo']?? '',
+            'email' => $data['email']?? '',
+        ]);
+    }
+
+    /**
+     * Codice a prova di dettatura (5 caratteri): mix lettere + numeri.
+     * Esclusi: 0/O, 1/I/L, 5/S, 8/B, 2/Z.
+     */
+    public function generaCodiceCupon(int $length = 5): string
+    {
+        $lettere = 'ACDEFGHJKMNPQRTUVWXY';
+        $numeri = '34679';
+        $chars = $lettere.$numeri;
+
+        // Almeno 2 numeri e il resto lettere, poi shuffle (sempre 5 caratteri)
+        $numCount = min(2, $length - 1);
+        $letterCount = $length - $numCount;
+
+        $codice = '';
+        for ($i = 0; $i < $letterCount; $i++) {
+            $codice .= $lettere[random_int(0, strlen($lettere) - 1)];
+        }
+        for ($i = 0; $i < $numCount; $i++) {
+            $codice .= $numeri[random_int(0, strlen($numeri) - 1)];
+        }
+
+        return str_shuffle($codice);
+    }
+
+    private function checkImporto(Cupon $cupon, $importo){
+        if($cupon->importo >= $importo  ){
+            return true;
+        }
+        return false;
+    }
+
+
+}

app/Http/Controllers/DispositivoController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Dispositivo;
 use App\DataTables\DispositivoDataTable;
 use App\DataTables\DispositivoDataTableEditor;
 use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Session;
 
 
 class DispositivoController extends Controller
     
     public function index(DispositivoDataTable $dataTable)
     {
+        $dataTable->attivita_id = Session::get('attivita_attuale');
         return $dataTable->render('dispositivo.index');
     }
     public function store(DispositivoDataTableEditor $editor)

app/Http/Controllers/EndpointController.php

 
 namespace App\Http\Controllers;
 
+
+use App\Models\Endpoint;
+use App\Models\PrintJob;
+use App\Models\Attivita;
+use App\Models\Dispositivo;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Log;
 use Illuminate\Support\Facades\Http;
-use App\Models\Endpoint;
-use App\Models\Dispositivo;
-use App\Models\PrintJob;
-use App\DataTables\EndpointDataTable;
+use Illuminate\Routing\Controllers\Middleware;
 use App\DataTables\EndpointDataTableEditor;
+use App\DataTables\EndpointDataTable;
 use Illuminate\Support\Facades\Validator;
-use App\Models\Attivita;
-use Illuminate\Support\Str;
 use Illuminate\Support\Facades\Session;
-use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Str;
+use App\Services\Attivita\AttivitaService;
 
 class EndpointController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-endpoint', only: ['index', 'show', 'istruzioni']),
+            new Middleware('permission:view-endpoint', only: ['index', 'show', 'istruzioni', 'download_festagent']),
             new Middleware('permission:create-endpoint|edit-endpoint|delete-endpoint', only: ['store', 'update', 'destroy']),
-            new Middleware('permission:create-endpoint', only: ['richiedi_nuovo_product_key']),
+            new Middleware('permission:create-endpoint', only: ['richiedi_nuovo_product_key', 'collega_questo_pc']),
         ];
     }
 
             abort(404);
         }
 
+        AttivitaService::garantisciAttivita($endpoint->attivita_id);
+        
         return view('endpoint.show', compact('endpoint'));
     }
 
     //deeplink
     public function collega_questo_pc(Request $request)
     {
-        $endpoint = Endpoint::where('attivita_id', Session::get('attivita_attuale'))
+        $attivitaId = Session::get('attivita_attuale');
+        AttivitaService::garantisciAttivita($attivitaId);
+
+        $endpoint = Endpoint::where('attivita_id', $attivitaId)
         ->where('user_id', $request->user()->id)
         ->where('status', Endpoint::NON_REGISTRATO)
         ->first();
         }else{
 
         $endpoint = new Endpoint();
-        $endpoint->attivita_id = $request->attivita_id;
+        $endpoint->attivita_id = $attivitaId;
         $endpoint->user_id = $request->user()->id;
         $endpoint->deeplink_token = ['token' => Str::random(32) , 'timestamp' => now()->timestamp , 'status' => 'pending'];
         $endpoint->product_key = $this->creaProductKey();
             'message' => 'Endpoint collegato con successo',
             'status' => 'success',
             'success' => true,
-            'endpoint' => $endpoint,
+            'endpoint' => $endpoint->makeHidden(['product_key', 'secret', 'deeplink_token', 'token']),
             'url' => url('fest-agent://pair?token=' . $endpoint->deeplink_token['token'] . '&server=' . $server),
         ]);
     }
         }
         $endpoint->update([
             'status' => Endpoint::DISABILITATO,
+            'token' => null,
         ]);
         return response()->json([
             'message' => 'Endpoint disattivato con successo',
             'token' => 'required|string|max:255',
         ]);
         $endpoint = Endpoint::where('deeplink_token->token', $request->token)->first();
+
+        //Se non c'è return
         if(!$endpoint){
             return response()->json(['message' => 'Endpoint non trovato', 'status' => 'error', 'success' => false], 404);
         }
+
+        // Se scaduto dopo 10 minuti return
+        if($endpoint->deeplink_token['timestamp'] < now()->subMinutes(10)->timestamp){
+            $endpoint->deeplink_token['status'] = 'expired';
+            $endpoint->save();
+            return response()->json(['message' => 'Token scaduto', 'status' => 'error', 'success' => false], 400);
+        }
+
+        //Se già usato return
+        if($endpoint->deeplink_token['status'] == 'paired'){
+            return response()->json(['message' => 'Endpoint già registrato', 'status' => 'error', 'success' => false], 400);
+        }
+
+
         $deeplink_token = $endpoint->deeplink_token;
         $deeplink_token['status'] = 'paired';
         $endpoint->update([
-            'deeplink_token' => $deeplink_token,
+            'deeplink_token' => '',//$deeplink_token,
             'status' => Endpoint::REGISTRATO,
             'token' => Str::random(32),
         ]);
             'message' => 'Endpoint registrato con successo',
             'status' => 'success',
             'success' => true,
-            'endpoint' => $endpoint,
+            'endpoint' => $endpoint->makeHidden(['product_key', 'secret', 'deeplink_token']),
             'token' => $endpoint->token,
         ]);
     }
 
     public function stampanti_register(Request $request)
     {
-        Log::info('stampanti_register');
-        Log::info($request->all());
+        // Log::info('stampanti_register');
+        // Log::info($request->all());
 
         $stampanti_da_registrare = $request->input('stampanti', []);
         $endpoint = $request->endpoint;
     public function esito_stampa(Request $request)
 {
     $request->validate([
-        'printJob_id' => 'required|integer|exists:print_job,id',
+        'printJob_id' => 'required|integer',
         'esito' => 'required|string|in:success,error',
     ]);
 
     $printJob = PrintJob::query()
         ->whereKey($request->printJob_id)
+        ->whereIn(
+            'stampante_id',
+            $request->endpoint->stampanti()->pluck('id')
+        )
         ->first();
 
     if (! $printJob) {
                     break;
             }
         }
+        if (in_array($request->input('action'), ['edit', 'remove'], true)) {
+            foreach (array_keys($request->input('data', [])) as $id) {
+                AttivitaService::garantisciAttivita(Endpoint::find($id)?->attivita_id);
+            }
+        }
+
         return $editor->process($request);
     }
     public function index_api(Request $request)
     {
-        $endpoints = Endpoint::all();
+        if($request->attivita_id){
+            $attivita_id = $request->attivita_id;
+        }else{
+            return response()->json([
+                'message' => 'Attività non trovata',
+                'status' => 'error',
+                'success' => false,
+            ], 404);
+        }
+        AttivitaService::api_garantisciAttivita($attivita_id);
+
+        $endpoints = Endpoint::where('attivita_id', $attivita_id)->get()->makeHidden(['product_key', 'secret', 'deeplink_token','token']);
         return response()->json([
          'message' => 'Endpoint trovati con successo',
          'count' => $endpoints->count(),
 
         if($request->has('first_time') && $request->first_time == true){
             //la prima registrazione
-            Log::info('api_register_product_key');
-            Log::info('FIRST TIME');
-            Log::info('Request: ' . json_encode($request->all()));
+            // Log::info('api_register_product_key');
+            // Log::info('FIRST TIME');
+            // Log::info('Request: ' . json_encode($request->all()));
         $validator = Validator::make($request->all(), [
-            'product_key' => 'required|string|max:25,exists:endpoint,product_key',
+            'product_key' => 'required|string|max:25|exists:endpoint,product_key',
         ], [
             'product_key.required' => 'Il product key è richiesto',
             'product_key.string' => 'Il product key deve essere una stringa',
 
         if($validator->fails()){
             Log::error('api_register_product_key');
-            Log::error('Request: ' . $request->all());
+            // Log::error('Request: ' . $request->all());
             Log::error('Validator fails: ' . $validator->messages());
             return response()->json([
                 'message' => $validator->messages(),
                 'status' => 'error',
                 'success' => false,
             ], 404);
-        }elseif($endpoint->status == Endpoint::REGISTRATO){
-            Log::error('Endpoint già registrato');
+        }elseif($endpoint->status != Endpoint::NON_REGISTRATO){
             return response()->json([
-                'message' => 'Endpoint già registrato',
+                'message' => 'Endpoint non può essere registrato',
                 'status' => 'error',
                 'success' => false,
             ], 400);
             'message' => 'Endpoint trovato con successo',
             'status' => 'success',
             'success' => true,
-            'endpoint' => $endpoint,
+            'endpoint' => $endpoint->makeHidden(['product_key', 'secret', 'deeplink_token','token']),
             'licenza' => $licenza??null,
             'attivita' => $attivita??null,
         ]);
         //se non è la prima registrazione può modificare gli attributi dell'endpoint
         Log::info('api_register_product_key');
         Log::info('NOT ft');
-        Log::info('Request: ' . json_encode($request->all()));
+        // Log::info('Request: ' . json_encode($request->all()));
         // dd($request->all() , 'NOT ft');
 
         $validator = Validator::make($request->all(), [
             'label' => 'required|string|max:255',
             'descrizione' => 'nullable|string|max:255',
             'ubicazione' => 'nullable|string|max:255',
+            'product_key' => 'nullable|string|max:25|exists:endpoint,product_key',
         ], [
             'label.required' => 'Il label è richiesto',
             'label.string' => 'Il label deve essere una stringa',
             'descrizione.max' => 'La descrizione deve essere lungo al massimo 255 caratteri',
             'ubicazione.string' => 'L\'ubicazione deve essere una stringa',
             'ubicazione.max' => 'L\'ubicazione deve essere lungo al massimo 255 caratteri',
+            'product_key.string' => 'Il product key deve essere una stringa',
+            'product_key.max' => 'Il product key deve essere lungo al massimo 25 caratteri',
+            'product_key.exists' => 'Il product key non è valido',
         ]);
 
         if($validator->fails()){
         $endpoint = Endpoint::where('product_key', $request->product_key)->where('status', Endpoint::REGISTRATO)->first();
         if(!$endpoint){
             Log::error('Endpoint non trovato');
-            Log::error('Request: ' . json_encode($request->all()));
+            // Log::error('Request: ' . json_encode($request->all()));
             return response()->json([
                 'message' => 'Endpoint non trovato',
                 'status' => 'error',
             'message' => 'Endpoint aggiornato con successo',
             'status' => 'success',
             'success' => true,
-            'endpoint' => $endpoint,
+            'endpoint' => $endpoint->makeHidden(['product_key', 'secret', 'deeplink_token','token']),
             'token' => $endpoint->token,
         ]);
 
             'attivita_id.exists' => 'L\'attività non è valida',
         ]);
 
+        AttivitaService::garantisciAttivita($request->attivita_id);
 
         $attivita = Attivita::find($request->attivita_id);
         
 
     public function download_festagent(Request $request)
     {
+        $filePath = '001_fest.exe';
+
+        if (!Storage::disk('festAgent')->exists($filePath)) {
+            abort(404, 'Il file richiesto non esiste.');
+        }
+   
         return Storage::disk('festAgent')->download('001_fest.exe', '001_fest.exe');   
     }
 }

app/Http/Controllers/EventoController.php

 
 use Illuminate\Http\Request;
 use App\Models\Evento;
+use App\Models\EventoForm;
+use App\Models\OpzioneForm;
+use App\Models\Prenotazione;
 use App\DataTables\EventoDataTable;
 use App\DataTables\EventoDataTableEditor;
 use Illuminate\Support\Facades\Auth;
-use App\DataTables\EventoFormDataTable;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Routing\Controllers\Middleware;
+use Illuminate\Support\Facades\Session;
+use Illuminate\Support\Str;
+use App\Services\Attivita\AttivitaService;
 
 
 class EventoController extends Controller
         'delete-evento' => 'Elimina',
     ];
 
+    // ADMIN
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-evento', only: ['index']),
-            new Middleware('permission:create-evento|edit-evento|delete-evento', only: ['store', 'update', 'destroy']),
+            new Middleware('permission:view-evento', only: ['index', 'admin_show']),
+            new Middleware('permission:create-evento|edit-evento|delete-evento', only: [
+                'store', 'update', 'destroy', 'crea', 'edit', 'geocodeLuogo',
+                'gallery_edit', 'gallery_upload',
+                'applicaPresetDomande',
+                'storeDomanda', 'updateDomanda', 'destroyDomanda', 'reorderDomande',
+                'uploadLocandina', 'destroyLocandina', 'uploadCopertina', 'destroyCopertina',
+            ]),
         ];
     }
 
+    // ADMIN
     public function index(EventoDatatable $dataTable)
     {
-        return $dataTable->render('evento.index');
+      $dataTable->attivita_id = Session::get('attivita_attuale');
+      return $dataTable->render('evento.index', [
+        'attivita_id' => Session::get('attivita_attuale'),
+      ]);
     }
+
+    // ADMIN
     public function store(EventoDataTableEditor $editor)
     {
         $request = request();
         return $editor->process($request);
     }
 
-    public function show(Request $request)
+    // ADMIN — cruscotto evento
+    public function admin_show(Request $request)
     {
-      // dd($request->all());
-        $evento = Evento::find($request->get('evento_id'));
+        $evento = Evento::with([
+            'attivita',
+            'sale.tavoli' => fn ($q) => $q->where('is_attivo', true),
+        ])->find($request->get('evento_id'));
+
+        if (! $evento) {
+            return redirect()->route('evento.index')->with('error', 'Evento non trovato');
+        }
+        
+        AttivitaService::garantisciEventoDiQuestaAttivita($evento);
+
+        $prenotazioni = $evento->prenotazioni()
+            ->whereNotIn('stato', [
+                Prenotazione::STATO_CANCELLATA,
+                Prenotazione::STATO_ANNULLATA,
+                Prenotazione::STATO_RIFIUTATA,
+            ]);
+
+        $galleria = is_array(json_decode($evento->galleria, true))
+            ? json_decode($evento->galleria, true)
+            : [];
+
+        $disk = Storage::disk('eventi');
+        $locandinaUrl = null;
+        if (filled($evento->immagine) && $disk->exists($evento->immagine)) {
+            $locandinaUrl = $disk->url($evento->immagine).'?v='.$disk->lastModified($evento->immagine);
+        }
+
+        $postiEvento = $evento->posti !== null ? (int) $evento->posti : null;
+        $postiPiantina = (int) $evento->sale->sum(fn ($sala) => $sala->tavoli->sum('posti'));
+        $tavoliCount = (int) $evento->sale->sum(fn ($sala) => $sala->tavoli->count());
+        $alertPosti = null;
+        if ($postiEvento !== null && $postiPiantina !== $postiEvento) {
+            $alertPosti = [
+                'tipo' => $postiPiantina < $postiEvento ? 'warning' : 'info',
+                'posti_evento' => $postiEvento,
+                'posti_piantina' => $postiPiantina,
+            ];
+        }
+
+        $stats = [
+            'prenotazioni' => (clone $prenotazioni)->count(),
+            'confermate' => (clone $prenotazioni)->where('confermata', true)->count(),
+            'coperti_confermati' => (int) $evento->getCopertiConfermati(),
+            'posti' => $postiEvento,
+            'posti_piantina' => $postiPiantina,
+            'tavoli' => $tavoliCount,
+            'galleria' => count($galleria),
+            'prenotabile' => $evento->isPrenotabileOra(),
+            'messaggio_prenotazione' => $evento->messaggioStatoPrenotazione(),
+        ];
+
+        return view('evento.admin_show', [
+            'evento' => $evento,
+            'stats' => $stats,
+            'alertPosti' => $alertPosti,
+            'locandinaUrl' => $locandinaUrl,
+            'stati' => Evento::stati(),
+        ]);
+    }
+
+    // CLIENTE — scheda pubblica evento
+    public function show(string $codice)
+    {
+        $evento = Evento::with('attivita')->where('codice', $codice)->first();
+
+        if (! $evento || ! $evento->isVisibilePublicamente()) {
+            return redirect()->route('welcome')->with('error', 'Evento non trovato o non disponibile.');
+        }
+
+        $galleriaItems = is_array(json_decode($evento->galleria, true)) ? json_decode($evento->galleria, true) : [];
+
         return view('evento.show', [
-          'evento' => $evento , 
-          'galleriaItems' => is_array(json_decode($evento->galleria, true)) ? json_decode($evento->galleria, true) : []]);
+            'evento' => $evento,
+            'galleriaItems' => $galleriaItems,
+            'prenotabileOra' => $evento->isPrenotabileOra(),
+            'messaggioPrenotazione' => $evento->messaggioStatoPrenotazione(),
+        ]);
+    }
+
+    // CLIENTE — redirect da ?evento_id=… alla scheda pubblica con codice
+    public function showLegacy(Request $request)
+    {
+        $evento = Evento::find($request->get('evento_id'));
+        if (! $evento) {
+            return redirect()->route('welcome')->with('error', 'Evento non trovato o non disponibile.');
+        }
+
+        return redirect()->route('evento.show', ['codice' => $evento->publicCodice()]);
     }
 
+    // ADMIN
     public function gallery_edit(Request $request)
     {
       $evento = Evento::find($request->get('evento_id'));
+      if(!$evento) return redirect()->route('evento.index')->with('error', 'Evento non trovato');
+      AttivitaService::garantisciEventoDiQuestaAttivita($evento);
 
       return view('evento.gallery.edit', [
           'evento' => $evento,
       ]);
     }
 
+    // ADMIN
     public function gallery_upload(Request $request)
     {
       $evento = Evento::find($request->get('evento_id'));
+      if(!$evento) return redirect()->route('evento.index')->with('error', 'Evento non trovato');
+      AttivitaService::garantisciEventoDiQuestaAttivita($evento);
+
       $galleria = json_decode($evento->galleria);
       if($galleria == null) $galleria = [];
       $nome = $request->file('file')->getClientOriginalName();
       return redirect()->route('evento.gallery.edit', ['evento_id' => $evento->id])->with('success', 'Foto aggiunta con successo');
     }
 
-    public function edit(Request $request , EventoFormDataTable $dataTable)
+    // ADMIN
+    public function edit(Request $request)
     {
-      $evento = Evento::find($request->get('evento_id'));
-      $dataTable->evento_id = $evento->id;
-      return $dataTable->render('evento.edit', compact('evento'));
+      $evento = Evento::with(['attivita', 'form' => function ($q) {
+        $q->orderBy('ordine_visualizzazione')->orderBy('id')->with(['opzioni_form' => function ($oq) {
+          $oq->orderBy('ordine')->orderBy('id');
+        }]);
+      }])->find($request->get('evento_id'));
+
+      if (! $evento) {
+        return redirect()->route('evento.index')->with('error', 'Evento non trovato');
+      }
+
+      AttivitaService::garantisciEventoDiQuestaAttivita($evento);
+
+      // Se non ci sono domande, applica subito il set "pasto" così sono visibili
+      if ($evento->form->isEmpty()) {
+        $this->applyDomandePreset($evento, 'pasto');
+        $evento->load(['form' => function ($q) {
+          $q->orderBy('ordine_visualizzazione')->orderBy('id')->with(['opzioni_form' => function ($oq) {
+            $oq->orderBy('ordine')->orderBy('id');
+          }]);
+        }]);
+      }
+
+      return view('evento.edit', compact('evento'));
     }
 
+    // ADMIN
+    public function crea(Request $request)
+    {
+      $attivitaId = Session::get('attivita_attuale');
+      if (! (int) $attivitaId) {
+        abort(404);
+      }
+      AttivitaService::garantisciAttivita($attivitaId);
+
+      $nome = $request->get('nome');
+      $evento = Evento::create([
+        'nome' => $nome,
+        'attivita_id' => $attivitaId,
+        'is_attivo' => false,
+        'codice' => Str::random(30),
+      ]);
+
+      $this->applyDomandePreset($evento, 'pasto');
+
+      return redirect()->route('evento.edit', ['evento_id' => $evento->id, 'tab' => 'prenotazione']);
+    }
+
+    // ADMIN
+    public function applicaPresetDomande(Request $request)
+    {
+        $request->validate([
+            'evento_id' => 'required|exists:evento,id',
+            'preset' => 'required|string|in:allergie,orario,bambini,pasto',
+        ]);
+
+        if (! Auth::user()->can('edit-evento') && ! Auth::user()->can('create-evento')) {
+            abort(403);
+        }
+
+        $evento = Evento::findOrFail($request->evento_id);
+        if(!$evento) return redirect()->route('evento.index')->with('error', 'Evento non trovato');
+        AttivitaService::garantisciEventoDiQuestaAttivita($evento);
+
+        $result = $this->applyDomandePreset($evento, $request->input('preset'));
+
+        $message = $result['aggiunte'] > 0
+            ? "Aggiunte {$result['aggiunte']} domande".($result['saltate'] > 0 ? " ({$result['saltate']} già presenti, saltate)" : '')
+            : 'Nessuna domanda aggiunta: risultano già presenti.';
+
+        return redirect()
+            ->route('evento.edit', ['evento_id' => $evento->id, 'tab' => 'prenotazione'])
+            ->with('success', $message);
+    }
+
+    // ADMIN
+    public function storeDomanda(Request $request)
+    {
+        $data = $this->validateDomanda($request);
+        $evento = Evento::findOrFail($data['evento_id']);
+        if(!$evento) return redirect()->route('evento.index')->with('error', 'Evento non trovato');
+        AttivitaService::garantisciEventoDiQuestaAttivita($evento);
+
+        if (! Auth::user()->can('edit-evento') && ! Auth::user()->can('create-evento')) {
+            abort(403);
+        }
+
+        DB::transaction(function () use ($evento, $data) {
+            $ordine = (int) EventoForm::where('evento_id', $evento->id)->max('ordine_visualizzazione') + 1;
+            $form = EventoForm::create([
+                'evento_id' => $evento->id,
+                'label' => $data['label'],
+                'descrizione' => $data['descrizione'] ?? null,
+                'tipo' => $data['tipo'],
+                'obbligatoria' => (bool) ($data['obbligatoria'] ?? false),
+                'per_coperto' => (bool) ($data['per_coperto'] ?? false),
+                'nascosta' => false,
+                'nascondi_se_auth' => false,
+                'ordine_visualizzazione' => $ordine,
+            ]);
+            $this->syncOpzioniDomanda($form, $data);
+        });
+
+        return redirect()
+            ->route('evento.edit', ['evento_id' => $evento->id, 'tab' => 'prenotazione'])
+            ->with('success', 'Domanda aggiunta.');
+    }
+
+    // ADMIN
+    public function updateDomanda(Request $request, $domanda_id)
+    {
+        $form = EventoForm::findOrFail($domanda_id);
+        if(!$form) return redirect()->route('evento.index')->with('error', 'Domanda non trovata');
+        AttivitaService::garantisciEventoDiQuestaAttivita($form->evento);
+        
+        $data = $this->validateDomanda($request, $form);
+
+        if (! Auth::user()->can('edit-evento')) {
+            abort(403);
+        }
+
+        if ((int) $form->evento_id !== (int) $data['evento_id']) {
+            abort(422, 'Domanda non valida per questo evento.');
+        }
+
+        DB::transaction(function () use ($form, $data) {
+            $form->update([
+                'label' => $data['label'],
+                'descrizione' => $data['descrizione'] ?? null,
+                'tipo' => $data['tipo'],
+                'obbligatoria' => (bool) ($data['obbligatoria'] ?? false),
+                'per_coperto' => (bool) ($data['per_coperto'] ?? false),
+            ]);
+            $this->syncOpzioniDomanda($form, $data);
+        });
+
+        return redirect()
+            ->route('evento.edit', ['evento_id' => $form->evento_id, 'tab' => 'prenotazione'])
+            ->with('success', 'Domanda aggiornata.');
+    }
+
+    // ADMIN
+    public function destroyDomanda(Request $request, $domanda_id)
+    {
+        $form = EventoForm::findOrFail($domanda_id);
+        if(!$form) return redirect()->route('evento.index')->with('error', 'Domanda non trovata');
+        AttivitaService::garantisciEventoDiQuestaAttivita($form->evento);
+
+        if (! Auth::user()->can('edit-evento') && ! Auth::user()->can('delete-evento')) {
+            abort(403);
+        }
+
+        $eventoId = $form->evento_id;
+        $form->delete(); // cascade su opzioni e risposte
+
+        return redirect()
+            ->route('evento.edit', ['evento_id' => $eventoId, 'tab' => 'prenotazione'])
+            ->with('success', 'Domanda eliminata.');
+    }
+
+    // ADMIN
+    public function reorderDomande(Request $request)
+    {
+        $data = $request->validate([
+            'evento_id' => 'required|exists:evento,id',
+            'ordine' => 'required|array|min:1',
+            'ordine.*' => 'integer|exists:evento_form,id',
+        ]);
+
+        if (! Auth::user()->can('edit-evento')) {
+            abort(403);
+        }
+
+        $eventoId = (int) $data['evento_id'];
+        if(!$eventoId) return redirect()->route('evento.index')->with('error', 'Evento non trovato');
+        AttivitaService::garantisciEventoDiQuestaAttivita(Evento::find($eventoId));
+        
+        $ids = array_map('intval', $data['ordine']);
+
+        $validIds = EventoForm::where('evento_id', $eventoId)
+            ->whereIn('id', $ids)
+            ->pluck('id')
+            ->map(fn ($id) => (int) $id)
+            ->all();
+
+        if (count($validIds) !== count($ids) || count(array_diff($ids, $validIds)) > 0) {
+            return response()->json(['message' => 'Ordine non valido per questo evento.'], 422);
+        }
+
+        DB::transaction(function () use ($ids) {
+            foreach ($ids as $index => $id) {
+                EventoForm::where('id', $id)->update([
+                    'ordine_visualizzazione' => $index + 1,
+                ]);
+            }
+        });
+
+        return response()->json(['ok' => true]);
+    }
+
+    // ADMIN (helper)
+    private function validateDomanda(Request $request, ?EventoForm $existing = null): array
+    {
+        $tipi = [
+            EventoForm::TESTO,
+            EventoForm::NUMERO,
+            EventoForm::CHECKBOX,
+            EventoForm::SELEZIONE,
+            EventoForm::MULTISELEZIONE,
+        ];
+
+        return $request->validate([
+            'evento_id' => 'required|exists:evento,id',
+            'label' => 'required|string|max:255',
+            'descrizione' => 'nullable|string|max:1000',
+            'tipo' => 'required|in:'.implode(',', $tipi),
+            'obbligatoria' => 'nullable|boolean',
+            'per_coperto' => 'nullable|boolean',
+            'opzioni_testo' => 'nullable|string',
+        ]);
+    }
+
+    // ADMIN (helper)
+    private function syncOpzioniDomanda(EventoForm $form, array $data): void
+    {
+        $needsOpzioni = in_array($form->tipo, [EventoForm::SELEZIONE, EventoForm::MULTISELEZIONE], true);
+
+        if (! $needsOpzioni) {
+            OpzioneForm::where('evento_form_id', $form->id)->delete();
+            return;
+        }
+
+        $lines = preg_split('/\r\n|\r|\n/', (string) ($data['opzioni_testo'] ?? '')) ?: [];
+        $labels = array_values(array_filter(array_map('trim', $lines), fn ($l) => $l !== ''));
+
+        OpzioneForm::where('evento_form_id', $form->id)->delete();
+        foreach ($labels as $i => $label) {
+            OpzioneForm::create([
+                'evento_form_id' => $form->id,
+                'label' => $label,
+                'ordine' => $i + 1,
+            ]);
+        }
+    }
+
+    // ADMIN (helper)
+    /**
+     * @return array{aggiunte:int,saltate:int}
+     */
+    private function applyDomandePreset(Evento $evento, string $preset): array
+    {
+        $definitions = $this->domandePresetDefinitions($preset);
+        $aggiunte = 0;
+        $saltate = 0;
+
+        DB::transaction(function () use ($evento, $definitions, &$aggiunte, &$saltate) {
+            $ordine = (int) EventoForm::where('evento_id', $evento->id)->max('ordine_visualizzazione');
+
+            foreach ($definitions as $def) {
+                $exists = EventoForm::where('evento_id', $evento->id)
+                    ->where('label', $def['label'])
+                    ->exists();
+
+                if ($exists) {
+                    $saltate++;
+                    continue;
+                }
+
+                $ordine++;
+                $form = EventoForm::create([
+                    'evento_id' => $evento->id,
+                    'label' => $def['label'],
+                    'descrizione' => $def['descrizione'] ?? null,
+                    'tipo' => $def['tipo'],
+                    'obbligatoria' => (bool) ($def['obbligatoria'] ?? false),
+                    'nascosta' => false,
+                    'nascondi_se_auth' => false,
+                    'ordine_visualizzazione' => $ordine,
+                ]);
+
+                foreach ($def['opzioni'] ?? [] as $i => $opzioneLabel) {
+                    OpzioneForm::create([
+                        'evento_form_id' => $form->id,
+                        'label' => $opzioneLabel,
+                        'ordine' => $i + 1,
+                    ]);
+                }
+
+                $aggiunte++;
+            }
+        });
+
+        return ['aggiunte' => $aggiunte, 'saltate' => $saltate];
+    }
+
+    // ADMIN (helper)
+    private function domandePresetDefinitions(string $preset): array
+    {
+        return match ($preset) {
+            'allergie' => [
+                [
+                    'label' => 'Allergie o intolleranze',
+                    'descrizione' => 'Indica eventuali allergie o intolleranze alimentari',
+                    'tipo' => EventoForm::TESTO,
+                    'obbligatoria' => false,
+                ],
+            ],
+            'orario' => [
+                [
+                    'label' => 'Preferenza orario',
+                    'descrizione' => 'Scegli la fascia preferita',
+                    'tipo' => EventoForm::SELEZIONE,
+                    'obbligatoria' => true,
+                    'opzioni' => ['Pranzo', 'Cena'],
+                ],
+            ],
+            'bambini' => [
+                [
+                    'label' => 'Quanti bambini?',
+                    'descrizione' => 'Numero di bambini nel gruppo (0 se nessuno)',
+                    'tipo' => EventoForm::NUMERO,
+                    'obbligatoria' => false,
+                ],
+            ],
+            'pasto' => [
+                [
+                    'label' => 'Preferenza orario',
+                    'descrizione' => 'Scegli la fascia preferita',
+                    'tipo' => EventoForm::SELEZIONE,
+                    'obbligatoria' => true,
+                    'opzioni' => ['Pranzo', 'Cena'],
+                ],
+                [
+                    'label' => 'Allergie o intolleranze',
+                    'descrizione' => 'Indica eventuali allergie o intolleranze alimentari',
+                    'tipo' => EventoForm::TESTO,
+                    'obbligatoria' => false,
+                ],
+                [
+                    'label' => 'Quanti bambini?',
+                    'descrizione' => 'Numero di bambini nel gruppo (0 se nessuno)',
+                    'tipo' => EventoForm::NUMERO,
+                    'obbligatoria' => false,
+                ],
+            ],
+            default => [],
+        };
+    }
+
+    // ADMIN
+    public function update(Request $request, $evento_id)
+    {
+        $evento = Evento::findOrFail($evento_id);
+
+        if(!$evento) return redirect()->route('evento.index')->with('error', 'Evento non trovato');
+        AttivitaService::garantisciEventoDiQuestaAttivita($evento);
+
+        if (! Auth::user()->can('edit-evento')) {
+            abort(403);
+        }
+
+        foreach (['descrizione', 'data_inizio', 'data_fine', 'posti', 'prezzo', 'note', 'apertura_prenotazione', 'chiusura_prenotazione', 'tempo_cortesia_ore', 'luogo', 'luogo_lat', 'luogo_lng'] as $field) {
+            if ($request->input($field) === '') {
+                $request->merge([$field => null]);
+            }
+        }
+
+        $stati = implode(',', array_keys(Evento::stati()));
+
+        $data = $request->validate([
+            'nome' => 'required|string|max:255',
+            'descrizione' => 'nullable|string',
+            'stato' => 'required|in:'.$stati,
+            'is_attivo' => 'nullable|boolean',
+            'data_inizio' => 'nullable|date',
+            'data_fine' => 'nullable|date|after_or_equal:data_inizio',
+            'posti' => 'nullable|integer|min:0',
+            'prezzo' => 'nullable|numeric|min:0',
+            'prezzo_fisso' => 'nullable|boolean',
+            'note' => 'nullable|string',
+            'apertura_prenotazione' => 'nullable|date',
+            'chiusura_prenotazione' => 'nullable|date|after_or_equal:apertura_prenotazione',
+            'tempo_cortesia_ore' => 'nullable|integer|min:0|max:8760',
+            'conferma_automatica' => 'nullable|boolean',
+            'nascondi_posti_disponibili' => 'nullable|boolean',
+            'cliente_modifica_se_confermata' => 'nullable|boolean',
+            'cliente_annulla_se_confermata' => 'nullable|boolean',
+            'luogo' => 'nullable|string|max:255',
+            'luogo_lat' => 'nullable|numeric|between:-90,90',
+            'luogo_lng' => 'nullable|numeric|between:-180,180',
+            'email_testo_inviata' => 'nullable|string|max:2000',
+            'email_testo_confermata' => 'nullable|string|max:2000',
+        ]);
+
+        $data['prezzo_fisso'] = $request->boolean('prezzo_fisso');
+        $data['is_attivo'] = $request->boolean('is_attivo');
+
+        if (! $request->filled('apertura_prenotazione') && ! $request->filled('chiusura_prenotazione')) {
+            $data['apertura_prenotazione'] = null;
+            $data['chiusura_prenotazione'] = null;
+        }
+
+        $info = is_array($evento->info) ? $evento->info : [];
+        $info['tempo_cortesia_ore'] = $request->filled('tempo_cortesia_ore')
+            ? (int) $request->input('tempo_cortesia_ore')
+            : null;
+        $info['conferma_automatica'] = $request->boolean('conferma_automatica');
+        $info['nascondi_posti_disponibili'] = $request->boolean('nascondi_posti_disponibili');
+        $info['cliente_modifica_se_confermata'] = $request->boolean('cliente_modifica_se_confermata');
+        $info['cliente_annulla_se_confermata'] = $request->boolean('cliente_annulla_se_confermata');
+        $info['luogo'] = $request->filled('luogo') ? trim((string) $request->input('luogo')) : null;
+        if (! $request->filled('luogo')) {
+            $info['luogo_lat'] = null;
+            $info['luogo_lng'] = null;
+        } else {
+            $info['luogo_lat'] = $request->filled('luogo_lat') ? (float) $request->input('luogo_lat') : null;
+            $info['luogo_lng'] = $request->filled('luogo_lng') ? (float) $request->input('luogo_lng') : null;
+        }
+
+        $testoInviata = trim((string) $request->input('email_testo_inviata', ''));
+        $testoConfermata = trim((string) $request->input('email_testo_confermata', ''));
+        $info['email_testo_inviata'] = $testoInviata !== '' ? $testoInviata : null;
+        $info['email_testo_confermata'] = $testoConfermata !== '' ? $testoConfermata : null;
+
+        $data['info'] = $info;
+
+        unset(
+            $data['tempo_cortesia_ore'],
+            $data['conferma_automatica'],
+            $data['nascondi_posti_disponibili'],
+            $data['cliente_modifica_se_confermata'],
+            $data['cliente_annulla_se_confermata'],
+            $data['luogo'],
+            $data['luogo_lat'],
+            $data['luogo_lng'],
+            $data['email_testo_inviata'],
+            $data['email_testo_confermata']
+        );
+
+        $evento->update($data);
+
+        $tab = $request->input('tab', 'generali');
+        if (! in_array($tab, ['generali', 'kit', 'prenotazione', 'avanzate', 'email'], true)) {
+            $tab = 'generali';
+        }
+
+        return redirect()
+            ->route('evento.edit', ['evento_id' => $evento->id, 'tab' => $tab])
+            ->with('success', 'Evento aggiornato.');
+    }
+
+    // ADMIN
+    public function geocodeLuogo(Request $request)
+    {
+        if (! Auth::user()->can('edit-evento')) {
+            abort(403);
+        }
+
+        $query = trim((string) $request->query('q', ''));
+        if (strlen($query) < 3) {
+            return response()->json([]);
+        }
+
+        $response = Http::withHeaders([
+            'User-Agent' => config('app.name').' ('.config('app.url').')',
+        ])->get('https://nominatim.openstreetmap.org/search', [
+            'format' => 'json',
+            'q' => $query,
+            'limit' => 6,
+            'addressdetails' => 0,
+            'countrycodes' => 'it',
+        ]);
+
+        if (! $response->successful()) {
+            return response()->json([]);
+        }
+
+        $results = collect($response->json())
+            ->map(fn (array $item) => [
+                'label' => $item['display_name'] ?? '',
+                'lat' => isset($item['lat']) ? (float) $item['lat'] : null,
+                'lng' => isset($item['lon']) ? (float) $item['lon'] : null,
+            ])
+            ->filter(fn (array $item) => filled($item['label']))
+            ->values();
+
+        return response()->json($results);
+    }
+
+    // ADMIN
+    public function uploadLocandina(Request $request, $evento_id)
+    {
+        return $this->uploadImmagineEvento($request, $evento_id, 'locandina', 'immagine', 'Locandina aggiornata.');
+    }
+
+    // ADMIN
+    public function destroyLocandina(Request $request, $evento_id)
+    {
+        return $this->destroyImmagineEvento($evento_id, 'immagine', 'Locandina rimossa.');
+    }
+
+    // ADMIN
+    public function uploadCopertina(Request $request, $evento_id)
+    {
+        return $this->uploadImmagineEvento($request, $evento_id, 'copertina', 'copertina', 'Copertina aggiornata.');
+    }
+
+    // ADMIN
+    public function destroyCopertina(Request $request, $evento_id)
+    {
+        return $this->destroyImmagineEvento($evento_id, 'copertina', 'Copertina rimossa.');
+    }
+
+    // ADMIN (helper)
+    private function uploadImmagineEvento(Request $request, $evento_id, string $inputName, string $column, string $message)
+    {
+        $evento = Evento::findOrFail($evento_id);
+        if(!$evento) return redirect()->route('evento.index')->with('error', 'Evento non trovato');
+        AttivitaService::garantisciEventoDiQuestaAttivita($evento);
+        
+        if (! Auth::user()->can('edit-evento')) {
+            abort(403);
+        }
+
+        $request->validate([
+            $inputName => 'required|file|image|mimes:jpeg,png,jpg,gif,webp|max:5120',
+        ]);
+
+        $disk = Storage::disk('eventi');
+        $dir = (string) $evento->id;
+        $ext = strtolower($request->file($inputName)->getClientOriginalExtension() ?: 'jpg');
+        // Nome univoco: evita cache browser sulla stessa URL dopo sostituzione
+        $filename = $column.'_'.time().'_'.Str::random(4).'.'.$ext;
+        $path = $dir.'/'.$filename;
+
+        $oldPath = $evento->{$column};
+        if (filled($oldPath) && $disk->exists($oldPath)) {
+            $disk->delete($oldPath);
+        }
+
+        $disk->makeDirectory($dir);
+        $disk->putFileAs($dir, $request->file($inputName), $filename);
+
+        $evento->{$column} = $path;
+        $evento->save();
+
+        return redirect()
+            ->route('evento.edit', ['evento_id' => $evento->id, 'tab' => 'kit'])
+            ->with('success', $message);
+    }
+
+    // ADMIN (helper)
+    private function destroyImmagineEvento($evento_id, string $column, string $message)
+    {
+        $evento = Evento::findOrFail($evento_id);
+        if(!$evento) return redirect()->route('evento.index')->with('error', 'Evento non trovato');
+        AttivitaService::garantisciEventoDiQuestaAttivita($evento);
+        
+        if (! Auth::user()->can('edit-evento') && ! Auth::user()->can('delete-evento')) {
+            abort(403);
+        }
+
+        $disk = Storage::disk('eventi');
+        if (filled($evento->{$column}) && $disk->exists($evento->{$column})) {
+            $disk->delete($evento->{$column});
+        }
+
+        $evento->{$column} = null;
+        $evento->save();
+
+        return redirect()
+            ->route('evento.edit', ['evento_id' => $evento->id, 'tab' => 'kit'])
+            ->with('success', $message);
+    }
 }

app/Http/Controllers/EventoFormController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\EventoForm;
 use App\Models\Evento;

app/Http/Controllers/EventoPiantinaController.php

+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Evento;
+use App\Models\EventoSala;
+use App\Models\EventoTavolo;
+use App\Models\Prenotazione;
+use App\Models\PrenotazioneAssegnazioneTavolo;
+use App\Services\Attivita\AttivitaService;
+use App\Services\Prenotazione\AssegnaTavoliAutomatico;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controllers\Middleware;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Str;
+
+class EventoPiantinaController extends Controller
+{
+    public static function middleware(): array
+    {
+        return [
+            new Middleware('permission:view-evento', only: ['edit', 'assegnazioni']),
+            new Middleware('permission:edit-evento', only: [
+                'storeSala',
+                'updateSala',
+                'destroySala',
+                'uploadPiantina',
+                'destroyPiantina',
+                'storeTavolo',
+                'updateTavolo',
+                'destroyTavolo',
+                'batchTavoli',
+                'assegna',
+                'assegnaAutomatico',
+                'rimuoviAssegnazione',
+            ]),
+        ];
+    }
+
+    /**
+     * Editor piantina (sala + tavoli).
+     */
+    public function edit(Request $request)
+    {
+        $evento = $this->findEventoOrFail($request->get('evento_id'));
+        $sale = $this->saleList($evento);
+        $sala = $this->resolveSala($request, $evento, $sale);
+        $sala->load(['tavoli' => fn ($q) => $q->orderBy('ordine_in_gruppo')->orderBy('label')]);
+
+        return view('evento.piantina.edit', [
+            'evento' => $evento,
+            'sala' => $sala,
+            'sale' => $sale,
+            'piantinaUrl' => $this->piantinaUrl($sala),
+            'griglia' => $sala->grigliaConfig(),
+        ]);
+    }
+
+    /**
+     * Crea una nuova sala/zona per l'evento.
+     */
+    public function storeSala(Request $request, int $evento_id)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $data = $request->validate([
+            'nome' => 'nullable|string|max:255',
+        ]);
+
+        $ordine = (int) $evento->sale()->max('ordine');
+        $sala = EventoSala::create([
+            'evento_id' => $evento->id,
+            'nome' => filled($data['nome'] ?? null) ? trim($data['nome']) : 'Nuova sala',
+            'ordine' => $ordine + 1,
+        ]);
+
+        return redirect()
+            ->route('evento.piantina.edit', $this->piantinaParams($evento, $sala))
+            ->with('success', 'Sala creata.');
+    }
+
+    /**
+     * Aggiorna metadati sala (nome, dimensioni).
+     */
+    public function updateSala(Request $request, int $evento_id)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $sala = $this->resolveSala($request, $evento);
+
+        $data = $request->validate([
+            'nome' => 'sometimes|nullable|string|max:255',
+            'larghezza' => 'sometimes|nullable|integer|min:1|max:20000',
+            'altezza' => 'sometimes|nullable|integer|min:1|max:20000',
+            'griglia_attiva' => 'nullable|boolean',
+            'griglia_modalita' => 'nullable|string|in:celle,libera',
+            'griglia_cols' => 'nullable|integer|min:1|max:40',
+            'griglia_rows' => 'nullable|integer|min:1|max:40',
+            'griglia_margin_top' => 'nullable|numeric|between:0,40',
+            'griglia_margin_right' => 'nullable|numeric|between:0,40',
+            'griglia_margin_bottom' => 'nullable|numeric|between:0,40',
+            'griglia_margin_left' => 'nullable|numeric|between:0,40',
+            'griglia_inset' => 'nullable|numeric|between:0,40',
+            'griglia_inset_v' => 'nullable|numeric|between:0,40',
+            'griglia_colonne' => 'nullable|string|max:255',
+        ]);
+
+        if ($request->exists('nome')) {
+            $sala->nome = filled($data['nome'] ?? null) ? trim($data['nome']) : null;
+        }
+        if ($request->exists('larghezza')) {
+            $sala->larghezza = $data['larghezza'] ?? null;
+        }
+        if ($request->exists('altezza')) {
+            $sala->altezza = $data['altezza'] ?? null;
+        }
+
+        $info = is_array($sala->info) ? $sala->info : [];
+        $prev = is_array($info['griglia'] ?? null) ? $info['griglia'] : [];
+        $modalita = $data['griglia_modalita'] ?? ($prev['modalita'] ?? 'libera');
+        if (! in_array($modalita, ['celle', 'libera'], true)) {
+            $modalita = 'libera';
+        }
+
+        $attiva = $request->exists('griglia_attiva')
+            ? $request->boolean('griglia_attiva')
+            : (bool) ($prev['attiva'] ?? ($modalita === 'celle'));
+
+        $info['griglia'] = [
+            'attiva' => $attiva,
+            'modalita' => $modalita,
+            'cols' => (int) ($data['griglia_cols'] ?? ($prev['cols'] ?? 10)),
+            'rows' => (int) ($data['griglia_rows'] ?? ($prev['rows'] ?? 4)),
+            'margin_top' => (float) ($data['griglia_margin_top'] ?? ($prev['margin_top'] ?? 14)),
+            'margin_right' => (float) ($data['griglia_margin_right'] ?? ($prev['margin_right'] ?? 2)),
+            'margin_bottom' => (float) ($data['griglia_margin_bottom'] ?? ($prev['margin_bottom'] ?? 2)),
+            'margin_left' => (float) ($data['griglia_margin_left'] ?? ($prev['margin_left'] ?? 8)),
+            'inset' => (float) ($data['griglia_inset'] ?? ($prev['inset'] ?? 6)),
+            'inset_v' => (float) ($data['griglia_inset_v'] ?? ($prev['inset_v'] ?? 1.5)),
+            'colonne' => trim((string) ($data['griglia_colonne'] ?? ($prev['colonne'] ?? 'A,B,C,D,E,F,H,K,P,R'))),
+        ];
+        $sala->info = $info;
+        $sala->save();
+
+        if ($request->expectsJson() || $request->wantsJson()) {
+            return response()->json([
+                'ok' => true,
+                'griglia' => $sala->grigliaConfig(),
+            ]);
+        }
+
+        return redirect()
+            ->route('evento.piantina.edit', $this->piantinaParams($evento, $sala))
+            ->with('success', 'Sala e griglia aggiornate.');
+    }
+
+    /**
+     * Elimina una sala (non l'ultima).
+     */
+    public function destroySala(Request $request, int $evento_id, int $sala_id)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $sala = $evento->sale()->where('id', $sala_id)->firstOrFail();
+
+        if ($evento->sale()->count() <= 1) {
+            return redirect()
+                ->route('evento.piantina.edit', $this->piantinaParams($evento, $sala))
+                ->with('error', 'Non puoi eliminare l’unica sala dell’evento.');
+        }
+
+        $disk = Storage::disk('eventi');
+        if (filled($sala->immagine) && $disk->exists($sala->immagine)) {
+            $disk->delete($sala->immagine);
+        }
+        $sala->delete();
+
+        $next = $this->ensureSala($evento);
+
+        return redirect()
+            ->route('evento.piantina.edit', $this->piantinaParams($evento, $next))
+            ->with('success', 'Sala eliminata.');
+    }
+
+    /**
+     * Upload immagine piantina.
+     */
+    public function uploadPiantina(Request $request, int $evento_id)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $sala = $this->resolveSala($request, $evento);
+
+        $request->validate([
+            'immagine' => 'required|file|image|mimes:jpeg,png,jpg,gif,webp|max:8192',
+        ]);
+
+        $disk = Storage::disk('eventi');
+        $dir = $evento->id.'/piantina';
+        $ext = strtolower($request->file('immagine')->getClientOriginalExtension() ?: 'jpg');
+        $filename = 'piantina_'.time().'_'.Str::random(4).'.'.$ext;
+        $path = $dir.'/'.$filename;
+
+        if (filled($sala->immagine) && $disk->exists($sala->immagine)) {
+            $disk->delete($sala->immagine);
+        }
+
+        $disk->makeDirectory($dir);
+        $disk->putFileAs($dir, $request->file('immagine'), $filename);
+
+        $sala->immagine = $path;
+
+        // Dimensioni naturali se non impostate
+        $full = $disk->path($path);
+        if (is_file($full) && (! $sala->larghezza || ! $sala->altezza)) {
+            $size = @getimagesize($full);
+            if (is_array($size)) {
+                $sala->larghezza = $sala->larghezza ?: (int) $size[0];
+                $sala->altezza = $sala->altezza ?: (int) $size[1];
+            }
+        }
+
+        $sala->save();
+
+        return redirect()
+            ->route('evento.piantina.edit', $this->piantinaParams($evento, $sala))
+            ->with('success', 'Piantina caricata.');
+    }
+
+    public function destroyPiantina(Request $request, int $evento_id)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $sala = $this->resolveSala($request, $evento);
+
+        $disk = Storage::disk('eventi');
+        if (filled($sala->immagine) && $disk->exists($sala->immagine)) {
+            $disk->delete($sala->immagine);
+        }
+
+        $sala->immagine = null;
+        $sala->save();
+
+        return redirect()
+            ->route('evento.piantina.edit', $this->piantinaParams($evento, $sala))
+            ->with('success', 'Piantina rimossa.');
+    }
+
+    /**
+     * Crea un tavolo sulla piantina.
+     */
+    public function storeTavolo(Request $request, int $evento_id)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $sala = $this->resolveSala($request, $evento);
+
+        $data = $request->validate([
+            'label' => 'required|string|max:50',
+            'posti' => 'required|integer|min:1|max:200',
+            'x' => 'nullable|numeric|between:0,100',
+            'y' => 'nullable|numeric|between:0,100',
+            'w' => 'nullable|numeric|between:0.5,100',
+            'h' => 'nullable|numeric|between:0.5,100',
+            'rotazione' => 'nullable|integer|between:-360,360',
+            'forma' => 'nullable|string|in:rettangolo,cerchio',
+            'gruppo_id' => 'nullable|string|max:100',
+            'ordine_in_gruppo' => 'nullable|integer|min:0|max:9999',
+            'is_attivo' => 'nullable|boolean',
+        ]);
+
+        $tavolo = EventoTavolo::create([
+            'evento_sala_id' => $sala->id,
+            'label' => trim($data['label']),
+            'posti' => (int) $data['posti'],
+            'x' => (float) ($data['x'] ?? 10),
+            'y' => (float) ($data['y'] ?? 10),
+            'w' => (float) ($data['w'] ?? 8),
+            'h' => (float) ($data['h'] ?? 8),
+            'rotazione' => (int) ($data['rotazione'] ?? 0),
+            'forma' => $data['forma'] ?? EventoTavolo::FORMA_RETTANGOLO,
+            'gruppo_id' => filled($data['gruppo_id'] ?? null) ? trim($data['gruppo_id']) : null,
+            'ordine_in_gruppo' => (int) ($data['ordine_in_gruppo'] ?? 0),
+            'is_attivo' => $request->boolean('is_attivo', true),
+        ]);
+
+        if ($request->expectsJson() || $request->wantsJson()) {
+            return response()->json(['ok' => true, 'tavolo' => $tavolo]);
+        }
+
+        return redirect()
+            ->route('evento.piantina.edit', $this->piantinaParams($evento, $sala))
+            ->with('success', 'Tavolo '.$tavolo->label.' aggiunto.');
+    }
+
+    /**
+     * Aggiorna tavolo (posizione, posti, gruppo…).
+     */
+    public function updateTavolo(Request $request, int $evento_id, int $tavolo_id)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $sala = $this->resolveSala($request, $evento);
+        $tavolo = EventoTavolo::where('evento_sala_id', $sala->id)->findOrFail($tavolo_id);
+
+        $data = $request->validate([
+            'label' => 'sometimes|required|string|max:50',
+            'posti' => 'sometimes|required|integer|min:1|max:200',
+            'x' => 'nullable|numeric|between:0,100',
+            'y' => 'nullable|numeric|between:0,100',
+            'w' => 'nullable|numeric|between:0.5,100',
+            'h' => 'nullable|numeric|between:0.5,100',
+            'rotazione' => 'nullable|integer|between:-360,360',
+            'forma' => 'nullable|string|in:rettangolo,cerchio',
+            'gruppo_id' => 'nullable|string|max:100',
+            'ordine_in_gruppo' => 'nullable|integer|min:0|max:9999',
+            'is_attivo' => 'nullable|boolean',
+        ]);
+
+        if (array_key_exists('label', $data)) {
+            $tavolo->label = trim($data['label']);
+        }
+        if (array_key_exists('posti', $data)) {
+            $tavolo->posti = (int) $data['posti'];
+        }
+        foreach (['x', 'y', 'w', 'h'] as $coord) {
+            if (array_key_exists($coord, $data) && $data[$coord] !== null) {
+                $tavolo->{$coord} = (float) $data[$coord];
+            }
+        }
+        if (array_key_exists('rotazione', $data) && $data['rotazione'] !== null) {
+            $tavolo->rotazione = (int) $data['rotazione'];
+        }
+        if (array_key_exists('forma', $data) && $data['forma'] !== null) {
+            $tavolo->forma = $data['forma'];
+        }
+        if (array_key_exists('gruppo_id', $data)) {
+            $tavolo->gruppo_id = filled($data['gruppo_id']) ? trim($data['gruppo_id']) : null;
+        }
+        if (array_key_exists('ordine_in_gruppo', $data) && $data['ordine_in_gruppo'] !== null) {
+            $tavolo->ordine_in_gruppo = (int) $data['ordine_in_gruppo'];
+        }
+        if ($request->has('is_attivo')) {
+            $tavolo->is_attivo = $request->boolean('is_attivo');
+        }
+
+        $tavolo->save();
+
+        if ($request->expectsJson() || $request->wantsJson()) {
+            return response()->json(['ok' => true, 'tavolo' => $tavolo->fresh()]);
+        }
+
+        return redirect()
+            ->route('evento.piantina.edit', $this->piantinaParams($evento, $sala))
+            ->with('success', 'Tavolo aggiornato.');
+    }
+
+    public function destroyTavolo(Request $request, int $evento_id, int $tavolo_id)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $sala = $this->resolveSala($request, $evento);
+        $tavolo = EventoTavolo::where('evento_sala_id', $sala->id)->findOrFail($tavolo_id);
+        $label = $tavolo->label;
+        $tavolo->delete();
+
+        if ($request->expectsJson() || $request->wantsJson()) {
+            return response()->json(['ok' => true]);
+        }
+
+        return redirect()
+            ->route('evento.piantina.edit', $this->piantinaParams($evento, $sala))
+            ->with('success', 'Tavolo '.$label.' eliminato.');
+    }
+
+    /**
+     * Aggiorna geometria/label di più tavoli in un colpo (allinea griglia).
+     */
+    public function batchTavoli(Request $request, int $evento_id)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $sala = $this->resolveSala($request, $evento);
+
+        $data = $request->validate([
+            'tavoli' => 'required|array|min:1|max:200',
+            'tavoli.*.id' => 'required|integer',
+            'tavoli.*.x' => 'nullable|numeric|between:0,100',
+            'tavoli.*.y' => 'nullable|numeric|between:0,100',
+            'tavoli.*.w' => 'nullable|numeric|between:0.5,100',
+            'tavoli.*.h' => 'nullable|numeric|between:0.5,100',
+            'tavoli.*.label' => 'nullable|string|max:50',
+            'tavoli.*.posti' => 'nullable|integer|min:1|max:200',
+            'tavoli.*.gruppo_id' => 'nullable|string|max:100',
+            'tavoli.*.ordine_in_gruppo' => 'nullable|integer|min:0|max:9999',
+        ]);
+
+        $ids = collect($data['tavoli'])->pluck('id')->map(fn ($id) => (int) $id)->all();
+        $existing = EventoTavolo::query()
+            ->where('evento_sala_id', $sala->id)
+            ->whereIn('id', $ids)
+            ->get()
+            ->keyBy('id');
+
+        $updated = [];
+        foreach ($data['tavoli'] as $row) {
+            $tavolo = $existing->get((int) $row['id']);
+            if (! $tavolo) {
+                continue;
+            }
+            foreach (['x', 'y', 'w', 'h'] as $coord) {
+                if (array_key_exists($coord, $row) && $row[$coord] !== null) {
+                    $tavolo->{$coord} = (float) $row[$coord];
+                }
+            }
+            if (array_key_exists('label', $row) && filled($row['label'])) {
+                $tavolo->label = trim($row['label']);
+            }
+            if (array_key_exists('posti', $row) && $row['posti'] !== null) {
+                $tavolo->posti = (int) $row['posti'];
+            }
+            if (array_key_exists('gruppo_id', $row)) {
+                $tavolo->gruppo_id = filled($row['gruppo_id']) ? trim($row['gruppo_id']) : null;
+            }
+            if (array_key_exists('ordine_in_gruppo', $row) && $row['ordine_in_gruppo'] !== null) {
+                $tavolo->ordine_in_gruppo = (int) $row['ordine_in_gruppo'];
+            }
+            $tavolo->save();
+            $updated[] = $tavolo->fresh();
+        }
+
+        return response()->json(['ok' => true, 'tavoli' => $updated]);
+    }
+
+    /**
+     * Vista assegnazione prenotazioni → tavoli.
+     */
+    public function assegnazioni(Request $request)
+    {
+        $evento = $this->findEventoOrFail($request->get('evento_id'));
+        $sale = $this->saleList($evento);
+        $sala = $this->resolveSala($request, $evento, $sale);
+        $sala->load([
+            'tavoli' => fn ($q) => $q->where('is_attivo', true)
+                ->with(['assegnazioni.prenotazione'])
+                ->orderBy('ordine_in_gruppo')
+                ->orderBy('label'),
+        ]);
+
+        $prenotazioni = Prenotazione::query()
+            ->where('evento_id', $evento->id)
+            ->whereNotIn('stato', [
+                Prenotazione::STATO_CANCELLATA,
+                Prenotazione::STATO_ANNULLATA,
+                Prenotazione::STATO_RIFIUTATA,
+            ])
+            ->with(['assegnazioniTavolo.eventoTavolo'])
+            ->orderByDesc('confermata')
+            ->orderBy('cognome')
+            ->orderBy('nome')
+            ->get();
+
+        $tavoliJs = $sala->tavoli->map(function (EventoTavolo $t) {
+            $occupati = $t->postiOccupati();
+
+            return [
+                'id' => $t->id,
+                'label' => $t->label,
+                'posti' => (int) $t->posti,
+                'occupati' => $occupati,
+                'liberi' => max(0, (int) $t->posti - $occupati),
+                'x' => (float) $t->x,
+                'y' => (float) $t->y,
+                'w' => (float) $t->w,
+                'h' => (float) $t->h,
+                'forma' => $t->forma ?: 'rettangolo',
+                'gruppo_id' => $t->gruppo_id,
+                'assegnazioni' => $t->assegnazioni->map(fn ($a) => [
+                    'id' => $a->id,
+                    'posti' => (int) $a->posti_assegnati,
+                    'prenotazione_id' => (int) $a->prenotazione_id,
+                    'nome' => trim(($a->prenotazione?->cognome ?? '').' '.($a->prenotazione?->nome ?? '')),
+                    'codice' => $a->prenotazione?->codice,
+                ])->values(),
+            ];
+        })->values();
+
+        $prenotazioniJs = $prenotazioni->map(function (Prenotazione $p) {
+            $coperti = max(1, (int) ($p->numero_persone ?? 1));
+            $assegnati = (int) $p->assegnazioniTavolo->sum('posti_assegnati');
+
+            return [
+                'id' => $p->id,
+                'nome' => trim(($p->cognome ?? '').' '.($p->nome ?? '')),
+                'codice' => $p->codice,
+                'stato' => $p->stato,
+                'confermata' => (bool) $p->confermata,
+                'coperti' => $coperti,
+                'assegnati' => $assegnati,
+                'rimasti' => max(0, $coperti - $assegnati),
+                'assegnazioni' => $p->assegnazioniTavolo->map(fn ($a) => [
+                    'id' => $a->id,
+                    'posti' => (int) $a->posti_assegnati,
+                    'tavolo_id' => (int) $a->evento_tavolo_id,
+                    'label' => $a->eventoTavolo?->label,
+                    'gruppo_id' => $a->eventoTavolo?->gruppo_id,
+                ])->values(),
+            ];
+        })->values();
+
+        return view('evento.piantina.assegnazioni', [
+            'evento' => $evento,
+            'sala' => $sala,
+            'sale' => $sale,
+            'prenotazioni' => $prenotazioni,
+            'piantinaUrl' => $this->piantinaUrl($sala),
+            'tavoliJs' => $tavoliJs,
+            'prenotazioniJs' => $prenotazioniJs,
+            'griglia' => $sala->grigliaConfig(),
+        ]);
+    }
+
+    /**
+     * Assegna automaticamente le prenotazioni ai tavoli (intere + buchi + spezza colonna).
+     */
+    public function assegnaAutomatico(Request $request, int $evento_id, AssegnaTavoliAutomatico $service)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $sala = $this->resolveSala($request, $evento);
+
+        $data = $request->validate([
+            'solo_confermate' => 'nullable|boolean',
+        ]);
+
+        $stats = $service->esegui($evento, $sala, [
+            'solo_confermate' => $request->boolean('solo_confermate'),
+        ]);
+
+        $msg = sprintf(
+            'Assegnazione automatica: %d posti su %d prenotazioni (%d intere, %d nei buchi, %d spezzate).',
+            $stats['posti_assegnati'],
+            $stats['prenotazioni_toccate'],
+            $stats['intere'],
+            $stats['buchi'],
+            $stats['spezzate']
+        );
+        if ($stats['non_collocate'] > 0) {
+            $msg .= ' '.$stats['non_collocate'].' ancora senza posto completo.';
+        }
+
+        if ($request->expectsJson() || $request->wantsJson()) {
+            return response()->json([
+                'ok' => true,
+                'message' => $msg,
+                'stats' => $stats,
+            ]);
+        }
+
+        return redirect()
+            ->route('evento.piantina.assegnazioni', $this->piantinaParams($evento, $sala))
+            ->with('success', $msg);
+    }
+
+    /**
+     * Assegna posti di una prenotazione a un tavolo (eventualmente spezzati).
+     */
+    public function assegna(Request $request, int $evento_id)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $sala = $this->resolveSala($request, $evento);
+
+        $data = $request->validate([
+            'prenotazione_id' => 'required|integer|exists:prenotazione,id',
+            'evento_tavolo_id' => 'required|integer|exists:evento_tavolo,id',
+            'posti_assegnati' => 'nullable|integer|min:1|max:200',
+        ]);
+
+        $prenotazione = Prenotazione::where('evento_id', $evento->id)->findOrFail($data['prenotazione_id']);
+        $tavolo = EventoTavolo::where('evento_sala_id', $sala->id)->findOrFail($data['evento_tavolo_id']);
+
+        if (in_array($prenotazione->stato, [
+            Prenotazione::STATO_CANCELLATA,
+            Prenotazione::STATO_ANNULLATA,
+            Prenotazione::STATO_RIFIUTATA,
+        ], true)) {
+            return $this->assegnazioneFail($request, $evento, 'Prenotazione non assegnabile in questo stato.', $sala);
+        }
+
+        $coperti = max(1, (int) ($prenotazione->numero_persone ?? 1));
+        $giaAssegnati = (int) $prenotazione->assegnazioniTavolo()->sum('posti_assegnati');
+        $rimanenti = max(0, $coperti - $giaAssegnati);
+        if ($rimanenti < 1) {
+            return $this->assegnazioneFail($request, $evento, 'Tutti i coperti di questa prenotazione sono già assegnati.', $sala);
+        }
+
+        $postiRichiesti = (int) ($data['posti_assegnati'] ?? $rimanenti);
+        $postiRichiesti = min(max(1, $postiRichiesti), $rimanenti);
+
+        // Se spezza su un secondo tavolo, deve essere dello stesso gruppo (tavoli attaccati)
+        $esistenti = $prenotazione->assegnazioniTavolo()->with('eventoTavolo')->get();
+        if ($esistenti->isNotEmpty()) {
+            $okVicino = $esistenti->contains(function (PrenotazioneAssegnazioneTavolo $a) use ($tavolo) {
+                $t = $a->eventoTavolo;
+                if (! $t) {
+                    return false;
+                }
+                if ((int) $t->id === (int) $tavolo->id) {
+                    return true;
+                }
+                if (! filled($t->gruppo_id) || ! filled($tavolo->gruppo_id)) {
+                    return false;
+                }
+
+                return $t->gruppo_id === $tavolo->gruppo_id
+                    && (int) $t->evento_sala_id === (int) $tavolo->evento_sala_id;
+            });
+
+            if (! $okVicino) {
+                return $this->assegnazioneFail(
+                    $request,
+                    $evento,
+                    'Per spezzare i coperti usa un tavolo dello stesso gruppo (tavoli attaccati).',
+                    $sala
+                );
+            }
+        }
+
+        $assegnazione = PrenotazioneAssegnazioneTavolo::firstOrNew([
+            'prenotazione_id' => $prenotazione->id,
+            'evento_tavolo_id' => $tavolo->id,
+        ]);
+
+        $giaSuQuesto = $assegnazione->exists ? (int) $assegnazione->posti_assegnati : 0;
+        $altriSuQuesto = (int) $tavolo->assegnazioni()
+            ->when($assegnazione->exists, fn ($q) => $q->where('id', '!=', $assegnazione->id))
+            ->sum('posti_assegnati');
+        $liberiPerQuesta = max(0, (int) $tavolo->posti - $altriSuQuesto - $giaSuQuesto);
+        $aggiungi = min($postiRichiesti, $liberiPerQuesta);
+
+        if ($aggiungi < 1) {
+            return $this->assegnazioneFail($request, $evento, 'Il tavolo non ha posti liberi sufficienti.', $sala);
+        }
+
+        $assegnazione->posti_assegnati = $giaSuQuesto + $aggiungi;
+        if (! $assegnazione->exists) {
+            $assegnazione->ordine = (int) ($esistenti->max('ordine') ?? -1) + 1;
+        }
+        $assegnazione->save();
+
+        if ($request->expectsJson() || $request->wantsJson()) {
+            return response()->json([
+                'ok' => true,
+                'aggiunti' => $aggiungi,
+                'assegnazione' => $assegnazione->fresh(['eventoTavolo', 'prenotazione']),
+                'tavolo' => $this->tavoloPayload($tavolo->fresh(['assegnazioni.prenotazione'])),
+                'prenotazione' => $this->prenotazionePayload($prenotazione->fresh(['assegnazioniTavolo.eventoTavolo'])),
+            ]);
+        }
+
+        return redirect()
+            ->route('evento.piantina.assegnazioni', $this->piantinaParams($evento, $sala))
+            ->with('success', 'Assegnati '.$aggiungi.' posti a '.$tavolo->label.'.');
+    }
+
+    public function rimuoviAssegnazione(Request $request, int $evento_id, int $assegnazione_id)
+    {
+        $evento = $this->findEventoOrFail($evento_id);
+        $sala = $this->resolveSala($request, $evento);
+
+        $assegnazione = PrenotazioneAssegnazioneTavolo::query()
+            ->whereKey($assegnazione_id)
+            ->whereHas('prenotazione', fn ($q) => $q->where('evento_id', $evento->id))
+            ->firstOrFail();
+
+        $prenotazione = $assegnazione->prenotazione;
+        $tavolo = $assegnazione->eventoTavolo;
+        $assegnazione->delete();
+
+        if ($tavolo && ! $tavolo->relationLoaded('assegnazioni')) {
+            $tavolo->load(['assegnazioni.prenotazione']);
+        }
+        if ($prenotazione && ! $prenotazione->relationLoaded('assegnazioniTavolo')) {
+            $prenotazione->load(['assegnazioniTavolo.eventoTavolo']);
+        }
+
+        if ($request->expectsJson() || $request->wantsJson()) {
+            return response()->json([
+                'ok' => true,
+                'tavolo' => $tavolo ? $this->tavoloPayload($tavolo->fresh(['assegnazioni.prenotazione'])) : null,
+                'prenotazione' => $prenotazione ? $this->prenotazionePayload($prenotazione->fresh(['assegnazioniTavolo.eventoTavolo'])) : null,
+            ]);
+        }
+
+        return redirect()
+            ->route('evento.piantina.assegnazioni', $this->piantinaParams($evento, $sala))
+            ->with('success', 'Assegnazione rimossa.');
+    }
+
+    private function tavoloPayload(EventoTavolo $t): array
+    {
+        $occupati = $t->postiOccupati();
+
+        return [
+            'id' => $t->id,
+            'label' => $t->label,
+            'posti' => (int) $t->posti,
+            'occupati' => $occupati,
+            'liberi' => max(0, (int) $t->posti - $occupati),
+            'x' => (float) $t->x,
+            'y' => (float) $t->y,
+            'w' => (float) $t->w,
+            'h' => (float) $t->h,
+            'forma' => $t->forma ?: 'rettangolo',
+            'gruppo_id' => $t->gruppo_id,
+            'assegnazioni' => $t->assegnazioni->map(fn ($a) => [
+                'id' => $a->id,
+                'posti' => (int) $a->posti_assegnati,
+                'prenotazione_id' => (int) $a->prenotazione_id,
+                'nome' => trim(($a->prenotazione?->cognome ?? '').' '.($a->prenotazione?->nome ?? '')),
+                'codice' => $a->prenotazione?->codice,
+            ])->values(),
+        ];
+    }
+
+    private function prenotazionePayload(Prenotazione $p): array
+    {
+        $coperti = max(1, (int) ($p->numero_persone ?? 1));
+        $assegnati = (int) $p->assegnazioniTavolo->sum('posti_assegnati');
+
+        return [
+            'id' => $p->id,
+            'nome' => trim(($p->cognome ?? '').' '.($p->nome ?? '')),
+            'codice' => $p->codice,
+            'stato' => $p->stato,
+            'confermata' => (bool) $p->confermata,
+            'coperti' => $coperti,
+            'assegnati' => $assegnati,
+            'rimasti' => max(0, $coperti - $assegnati),
+            'assegnazioni' => $p->assegnazioniTavolo->map(fn ($a) => [
+                'id' => $a->id,
+                'posti' => (int) $a->posti_assegnati,
+                'tavolo_id' => (int) $a->evento_tavolo_id,
+                'label' => $a->eventoTavolo?->label,
+                'gruppo_id' => $a->eventoTavolo?->gruppo_id,
+            ])->values(),
+        ];
+    }
+
+    private function findEventoOrFail(mixed $eventoId): Evento
+    {
+        $evento = Evento::find($eventoId);
+        if (! $evento) {
+            abort(404, 'Evento non trovato');
+        }
+
+        AttivitaService::garantisciEventoDiQuestaAttivita($evento);
+
+        return $evento;
+    }
+
+    /**
+     * @return \Illuminate\Support\Collection<int, EventoSala>
+     */
+    private function saleList(Evento $evento)
+    {
+        $sale = $evento->sale()->get();
+        if ($sale->isEmpty()) {
+            $sale = collect([$this->ensureSala($evento)]);
+        }
+
+        return $sale;
+    }
+
+    private function resolveSala(Request $request, Evento $evento, $sale = null): EventoSala
+    {
+        $sale = $sale ?? $this->saleList($evento);
+        $salaId = (int) ($request->input('sala_id') ?: $request->query('sala_id') ?: 0);
+
+        if ($salaId > 0) {
+            $found = $sale->firstWhere('id', $salaId);
+            if ($found) {
+                return $found;
+            }
+            abort(404, 'Sala non trovata');
+        }
+
+        return $sale->first() ?? $this->ensureSala($evento);
+    }
+
+    private function ensureSala(Evento $evento): EventoSala
+    {
+        $sala = $evento->sale()->orderBy('ordine')->orderBy('id')->first();
+        if ($sala) {
+            return $sala;
+        }
+
+        return EventoSala::create([
+            'evento_id' => $evento->id,
+            'nome' => 'Sala principale',
+            'ordine' => 0,
+        ]);
+    }
+
+    private function piantinaParams(Evento $evento, EventoSala $sala): array
+    {
+        return [
+            'evento_id' => $evento->id,
+            'sala_id' => $sala->id,
+        ];
+    }
+
+    private function piantinaUrl(?EventoSala $sala): ?string
+    {
+        if (! $sala || ! filled($sala->immagine)) {
+            return null;
+        }
+
+        $disk = Storage::disk('eventi');
+        if (! $disk->exists($sala->immagine)) {
+            return null;
+        }
+
+        return $disk->url($sala->immagine).'?v='.$disk->lastModified($sala->immagine);
+    }
+
+    private function assegnazioneFail(Request $request, Evento $evento, string $message, ?EventoSala $sala = null)
+    {
+        if ($request->expectsJson() || $request->wantsJson()) {
+            return response()->json(['ok' => false, 'error' => $message], 422);
+        }
+
+        $params = ['evento_id' => $evento->id];
+        if ($sala) {
+            $params['sala_id'] = $sala->id;
+        } elseif ($request->input('sala_id') || $request->query('sala_id')) {
+            $params['sala_id'] = (int) ($request->input('sala_id') ?: $request->query('sala_id'));
+        }
+
+        return redirect()
+            ->route('evento.piantina.assegnazioni', $params)
+            ->with('error', $message);
+    }
+}

app/Http/Controllers/FatturaController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Fattura;
 use App\DataTables\FatturaDataTable;
 public static function middleware(): array
 {
     return [
-        new Middleware('permission:view-fattura', only: ['index', 'show']),
-        new Middleware('permission:create-fattura|edit-fattura|delete-fattura', only: ['store', 'update', 'destroy']),
+            new Middleware('permission:view-fattura', only: ['index', 'show', 'need_fatturazione_mensile']),
+            new Middleware('permission:create-fattura|edit-fattura|delete-fattura', only: ['store', 'update', 'destroy', 'registra_pagamento']),
     ];
 }
 
     if(!Auth::user()->hasAnyRole(['superadmin','amministratore'])) return response()->json(['error' => 'Non hai i permessi per vedere una fattura'],403);
 
     $fattura = Fattura::findOrFail($request->fattura_id);
+    if (! Auth::user()->hasRole('superadmin') && (int) $fattura->user_id !== (int) Auth::id()) {
+        abort(404);
+    }
     return view('fattura.show', compact('fattura'));
 }
 
 public function registra_pagamento(Request $request)
 {
     $fattura = Fattura::findOrFail($request->fattura_id);
+    if (! Auth::user()->hasRole('superadmin') && (int) $fattura->user_id !== (int) Auth::id()) {
+        abort(404);
+    }
     $fattura->stato = Fattura::PAGATA;
     $fattura->info= json_encode(['pagamento_registrato_il' => now()]);
     $fattura->save();

app/Http/Controllers/FornitoreController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Fornitore;
 use App\DataTables\FornitoreDataTable;
 use App\DataTables\FornitoreDataTableEditor;
 use Illuminate\Support\Facades\Auth;
+use App\Services\Attivita\AttivitaService;
 
 class FornitoreController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-fornitore', only: ['index', 'show']),
+            new Middleware('permission:view-fornitore', only: ['index', 'show', 'show_modal']),
             new Middleware('permission:create-fornitore|edit-fornitore|delete-fornitore', only: ['store', 'update', 'destroy']),
         ];
     }
     {
         $fornitore = Fornitore::find($request->get('fornitore_id'));
         if(!$fornitore) return redirect()->route('fornitore.index')->with('error', 'Fornitore non trovato');
+        AttivitaService::garantisciAttivita($fornitore->attivita_id);
         if(!Auth::user()->can('view-fornitore')) return abort(403, 'Non hai permesso di vedere questo fornitore');
         return view('fornitore.show_modal', ['fornitore' => $fornitore]);
     }
     {
         $fornitore = Fornitore::find($request->get('fornitore_id'));
         if(!$fornitore) return redirect()->route('fornitore.index')->with('error', 'Fornitore non trovato');
+        AttivitaService::garantisciAttivita($fornitore->attivita_id);
         if(!Auth::user()->can('view-fornitore')) return abort(403, 'Non hai permesso di vedere questo fornitore');
         return view('fornitore.show', ['fornitore' => $fornitore]);
     }

app/Http/Controllers/ImpostazioniController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use App\Models\Attivita;
 use Illuminate\Http\Request;
 use App\Models\Impostazioni;
 use Illuminate\Support\Facades\Session;
 use App\DataTables\ImpostazioniDataTable;
 use App\DataTables\ImpostazioniDataTableEditor;
+use App\Services\Attivita\AttivitaService;
 
 class ImpostazioniController extends Controller
 {
     {
         return [
             new Middleware('permission:view-impostazioni', only: ['index']),
-            new Middleware('permission:create-impostazioni|edit-impostazioni|delete-impostazioni', only: ['store']),
+            new Middleware('permission:create-impostazioni|edit-impostazioni|delete-impostazioni', only: ['store', 'edit']),
         ];
     }
     
     {
         $impostazione = Impostazioni::find($impostazione_id);
         if(!$impostazione) return redirect()->route('impostazioni.index')->with('error', 'Impostazione non trovata');
+        AttivitaService::garantisciAttivita($impostazione->attivita_id);
         return view('impostazioni.edit', compact('impostazione'));
     }
 }

app/Http/Controllers/ListinoPrezziController.php

 namespace App\Http\Controllers;
 
 use Illuminate\Http\Request;
+use Illuminate\Routing\Controllers\Middleware;
 use App\Models\ListinoPrezzi;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Validator;
     
     public static function middleware(): array
     {
-        return  [
-                    new Middleware('role:superadmin', ['only' => ['index', 'store']]),
-                    new Middleware('role:amministratore', ['only' => ['show_listino_cliente']]),
-                ];
+        return [
+            new Middleware('role:superadmin', only: ['index', 'store']),
+            new Middleware('role:amministratore', only: ['show_listino_cliente']),
+        ];
     }
 
     public function index(ListinoPrezziDataTable $dataTable)

app/Http/Controllers/MappaDispositiviController.php

 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Session;
 use Illuminate\Routing\Controllers\Middleware;
+use App\Services\Attivita\AttivitaService;
 
 class MappaDispositiviController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-mappa_dispositivi', only: ['index']),
+            new Middleware('permission:view-mappa_dispositivi', only: ['index', 'show']),
             new Middleware('permission:create-mappa_dispositivi|edit-mappa_dispositivi|delete-mappa_dispositivi', only: ['store', 'update', 'destroy']),
         ];
     }
     
     public function index(DispositivoDataTable $dataTable)
     {
+        $dataTable->attivita_id = Session::get('attivita_attuale');
         if (request()->ajax()) {
             return $dataTable->ajax();
         }
     public function show($dispositivo_id)
     {
         $dispositivo = Dispositivo::find($dispositivo_id);
+        if (! $dispositivo) {
+            abort(404);
+        }
+        AttivitaService::garantisciAttivita($dispositivo->attivita_id);
+
         return view('mappa_dispositivi.show', ['dispositivo' => $dispositivo]);
     }
 
         $grouped = array_fill_keys($tipi, []);
         $grouped['_altro'] = [];
 
-        $attivitaAttiveIds = Attivita::query()
-            ->where('is_attiva', true)
-            ->pluck('id');
+        $attivitaQuery = Attivita::query()->where('is_attiva', true);
+        if (! Auth::user()?->hasRole('superadmin')) {
+            $attivitaQuery->where('user_id', Auth::id());
+        }
+        $attivitaAttiveIds = $attivitaQuery->pluck('id');
 
         $devices = Dispositivo::query()
             ->with('attivita:id,nome')

app/Http/Controllers/MetodoPagamentoController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\MetodoPagamento;
 use App\DataTables\MetodoPagamentoDataTable;
     {
         return [
             new Middleware('permission:view-metodo_pagamento', only: ['index']),
-            new Middleware('permission:create-metodo_pagamento|edit-metodo_pagamento|delete-metodo_pagamento', only: ['store', 'update', 'destroy']),
+            new Middleware('permission:create-metodo_pagamento|edit-metodo_pagamento|delete-metodo_pagamento', only: ['store', 'update', 'destroy', 'segresta_wallet_chiE']),
         ];
     }
     

app/Http/Controllers/MonitorController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Dispositivo;
 use App\Models\MonitorHasContenuto;
 use Illuminate\Support\Facades\Auth;
 use Carbon\Carbon;
 use Illuminate\Support\Facades\Session;
+use App\Services\Attivita\AttivitaService;
 
 
 class MonitorController extends Controller
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-monitor', only: ['index']),
-            new Middleware('permission:create-monitor|edit-monitor|delete-monitor', only: ['store', 'update', 'destroy']),
+            new Middleware('permission:view-monitor', only: ['index', 'show']),
+            new Middleware('permission:create-monitor|edit-monitor|delete-monitor', only: ['store', 'update', 'destroy', 'gestisci_contenuto_monitor', 'gestisci_contenuto_store']),
         ];
     }
     
         if($monitor == null){
             return redirect()->route('monitor.index')->with('error', 'Dispositivo monitor non trovato');
         }
+        AttivitaService::garantisciAttivita($monitor->attivita_id);
 
         $monitor_has_contenuto = MonitorHasContenuto::with(['cucina', 'contenuto_bacheca', 'bacheca.contenuti'])
             ->where('monitor_id', $monitor->id)
         if($monitor == null){
             abort(404, 'Dispositivo monitor non trovato');
         }
+        AttivitaService::garantisciAttivita($monitor->attivita_id);
         $monitor_has_contenuto = MonitorHasContenuto::where('monitor_id', $monitor->id)->first();
 
         $bacheche = Bacheca::query()
 
         $isBacheca = (bool) $request->boolean('is_bacheca');
 
+        $monitor = Dispositivo::find($request->get('monitor_id'));
+        if (! $monitor) {
+            abort(404);
+        }
+        AttivitaService::garantisciAttivita($monitor->attivita_id);
+
+        if ($isBacheca) {
+            $bacheca = Bacheca::find($request->get('bacheca_id'));
+            if (! $bacheca || (int) $bacheca->attivita_id !== (int) $monitor->attivita_id) {
+                abort(404);
+            }
+        } else {
+            $cucina = \App\Models\Cucina::find($request->get('cucina_id'));
+            if (! $cucina || (int) $cucina->attivita_id !== (int) $monitor->attivita_id) {
+                abort(404);
+            }
+        }
+
         MonitorHasContenuto::updateOrCreate([
             'monitor_id' => $request->get('monitor_id'),
         ], [

app/Http/Controllers/OperatoreController.php

 use App\DataTables\OperatoreDataTableEditor;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Routing\Controllers\Middleware;
-use Illuminate\Routing\Controllers\HasMiddleware;
 use Illuminate\Support\Facades\Hash;
 use Illuminate\Support\Facades\Validator;
 use Illuminate\Support\Str;
 use App\Models\Ordine;
 use Illuminate\Support\Facades\Session;
 use App\DataTables\RigaOrdineDataTable;
+use App\Services\Attivita\AttivitaService;
 
 
 class OperatoreController extends Controller
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-operatore', only: ['index']),
-            new Middleware('permission:create-operatore|edit-operatore|delete-operatore', only: ['store', 'update', 'destroy']),
+            new Middleware('permission:view-operatore', only: ['index', 'show']),
+            new Middleware('permission:create-operatore|edit-operatore|delete-operatore', only: ['store', 'update', 'destroy', 'update_password', 'update_dispositivi']),
         ];
     }
     
         if (!$operatore) {
             return redirect()->back()->with('error', 'Operatore non trovato');
         }
+        AttivitaService::garantisciAttivita($operatore->attivita_id);
         return view('operatore.show', ['operatore' => $operatore , 'dispositivi' => $operatore->dispositivi]);
     }
 
     public function update_password(Request $request)
     {
         $operatore = Operatore::find($request->get('operatore_id'));
+        if (!$operatore) {
+            return redirect()->back()->with('error', 'Operatore non trovato');
+        }
+        AttivitaService::garantisciAttivita($operatore->attivita_id);
         $operatore->password = Hash::make($request->get('password'));
         $operatore->save();
         return redirect()->route('operatore.show', ['operatore_id' => $operatore->id])->with('success', 'Password aggiornata con successo');
         if (!$operatore) {
             return redirect()->back()->with('error', 'Operatore non trovato');
         }
+        AttivitaService::garantisciAttivita($operatore->attivita_id);
+
+        $ids = array_values(array_unique(array_map('intval', $ids)));
+        if ($ids !== []) {
+            $dispositivi = Dispositivo::query()->whereIn('id', $ids)->get();
+            if ($dispositivi->count() !== count($ids)
+                || $dispositivi->contains(fn ($dispositivo) => (int) $dispositivo->attivita_id !== (int) $operatore->attivita_id)
+            ) {
+                abort(404);
+            }
+        }
 
         $operatore->dispositivi()->sync($ids);
 
             return redirect()->route('punto-vendita.index')
             ->with('error', 'Punto di vendita non trovato');
         }
+        $operatore = Auth::guard('operatore')->user();
+        if (! $operatore
+            || (int) $puntoVendita->attivita_id !== (int) $operatore->attivita_id
+            || ! $operatore->dispositivi()->where('dispositivo.id', $puntoVendita->id)->exists()
+        ) {
+            return redirect()->route('operatore.landing')->with('error', 'Non sei autorizzato a accedere a questo dispositivo');
+        }
 // dd('A',$puntoVendita);
         if($puntoVendita->binding_token == '' || $puntoVendita->binding_token == null ){
             $puntoVendita->binding_token = Hash::make(Str::random(32));

app/Http/Controllers/OrdineController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Ordine;
 use App\DataTables\OrdineDataTable;
 use App\DataTables\OrdineDataTableEditor;
 use Illuminate\Support\Facades\Auth;
+use App\Services\Attivita\AttivitaService;
 
 class OrdineController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-ordine', only: ['index']),
+            new Middleware('permission:view-ordine', only: ['index', 'show', 'show_modal']),
             new Middleware('permission:create-ordine|edit-ordine|delete-ordine', only: ['store', 'update', 'destroy']),
         ];
     }
 
     public function show(Request $request)
     {
-        $ordine = Ordine::find($request->get('ordine_id'));
+        $ordine = Ordine::with([
+            'dispositivo',
+            'attivita',
+            'prenotazione',
+            'pagamenti.metodo_pagamento',
+            'asporto',
+            'righe_ordine.piatto.cucina',
+            'righe_ordine.piatto.elencoAllergeni',
+            'righe_ordine.has_variante.variante_piatto',
+        ])->find($request->get('ordine_id'));
+        if (! $ordine) {
+            abort(404);
+        }
+        AttivitaService::garantisciAttivita($ordine->attivita_id);
+
         return view('ordine.show', compact('ordine'));
     }
 
     public function show_modal(Request $request)
     {
         $ordine = Ordine::find($request->get('ordine_id'));
+        if (! $ordine) {
+            abort(404);
+        }
+        AttivitaService::garantisciAttivita($ordine->attivita_id);
+
         return view('ordine.show_modal', compact('ordine'));
     }
 }

app/Http/Controllers/PagamentoController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Pagamento;
-use App\Models\MetodoPagamento;
+use App\Models\PrimaNota;
 use App\DataTables\PagamentoDataTable;
 use App\DataTables\PagamentoDataTableEditor;
 use Illuminate\Support\Facades\Auth;
+use App\Services\Attivita\AttivitaService;
 
 class PagamentoController extends Controller
 {
         'create-pagamento' => 'Crea',
         'edit-pagamento' => 'Modifica',
         'delete-pagamento' => 'Elimina',
+        'storna-pagamento' => 'Storna',
     ];
 
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-pagamento', only: ['index', 'show']),
+            new Middleware('permission:view-pagamento', only: ['index', 'show', 'show_modal']),
             new Middleware('permission:create-pagamento|edit-pagamento|delete-pagamento', only: ['store', 'update', 'destroy']),
+            new Middleware('permission:storna-pagamento|edit-pagamento', only: ['stornaPagamento']),
         ];
     }
 
     {
         $request = request();
         $input = $request->all();
-        if($request->has('action')){
-            switch($input['action']){
+        if ($request->has('action')) {
+            switch ($input['action']) {
                 case 'create':
-                    if(!Auth::user()->can('create-pagamento')) return;
+                    if (! Auth::user()->can('create-pagamento')) {
+                        return;
+                    }
                     break;
                 case 'edit':
-                    if(!Auth::user()->can('edit-pagamento')) return;
+                    if (! Auth::user()->can('edit-pagamento')) {
+                        return;
+                    }
                     break;
                 case 'remove':
-                    if(!Auth::user()->can('delete-pagamento')) return;
+                    if (! Auth::user()->can('delete-pagamento')) {
+                        return;
+                    }
                     break;
-                }
+            }
+        }
+
         return $editor->process($request);
     }
-}
+
+    public function show_modal(Request $request)
+    {
+        $pagamento = Pagamento::query()->find($request->get('pagamento_id'));
+        if (! $pagamento) {
+            return redirect()->route('pagamento.index')->with('error', 'Pagamento non trovato');
+        }
+
+        AttivitaService::garantisciAttivita($pagamento->attivita_id);
+
+        if (! Auth::user()->can('view-pagamento')) {
+            return abort(403, 'Non hai permesso di vedere questo pagamento');
+        }
+
+        $pagamento->loadMissing(['metodo_pagamento', 'ordine', 'prenotazione', 'attivita', 'movimenti_prima_nota.categoria_contabile']);
+
+        return view('pagamento.show_modal', compact('pagamento'));
+    }
 
     public function show(Request $request)
     {
-        $pagamento = Pagamento::find($request->get('pagamento_id'));
-        if(!$pagamento) return redirect()->route('pagamento.index')->with('error', 'Pagamento non trovato');
+        $pagamento = Pagamento::query()->find($request->get('pagamento_id'));
+        if (! $pagamento) {
+            return redirect()->route('pagamento.index')->with('error', 'Pagamento non trovato');
+        }
+
+        AttivitaService::garantisciAttivita($pagamento->attivita_id);
+
+        if (! Auth::user()->can('view-pagamento')) {
+            return abort(403, 'Non hai permesso di vedere questo pagamento');
+        }
+
+        $pagamento->loadMissing(['metodo_pagamento', 'ordine', 'prenotazione', 'attivita', 'movimenti_prima_nota.categoria_contabile']);
+
+        return view('pagamento.show', compact('pagamento'));
+    }
+
+    public function stornaPagamento(Request $request)
+    {
+        $pagamento = Pagamento::query()->find($request->get('pagamento_id'));
+        if (! $pagamento) {
+            return response()->json(['success' => false, 'message' => 'Pagamento non trovato'], 404);
+        }
+
+        AttivitaService::garantisciAttivita($pagamento->attivita_id);
+
+        $info = $pagamento->info ?? [];
+        if (($info['storno'] ?? false) || $pagamento->stato === Pagamento::ANNULLATO) {
+            return response()->json(['success' => false, 'message' => 'Pagamento già stornato'], 422);
+        }
+
+        if ($pagamento->movimenti_prima_nota()->where('tipo_movimento', PrimaNota::USCITA)->exists()) {
+            return response()->json(['success' => false, 'message' => 'Pagamento già stornato'], 422);
+        }
+
+        $movimento = $pagamento->movimenti_prima_nota()
+            ->whereIn('tipo_movimento', [PrimaNota::ENTRATA, PrimaNota::NO_CONTABILE])
+            ->first();
+
+        if (! $movimento) {
+            return response()->json(['success' => false, 'message' => 'Movimento originale non trovato'], 422);
+        }
+
+        $tipoStorno = $movimento->tipo_movimento === PrimaNota::NO_CONTABILE
+            ? PrimaNota::NO_CONTABILE
+            : PrimaNota::USCITA;
+
+        PrimaNota::create([
+            'attivita_id' => $pagamento->attivita_id,
+            'categoria_contabile_id' => $movimento->categoria_contabile_id,
+            'pagamento_id' => $pagamento->id,
+            'fornitore_id' => $movimento->fornitore_id,
+            'ordine_id' => $pagamento->ordine_id,
+            'prenotazione_id' => $pagamento->prenotazione_id,
+            'evento_id' => $movimento->evento_id,
+            'tipo_movimento' => $tipoStorno,
+            'importo' => $pagamento->importo,
+            'causale' => 'Storno pagamento #' . $pagamento->id . ' - ' . $pagamento->causale,
+            'riferimento' => 'storno:pagamento:' . $pagamento->id,
+        ]);
+
+        $pagamento->stato = Pagamento::ANNULLATO;
+        $pagamento->info = array_merge($info, [
+            'storno' => true,
+            'storno_data' => now()->toIso8601String(),
+            'storno_user' => Auth::id(),
+        ]);
+        $pagamento->save();
 
-        if(!Auth::user()->can('view-pagamento')) return abort(403, 'Non hai permesso di vedere questo pagamento');
-        // if($request->has('modal')){
-        return view('pagamento.show', ['pagamento' => $pagamento]);
+        return response()->json(['success' => true]);
     }
 }

app/Http/Controllers/PiattoController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Piatto;
 use App\Models\PiattoHasAllergene;
 use App\DataTables\PiattoDataTableEditor;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Session;
+use App\Services\Attivita\AttivitaService;
 
 class PiattoController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-piatto', only: ['index']),
+            new Middleware('permission:view-piatto', only: ['index', 'datatable']),
             new Middleware('permission:create-piatto|edit-piatto|delete-piatto', only: ['store', 'update', 'destroy']),
         ];
     }
 
       foreach ($payload as $piattoId => $data) {
         $piattoId = (int) $piattoId;
+        $piatto = Piatto::find($piattoId);
+        if (! $piatto) {
+          abort(404);
+        }
+        AttivitaService::garantisciAttivita($piatto->attivita_id);
+
         $allergenIds = $data['allergeni'] ?? [];
 
         if (is_string($allergenIds)) {

app/Http/Controllers/PrenotazioneTavoloController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\PrenotazioneTavolo;
 use App\DataTables\PrenotazioneTavoloDataTable;
 use Illuminate\Support\Facades\Validator;
 use Illuminate\Support\Str;
 use Illuminate\Support\Facades\Session;
+use App\Models\Tavolo;
 
 class PrenotazioneTavoloController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-prenotazione_tavolo', only: ['index']),
+            new Middleware('permission:view-prenotazione_tavolo', only: ['index', 'oggi', 'appelloPrenotazioniTavoli']),
             new Middleware('permission:create-prenotazione_tavolo|edit-prenotazione_tavolo|delete-prenotazione_tavolo', only: ['store', 'update', 'destroy']),
         ];
     }
             'data_prenotazione' => 'required|date',
             'ora_prenotazione' => 'required',
         ]);
+        $tavolo = Tavolo::find($request->tavolo_id);
+        if (! $tavolo || (int) $tavolo->attivita_id !== (int) $attivita->id) {
+            return redirect()->back()->with('error', 'Tavolo non valido');
+        }
         $prenotazione = new PrenotazioneTavolo();
-        $prenotazione->fill($request->all());
+        $prenotazione->fill($request->only([
+            'nome', 'email', 'telefono', 'data_prenotazione', 'ora_prenotazione',
+        ]));
+        $prenotazione->attivita_id = $attivita->id;
+        $prenotazione->tavolo_id = $tavolo->id;
         $prenotazione->stato = PrenotazioneTavolo::STATO_INVIATA;
         // dd($prenotazione);
         $prenotazione->save();
     }
 
     public function cliente_show(Request $request, $prenotazione_tavoli_id){
-        $prenotazione = PrenotazioneTavolo::find($request->get('prenotazione_tavolo_id')|| $prenotazione_tavoli_id);
+        $id = $prenotazione_tavoli_id ?: $request->get('prenotazione_tavolo_id');
+        $prenotazione = PrenotazioneTavolo::find($id);
         if(!$prenotazione) return redirect()->route('cliente.attivita.show')->with('error', 'Prenotazione non trovata');
         return view('prenotazione_tavolo.cliente.show')->with(['prenotazione' => $prenotazione]);
     }

app/Http/Controllers/PrimaNotaController.php

 use App\DataTables\PrimaNotaDataTableEditor;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Routing\Controllers\Middleware;
+use App\Services\Attivita\AttivitaService;
 
 class PrimaNotaController extends Controller
 { 
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-primanota', only: ['index', 'statistiche']),
+            new Middleware('permission:view-primanota', only: ['index', 'statistiche', 'show']),
             new Middleware('permission:create-primanota|edit-primanota|delete-primanota', only: ['store', 'update', 'destroy']),
         ];
     }
                     break;
                 }
         return $editor->process($request);
+        }
     }
-}
+
 
     public function show(Request $request)
     {
-        $primanota = PrimaNota::find($request->get('primanota_id'));
+        $primanota = PrimaNota::query()->find($request->get('primanota_id'));
+        if (! $primanota) {
+            return redirect()->route('prima-nota.index')->with('error', 'Prima nota non trovata');
+        }
+        AttivitaService::garantisciAttivita($primanota->attivita_id);
+
+        $primanota->loadMissing([
+            'attivita',
+            'categoria_contabile',
+            'pagamento.metodo_pagamento',
+            'ordine',
+            'prenotazione',
+            'evento',
+            'fornitore',
+        ]);
+
         return view('prima_nota.show', compact('primanota'));
     }
+
+
 }

app/Http/Controllers/PrintJobController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\PrintJob;
 use App\DataTables\PrintJobDataTable;
 use App\DataTables\PrintJobDataTableEditor;
 use Illuminate\Support\Facades\Auth;
+use App\Services\Attivita\AttivitaService;
 
 class PrintJobController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-print-job', only: ['index']),
+            new Middleware('permission:view-print-job', only: ['index', 'show']),
             new Middleware('permission:create-print-job|edit-print-job|delete-print-job', only: ['store', 'update', 'destroy']),
         ];
     }
     
     public function index(PrintJobDataTable $dataTable)
     {
+        $dataTable->attivita_id = session('attivita_attuale');
         return $dataTable->render('print_job.index');
     }
     public function store(PrintJobDataTableEditor $editor)
     }
     public function show(Request $request)
     {
-        $print_job = PrintJob::find($request->get('print_job_id'));
+        $print_job = PrintJob::with(['dispositivo', 'stampante'])->find($request->get('print_job_id'));
+        if (! $print_job) {
+            abort(404);
+        }
+        AttivitaService::garantisciAttivita(
+            $print_job->dispositivo?->attivita_id ?? $print_job->stampante?->attivita_id
+        );
         return view('print_job.show', compact('print_job'));
     }
 }

app/Http/Controllers/PuntoOperatoreController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Dispositivo;
 use App\DataTables\PuntoOperatoreDataTable;
 use App\DataTables\PuntoOperatoreDataTableEditor;
 use Illuminate\Support\Facades\Auth;
+use App\Services\Attivita\AttivitaService;
 
 class PuntoOperatoreController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-punto_operatore', only: ['index']),
+            new Middleware('permission:view-punto_operatore', only: ['index', 'show']),
             new Middleware('permission:edit-punto_operatore', only: ['toggle_is_attivo']),
             new Middleware('permission:create-punto_operatore|edit-punto_operatore|delete-punto_operatore', only: ['store', 'update', 'destroy']),
         ];
         if(!$dispositivo){
             return redirect()->back()->with('error', 'Punto operatore non trovato');
         }
+        AttivitaService::garantisciAttivita($dispositivo->attivita_id);
 
         $dispositivo->is_attivo = !$dispositivo->is_attivo;
         $dispositivo->save();
         if(!$dispositivo){
             return redirect()->back()->with('error', 'Punto operatore non trovato');
         }
+        AttivitaService::garantisciAttivita($dispositivo->attivita_id);
         return view('punto_operatore.show', ['dispositivo' => $dispositivo]);
     }
 }

app/Http/Controllers/PuntoVenditaController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use App\DataTables\PuntoVenditaDataTable;
 use App\DataTables\PuntoVenditaDataTableEditor;
 use App\DataTables\RigaOrdineDataTable;
 
 use App\Models\Dispositivo;
+use App\Models\Cucina;
 use App\Models\Ordine;
 use App\Models\Pagamento;
 use App\Models\RigaOrdine;
 use App\Models\SaltacodaOrdine;
 use App\Models\SaltacodaRigaOrdine;
 use App\Models\SaltacodaRigaOrdineHasVariante;
+use App\Services\Attivita\AttivitaService;
 
 use Illuminate\Support\Str;
 use Illuminate\Http\Request;
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-punto_vendita', only: ['index', 'dettagli_punto_vendita', 'dettagli']),
-            new Middleware('permission:create-punto_vendita|edit-punto_vendita|delete-punto_vendita', only: ['store', 'update', 'destroy', 'edit', 'associa_cucina']),
+            new Middleware('permission:view-punto_vendita', only: [
+                'index', 'dettagli_punto_vendita', 'dettagli', 'show',
+                'riepilogo', 'riepilogo_cassa', 'cerca_pre_ordine',
+            ]),
+            new Middleware('permission:create-punto_vendita|edit-punto_vendita|delete-punto_vendita', only: [
+                'store', 'update', 'destroy', 'edit', 'associa_cucina',
+                'dissocia_dispositivo', 'importa_pre_ordine',
+            ]),
         ];
     }
 
             return redirect()->route('punto-vendita.index')
                 ->with('error', 'Punto di vendita non trovato');
         }
+        AttivitaService::garantisciAttivita($puntoVendita->attivita_id);
 
         return view('punto_vendita.dettaglio_punto_vendita', compact('puntoVendita'));
     }
             return redirect()->route('punto-vendita.index')
                 ->with('error', 'Punto di vendita non trovato');
         }
+        AttivitaService::garantisciAttivita($puntoVendita->attivita_id);
 
         return view('punto_vendita.edit', ['puntoVendita' => $puntoVendita]);
     }
             return redirect()->route('punto-vendita.index')
                 ->with('error', 'Punto di vendita non trovato');
         }
+        AttivitaService::garantisciAttivita($puntoVendita->attivita_id);
 
         if (Auth::user()->can('edit-punto_vendita')) {
 
             //         }
             // }
 
+            unset($validated['attivita_id']);
+
+            if (! empty($validated['endpoint_id'])) {
+                $endpoint = \App\Models\Endpoint::find($validated['endpoint_id']);
+                if (! $endpoint || (int) $endpoint->attivita_id !== (int) $puntoVendita->attivita_id) {
+                    abort(404);
+                }
+            }
+
             if ($request->has('info')) {
                 $validated['info'] = json_decode($request->info, true);
             }
             if ($request->has('url_stampante')) {
-                $validated['endpoint_id'] = Dispositivo::where('id', $validated['url_stampante'])
-                    ->where('tipo', Dispositivo::STAMPANTE)->first()->endpoint_id ?? null;
-
+                $stampante = Dispositivo::where('id', $validated['url_stampante'])
+                    ->where('tipo', Dispositivo::STAMPANTE)
+                    ->where('attivita_id', $puntoVendita->attivita_id)
+                    ->first();
+                $validated['endpoint_id'] = $stampante->endpoint_id ?? null;
             }
 
             $puntoVendita->update($validated);
         if (! $puntoVendita) {
             return response()->json(['success' => false, 'message' => 'Punto di vendita non trovato']);
         }
+        AttivitaService::garantisciAttivita($puntoVendita->attivita_id);
 
         if (Auth::user()->can('edit-punto_vendita')) {
-            $cucine_ids = $request->get('cucine_ids');
+            $cucine_ids = array_values(array_filter(array_map('intval', (array) $request->get('cucine_ids', []))));
+            if ($cucine_ids !== []) {
+                $cucine = Cucina::query()
+                    ->whereIn('id', $cucine_ids)
+                    ->get();
+                if ($cucine->count() !== count($cucine_ids)
+                    || $cucine->contains(fn ($cucina) => (int) $cucina->attivita_id !== (int) $puntoVendita->attivita_id)
+                ) {
+                    abort(404);
+                }
+            }
             $puntoVendita->hasCucine()->sync($cucine_ids);
 
             return response()->json(['success' => true, 'message' => 'Cucine associate con successo']);
             return redirect()->route('punto-vendita.index')
                 ->with('error', 'Punto di vendita non trovato');
         }
-
+        AttivitaService::garantisciAttivita($puntoVendita->attivita_id);
+        
         if($puntoVendita->attivita->user_id != Auth::user()->id){
             session(['attivita_attuale' => null]);
             Cookie::queue(Cookie::forget('binding_token'));
                     if ($isDataTableDrawRequest) {
                         // Prosegue senza interrompere la risposta DataTable.
                     } else {
-                        dd('11, altro dispositivo', json_encode(request()->cookie()));
-
                         return redirect()->route('punto-vendita.index')->with('error', 'Dispositivo già occupato. Dissociare per potervi accedere.');
                     }
                 }
         if (! $puntoVendita) {
             return response()->json(['success' => false, 'message' => 'Punto di vendita non trovato']);
         }
-
+        AttivitaService::garantisciAttivita($puntoVendita->attivita_id);
+        
         Cookie::queue(Cookie::forget('binding_token'));
 
         $puntoVendita->binding_token = null;
             return redirect()->route('punto-vendita.kiosk.index')
                 ->with('error', 'Ordine non trovato');
         }
+        AttivitaService::garantisciAttivita($ordine->attivita_id);
 
         return view('punto_vendita.kiosk.riepilogo', ['ordine' => $ordine]);
     }
             return redirect()->route('punto-vendita.index')
                 ->with('error', 'Punto di vendita non trovato');
         }
-
+        AttivitaService::garantisciAttivita($puntoVendita->attivita_id);
+        
         return view('punto_vendita.dettagli', ['puntoVendita' => $puntoVendita]);
     }
 
             return redirect()->route('punto-vendita.index')
                 ->with('error', 'Punto di vendita non trovato');
         }
-        // Calcola la data di oggi
+        AttivitaService::garantisciAttivita($puntoVendita->attivita_id);
+        
         $oggi = now()->startOfDay();
 
-        // Recupera tutti gli ordini di oggi per il punto vendita
-        $ordiniOggi = \App\Models\Ordine::where('dispositivo_id', $puntoVendita->id)
+        // Solo ordini effettivamente pagati (esclude carrelli e tentativi falliti)
+        $ordiniOggi = Ordine::query()
+            ->where('dispositivo_id', $puntoVendita->id)
+            ->where('stato', Ordine::PAGATO)
             ->whereDate('created_at', $oggi)
             ->get();
 
-        // Conta il totale ordini di oggi
         $totaleOrdiniOggi = $ordiniOggi->count();
-
         $ordineIds = $ordiniOggi->pluck('id')->all();
 
         if ($ordineIds === []) {
             $pagamentiPerMetodo = [];
             $pagamentiConteggioPerMetodo = [];
         } else {
-            // Somma importi pagamenti legati agli ordini di oggi di questo punto vendita
-            $totaleIncassi = (float) Pagamento::query()
+            // Solo pagamenti con stato "pagato" (scopePerIncasso)
+            $pagamentiBase = Pagamento::query()
                 ->whereIn('ordine_id', $ordineIds)
-                ->sum('importo');
+                ->perIncasso();
 
-            // Raggruppa per metodo_pagamento_id (colonna reale su tabella pagamento)
-            $pagamentiPerMetodo = Pagamento::query()
-                ->whereIn('ordine_id', $ordineIds)
+            $totaleIncassi = (float) (clone $pagamentiBase)->sum('importo');
+
+            $pagamentiPerMetodo = (clone $pagamentiBase)
                 ->selectRaw('metodo_pagamento_id, SUM(importo) as totale_importo')
                 ->groupBy('metodo_pagamento_id')
                 ->pluck('totale_importo', 'metodo_pagamento_id')
                 ->map(fn ($v) => (float) $v)
                 ->all();
 
-            $pagamentiConteggioPerMetodo = Pagamento::query()
-                ->whereIn('ordine_id', $ordineIds)
+            $pagamentiConteggioPerMetodo = (clone $pagamentiBase)
                 ->selectRaw('metodo_pagamento_id, COUNT(*) as conteggio')
                 ->groupBy('metodo_pagamento_id')
                 ->pluck('conteggio', 'metodo_pagamento_id')
     public function cerca_pre_ordine(Request $request)
     {
         $codice = $request->get('codice');
-        // $pre_ordine = \App\Models\SaltacodaOrdine::where('codice' , $codice)->first();
-        // $pre_ordine = \App\Models\SaltacodaOrdine::where('codice', 'like', '%PRE_'.strtoupper($codice).'%')->first();
-        $pre_ordine = \App\Models\SaltacodaOrdine::where('codice', 'like', '%'.strtoupper($codice).'%')->first();
+        if($codice == '' || $codice == null) {
+            return view('punto_vendita.cassa._partials.pre_ordine', ['success' => false, 'error' => 'Codice pre-ordine non valido']);
+        }
+        $codice = SaltacodaOrdine::normalizzaCodice($codice);
+        if ($codice === '') {
+            return view('punto_vendita.cassa._partials.pre_ordine', ['success' => false, 'error' => 'Codice pre-ordine non valido']);
+        }
+        if (strlen($codice) < 3) {
+            return view('punto_vendita.cassa._partials.pre_ordine', ['success' => false, 'error' => 'Inserisci almeno 3 caratteri']);
+        }
 
-        // Se non trovato, prova con "PRE_" come prefisso se non già presente
-        if (! $pre_ordine && stripos($codice, 'PRE_') !== 0) {
-            $pre_ordine = \App\Models\SaltacodaOrdine::where('codice', 'like', '%PRE_'.strtoupper($codice).'%')->first();
+        if (! Session::has('attivita_attuale') || Session::get('attivita_attuale') === null) {
+            return view('punto_vendita.cassa._partials.pre_ordine', ['success' => false, 'error' => 'Attività non trovata']);
         }
 
-        if (! $pre_ordine) {
-            return view('punto_vendita.cassa._partials.pre_ordine', ['success' => false, 'error' => 'Pre-ordine non trovato']);
+        $attivitaId = (int) Session::get('attivita_attuale');
+        $query = SaltacodaOrdine::query()->where('attivita_id', $attivitaId);
 
-            // return response()->json(['success' => false, 'message' => 'Pre-ordine non trovato']);
-        }
+        $pre_ordine = strlen($codice) >= 6
+            ? $query->where('codice', $codice)->first()
+            : $query->where('codice', 'like', $codice.'%')->first();
 
-        if (! (Session::has('attivita_attuale') && Session::get('attivita_attuale') != null && (int) Session::get('attivita_attuale') == (int) $pre_ordine->attivita_id)) {
-            return view('punto_vendita.cassa._partials.pre_ordine', ['success' => false, 'error' => 'Attività non trovata']);
-    
-        // return response()->json(['success' => false, 'message' => 'Pre-ordine non trovato']);
+        if (! $pre_ordine) {
+            return view('punto_vendita.cassa._partials.pre_ordine', ['success' => false, 'error' => 'Pre-ordine non trovato']);
         }
 
         return view('punto_vendita.cassa._partials.pre_ordine', ['pre_ordine' => $pre_ordine]);
     public function importa_pre_ordine(Request $request)
 {
     $codice = (string) $request->get('codice');
+    if($codice == '' || $codice == null) {
+        return response()->json(['success' => false, 'message' => 'Codice pre-ordine non valido']);
+    }
+    $codice = SaltacodaOrdine::normalizzaCodice($codice);
 
     if (! Session::has('attivita_attuale') || Session::get('attivita_attuale') === null) {
         return response()->json(['success' => false, 'message' => 'Attività non trovata']);
             if (! $ordine || $ordine->stato !== Ordine::CARRELLO) {
                 return response()->json(['success' => false, 'message' => 'Ordine non valido']);
             }
+            AttivitaService::garantisciAttivita($ordine->attivita_id);
 
             $isPrimoImport = $pre_ordine->stato === SaltacodaOrdine::PRE_ORDINE;
             $isRipristino = $pre_ordine->stato === SaltacodaOrdine::PRE_CARRELLO

app/Http/Controllers/RigaFatturazioneController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Storage;
 use Illuminate\Support\Facades\Validator;

app/Http/Controllers/RigaOrdineController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use Illuminate\Database\Eloquent\Builder;
 use App\Models\Dispositivo;
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-riga_ordine', only: ['index']),
-            new Middleware('permission:create-riga_ordine|edit-riga_ordine|delete-riga_ordine', only: ['store', 'update', 'destroy']),
+            new Middleware('permission:view-riga_ordine|view-cucina|view-asporto|view-punto_vendita', only: ['index', 'datatable', 'dettagli', 'lista_da_chiamare', 'lista_chiamate']),
+            new Middleware('permission:create-riga_ordine|edit-riga_ordine|delete-riga_ordine|view-cucina|view-asporto|view-punto_vendita', only: ['store', 'update', 'destroy', 'chiamata', 'ritiro']),
         ];
     }
 
-    public function dettagli(Request $request){
-        if($request->has('riga_ordine_id')){
-            $riga_ordine = RigaOrdine::find($request->riga_ordine_id);
-            if($riga_ordine == null){ return response()->json(['success' => false, 'message' => 'Riga ordine non trovata']); }
-            return view('punto_vendita.cassa._partials.carrello.cmd_carrello', ['cmd' => 'dettagli', 'riga_ordine_id' => $riga_ordine->id]);
+    public function dettagli(Request $request)
+    {
+        if (! $request->has('riga_ordine_id')) {
+            return response()->json(['success' => false, 'message' => 'ID non valido']);
         }
-        return response()->json(['success' => false, 'message' => 'ID non valido']);
-        
+
+        $riga_ordine = app(\App\Services\Carrello\CarrelloService::class)
+            ->rigaDiQuestaCassa((int) $request->riga_ordine_id);
+
+        return view('punto_vendita.cassa._partials.carrello.cmd_carrello', ['cmd' => 'dettagli', 'riga_ordine_id' => $riga_ordine->id]);
     }
 
     public function lista_da_chiamare(Request $request){

app/Http/Controllers/RigaOrdineNotificaController.php

     public function salva_fcm_token(Request $request)
     {
         $request->validate([
-            'ordine_id' => 'required|integer',
+            'ordine_codice' => 'required|string',
             'fcm_token' => 'required|string',
         ]);
 
         $ordine = Ordine::query()
-            ->where('id', $request->input('ordine_id'))
+            ->where('codice', $request->input('ordine_codice'))
             ->where('stato', Ordine::PAGATO)
             ->first();
 

app/Http/Controllers/RoleController.php

   public static function middleware(): array
   {
     return [
-      new Middleware('permission:view-role', only: ['index']),
+      new Middleware('permission:view-role', only: ['index', 'showEdit', 'showNew', 'getPermissions']),
+      new Middleware('permission:create-role', only: ['createRole']),
+      new Middleware('permission:edit-role', only: ['updatePermission']),
       new Middleware('permission:create-role|edit-role|remove-role', only: ['store']),
     ];
   }

app/Http/Controllers/SaltacodaController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Attivita;
 use App\Models\Cucina;
 use App\Models\Piatto;
 use App\Models\Saltacoda;
 use App\Models\SaltacodaOrdine;
-use App\Models\SaltacodaRigaordine;
+use App\Models\SaltacodaRigaOrdine;
 use App\Models\VariantePiatto;
 use App\Models\SaltacodaRigaOrdineHasVariante;
 use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Str;
+use App\Services\Attivita\AttivitaService;
 
 
 class SaltacodaController extends Controller
     {
         return [
             new Middleware('permission:view-saltacoda', only: ['index']),
-            new Middleware('permission:create-saltacoda|edit-saltacoda|delete-saltacoda', only: ['store', 'update', 'destroy']),
+            new Middleware('permission:create-saltacoda|edit-saltacoda|delete-saltacoda', only: ['store', 'update', 'destroy', 'attiva']),
         ];
     }
 
             'istruzioni' => 'nullable|json',
         ]);
 
+        AttivitaService::garantisciAttivita($request->attivita_id);
+
         $saltacoda = Saltacoda::updateOrCreate(
             ['attivita_id' => $request->attivita_id],
             [
         return redirect()->route('saltacoda.index')->with('success', 'Saltacoda salvato');
     }
 
-    public function show(Request $request)
+
+    ///METODI CLIENTE NON AUTENTICATI
+    public function show(Request $request, $slug)
     {
-        $attivita = Attivita::find($request->get('attivita_id'));
+        $attivita = Attivita::where('slug', $slug)->first();
         if(!$attivita) {
             return response()->json([
                 'success' => false,
             }
         }
 
+        $ordineInModifica = null;
+        $avvisiModifica = null;
+        if ($request->filled('codice')) {
+            $preOrdine = $this->trovaPreOrdineModificabile(
+                $request->get('codice'),
+                (int) $attivita->id,
+                false,
+                $this->tokenCliente($request)
+            );
+            if ($preOrdine) {
+                $avvisiModifica = $this->analizzaOrdineNonValido($preOrdine);
+                $ordineInModifica = $this->serializzaPreOrdinePerModifica($preOrdine);
+            }
+        }
+
         return view('saltacoda.show', [
             'attivita' => $attivita,
             'cucine' => $cucine,
             'saltacoda_id' => $saltacoda->id,
             'varianti_per_piatto' => $variantiPerPiatto,
             'varianti_per_cucina' => $variantiPerCucina,
+            'ordine_in_modifica' => $ordineInModifica,
+            'avvisi_modifica' => $avvisiModifica,
         ]);
     }
 
     public function pre_ordine_salva(Request $request)
-    {
+    {       
         $request->validate([
             'saltacoda_id' => 'required|exists:saltacoda,id',
             'attivita_id' => 'required|exists:attivita,id',
             'riga_ordine.*.varianti.*' => 'integer|exists:variante_piatto,id',
             'info_cliente' => 'nullable|array',
             'idempotency_key' => 'nullable|string|max:120',
+            'codice' => 'nullable|string|max:9',
+            't' => 'nullable|string|max:64',
         ]);
 
         $saltacoda = Saltacoda::where('id', $request->saltacoda_id)
             ], 422);
         }
 
+        $isModifica = $request->filled('codice');
+
         try {
-            $saltacoda_ordine = DB::transaction(function () use ($request) {
-                $saltacoda_ordine = SaltacodaOrdine::firstOrNew([
-                    'riferimento' => $request->idempotency_key,
-                ]);
+            $saltacoda_ordine = DB::transaction(function () use ($request, $isModifica) {
+                if ($isModifica) {
+                    $saltacoda_ordine = $this->trovaPreOrdineModificabile(
+                        $request->codice,
+                        (int) $request->attivita_id,
+                        true,
+                        $this->tokenCliente($request)
+                    );
+
+                    if (!$saltacoda_ordine) {
+                        throw new \InvalidArgumentException('Questo pre-ordine non può più essere modificato.');
+                    }
+                } else {
+                    $saltacoda_ordine = SaltacodaOrdine::firstOrNew([
+                        'riferimento' => $request->idempotency_key,
+                    ]);
+
+                    if (!$saltacoda_ordine->exists) {
+                        $saltacoda_ordine->codice = $this->genera_codice_saltacoda();
+                        $saltacoda_ordine->token = Str::random(32);
+                    } elseif (! filled($saltacoda_ordine->token)) {
+                        $saltacoda_ordine->token = Str::random(32);
+                    }
 
-                if (!$saltacoda_ordine->exists) {
-                    $saltacoda_ordine->codice = $this->genera_codice_saltacoda();
+                    $saltacoda_ordine->riferimento = $request->idempotency_key;
                 }
 
                 $saltacoda_ordine->fill([
-                    'riferimento' => $request->idempotency_key,
                     'attivita_id' => $request->attivita_id,
                     'info' => $request->info_cliente,
                     'prenotazione_id' => null,
                 $saltacoda_ordine->save();
 
                 $saltacoda_ordine->saltacoda_riga_ordine()->delete();
-
-                foreach ($request->riga_ordine as $riga) {
-                    $piatto = Piatto::query()
-                        ->where('id', $riga['piatto_id'])
-                        ->where('attivita_id', $request->attivita_id)
-                        ->first();
-
-                    if (!$piatto) {
-                        throw new \InvalidArgumentException('Piatto non valido per questa attività.');
-                    }
-
-                    $qta = (int) $riga['qta'];
-                    $varianteIds = collect($riga['varianti'] ?? [])->unique()->values();
-                    $varianti = $varianteIds->isEmpty()
-                        ? collect()
-                        : VariantePiatto::query()
-                            ->where('attivita_id', $request->attivita_id)
-                            ->where('is_attivo', true)
-                            ->whereIn('id', $varianteIds)
-                            ->get();
-
-                    if ($varianteIds->count() !== $varianti->count()) {
-                        throw new \InvalidArgumentException('Una o più varianti non sono valide per questa attività.');
-                    }
-
-                    $prezzoRiga = $this->calcolaPrezzoRigaSaltacoda($piatto, $qta, $varianti);
-
-                    $saltacoda_riga = SaltacodaRigaordine::create([
-                        'saltacoda_ordine_id' => $saltacoda_ordine->id,
-                        'piatto_id' => $piatto->id,
-                        'quantita' => $qta,
-                        'note' => $riga['note'] ?? null,
-                        'prezzo' => $prezzoRiga,
-                    ]);
-
-                    foreach ($varianti as $variante) {
-                        SaltacodaRigaOrdineHasVariante::create([
-                            'saltacoda_riga_ordine_id' => $saltacoda_riga->id,
-                            'variante_id' => $variante->id,
-                            'nota' => null,
-                        ]);
-                    }
-                }
+                $this->salvaRighePreOrdine($saltacoda_ordine, $request);
 
                 $saltacoda_ordine->prezzo = $saltacoda_ordine->saltacoda_riga_ordine()->sum('prezzo');
                 $saltacoda_ordine->save();
                 ]);
             });
 
-            return response()->json([
+            $json = response()->json([
                 'success' => true,
-                'message' => 'Pre-ordine salvato',
+                'message' => $isModifica ? 'Pre-ordine aggiornato' : 'Pre-ordine salvato',
                 'data' => $saltacoda_ordine,
+                'token' => $saltacoda_ordine->token,
             ]);
+
+            if (filled($saltacoda_ordine->token)) {
+                $json->cookie(
+                    'saltacoda_token',
+                    $saltacoda_ordine->token,
+                    60 * 12,
+                    '/',
+                    null,
+                    false,
+                    true,
+                    false,
+                    'lax'
+                );
+            }
+
+            return $json;
+
         } catch (\InvalidArgumentException $exception) {
             return response()->json([
                 'success' => false,
 
     public function pre_ordine_show(Request $request)
     {
+        if($request->get('codice') === '' || $request->get('codice') == '' || $request->get('codice') == null) {
+            return abort(404);
+        }
+        $codice = SaltacodaOrdine::normalizzaCodice($request->get('codice'));
+        $token = $this->tokenCliente($request);
+        if ($codice === '' || $token === '') {
+            return abort(404);
+        }
+
         $saltacoda_ordine = SaltacodaOrdine::query()
             ->with([
                 'saltacoda_riga_ordine.piatto',
                 'saltacoda_riga_ordine.saltacoda_has_variante.variante_piatto',
                 'attivita',
             ])
-            ->where('codice', $request->get('codice'))
+            ->where('codice', $codice)
+            ->where('token', $token)
             ->first();
         if(!$saltacoda_ordine) {
             return abort(404);
         }
-        return view('saltacoda.pre_ordine', ['saltacoda_ordine' => $saltacoda_ordine]);
+
+        $avvisiModifica = null;
+        if ($saltacoda_ordine->stato === SaltacodaOrdine::PRE_ORDINE) {
+            $avvisiModifica = $this->analizzaOrdineNonValido($saltacoda_ordine);
+        }
+
+        return view('saltacoda.pre_ordine', [
+            'saltacoda_ordine' => $saltacoda_ordine,
+            'modificabile' => $saltacoda_ordine->stato === SaltacodaOrdine::PRE_ORDINE,
+            'avvisi_modifica' => $avvisiModifica,
+        ]);
+    }
+
+
+    ///METODI PRIVATI
+
+    private function tokenCliente(Request $request): string
+    {
+        return trim((string) ($request->cookie('saltacoda_token') ?: $request->input('t') ?: ''));
+    }
+
+    private function trovaPreOrdineModificabile(?string $codice, int $attivitaId, bool $lock = false, ?string $token = null): ?SaltacodaOrdine
+    {
+        $codice = SaltacodaOrdine::normalizzaCodice($codice);
+        $token = trim((string) $token);
+        if ($codice === '' || $token === '') {
+            return null;
+        }
+
+        $query = SaltacodaOrdine::query()
+            ->with([
+                'saltacoda_riga_ordine.piatto',
+                'saltacoda_riga_ordine.saltacoda_has_variante.variante_piatto',
+            ])
+            ->where('codice', $codice)
+            ->where('token', $token)
+            ->where('attivita_id', $attivitaId)
+            ->where('stato', SaltacodaOrdine::PRE_ORDINE);
+
+        if ($lock) {
+            $query->lockForUpdate();
+        }
+
+        return $query->first();
+    }
+
+    private function analizzaOrdineNonValido(SaltacodaOrdine $ordine): array
+    {
+        $ordine->loadMissing([
+            'saltacoda_riga_ordine.piatto',
+            'saltacoda_riga_ordine.saltacoda_has_variante.variante_piatto',
+        ]);
+
+        $piattiRimossi = [];
+        $variantiRimosse = [];
+
+        foreach ($ordine->saltacoda_riga_ordine as $riga) {
+            $piatto = $riga->piatto;
+            $nomePiatto = $piatto?->nome ?? ('Piatto #' . $riga->piatto_id);
+
+            if (!$piatto || !$piatto->is_attivo) {
+                $piattiRimossi[] = [
+                    'nome' => $nomePiatto,
+                    'qta' => (int) $riga->quantita,
+                ];
+                continue;
+            }
+
+            foreach ($riga->saltacoda_has_variante as $hasVariante) {
+                $variante = $hasVariante->variante_piatto;
+                if (!$variante || !$variante->is_attivo) {
+                    $variantiRimosse[] = [
+                        'piatto' => $nomePiatto,
+                        'label' => $variante?->label ?? 'Opzione',
+                    ];
+                }
+            }
+        }
+
+        return [
+            'piatti_rimossi' => $piattiRimossi,
+            'varianti_rimosse' => $variantiRimosse,
+            'ha_problemi' => $piattiRimossi !== [] || $variantiRimosse !== [],
+        ];
+    }
+
+    private function pulisciOrdineNonValido(SaltacodaOrdine $ordine): array
+    {
+        $avvisi = $this->analizzaOrdineNonValido($ordine);
+        if (!$avvisi['ha_problemi']) {
+            return $avvisi;
+        }
+
+        $ordine->loadMissing([
+            'saltacoda_riga_ordine.piatto',
+            'saltacoda_riga_ordine.saltacoda_has_variante.variante_piatto',
+        ]);
+
+        $dirty = false;
+
+        foreach ($ordine->saltacoda_riga_ordine as $riga) {
+            $piatto = $riga->piatto;
+
+            if (!$piatto || !$piatto->is_attivo) {
+                $riga->saltacoda_has_variante()->delete();
+                $riga->delete();
+                $dirty = true;
+                continue;
+            }
+
+            $rigaDirty = false;
+            foreach ($riga->saltacoda_has_variante as $hasVariante) {
+                $variante = $hasVariante->variante_piatto;
+                if (!$variante || !$variante->is_attivo) {
+                    $hasVariante->delete();
+                    $rigaDirty = true;
+                    $dirty = true;
+                }
+            }
+
+            if ($rigaDirty) {
+                $riga->load('saltacoda_has_variante.variante_piatto');
+                $variantiValide = $riga->saltacoda_has_variante
+                    ->map(fn ($hasVariante) => $hasVariante->variante_piatto)
+                    ->filter();
+
+                $riga->prezzo = $this->calcolaPrezzoRigaSaltacoda(
+                    $piatto,
+                    (int) $riga->quantita,
+                    $variantiValide
+                );
+                $riga->save();
+            }
+        }
+
+        if ($dirty) {
+            $ordine->prezzo = $ordine->saltacoda_riga_ordine()->sum('prezzo');
+            $ordine->save();
+        }
+
+        return $avvisi;
+    }
+
+    private function serializzaPreOrdinePerModifica(SaltacodaOrdine $ordine): array
+    {
+        $ordine->loadMissing([
+            'saltacoda_riga_ordine.piatto',
+            'saltacoda_riga_ordine.saltacoda_has_variante.variante_piatto',
+        ]);
+
+        $righe = [];
+        foreach ($ordine->saltacoda_riga_ordine as $riga) {
+            $piatto = $riga->piatto;
+            if (!$piatto || !$piatto->is_attivo) {
+                continue;
+            }
+
+            $varianti = [];
+            foreach ($riga->saltacoda_has_variante as $hasVariante) {
+                $variante = $hasVariante->variante_piatto;
+                if (!$variante || !$variante->is_attivo) {
+                    continue;
+                }
+
+                $varianti[] = [
+                    'id' => $variante->id,
+                    'label' => $variante->label,
+                    'prezzo' => (float) $variante->prezzo,
+                    'scope' => filled($variante->piatto_id) ? 'piatto' : 'cucina',
+                ];
+            }
+
+            $righe[] = [
+                'piatto_id' => $riga->piatto_id,
+                'cucina_id' => $piatto->cucina_id,
+                'nome' => $piatto->nome,
+                'qta' => (int) $riga->quantita,
+                'note' => $riga->note ?? '',
+                'prezzo_base' => (float) $piatto->prezzo,
+                'varianti' => $varianti,
+            ];
+        }
+
+        $info = $ordine->info;
+        if (is_string($info)) {
+            $decoded = json_decode($info, true);
+            $info = is_array($decoded) ? $decoded : [];
+        }
+        if (!is_array($info)) {
+            $info = [];
+        }
+
+        return [
+            'codice' => $ordine->codice,
+            'info_cliente' => $info,
+            'righe' => $righe,
+        ];
+    }
+
+    private function salvaRighePreOrdine(SaltacodaOrdine $saltacoda_ordine, Request $request): void
+    {
+        foreach ($request->riga_ordine as $riga) {
+            $piatto = Piatto::query()
+                ->where('id', $riga['piatto_id'])
+                ->where('attivita_id', $request->attivita_id)
+                ->first();
+
+            if (!$piatto) {
+                throw new \InvalidArgumentException('Piatto non valido per questa attività.');
+            }
+
+            $qta = (int) $riga['qta'];
+            $varianteIds = collect($riga['varianti'] ?? [])->unique()->values();
+            $varianti = $varianteIds->isEmpty()
+                ? collect()
+                : VariantePiatto::query()
+                    ->where('attivita_id', $request->attivita_id)
+                    ->where('is_attivo', true)
+                    ->whereIn('id', $varianteIds)
+                    ->get();
+
+            if ($varianteIds->count() !== $varianti->count()) {
+                throw new \InvalidArgumentException('Una o più varianti non sono valide per questa attività.');
+            }
+
+            $prezzoRiga = $this->calcolaPrezzoRigaSaltacoda($piatto, $qta, $varianti);
+
+            $saltacoda_riga = SaltacodaRigaOrdine::create([
+                'saltacoda_ordine_id' => $saltacoda_ordine->id,
+                'piatto_id' => $piatto->id,
+                'quantita' => $qta,
+                'note' => $riga['note'] ?? null,
+                'prezzo' => $prezzoRiga,
+            ]);
+
+            foreach ($varianti as $variante) {
+                SaltacodaRigaOrdineHasVariante::create([
+                    'saltacoda_riga_ordine_id' => $saltacoda_riga->id,
+                    'variante_id' => $variante->id,
+                    'nota' => null,
+                ]);
+            }
+        }
     }
 
     private function calcolaPrezzoRigaSaltacoda(Piatto $piatto, int $qta, $varianti): float
         $parteLettera = $lettereSicure[rand(0, count($lettereSicure) - 1)];
         $parteCifre2 = str_pad(strval(rand(0, 99)), 2, '0', STR_PAD_LEFT);
         $parteCifre3 = str_pad(strval(rand(0, 999)), 3, '0', STR_PAD_LEFT);
-        $codice = strtoupper($parteLettera . $parteCifre2 . '-' . $parteCifre3);
+        $codice = strtoupper($parteLettera . $parteCifre2 . $parteCifre3);
 
         if (SaltacodaOrdine::where('codice', $codice)->exists()) {
             return $this->genera_codice_saltacoda();

app/Http/Controllers/StampanteController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\Dispositivo;
 use App\DataTables\StampanteDataTable;

app/Http/Controllers/TavoloController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use App\Models\Tavolo;
 use App\DataTables\TavoloDataTable;
 use App\DataTables\TavoloDataTableEditor;

app/Http/Controllers/TestiController.php

 namespace App\Http\Controllers;
 
 use Illuminate\Http\Request;
+use Illuminate\Routing\Controllers\Middleware;
 use App\Models\Testi;
 use App\DataTables\TestiDataTable;
 use App\DataTables\TestiDataTableEditor;
         return [
             new Middleware('permission:view-testi', only: ['index']),
             new Middleware('permission:create-testi|edit-testi|delete-testi', only: ['store', 'update', 'destroy']),
-            new Middleware('permission:show-testi-cliente', only: ['show_cliente']),
         ];
     }
 
     {
         switch($request->get('oggetto')){
             case 'privacy':
+                $attivitaId = (int) ($request->get('attivita_id') ?: Session::get('attivita_attuale'));
+                if ($attivitaId <= 0) {
+                    abort(404);
+                }
                 $testi = Testi::where('ambiente', 'cliente')
                 ->where('tipo', 'privacy')
                 ->where('is_attivo', true)
+                ->where('attivita_id', $attivitaId)
                 ->orderBy('created_at', 'desc')
                 ->first();
                 break;
             default:
-                $testi = Testi::find($request->get('testi_id'));
+                $testi = Testi::query()
+                    ->where('is_attivo', true)
+                    ->find($request->get('testi_id'));
                 break;
         }
 

app/Http/Controllers/TombolaController.php

 namespace App\Http\Controllers;
 
 use Illuminate\Http\Request;
+use Illuminate\Routing\Controllers\Middleware;
 use App\Models\Tombola;
 use Illuminate\Support\Facades\Session;
 use Illuminate\Support\Facades\Auth;
 use App\Models\Attivita;
+use App\Services\Attivita\AttivitaService;
 
 class TombolaController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-tombola', only: ['index']),
-            new Middleware('permission:create-tombola|edit-tombola|delete-tombola', only: ['getTabellone', 'estrai', 'azzera', 'estratti']),
+            new Middleware('permission:view-tombola', only: ['index', 'tabellone']),
+            new Middleware('permission:create-tombola|edit-tombola|delete-tombola', only: ['getTabellone', 'estrai', 'azzera']),
         ];
     }
     public function getTabellone(Request $request, $attivita_id){
         if(!$attivita){
             return redirect()->route('tombola.index')->with('error', 'Attivita non trovata.');
         }
+        AttivitaService::garantisciAttivita($attivita->id);
         if(!Auth::user()->can('create-tombola')){
             return redirect()->route('tombola.index')->with('error', 'Non hai permesso di creare il tabellone.');
         }
     public function tabellone(Request $request, $attivita_id){
         if(!Auth::user()->can('view-tombola')){
             return redirect()->route('tombola.index')->with('error', 'Non hai permesso di vedere il tabellone.');
-        }elseif(!Attivita::find($attivita_id)->user_id == Auth::user()->id){
-            return redirect()->route('tombola.index')->with('error', 'Non sei autorizzato a vedere il tabellone di questa attività.');
         }
         $attivita = Attivita::find($attivita_id);
         if(!$attivita){
             return redirect()->route('tombola.index')->with('error', 'Attivita non trovata.');
         }
+        AttivitaService::garantisciAttivita($attivita->id);
         return view('tombola.tabellone', [
             'attivita' => $attivita,
         ]);
         if(!$attivita){
             return redirect()->route('tombola.index')->with('error', 'Attivita non trovata.');
         }
+        AttivitaService::garantisciAttivita($attivita->id);
         if(!Auth::user()->can('view-tombola')){
             return redirect()->route('tombola.index')->with('error', 'Non hai permesso di estrarre numeri.');
-        }elseif($attivita->user_id != Auth::user()->id){
-            return redirect()->route('tombola.index')->with('error', 'Non sei autorizzato a estrarre numeri da questa attività.');
         }
         $tabellone = Tombola::where('attivita_id', $attivita_id);
         $tombola = $tabellone->where('estratto', false)->inRandomOrder()->first();
         if(!$attivita){
             return redirect()->route('tombola.index')->with('error', 'Attivita non trovata.');
         }
+        AttivitaService::garantisciAttivita($attivita->id);
         if(!Auth::user()->can('delete-tombola')){
             return redirect()->route('tombola.index')->with('error', 'Non hai permesso di azzerare la tombola.');
-        }elseif($attivita->user_id != Auth::user()->id){
-            return redirect()->route('tombola.index')->with('error', 'Non sei autorizzato a azzerare la tombola di questa attività.');
         }
 
         Tombola::where('attivita_id', $attivita_id)->update([

app/Http/Controllers/UserController.php

   public static function middleware(): array
   {
     return [
-      new Middleware('permission:view-user', only: ['index']),
+      new Middleware('permission:view-user', only: ['index', 'admin_list']),
+      new Middleware('permission:create-user', only: ['create']),
+      new Middleware('permission:edit-user', only: ['edit_profilo', 'updateProfile', 'upload_foto_profilo', 'showCropImage', 'cropImage']),
       new Middleware('permission:create-user|edit-user|remove-user', only: ['store', 'admin_aggiorna']),
       new Middleware('role:superadmin', only: ['superadmin_impersonate']),
     ];