Stampe: comande cucina, check stampanti e biglietto ritiro.

Se lo scontrino e gia in corso le comande partono comunque; senza stampante si logga e non si crasha.

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

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/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/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/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/Jobs/ElaboraJobStampa.php

 use Illuminate\Queue\SerializesModels;
 use App\Services\Stampa\CreaScontrino;
 use App\Services\Stampa\CreaComandaCucina;
+use App\Services\Stampa\CreaCupon;
+use App\Models\Cupon;
 use Throwable;
 use Illuminate\Support\Facades\Log;
 
+
 class ElaboraJobStampa implements ShouldQueue
 {
     use Dispatchable;
                     Log::error('Print job senza cucina associata.');
                     throw new \RuntimeException('Print job senza cucina associata.');
                 }
-                $payload = array_merge($payload, app(CreaComandaCucina::class)->perOrdine($job->ordine, $cucina_id));
+                $payload = array_merge($payload, app(CreaComandaCucina::class)->perOrdine($job->ordine, (int) $cucina_id));
+        } elseif (str_starts_with($job->tipo, PrintJob::TIPO_COMANDA_RITIRO.'_')) {
+            if ($job->ordine === null) {
+                Log::error('Print job senza ordine associato.');
+                throw new \RuntimeException('Print job senza ordine associato.');
+            }
+
+            $prefix = PrintJob::TIPO_COMANDA_RITIRO.'_';
+            $cucina_id = substr($job->tipo, strlen($prefix));
+
+            if ($cucina_id === '' || ! is_numeric($cucina_id)) {
+                Log::error('Print job ritiro senza cucina associata.');
+                throw new \RuntimeException('Print job ritiro senza cucina associata.');
+            }
+
+            $payload = array_merge($payload, app(CreaComandaCucina::class)->perOrdineRitiro($job->ordine, (int) $cucina_id));
+        } elseif ($job->tipo === PrintJob::TIPO_CUPON) {
+            $cupon = Cupon::find($job->printable_id);
+            if($cupon === null){
+                Log::error('Cupon non trovato.');
+                throw new \RuntimeException('Cupon non trovato.');
+            }
+            
+            $payload = array_merge($payload, app(CreaCupon::class)->perCupon($cupon));
         }else{
             Log::error('Tipo di stampa non supportato: '.$job->tipo);
             throw new \RuntimeException('Tipo di stampa non supportato: '.$job->tipo);

app/Models/AbstractModels/AbstractPrintJob.php

         'printed_at' => 'datetime',
         'failed_at' => 'datetime',
         'created_at' => 'datetime',
-        'updated_at' => 'datetime'
+        'updated_at' => 'datetime',
+        'printable_id' => 'integer',
     ];
     
     /**  
         'printed_at',
         'failed_at',
         'created_at',
-        'updated_at'
+        'updated_at',
+        'printable_id',
     ];
     
     public function dispositivo()

app/Models/Cucina.php

 
 class Cucina extends \App\Models\AbstractModels\AbstractCucina
 {
-    protected $appends = ['coperto_come_piatto', 'colore'];
+    protected $appends = ['coperto_come_piatto', 'colore', 'stampa_ritiro'];
 
     public function getCopertoComePiattoAttribute()
     {
     $this->attributes['info'] = json_encode($info);
     }
 
+    public function getStampaRitiroAttribute(): bool
+    {
+        return (bool) ($this->info['stampa_ritiro'] ?? false);
+    }
+
+    public function setStampaRitiroAttribute($value): void
+    {
+        $info = is_array($this->info) ? $this->info : [];
+        $info['stampa_ritiro'] = filter_var($value, FILTER_VALIDATE_BOOLEAN);
+        $this->attributes['info'] = json_encode($info);
+    }
+
 }

app/Models/PrintJob.php

     /** Comanda unica aggregata (una riga job per ordine). */
     public const TIPO_COMANDA_CUCINA = 'comanda_cucina';
 
+    /** Biglietto ritiro su stampante cassa (una riga job per ordine e cucina). */
+    public const TIPO_COMANDA_RITIRO = 'comanda_ritiro';
+
     public const TIPO_PRECONTO = 'preconto';
 
+    public const TIPO_CUPON = 'cupon';
+
     /**
      * Tipo per comande per cucina distinte (idempotenza: include id cucina).
      */
         return 'comanda_cucina_'.$cucinaId;
     }
 
