Endpoint FestAgent: disattiva allineata e token solo se attivo.

Un agent disabilitato non pesca piu i job di stampa.

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

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/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/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/Middleware/EndpointTokenMiddleware.php

         if(!$token){
             Log::error('token-endpoint');
             Log::error('Token endpoint non trovato');
-            Log::error('Request: ' . json_encode($request->all()));
-            Log::error('Headers: ' . json_encode($request->header()));
+            // Log::error('Request: ' . json_encode($request->all()));
+            // Log::error('Headers: ' . json_encode($request->header()));
             return response()->json(['message' => 'Token endpoint non trovato', 'status' => 'error', 'success' => false], 401);
         }
         $endpoint = Endpoint::where('token', $token)->first();
         if(!$endpoint){
-            Log::error('token-endpoint');
-            Log::error('Endpoint non trovato con token ' . $token);
-            Log::error('Request: ' . json_encode($request->all()));
-            return response()->json(['message' => 'Endpoint non trovato con token ' . $token, 'status' => 'error', 'success' => false], 404);
+            Log::error('endpoint non trovato con token ');
+            return response()->json(['message' => 'Endpoint non trovato con token ', 'status' => 'error', 'success' => false], 404);
+        }
+        if ($endpoint->status !== Endpoint::ATTIVO) {
+            Log::warning('Endpoint non attivo', [
+                'endpoint_id' => $endpoint->id,
+                'status' => $endpoint->status,
+            ]);
+            return response()->json([
+                'message' => 'Endpoint non attivo',
+                'status' => 'error',
+                'success' => false,
+            ], 403);
         }
-        $request->merge(['endpoint' => $endpoint]);
+        $request->merge(['endpoint' => $endpoint->makeHidden(['product_key', 'secret', 'deeplink_token', 'token'])]);
         return $next($request);
     }
 }

resources/views/endpoint/index.blade.php

     $.ajax({
       url: "{{ route('endpoint.collega-questo-pc' , ['attivita_id' => session()->get('attivita_attuale')]) }}",
       type: 'POST',
-      success: function(response){
-        window.open(response.url, '_blank');
-      }
+      // success: function(response){
+      //   window.open(response.url, '_blank');
+      // }
     }).done(function(response){
-      window.open(response.url, '_blank');
+      if(response.url){
+        window.location.href = response.url;
+      }
       $('#dataTable_endpoint').DataTable().ajax.reload();
     }).fail(function(xhr, status, error){
       alert('Errore nel collegamento del PC. Riprova.');

routes/api.php

     Route::get('/endpoint/get-lavoro', [EndpointController::class, 'get_lavoro']);
     Route::post('/endpoint/stampanti/esito-stampa', [EndpointController::class, 'esito_stampa']);
     Route::get('/endpoint-check', [EndpointController::class, 'api_endpoint_check'])->name('api.endpoint.check');
-    Route::post('/endpoint/disattiva', [EndpointController::class, 'api_disattiva_endpoint'])->name('api.endpoint.disattiva');
+    Route::post('/endpoint/disattiva', [EndpointController::class, 'api_endpoint_disattiva'])->name('api.endpoint.disattiva');
 });
 
 Route::get('/endpoint/registra-product-key', [EndpointController::class, 'api_register_product_key'])->middleware('throttle:10,1');