Limita i CRUD admin all'attivita in sessione.

Così un operatore non legge o modifica dati di un'altra sagra.

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

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/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/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/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/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/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/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/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/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/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/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/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/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/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/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']),
     ];

app/Http/Controllers/VariantePiattoController.php

 
 namespace App\Http\Controllers;
 
+
+use Illuminate\Routing\Controllers\Middleware;
 use Illuminate\Http\Request;
 use App\Models\VariantePiatto;
 use App\DataTables\VariantePiattoDataTable;
 use App\DataTables\VariantePiattoDataTableEditor;
 use Illuminate\Support\Facades\Session;
 use Illuminate\Support\Facades\Auth;
+use App\Services\Attivita\AttivitaService;
 
 class VariantePiattoController extends Controller
 {
     public static function middleware(): array
     {
         return [
-            new Middleware('permission:view-variante-piatto', only: ['index']),
+            new Middleware('permission:view-variante-piatto', only: ['index', 'datatable', 'list']),
             new Middleware('permission:create-variante-piatto|edit-variante-piatto|delete-variante-piatto', only: ['store', 'update', 'destroy']),
         ];
     }
       }
 
     public function list(Request $request){
-        $attivita = \App\Models\Attivita::find(Session::get('attivita_attuale'));
+        $attivitaId = Session::get('attivita_attuale');
+        AttivitaService::garantisciAttivita($attivitaId);
+        $attivita = \App\Models\Attivita::find($attivitaId);
         if(!$attivita){
           return response()->json([
             'success' => false,
             'message' => 'Attività non trovata',
           ]);
         }
-        $rigaOrdine = \App\Models\RigaOrdine::find($request->riga_ordine_id);
-        if(!$rigaOrdine){
-          return response()->json([
-            'success' => false,
-            'message' => 'Riga ordine non trovata',
-          ]);
-        }
+        $rigaOrdine = app(\App\Services\Carrello\CarrelloService::class)
+            ->rigaDiQuestaCassa((int) $request->riga_ordine_id);
     
       $variantiCucina = VariantePiatto::query()
       ->where('attivita_id', $attivita->id)

app/Models/AbstractModels/AbstractUser.php

     {
         return $this->hasMany('\App\Models\Attivita', 'user_id', 'id');
     }
-    public function fatturazione()
+    public function fattura()
     {
-        return $this->hasMany('\App\Models\Fatturazione', 'user_id', 'id');
+        return $this->hasMany('\App\Models\Fattura', 'user_id', 'id');
     }
     
 }

app/Models/Attivita.php

             return null;
         }
 
-        return str_starts_with($this->path_logo, 'http')
-            ? $this->path_logo
-            : asset($this->path_logo);
+        if (str_starts_with($this->path_logo, 'http')) {
+            return $this->path_logo;
+        }
+
+        if (str_starts_with($this->path_logo, 'assets/')) {
+            return asset($this->path_logo);
+        }
+
+        $disk = Storage::disk('copertinaAttivita');
+        if ($disk->exists($this->path_logo)) {
+            return $disk->url($this->path_logo);
+        }
+
+        return asset($this->path_logo);
+    }
+
+    /**
+     * Path filesystem assoluto del logo (per DomPDF).
+     */
+    public function logoLocalPath(): ?string
+    {
+        if (empty($this->path_logo)) {
+            return null;
+        }
+
+        $raw = (string) $this->path_logo;
+        if (str_starts_with($raw, 'http://') || str_starts_with($raw, 'https://')) {
+            return $raw;
+        }
+
+        if (str_starts_with($raw, 'assets/')) {
+            $candidate = public_path($raw);
+
+            return is_file($candidate) ? $candidate : null;
+        }
+
+        $candidate = storage_path('app/public/copertinaAttivita/'.ltrim($raw, '/'));
+        if (is_file($candidate)) {
+            return $candidate;
+        }
+
+        $candidate = public_path(ltrim($raw, '/'));
+        if (is_file($candidate)) {
+            return $candidate;
+        }
+
+        $candidate = public_path('storage/'.ltrim($raw, '/'));
+
+        return is_file($candidate) ? $candidate : null;
     }
 
     public static function defaultLogoUrl(): string
         return mb_strtoupper(mb_substr($parts[0], 0, 1) . mb_substr($parts[1], 0, 1));
     }
 
+    /**
+     * Slug pubblico (fallback se mancante in DB).
+     */
+    public function publicSlug(): string
+    {
+        if (filled($this->slug)) {
+            return (string) $this->slug;
+        }
+
+        return \Illuminate\Support\Str::slug((string) $this->nome) ?: 'attivita-'.$this->id;
+    }
+
+    public function publicUrl(): string
+    {
+        return route('cliente.attivita.show', ['slug' => $this->publicSlug()]);
+    }
+
     public static function E_Mia($attivita_id)
     {
         return self::where('id', $attivita_id)->where('user_id', Auth::user()->id)->exists();

app/Observers/AttivitaObserver.php

 use App\Models\Impostazioni;
 use App\Models\Saltacoda;
 use App\Models\Asporto;
+use Illuminate\Support\Str;
 
 class AttivitaObserver
 {
+    /**
+     * Default slug prima del salvataggio.
+     */
+    public function creating(Attivita $attivita): void
+    {
+        if (! filled($attivita->slug)) {
+            $base = Str::slug((string) $attivita->nome) ?: 'attivita';
+            $slug = $base;
+            $i = 2;
+            while (Attivita::where('slug', $slug)->exists()) {
+                $slug = $base.'-'.$i;
+                $i++;
+            }
+            $attivita->slug = $slug;
+        }
+    }
+
     /**
      * Handle the Attivita "created" event.
      */
             'sito_web' => '',
             'note' => '',
         ]);
+        $attivita->saveQuietly();
 
         //crea saltacoda
         Saltacoda::create([

app/Services/Attivita/AttivitaService.php

+<?php
+
+namespace App\Services\Attivita;
+
+use App\Models\Evento;
+use App\Models\Attivita;
+
+class AttivitaService
+{
+
+    public static function garantisciEventoDiQuestaAttivita(?Evento $evento)
+    {
+        if (auth()->user()?->hasRole('superadmin')) {
+            return;
+        }
+
+        $attuale = (int) session('attivita_attuale');
+        if (! $evento || $attuale <= 0 || (int) $evento->attivita_id !== $attuale) {
+            abort(404);
+        }
+    }
+
+    public static function garantisciAttivita($attivita_id)
+    {
+        if (auth()->user()?->hasRole('superadmin')) {
+            return;
+        }
+
+        $attuale = (int) session('attivita_attuale');
+        if (! $attivita_id || $attuale <= 0 || (int) $attivita_id !== $attuale) {
+            abort(404);
+        }
+    }
+
+    public static function api_garantisciAttivita($attivita_id)
+    {
+        if (auth()->user()?->hasRole('superadmin')) {
+            return;
+        }
+        //Se non c'è o non è mia return 404
+        if (! $attivita_id || ! Attivita::E_Mia($attivita_id)) {
+            abort(404);
+        }
+    }
+
+}