+    public static function tipoComandaRitiro(int $cucinaId): string
+    {
+        return 'comanda_ritiro_'.$cucinaId;
+    }
+
     public static function getStatoLabel($stato)
     {
         return match($stato) {
 
     public static function getTipoLabel($tipo)
     {
-        if(str_starts_with($tipo, self::TIPO_COMANDA_CUCINA.'_')){
-            return 'Comanda cucina';//self::TIPO_COMANDA_CUCINA;
-        }else{
-            return match($tipo) {
-                self::TIPO_SCONTRINO => 'Scontrino',
-                self::TIPO_DUPLICATO_SCONTRINO => 'Duplicato scontrino',
-                self::TIPO_COMANDA_CUCINA => 'Comanda cucina',
-                self::TIPO_PRECONTO => 'Preconto',
-            };
+        if (str_starts_with($tipo, self::TIPO_COMANDA_CUCINA.'_')) {
+            return 'Comanda cucina';
         }
+
+        if (str_starts_with($tipo, self::TIPO_COMANDA_RITIRO.'_')) {
+            return 'Biglietto ritiro';
+        }
+
+        return match ($tipo) {
+            self::TIPO_SCONTRINO => 'Scontrino',
+            self::TIPO_DUPLICATO_SCONTRINO => 'Duplicato scontrino',
+            self::TIPO_COMANDA_CUCINA => 'Comanda cucina',
+            self::TIPO_PRECONTO => 'Preconto',
+            self::TIPO_CUPON => 'Cupon',
+            default => $tipo,
+        };
     }
 
     public function endpoint()

app/Observers/OrdineObserver.php

 use App\Models\Cucina;
 use Illuminate\Support\Facades\Log;
 use App\Models\SaltacodaOrdine;
+use Illuminate\Support\Str;
 
 class OrdineObserver
 {
      */
     public function created(Ordine $ordine): void
     {
-        //
+        if (filled($ordine->codice)) {
+            return;
+        }
+        do {
+            $codice = Str::random(32);
+        } while (Ordine::where('codice', $codice)->exists());
+        $ordine->codice = $codice;
+        $ordine->saveQuietly();
     }
 
     /**
             return;
         }
 
-        //Aggiorna lo stato del pre_ordine
+        //Aggiorna lo stato del pre_ordine (solo stessa attività dell'ordine)
         $preOrdineId = data_get($ordine->info, 'pre_ordine_id');
         $preOrdineCodice = data_get($ordine->info, 'pre_ordine_codice');
 
-        if ($preOrdineId || $preOrdineCodice) {
+        if (($preOrdineId || $preOrdineCodice) && $ordine->attivita_id) {
             $preOrdineQuery = SaltacodaOrdine::query()
-                ->where('stato', SaltacodaOrdine::PRE_CARRELLO);
+                ->where('stato', SaltacodaOrdine::PRE_CARRELLO)
+                ->where('attivita_id', $ordine->attivita_id);
 
             if ($preOrdineId) {
                 $preOrdineQuery->where('id', $preOrdineId);
                 $preOrdineQuery->where('codice', $preOrdineCodice);
             }
 
-            $preOrdineQuery->update(['stato' => SaltacodaOrdine::IMPORTATO]);
+            $saltacodaOrdine = $preOrdineQuery->first();
+            if ($saltacodaOrdine) {
+                $saltacodaOrdine->stato = SaltacodaOrdine::IMPORTATO;
+                $saltacodaOrdine->save();
+            } else {
+                Log::warning('Pre-ordine saltacoda non valido per ordine '.$ordine->id.' (attività/mismatch o stato errato)');
+            }
         }
-        
+
+        //Aggiorna utilizzo dispositivo solo se appartiene alla stessa attività
+        if ($ordine->dispositivo_id) {
+            $dispositivoOk = $ordine->dispositivo
+                && (int) $ordine->dispositivo->attivita_id === (int) $ordine->attivita_id;
+
+            if ($dispositivoOk) {
+                app(\App\Services\Fatturazione\RigaFatturazioneService::class)
+                    ->aggiornaUtilizzoDispositivo((int) $ordine->dispositivo_id, (int) $ordine->id);
+            } else {
+                Log::warning('Utilizzo dispositivo saltato: dispositivo '.$ordine->dispositivo_id.' non allineato all\'attività ordine '.$ordine->id);
+            }
+        }
+
+        //Crea l'asporto se l'ordine è asporto
+        if (isset($ordine->info['asporto']) && $ordine->info['asporto'] == true) {
+            app('\App\Services\Asporto\AsportoService')->creaAsporto($ordine);
+        }
+
+        $statiStampaGiaPresi = [
+            PrintJob::STATO_IN_CODA,
+            PrintJob::STATO_PRESO,
+            PrintJob::STATO_COMPLETATO,
+        ];
+
+        $stampanteCassaId = $ordine->dispositivo?->stampante_dispositivo()?->id;
+
         //Crea il print job per lo scontrino
         $printJob = PrintJob::query()->firstOrNew([
             'ordine_id' => $ordine->id,
         ]);
 
         if (
-            $printJob->exists
-            && in_array($printJob->stato, [
-                PrintJob::STATO_IN_CODA,
-                PrintJob::STATO_PRESO,
-                PrintJob::STATO_COMPLETATO,
-            ], true)
+            ! (
+                $printJob->exists
+                && in_array($printJob->stato, $statiStampaGiaPresi, true)
+            )
         ) {
-            return;
+            if (! $stampanteCassaId) {
+                Log::warning('Stampante cassa non configurata, scontrino saltato per ordine '.$ordine->id, [
+                    'dispositivo_id' => $ordine->dispositivo_id,
+                    'url_stampante' => $ordine->dispositivo?->url_stampante,
+                ]);
+            } else {
+                $printJob->fill([
+                    'dispositivo_id' => $ordine->dispositivo_id,
+                    'stampante_id' => $stampanteCassaId,
+                    'stato' => PrintJob::STATO_IN_ATTESA,
+                    'payload' => null,
+                ]);
+                $printJob->save();
+
+                ElaboraJobStampa::dispatch($printJob->id);
+            }
         }
 
-        $printJob->fill([
-            'dispositivo_id' => $ordine->dispositivo_id,
-            'stampante_id' => $ordine->dispositivo->url_stampante,
-            'stato' => PrintJob::STATO_IN_ATTESA,
-            'payload' => null,
-        ]);
-        $printJob->save();
-
-        ElaboraJobStampa::dispatch($printJob->id);
-
         //Crea comande cucine
         $cucine = $ordine->cucine();
-        foreach($cucine as $cucina){
+        foreach ($cucine as $cucina) {
+            $cucinaModel = Cucina::find($cucina);
+            if ($cucinaModel === null) {
+                Log::error('Cucina non trovata, comanda saltata', [
+                    'cucina_id' => $cucina,
+                    'ordine_id' => $ordine->id,
+                ]);
+                continue;
+            }
+
             $printJob = PrintJob::query()->firstOrNew([
                 'ordine_id' => $ordine->id,
                 'tipo' => PrintJob::tipoComandaCucina($cucina),
             ]);
             if (
-                $printJob->exists
-                && in_array($printJob->stato, [
-                    PrintJob::STATO_IN_CODA,
-                    PrintJob::STATO_PRESO,
-                    PrintJob::STATO_COMPLETATO,
-                ], true)
+                ! (
+                    $printJob->exists
+                    && in_array($printJob->stato, $statiStampaGiaPresi, true)
+                )
             ) {
-                continue;
-            }
-            $cucinaModel = Cucina::find($cucina);
-            if ($cucinaModel === null) {
-                Log::error('Cucina non trovata id: '.$cucina);
-                throw new \RuntimeException('Cucina non trovata id: '.$cucina);
-            }elseif($cucinaModel->stampante_id === null){
-                Log::warning('Stampante non trovata per la cucina '.$cucina.' ordine: '.$ordine->id);
-                // throw new \RuntimeException('Stampante non trovata per la cucina '.$cucina);
+                if ($cucinaModel->stampante_id === null) {
+                    Log::warning('Stampante non configurata per la cucina, comanda saltata', [
+                        'cucina_id' => $cucina,
+                        'ordine_id' => $ordine->id,
+                    ]);
+                } else {
+                    $printJob->fill([
+                        'dispositivo_id' => $ordine->dispositivo_id,
+                        'stampante_id' => $cucinaModel->stampante_id,
+                        'stato' => PrintJob::STATO_IN_ATTESA,
+                        'payload' => null,
+                    ]);
+                    $printJob->save();
+                    ElaboraJobStampa::dispatch($printJob->id);
+                }
             }
 
-            $printJob->fill([
-                'dispositivo_id' => $ordine->dispositivo_id,
-                'stampante_id' => $cucinaModel->stampante_id,
-                'stato' => PrintJob::STATO_IN_ATTESA,
-                'payload' => null,
-            ]);
-            $printJob->save();
-            ElaboraJobStampa::dispatch($printJob->id);
+            if ($cucinaModel->stampa_ritiro) {
+                if (! $stampanteCassaId) {
+                    Log::warning('Stampante cassa non configurata, biglietto ritiro saltato per ordine '.$ordine->id, [
+                        'cucina_id' => $cucina,
+                        'dispositivo_id' => $ordine->dispositivo_id,
+                    ]);
+                } else {
+                    $printJobRitiro = PrintJob::query()->firstOrNew([
+                        'ordine_id' => $ordine->id,
+                        'tipo' => PrintJob::tipoComandaRitiro((int) $cucina),
+                    ]);
+
+                    if (
+                        ! (
+                            $printJobRitiro->exists
+                            && in_array($printJobRitiro->stato, $statiStampaGiaPresi, true)
+                        )
+                    ) {
+                        $printJobRitiro->fill([
+                            'dispositivo_id' => $ordine->dispositivo_id,
+                            'stampante_id' => $stampanteCassaId,
+                            'stato' => PrintJob::STATO_IN_ATTESA,
+                            'payload' => null,
+                        ]);
+                        $printJobRitiro->save();
+                        ElaboraJobStampa::dispatch($printJobRitiro->id);
+                    }
+                }
+            }
         }
 
-        //Aggiorna il utilizzo del dispositivo
-        app('\App\Services\Fatturazione\RigaFatturazioneService')->aggiornaUtilizzoDispositivo($ordine->dispositivo_id);
 
-        //Crea l'asporto se l'ordine è asporto
-        if (isset($ordine->info['asporto']) && $ordine->info['asporto'] == true) {
-            app('\App\Services\Asporto\AsportoService')->creaAsporto($ordine);
-        }
+
    
     }
 

app/Services/Stampa/CreaComandaCucina.php

         ];
     }
 
+    /**
+     * Biglietto ritiro su stampante cassa: ID ordine, cucina e piatti (senza dati operativi della comanda).
+     */
+    public function perOrdineRitiro(Ordine $ordine, int $cucina_id): array
+    {
+        $ordine->loadMissing(['righe_ordine.piatto', 'righe_ordine.has_variante.variante_piatto']);
+        $cucina = Cucina::find($cucina_id);
+        if ($cucina === null) {
+            Log::error('--- CreaComandaCucina --- Cucina non trovata id: '.$cucina_id);
+            throw new \RuntimeException('--- CreaComandaCucina --- Cucina non trovata id: '.$cucina_id);
+        }
+
+        $dataOra = $ordine->created_at?->format('d/m/Y H:i') ?? now()->format('d/m/Y H:i');
+
+        $connector = new DummyPrintConnector;
+        $printer = new Printer($connector);
+
+        $this->printHeaderRitiro($printer, $ordine, $cucina->nome ?? null);
+
+        $printer->text("\n");
+        $printer->text($this->separator());
+        $this->printItemsTable($printer, $ordine, $cucina_id);
+
+        $printer->feed(2);
+        $printer->cut();
+
+        $bytes = $connector->getData();
+        $printer->close();
+
+        return [
+            'formato' => 'escpos_base64',
+            'dati' => base64_encode($bytes),
+            'ordine_id' => $ordine->id,
+            'ordine_numero' => $ordine->id,
+            'ordine_data' => $dataOra,
+        ];
+    }
+
+    private function printHeaderRitiro(Printer $printer, Ordine $ordine, ?string $nomeCucina): void
+    {
+        $printer->setJustification(Printer::JUSTIFY_CENTER);
+        $printer->setEmphasis(true);
+        $printer->setTextSize(2, 2);
+        $printer->text('#'.$ordine->id."\n");
+
+        if (! empty($nomeCucina)) {
+            $printer->text('RITIRO - '.$this->sanitizeLine((string) $nomeCucina)."\n");
+        }
+
+        $printer->setTextSize(1, 1);
+        $printer->setEmphasis(false);
+        $printer->text("\n");
+    }
+
     private function printHeader(Printer $printer, Ordine $ordine, ?string $nomeCucina, array $info): void
     {
         $printer->setJustification(Printer::JUSTIFY_CENTER);

app/Services/Stampa/CreaScontrino.php

         $printer->text($this->separator());
         $printer->setJustification(Printer::JUSTIFY_CENTER);
         if(Impostazioni::getImpostazione('stampa_qr_code_chiamata')){
-        $printer->qrCode(route('consulta.scontrino.show', ['ordine_id' => $ordine->id]) , Printer::QR_ECLEVEL_L, 6, Printer::QR_MODEL_2);
+        $printer->qrCode(route('consulta.scontrino.show', ['ordine_codice' => $ordine->codice]) , Printer::QR_ECLEVEL_L, 6, Printer::QR_MODEL_2);
         // $this->printQrCode($printer, route('consulta.scontrino.show', ['ordine_id' => $ordine->id]));
         }
         $printer->text("\n");