ladill-queue/app/Http/Controllers/Qms/TicketController.php

<?php

namespace App\Http\Controllers\Qms;

use App\Http\Controllers\Controller;
use App\Http\Controllers\Qms\Concerns\ScopesToAccount;
use App\Models\Counter;
use App\Models\ServiceQueue;
use App\Models\Ticket;
use App\Services\Qms\QueueEngine;
use App\Services\Qms\TicketPresenter;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\View\View;

class TicketController extends Controller
{
    use ScopesToAccount;

    public function __construct(
        protected QueueEngine $engine,
    ) {}

    public function index(Request $request): View
    {
        $this->authorizeAbility($request, 'tickets.view');
        $owner = $this->ownerRef($request);
        $organization = $this->organization($request);

        $tickets = Ticket::owned($owner)
            ->where('organization_id', $organization->id)
            ->with(['serviceQueue', 'counter'])
            ->when($request->query('queue'), fn ($q, $uuid) => $q->whereHas('serviceQueue', fn ($sq) => $sq->where('uuid', $uuid)))
            ->when($request->query('status'), fn ($q, $s) => $q->where('status', $s))
            ->latest('issued_at')
            ->paginate(30)
            ->withQueryString();

        $queues = ServiceQueue::owned($owner)->where('organization_id', $organization->id)->orderBy('name')->get();

        $ticketQuery = Ticket::owned($owner)->where('organization_id', $organization->id);

        $heroStats = [
            'today' => (clone $ticketQuery)->whereDate('issued_at', today())->count(),
            'waiting' => (clone $ticketQuery)->where('status', 'waiting')->count(),
            'serving' => (clone $ticketQuery)->whereIn('status', ['called', 'serving', 'on_hold'])->count(),
        ];

        return view('qms.tickets.index', compact('tickets', 'queues', 'organization', 'heroStats'));
    }

    public function create(Request $request): View
    {
        $this->authorizeAbility($request, 'tickets.issue');
        $owner = $this->ownerRef($request);
        $organization = $this->organization($request);

        $queues = ServiceQueue::owned($owner)
            ->where('organization_id', $organization->id)
            ->where('is_active', true)
            ->with([
                'branch',
                'counters' => fn ($q) => $q->where('is_active', true)->orderBy('name'),
            ])
            ->orderBy('name')
            ->get();

        $selectedQueueId = (int) (
            old('service_queue_id')
            ?? $request->query('queue')
            ?? $queues->first()?->id
            ?? 0
        );
        $selectedQueue = $queues->firstWhere('id', $selectedQueueId) ?? $queues->first();

        return view('qms.tickets.create', [
            'queues' => $queues,
            'organization' => $organization,
            'selectedQueue' => $selectedQueue,
            'ticketPriorities' => \App\Services\Qms\TicketPriorities::forOrganization($organization),
        ]);
    }

    public function store(Request $request): RedirectResponse
    {
        $this->authorizeAbility($request, 'tickets.issue');
        $owner = $this->ownerRef($request);

        $validated = $request->validate([
            'service_queue_id' => ['required', 'exists:queue_service_queues,id'],
            'assigned_counter_id' => ['nullable', 'exists:queue_counters,id'],
            'customer_name' => ['nullable', 'string', 'max:255'],
            'customer_phone' => ['nullable', 'string', 'max:50'],
            'priority' => ['nullable', 'string', 'in:'.implode(',', array_keys(config('qms.ticket_priorities')))],
        ]);

        $queue = ServiceQueue::findOrFail($validated['service_queue_id']);
        $this->authorizeOwner($request, $queue);

        if ($queue->usesAssignedOnlyRouting() && empty($validated['assigned_counter_id'])) {
            return back()
                ->withInput()
                ->withErrors(['assigned_counter_id' => 'Select a service point for this queue.']);
        }

        if (! empty($validated['assigned_counter_id'])) {
            $counter = Counter::query()->findOrFail($validated['assigned_counter_id']);
            $this->authorizeOwner($request, $counter);
            if (! $queue->counters()->where('queue_counters.id', $counter->id)->exists()) {
                return back()
                    ->withInput()
                    ->withErrors(['assigned_counter_id' => 'That service point is not linked to this queue.']);
            }
        }

        try {
            $ticket = $this->engine->issueTicket($queue, $owner, [
                ...$validated,
                'source' => 'reception',
                'actor_ref' => $owner,
            ]);
        } catch (\RuntimeException $e) {
            return back()->withInput()->withErrors(['service_queue_id' => $e->getMessage()]);
        }

        return redirect()->route('qms.tickets.show', $ticket)->with('success', 'Ticket issued.');
    }

    public function show(Request $request, Ticket $ticket): View
    {
        $this->authorizeAbility($request, 'tickets.view');
        $this->authorizeOwner($request, $ticket);

        $ticket->load([
            'serviceQueue',
            'counter',
            'events',
            'transfers.fromQueue',
            'transfers.toQueue',
        ]);

        return view('qms.tickets.show', [
            'ticket' => $ticket,
            'presented' => TicketPresenter::toArray($ticket),
        ]);
    }

    public function print(Request $request, Ticket $ticket): View
    {
        $this->authorizeAbility($request, 'tickets.view');
        $this->authorizeOwner($request, $ticket);
        $ticket->load(['serviceQueue', 'branch']);

        return view('qms.tickets.print', compact('ticket'));
    }
}