feat(tickets): add query_param to ticket filter fields in TicketFilterFormService and update related tests

app/Domains/Forms/Controllers/AdminApp/TicketFilterFormController.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Domains\Forms\Controllers\AdminApp;
+
+use App\Domains\Forms\Resources\TicketFilterFormResource;
+use App\Domains\Forms\Services\TicketFilterFormService;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+
+class TicketFilterFormController extends Controller
+{
+    public function __construct(private readonly TicketFilterFormService $formService) {}
+
+    public function __invoke(Request $request): TicketFilterFormResource
+    {
+        $tenant = $request->user('sanctum')->tenant()->firstOrFail();
+
+        return TicketFilterFormResource::make($this->formService->get($tenant));
+    }
+}

app/Domains/Forms/Controllers/AdminApp/TicketFormController.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Forms\Controllers\AdminApp;
+
+use App\Domains\Forms\Resources\TicketFormResource;
+use App\Domains\Forms\Services\TicketFormService;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+
+class TicketFormController extends Controller
+{
+    public function __construct(protected TicketFormService $ticketFormService) {}
+
+    public function __invoke(Request $request): TicketFormResource
+    {
+        return TicketFormResource::make(
+            $this->ticketFormService->get(
+                $request->user('sanctum')->tenant()->firstOrFail()
+            )
+        );
+    }
+}

app/Domains/Forms/Resources/TicketFilterFormResource.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Domains\Forms\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class TicketFilterFormResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        return [
+            'code' => $this->resource['code'],
+            'action' => $this->resource['action'],
+            'method' => $this->resource['method'],
+            'fields' => $this->resource['fields'],
+        ];
+    }
+}

app/Domains/Forms/Resources/TicketFormResource.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Domains\Forms\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class TicketFormResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        return [
+            'statuses' => $this->resource['statuses'],
+            'categories' => $this->resource['categories'],
+        ];
+    }
+}

app/Domains/Forms/Services/TicketFilterFormService.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace App\Domains\Forms\Services;
+
+use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticket\Models\Ticket;
+
+class TicketFilterFormService
+{
+    private const FIESTA_FUTBOL_INFANTIL = 'fiesta_futbol_infantil';
+
+    public function __construct(private readonly TicketFormService $ticketFormService) {}
+
+    /** @return array<string, mixed> */
+    public function get(Tenant $tenant): array
+    {
+        $fields = $this->commonFields();
+
+        if ($tenant->codigo === self::FIESTA_FUTBOL_INFANTIL) {
+            $fields = [
+                ...$this->fiestaFutbolInfantilFields($tenant),
+                ...$fields,
+            ];
+        }
+
+        return [
+            'code' => 'tickets_filter',
+            'action' => '/api/v1/adminapp/tenant/tickets',
+            'method' => 'GET',
+            'fields' => $fields,
+        ];
+    }
+
+    /** @return list<array<string, mixed>> */
+    private function fiestaFutbolInfantilFields(Tenant $tenant): array
+    {
+        $form = $this->ticketFormService->getForFilters($tenant);
+
+        return [
+            [
+                'name' => 'category',
+                'query_param' => 'category',
+                'label' => 'Categoría',
+                'type' => 'select',
+                'required' => false,
+                'default' => null,
+                'placeholder' => 'Categoría',
+                'options' => array_map(
+                    fn (array $category): array => [
+                        'value' => $category['value'],
+                        'label' => $category['label'],
+                        'children' => [
+                            'field' => 'product',
+                            'disabled' => $category['products'] === [],
+                            'options' => array_map(
+                                fn (array $product): array => [
+                                    'value' => $product['value'],
+                                    'label' => $product['label'],
+                                    'children' => [
+                                        'field' => 'type',
+                                        'disabled' => $product['types'] === [],
+                                        'options' => $product['types'],
+                                    ],
+                                ],
+                                $category['products'],
+                            ),
+                        ],
+                    ],
+                    $form['categories'],
+                ),
+            ],
+            $this->dependentSelect('product', 'Producto', 'category'),
+            $this->dependentSelect('type', 'Tipo', 'product'),
+        ];
+    }
+
+    /** @return list<array<string, mixed>> */
+    private function commonFields(): array
+    {
+        return [
+            [
+                'name' => 'date',
+                'query_param' => 'date',
+                'label' => 'Fecha',
+                'type' => 'date',
+                'required' => false,
+                'default' => null,
+            ],
+            [
+                'name' => 'status',
+                'query_param' => 'status',
+                'label' => 'Estado',
+                'type' => 'select',
+                'required' => false,
+                'default' => null,
+                'placeholder' => 'Estado',
+                'options' => [
+                    ['value' => Ticket::STATUS_ACTIVE, 'label' => 'Activo'],
+                    ['value' => Ticket::STATUS_USED, 'label' => 'Usado'],
+                    ['value' => Ticket::STATUS_EXPIRED, 'label' => 'Vencido'],
+                ],
+            ],
+        ];
+    }
+
+    /** @return array<string, mixed> */
+    private function dependentSelect(string $name, string $label, string $dependency): array
+    {
+        return [
+            'name' => $name,
+            'query_param' => $name,
+            'label' => $label,
+            'type' => 'select',
+            'required' => false,
+            'default' => null,
+            'placeholder' => $label,
+            'depends_on' => $dependency,
+            'disabled' => true,
+            'options' => [],
+        ];
+    }
+}

app/Domains/Forms/Services/TicketFormService.php

@@ -0,0 +1,336 @@
+<?php
+
+namespace App\Domains\Forms\Services;
+
+use App\Domains\Catalog\Models\CatalogItem;
+use App\Domains\Catalog\Models\Variant;
+use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticket\Models\Ticket;
+use Illuminate\Database\Eloquent\Collection;
+
+class TicketFormService
+{
+    private const PRODUCT = 'product';
+
+    /**
+     * @var array<string, array{label: string|null, product: string, type: string|null, order: int}>
+     */
+    private const CATEGORY_PRESENTATIONS = [
+        'entradas' => [
+            'label' => null,
+            'product' => self::PRODUCT,
+            'type' => null,
+            'order' => 1,
+        ],
+        'alojamientos' => [
+            'label' => 'Camping',
+            'product' => 'tipo_alojamiento',
+            'type' => null,
+            'order' => 2,
+        ],
+        'camping' => [
+            'label' => null,
+            'product' => 'tipo_alojamiento',
+            'type' => null,
+            'order' => 2,
+        ],
+        'comidas' => [
+            'label' => 'Comida',
+            'product' => 'event_date',
+            'type' => 'horario',
+            'order' => 3,
+        ],
+        'comida' => [
+            'label' => null,
+            'product' => 'event_date',
+            'type' => 'horario',
+            'order' => 3,
+        ],
+        'merchandising' => [
+            'label' => null,
+            'product' => self::PRODUCT,
+            'type' => 'color',
+            'order' => 4,
+        ],
+    ];
+
+    /**
+     * @return array{
+     *     statuses: list<array{value: string, label: string}>,
+     *     categories: list<array{
+     *         value: string,
+     *         label: string,
+     *         products: list<array{
+     *             value: string,
+     *             label: string,
+     *             types: list<array{value: string, label: string}>
+     *         }>
+     *     }>
+     * }
+     */
+    public function get(Tenant $tenant): array
+    {
+        $items = CatalogItem::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->where('has_tickets', true)
+            ->whereHas('category')
+            ->with($this->relations())
+            ->orderBy('group_order')
+            ->orderBy('nombre')
+            ->get();
+
+        return $this->build($items);
+    }
+
+    /**
+     * Return active catalog options plus soft-deleted sources still referenced by
+     * tickets, so historical tickets never become impossible to filter.
+     *
+     * @return array{
+     *     statuses: list<array{value: string, label: string}>,
+     *     categories: list<array{
+     *         value: string,
+     *         label: string,
+     *         products: list<array{
+     *             value: string,
+     *             label: string,
+     *             types: list<array{value: string, label: string}>
+     *         }>
+     *     }>
+     * }
+     */
+    public function getForFilters(Tenant $tenant): array
+    {
+        $historicalVariantIds = Ticket::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->whereNotNull('source_variant_id')
+            ->distinct()
+            ->pluck('source_variant_id')
+            ->map(fn ($id): int => (int) $id)
+            ->all();
+        $historicalCatalogItemIds = Ticket::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->whereNotNull('source_catalog_item_id')
+            ->distinct()
+            ->pluck('source_catalog_item_id')
+            ->map(fn ($id): int => (int) $id)
+            ->merge(
+                Variant::withTrashed()
+                    ->whereKey($historicalVariantIds)
+                    ->pluck('catalog_item_id')
+                    ->map(fn ($id): int => (int) $id),
+            )
+            ->unique()
+            ->values()
+            ->all();
+
+        $items = CatalogItem::withTrashed()
+            ->where('tenant_code', $tenant->codigo)
+            ->whereHas('category')
+            ->where(function ($query) use ($historicalCatalogItemIds): void {
+                $query
+                    ->where(function ($activeQuery): void {
+                        $activeQuery
+                            ->whereNull('catalog_items.deleted_at')
+                            ->where('has_tickets', true);
+                    })
+                    ->orWhereIn('catalog_items.id', $historicalCatalogItemIds);
+            })
+            ->with([
+                'category',
+                'itemAttributes.attribute.options',
+                'variants' => fn ($query) => $query
+                    ->withTrashed()
+                    ->where(function ($variantQuery) use ($historicalVariantIds): void {
+                        $variantQuery
+                            ->whereNull('variantes.deleted_at')
+                            ->orWhereIn('variantes.id', $historicalVariantIds);
+                    }),
+                'variants.definitions.itemAttribute.attribute.options',
+                'variants.eventDates',
+                'variants.eventDate',
+            ])
+            ->orderBy('group_order')
+            ->orderBy('nombre')
+            ->get();
+
+        return $this->build($items);
+    }
+
+    /**
+     * @param  Collection<int, CatalogItem>  $items
+     * @return array{
+     *     statuses: list<array{value: string, label: string}>,
+     *     categories: list<array{
+     *         value: string,
+     *         label: string,
+     *         products: list<array{
+     *             value: string,
+     *             label: string,
+     *             types: list<array{value: string, label: string}>
+     *         }>
+     *     }>
+     * }
+     */
+    private function build(Collection $items): array
+    {
+        $categories = [];
+
+        foreach ($items as $item) {
+            $sourceCategory = trim((string) $item->category?->nombre);
+            $categoryValue = mb_strtolower($sourceCategory);
+            $presentation = self::CATEGORY_PRESENTATIONS[$categoryValue] ?? [
+                'label' => null,
+                'product' => self::PRODUCT,
+                'type' => null,
+                'order' => PHP_INT_MAX,
+            ];
+
+            $categories[$categoryValue] ??= [
+                'value' => $categoryValue,
+                'label' => $presentation['label'] ?? $sourceCategory,
+                'order' => $presentation['order'],
+                'products' => [],
+            ];
+
+            foreach ($this->products($item, $presentation['product'], $presentation['type']) as $product) {
+                $productValue = $product['value'];
+                $existingProduct = $categories[$categoryValue]['products'][$productValue] ?? [
+                    'value' => $productValue,
+                    'label' => $product['label'],
+                    'types' => [],
+                ];
+
+                foreach ($product['types'] as $type) {
+                    $existingProduct['types'][$type['value']] = $type;
+                }
+
+                $categories[$categoryValue]['products'][$productValue] = $existingProduct;
+            }
+        }
+
+        uasort($categories, fn (array $left, array $right): int => $left['order'] <=> $right['order']
+            ?: $left['label'] <=> $right['label']);
+
+        return [
+            'statuses' => [
+                ['value' => Ticket::STATUS_ACTIVE, 'label' => 'Activo'],
+                ['value' => Ticket::STATUS_USED, 'label' => 'Usado'],
+                ['value' => Ticket::STATUS_EXPIRED, 'label' => 'Vencido'],
+            ],
+            'categories' => array_values(array_map(
+                fn (array $category): array => [
+                    'value' => $category['value'],
+                    'label' => $category['label'],
+                    'products' => array_values(array_map(
+                        fn (array $product): array => [
+                            'value' => $product['value'],
+                            'label' => $product['label'],
+                            'types' => array_values($product['types']),
+                        ],
+                        $category['products'],
+                    )),
+                ],
+                $categories,
+            )),
+        ];
+    }
+
+    /** @return list<string> */
+    private function relations(): array
+    {
+        return [
+            'category',
+            'itemAttributes.attribute.options',
+            'variants.definitions.itemAttribute.attribute.options',
+            'variants.eventDates',
+            'variants.eventDate',
+        ];
+    }
+
+    /**
+     * @return list<array{
+     *     value: string,
+     *     label: string,
+     *     types: list<array{value: string, label: string}>
+     * }>
+     */
+    private function products(CatalogItem $item, string $productCode, ?string $typeCode): array
+    {
+        if ($productCode === self::PRODUCT) {
+            return [[
+                'value' => $item->slug,
+                'label' => $item->nombre,
+                'types' => $this->types($item, $typeCode),
+            ]];
+        }
+
+        $products = [];
+
+        foreach ($item->variants as $variant) {
+            foreach ($this->variantOptions($variant, $productCode) as $productOption) {
+                $productValue = $productOption['value'];
+                $products[$productValue] ??= [
+                    'value' => $productValue,
+                    'label' => $this->optionLabel($productOption['label'], $productCode),
+                    'types' => [],
+                ];
+
+                foreach ($this->variantOptions($variant, $typeCode) as $typeOption) {
+                    $products[$productValue]['types'][$typeOption['value']] = $typeOption;
+                }
+            }
+        }
+
+        return array_values(array_map(
+            fn (array $product): array => [
+                'value' => $product['value'],
+                'label' => $product['label'],
+                'types' => array_values($product['types']),
+            ],
+            $products,
+        ));
+    }
+
+    /** @return list<array{value: string, label: string}> */
+    private function types(CatalogItem $item, ?string $typeCode): array
+    {
+        $types = [];
+
+        foreach ($item->variants as $variant) {
+            foreach ($this->variantOptions($variant, $typeCode) as $typeOption) {
+                $types[$typeOption['value']] = $typeOption;
+            }
+        }
+
+        return array_values($types);
+    }
+
+    /** @return list<array{value: string, label: string}> */
+    private function variantOptions(Variant $variant, ?string $attributeCode): array
+    {
+        if ($attributeCode === null) {
+            return [];
+        }
+
+        $selection = $variant->selectionOptions($variant->catalogItem->itemAttributes)
+            ->get($attributeCode);
+
+        if ($selection === null) {
+            return [];
+        }
+
+        return array_is_list($selection) ? $selection : [$selection];
+    }
+
+    private function optionLabel(string $label, string $attributeCode): string
+    {
+        if ($attributeCode !== 'event_date') {
+            return $label;
+        }
+
+        [$day, $month] = array_pad(explode('/', $label), 2, null);
+
+        return $day !== null && $month !== null ? "{$day}/{$month}" : $label;
+    }
+}

app/Domains/Forms/documentacion/README.md

@@ -9,6 +9,7 @@ Provee catálogos y opciones auxiliares para construir formularios del panel adm
 - `EventFormService`: devuelve redes sociales disponibles y las URL configuradas para el tenant.
 - `SaleFormService`: expone los estados admitidos para compras con sus etiquetas de presentación.
 - `StaffFormService`: lista categorías raíz que pueden asignarse al personal del tenant.
+- `TicketFormService`: expone estados y opciones anidadas de categoría, producto y tipo para los tickets de Fiesta Fútbol Infantil.
 
 Cada servicio tiene un controlador invocable y un `JsonResource` específico. `SocialMediaOptionResource` representa las opciones de redes sociales.
 
@@ -19,6 +20,7 @@ Bajo `/v1/adminapp/forms`, con `auth:sanctum` y `adminapp.tenant`:
 - `GET /event`.
 - `GET /sale`.
 - `GET /staff`.
+- `GET /fiesta-futbol-infantil/ticket`: estados y jerarquía categoría → producto → tipo para filtros de tickets.
 - `GET /fiesta-futbol-infantil/merchandise`: opciones de color y talle del tenant para merchandising.
 
 ## Dependencias

app/Domains/Forms/routes/adminapp.php

@@ -5,6 +5,8 @@ use App\Domains\Forms\Controllers\AdminApp\FoodFormController;
 use App\Domains\Forms\Controllers\AdminApp\MerchandiseFormController;
 use App\Domains\Forms\Controllers\AdminApp\SaleFormController;
 use App\Domains\Forms\Controllers\AdminApp\StaffFormController;
+use App\Domains\Forms\Controllers\AdminApp\TicketFilterFormController;
+use App\Domains\Forms\Controllers\AdminApp\TicketFormController;
 use Illuminate\Support\Facades\Route;
 
 Route::prefix('v1/adminapp/forms')
@@ -13,6 +15,13 @@ Route::prefix('v1/adminapp/forms')
         Route::get('event', EventFormController::class);
         Route::get('sale', SaleFormController::class);
         Route::get('staff', StaffFormController::class);
+        Route::get('tickets-filter', TicketFilterFormController::class)
+            ->middleware('tenant.menu:adminapp.tickets')
+            ->name('adminapp.forms.tickets-filter');
+        Route::get(
+            'fiesta-futbol-infantil/ticket',
+            TicketFormController::class
+        );
         Route::get(
             'fiesta-futbol-infantil/merchandise',
             MerchandiseFormController::class

app/Domains/Ticket/Controllers/AdminApp/TicketController.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Ticket\Controllers\AdminApp;
+
+use App\Domains\Ticket\Requests\AdminAppTicketIndexRequest;
+use App\Domains\Ticket\Resources\AdminApp\AdminAppTicketCollection;
+use App\Domains\Ticket\Services\AdminAppTicketService;
+use App\Http\Controllers\Controller;
+
+class TicketController extends Controller
+{
+    public function __construct(private readonly AdminAppTicketService $ticketService) {}
+
+    public function index(AdminAppTicketIndexRequest $request): AdminAppTicketCollection
+    {
+        $tenant = $request->user()->tenant()->firstOrFail();
+
+        return new AdminAppTicketCollection(
+            $this->ticketService->search($tenant, $request->validated())
+        );
+    }
+}

app/Domains/Ticket/Requests/AdminAppTicketIndexRequest.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Domains\Ticket\Requests;
+
+use App\Domains\Ticket\Models\Ticket;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class AdminAppTicketIndexRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /** @return array<string, list<string>> */
+    public function rules(): array
+    {
+        return [
+            'q' => ['sometimes', 'nullable', 'string', 'max:255'],
+            'category' => ['sometimes', 'nullable', 'string', 'max:255'],
+            'product' => ['sometimes', 'nullable', 'string', 'max:255'],
+            'type' => ['sometimes', 'nullable', 'string', 'max:255'],
+            'date' => ['sometimes', 'nullable', 'date_format:Y-m-d'],
+            'status' => [
+                'sometimes',
+                'nullable',
+                Rule::in([
+                    Ticket::STATUS_ACTIVE,
+                    Ticket::STATUS_USED,
+                    Ticket::STATUS_EXPIRED,
+                ]),
+            ],
+            'page' => ['sometimes', 'integer', 'min:1'],
+            'per_page' => ['sometimes', 'integer', 'min:1', 'max:100'],
+        ];
+    }
+}

app/Domains/Ticket/Resources/AdminApp/AdminAppTicketCollection.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Domains\Ticket\Resources\AdminApp;
+
+use App\Domains\Ticket\Services\AdminAppTicketResult;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\ResourceCollection;
+
+class AdminAppTicketCollection extends ResourceCollection
+{
+    /** @var class-string<AdminAppTicketResource> */
+    public $collects = AdminAppTicketResource::class;
+
+    private readonly int $scannedTickets;
+
+    private readonly int $totalTickets;
+
+    public function __construct(AdminAppTicketResult $result)
+    {
+        parent::__construct($result->tickets);
+
+        $this->scannedTickets = $result->scannedTickets;
+        $this->totalTickets = $result->totalTickets;
+    }
+
+    /** @return array{scanned_tickets: int, total_tickets: int} */
+    public function with(Request $request): array
+    {
+        return [
+            'scanned_tickets' => $this->scannedTickets,
+            'total_tickets' => $this->totalTickets,
+        ];
+    }
+}

app/Domains/Ticket/Resources/AdminApp/AdminAppTicketResource.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace App\Domains\Ticket\Resources\AdminApp;
+
+use App\Domains\Catalog\Models\ItemAttribute;
+use App\Domains\Purchase\Models\PurchaseItem;
+use App\Domains\Ticket\Models\Ticket;
+use App\Domains\Ticket\Resources\TicketResource;
+use Illuminate\Http\Request;
+
+/** @mixin Ticket */
+class AdminAppTicketResource extends TicketResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        $purchaseItem = $this->sourcePurchaseItem();
+
+        return [
+            ...parent::toArray($request),
+            'source_purchase_id' => $this->source_purchase_id,
+            'order_number' => $this->source_purchase_id,
+            'product' => $purchaseItem?->item_nombre
+                ?? $this->sourceCatalogItem?->nombre
+                ?? $this->name,
+            'amount' => $purchaseItem?->precio_unitario,
+            'client' => $this->sourcePurchase?->nombre_apellido ?? $this->user?->nombre_apellido,
+            'date' => $this->sourcePurchase?->created_at,
+            'status' => $this->status,
+            'scanned_by' => $this->scannerUser?->nombre_apellido,
+            'variant_properties' => $this->variantProperties(),
+        ];
+    }
+
+    private function sourcePurchaseItem(): ?PurchaseItem
+    {
+        return $this->sourcePurchase?->items->first(function (PurchaseItem $item): bool {
+            if ($this->source_variant_id !== null) {
+                return $item->source_variant_id === $this->source_variant_id;
+            }
+
+            return $item->source_catalog_item_id === $this->source_catalog_item_id
+                && $item->source_variant_id === null;
+        });
+    }
+
+    /**
+     * @return list<array{
+     *     code: string,
+     *     label: string,
+     *     values: list<array{value: string, label: string}>
+     * }>
+     */
+    private function variantProperties(): array
+    {
+        $variant = $this->sourceVariant;
+
+        if ($variant === null) {
+            return [];
+        }
+
+        $itemAttributes = $variant->definitions
+            ->map(fn ($definition) => $definition->itemAttribute)
+            ->filter()
+            ->merge($variant->catalogItem?->itemAttributes ?? collect())
+            ->unique('id')
+            ->values();
+
+        return $variant->selectionOptions($itemAttributes)
+            ->map(function (array $selection, string $attributeCode) use ($itemAttributes): array {
+                $itemAttribute = $itemAttributes->first(
+                    fn (ItemAttribute $itemAttribute): bool => $itemAttribute->attribute?->codigo
+                        === $attributeCode,
+                );
+                $values = array_is_list($selection) ? $selection : [$selection];
+
+                return [
+                    'code' => $attributeCode,
+                    'label' => $itemAttribute?->attribute?->nombre
+                        ?? ($attributeCode === 'event_date' ? 'Fecha' : $attributeCode),
+                    'values' => array_values($values),
+                ];
+            })
+            ->values()
+            ->all();
+    }
+}

app/Domains/Ticket/Services/AdminAppTicketResult.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Domains\Ticket\Services;
+
+use App\Domains\Ticket\Models\Ticket;
+use Illuminate\Pagination\LengthAwarePaginator;
+
+final readonly class AdminAppTicketResult
+{
+    /** @param LengthAwarePaginator<Ticket> $tickets */
+    public function __construct(
+        public LengthAwarePaginator $tickets,
+        public int $scannedTickets,
+        public int $totalTickets,
+    ) {}
+}

app/Domains/Ticket/Services/AdminAppTicketService.php

@@ -0,0 +1,154 @@
+<?php
+
+namespace App\Domains\Ticket\Services;
+
+use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticket\Models\Ticket;
+use Illuminate\Database\Eloquent\Builder;
+
+class AdminAppTicketService
+{
+    /**
+     * @param  array{q?: string|null, category?: string|null, product?: string|null, type?: string|null, date?: string|null, status?: string|null, page?: int, per_page?: int}  $filters
+     */
+    public function search(Tenant $tenant, array $filters = []): AdminAppTicketResult
+    {
+        $query = $this->baseQuery($tenant, $filters);
+
+        $tickets = (clone $query)
+            ->with([
+                ...TicketValidityResolver::RELATIONS,
+                ...TicketPresentationResolver::RELATIONS,
+                'user',
+                'scannerUser',
+                'sourceCatalogItem.category',
+                'sourcePurchase.items',
+            ])
+            ->orderByDesc('id')
+            ->paginateFromRequest()
+            ->withQueryString();
+
+        return new AdminAppTicketResult(
+            tickets: $tickets,
+            scannedTickets: (clone $query)->whereNotNull('used_at')->count(),
+            totalTickets: $tickets->total(),
+        );
+    }
+
+    /**
+     * @param  array{q?: string|null, category?: string|null, product?: string|null, type?: string|null, date?: string|null, status?: string|null, page?: int, per_page?: int}  $filters
+     * @return Builder<Ticket>
+     */
+    private function baseQuery(Tenant $tenant, array $filters): Builder
+    {
+        $search = trim((string) ($filters['q'] ?? ''));
+
+        $query = Ticket::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->when($search !== '', function (Builder $query) use ($search): void {
+                $query->when(
+                    ctype_digit($search),
+                    fn (Builder $searchQuery): Builder => $searchQuery
+                        ->where('tickets.id', (int) $search),
+                    fn (Builder $searchQuery): Builder => $searchQuery
+                        ->where('ticket', 'like', "%{$search}%"),
+                );
+            })
+            ->when($filters['category'] ?? null, function (Builder $query, string $category): void {
+                $query->whereHas('sourceCatalogItem.category', fn (Builder $categoryQuery): Builder => $categoryQuery
+                    ->whereRaw('LOWER(nombre) = ?', [mb_strtolower(trim($category))]));
+            })
+            ->when($filters['product'] ?? null, function (Builder $query, string $product) use ($filters): void {
+                $this->applyProductFilter($query, (string) ($filters['category'] ?? ''), $product);
+            })
+            ->when($filters['type'] ?? null, function (Builder $query, string $type) use ($filters): void {
+                $this->applyTypeFilter($query, (string) ($filters['category'] ?? ''), $type);
+            })
+            ->when($filters['date'] ?? null, fn (Builder $query, string $date): Builder => $query
+                ->whereHas('sourcePurchase', fn (Builder $purchaseQuery): Builder => $purchaseQuery
+                    ->whereDate('created_at', $date)));
+
+        $this->applyStatusFilter($query, $filters['status'] ?? null);
+
+        return $query;
+    }
+
+    /** @param Builder<Ticket> $query */
+    private function applyProductFilter(Builder $query, string $category, string $product): void
+    {
+        $category = $this->normalizedCategory($category);
+
+        if (in_array($category, ['alojamientos', 'camping'], true)) {
+            $this->whereVariantDefinition($query, 'tipo_alojamiento', $product);
+
+            return;
+        }
+
+        if (in_array($category, ['comidas', 'comida'], true)) {
+            $query->whereHas('sourceVariant', function (Builder $variantQuery) use ($product): void {
+                $variantQuery->where(function (Builder $dateQuery) use ($product): void {
+                    $dateQuery
+                        ->where('event_date_id', $product)
+                        ->orWhereHas('eventDates', fn (Builder $eventDateQuery): Builder => $eventDateQuery
+                            ->whereKey($product));
+                });
+            });
+
+            return;
+        }
+
+        $query->whereHas('sourceCatalogItem', fn (Builder $itemQuery): Builder => $itemQuery
+            ->where('slug', $product));
+    }
+
+    /** @param Builder<Ticket> $query */
+    private function applyTypeFilter(Builder $query, string $category, string $type): void
+    {
+        $attribute = match ($this->normalizedCategory($category)) {
+            'comidas', 'comida' => 'horario',
+            'merchandising' => 'color',
+            default => null,
+        };
+
+        if ($attribute !== null) {
+            $this->whereVariantDefinition($query, $attribute, $type);
+        }
+    }
+
+    /** @param Builder<Ticket> $query */
+    private function whereVariantDefinition(Builder $query, string $attribute, string $value): void
+    {
+        $query->whereHas('sourceVariant.definitions', fn (Builder $definitionQuery): Builder => $definitionQuery
+            ->where('value', $value)
+            ->whereHas('itemAttribute.attribute', fn (Builder $attributeQuery): Builder => $attributeQuery
+                ->where('codigo', $attribute)));
+    }
+
+    /** @param Builder<Ticket> $query */
+    private function applyStatusFilter(Builder $query, ?string $status): void
+    {
+        if ($status === null || $status === '') {
+            return;
+        }
+
+        if ($status === Ticket::STATUS_USED) {
+            $query->whereNotNull('used_at');
+
+            return;
+        }
+
+        $matchingIds = (clone $query)
+            ->whereNull('used_at')
+            ->with(TicketValidityResolver::RELATIONS)
+            ->get()
+            ->filter(fn (Ticket $ticket): bool => $ticket->status === $status)
+            ->pluck('id');
+
+        $query->whereIn('tickets.id', $matchingIds);
+    }
+
+    private function normalizedCategory(string $category): string
+    {
+        return mb_strtolower(trim($category));
+    }
+}

app/Domains/Ticket/documentacion/README.md

@@ -30,6 +30,12 @@ Bajo `/tenants/{tenant:codigo}`, protegidos por `auth:sanctum`:
 - `GET /tickets`.
 - `POST /tickets/pdf`.
 
+Bajo `/v1/adminapp/tenant`, protegido por `auth:sanctum`, `adminapp.tenant` y el menú
+`adminapp.tickets`:
+
+- `GET /tickets`, paginado y con búsqueda opcional mediante `q`. La respuesta incluye
+  `scanned_tickets` y `total_tickets` para el tenant autenticado.
+
 `TicketPdfService` genera la descarga y `TicketResource`/`ValidityTimeResource` definen las respuestas.
 
 ## Dependencias y reglas

app/Domains/Ticket/routes/adminapp.php

@@ -0,0 +1,12 @@
+<?php
+
+use App\Domains\Ticket\Controllers\AdminApp\TicketController;
+use Illuminate\Support\Facades\Route;
+
+Route::prefix('v1/adminapp/tenant')
+    ->middleware(['auth:sanctum', 'adminapp.tenant'])
+    ->group(function (): void {
+        Route::get('tickets', [TicketController::class, 'index'])
+            ->middleware('tenant.menu:adminapp.tickets')
+            ->name('adminapp.tickets.index');
+    });

app/Domains/Ticket/routes/api.php

@@ -11,3 +11,4 @@ Route::prefix('tenants/{tenant:codigo}')
     });
 
 require __DIR__.'/scanner.php';
+require __DIR__.'/adminapp.php';

database/migrations/2026_08_28_000000_add_fiesta_futbol_infantil_tickets_adminapp_menu.php

@@ -0,0 +1,82 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Support\Facades\DB;
+
+return new class extends Migration
+{
+    private const MENU_CODE = 'adminapp.tickets';
+
+    private const TENANT_CODE = 'fiesta_futbol_infantil';
+
+    public function up(): void
+    {
+        if (! DB::table('menues')->where('code', 'main.adminapp')->exists()) {
+            // Reference data is added by seeders on fresh installations.
+            return;
+        }
+
+        $now = now();
+
+        DB::transaction(function () use ($now): void {
+            DB::table('menues')->updateOrInsert(
+                ['code' => self::MENU_CODE],
+                [
+                    'label' => 'Tickets',
+                    'parent_menu_code' => 'main.adminapp',
+                    'content_type' => 'dynamic',
+                    'static_content_schema' => null,
+                    'route' => '/admin/tickets',
+                    'created_at' => $now,
+                    'updated_at' => $now,
+                ],
+            );
+
+            DB::table('tenants_menues')
+                ->where('menu_code', self::MENU_CODE)
+                ->where('tenant_code', '!=', self::TENANT_CODE)
+                ->delete();
+
+            if (DB::table('tenants')->where('codigo', self::TENANT_CODE)->exists()) {
+                DB::table('tenants_menues')->updateOrInsert(
+                    [
+                        'tenant_code' => self::TENANT_CODE,
+                        'menu_code' => self::MENU_CODE,
+                    ],
+                    [
+                        'static_content' => null,
+                        'created_at' => $now,
+                        'updated_at' => $now,
+                    ],
+                );
+            }
+
+            DB::table('roles')
+                ->whereIn('codigo', ['admin', 'adminapp'])
+                ->pluck('codigo')
+                ->each(function (string $roleCode): void {
+                    DB::table('roles_menues')->updateOrInsert([
+                        'rol_codigo' => $roleCode,
+                        'menu_codigo' => self::MENU_CODE,
+                    ]);
+                });
+        });
+    }
+
+    public function down(): void
+    {
+        DB::transaction(function (): void {
+            DB::table('tenants_menues')
+                ->where('menu_code', self::MENU_CODE)
+                ->delete();
+
+            DB::table('roles_menues')
+                ->where('menu_codigo', self::MENU_CODE)
+                ->delete();
+
+            DB::table('menues')
+                ->where('code', self::MENU_CODE)
+                ->delete();
+        });
+    }
+};

database/seeders/MenuSeeder.php

@@ -78,6 +78,12 @@ class MenuSeeder extends Seeder
                 'parent_menu_code' => 'main.adminapp',
                 'route' => '/admin/staff',
             ],
+            [
+                'code' => 'adminapp.tickets',
+                'label' => 'Tickets',
+                'parent_menu_code' => 'main.adminapp',
+                'route' => '/admin/tickets',
+            ],
             [
                 'code' => 'adminapp.fiesta-futbol-infantil.entradas',
                 'label' => 'Entradas',
@@ -270,6 +276,7 @@ class MenuSeeder extends Seeder
             'fiesta_futbol_infantil',
         ];
         $fiestaCategoryMenuCodes = [
+            'adminapp.tickets',
             'adminapp.fiesta-futbol-infantil.entradas',
             'adminapp.fiesta-futbol-infantil.alojamientos',
             'adminapp.fiesta-futbol-infantil.merchandising',

phpunit.xml

@@ -18,7 +18,7 @@
         </include>
     </source>
     <php>
-        <env name="APP_ENV" value="testing"/>
+        <env name="APP_ENV" value="testing" force="true"/>
         <env name="DB_DATABASE" value="shopit_test" force="true"/>
         <env name="APP_MAINTENANCE_DRIVER" value="file"/>
         <env name="APP_CONFIG_CACHE" value="bootstrap/cache/phpunit-config.php"/>

tests/Feature/Forms/AdminAppTicketFilterFormControllerTest.php

@@ -0,0 +1,283 @@
+<?php
+
+namespace Tests\Feature\Forms;
+
+use App\Domains\Attachable\Enums\AttachmentType;
+use App\Domains\Attachable\Models\Attachment;
+use App\Domains\Auth\Models\User;
+use App\Domains\Authorization\Enums\RoleCode;
+use App\Domains\Catalog\Models\CatalogItem;
+use App\Domains\Catalog\Services\CatalogService;
+use App\Domains\Menu\Models\Menu;
+use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticket\Models\Ticket;
+use Database\Seeders\AttributeSeeder;
+use Database\Seeders\AuthorizationSeeder;
+use Database\Seeders\FiestaFutbolInfantilProductSeeder;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Str;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class AdminAppTicketFilterFormControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->seed(AuthorizationSeeder::class);
+    }
+
+    public function test_authentication_is_required(): void
+    {
+        $this->getJson('/api/v1/adminapp/forms/tickets-filter')->assertUnauthorized();
+    }
+
+    public function test_the_tenant_must_have_the_tickets_menu(): void
+    {
+        $tenant = $this->createTenant('tenant_without_tickets');
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        $this->getJson('/api/v1/adminapp/forms/tickets-filter')->assertNotFound();
+    }
+
+    public function test_it_returns_the_common_ticket_filter_fields_for_other_tenants(): void
+    {
+        $tenant = $this->createTenant('another_tenant');
+        $this->grantTicketsMenu($tenant);
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        $this->getJson('/api/v1/adminapp/forms/tickets-filter')
+            ->assertOk()
+            ->assertExactJson([
+                'data' => [
+                    'code' => 'tickets_filter',
+                    'action' => '/api/v1/adminapp/tenant/tickets',
+                    'method' => 'GET',
+                    'fields' => [
+                        [
+                            'name' => 'date',
+                            'query_param' => 'date',
+                            'label' => 'Fecha',
+                            'type' => 'date',
+                            'required' => false,
+                            'default' => null,
+                        ],
+                        [
+                            'name' => 'status',
+                            'query_param' => 'status',
+                            'label' => 'Estado',
+                            'type' => 'select',
+                            'required' => false,
+                            'default' => null,
+                            'placeholder' => 'Estado',
+                            'options' => [
+                                ['value' => 'active', 'label' => 'Activo'],
+                                ['value' => 'used', 'label' => 'Usado'],
+                                ['value' => 'expired', 'label' => 'Vencido'],
+                            ],
+                        ],
+                    ],
+                ],
+            ]);
+    }
+
+    public function test_it_returns_the_complete_nested_form_for_fiesta_futbol_infantil(): void
+    {
+        $tenant = $this->createFiestaFutbolInfantilTenant();
+        $this->grantTicketsMenu($tenant);
+        $admin = $this->createAdminAppUser($tenant);
+        Sanctum::actingAs($admin);
+
+        $response = $this->getJson('/api/v1/adminapp/forms/tickets-filter')
+            ->assertOk()
+            ->assertJsonPath('data.fields.0.name', 'category')
+            ->assertJsonPath('data.fields.0.query_param', 'category')
+            ->assertJsonPath('data.fields.1.name', 'product')
+            ->assertJsonPath('data.fields.1.query_param', 'product')
+            ->assertJsonPath('data.fields.1.depends_on', 'category')
+            ->assertJsonPath('data.fields.2.name', 'type')
+            ->assertJsonPath('data.fields.2.query_param', 'type')
+            ->assertJsonPath('data.fields.2.depends_on', 'product')
+            ->assertJsonPath('data.fields.3.name', 'date')
+            ->assertJsonPath('data.fields.3.query_param', 'date')
+            ->assertJsonPath('data.fields.4.name', 'status')
+            ->assertJsonPath('data.fields.4.query_param', 'status');
+
+        $categories = collect($response->json('data.fields.0.options'));
+        $this->assertSame(
+            ['Entradas', 'Camping', 'Comida', 'Merchandising'],
+            $categories->pluck('label')->all(),
+        );
+
+        $entries = $categories->firstWhere('value', 'entradas');
+        $this->assertSame('Abono', $entries['children']['options'][0]['label']);
+        $this->assertTrue($entries['children']['options'][0]['children']['disabled']);
+
+        $camping = $categories->firstWhere('value', 'alojamientos');
+        $this->assertSame(
+            ['Carpa', 'Motorhome'],
+            collect($camping['children']['options'])->pluck('label')->all(),
+        );
+        $this->assertTrue($camping['children']['options'][0]['children']['disabled']);
+
+        $merchandise = $categories->firstWhere('value', 'merchandising');
+        $this->assertSame('Camiseta', $merchandise['children']['options'][0]['label']);
+        $this->assertSame(
+            ['Verde', 'Blanco'],
+            collect($merchandise['children']['options'][0]['children']['options'])->pluck('label')->all(),
+        );
+    }
+
+    public function test_a_food_schedule_is_only_returned_when_a_variant_exists_for_the_date(): void
+    {
+        $tenant = $this->createFiestaFutbolInfantilTenant();
+        $this->grantTicketsMenu($tenant);
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        $date = $tenant->eventDates()->orderByDesc('date')->firstOrFail();
+        $food = CatalogItem::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->where('slug', 'comida')
+            ->with([
+                'itemAttributes.attribute.options',
+                'variants.definitions.itemAttribute.attribute.options',
+                'variants.eventDates',
+                'variants.eventDate',
+            ])
+            ->firstOrFail();
+
+        $food->variants
+            ->filter(fn ($variant): bool => $variant->selectedEventDates()->contains('id', $date->id)
+                && $variant->selectionValues()->get('horario') === 'Almuerzo')
+            ->each->delete();
+
+        $response = $this->getJson('/api/v1/adminapp/forms/tickets-filter')->assertOk();
+        $foodCategory = collect($response->json('data.fields.0.options'))->firstWhere('value', 'comidas');
+        $dateProduct = collect($foodCategory['children']['options'])
+            ->firstWhere('value', (string) $date->id);
+        $schedules = collect($dateProduct['children']['options'])->pluck('value');
+
+        $this->assertNotContains('Almuerzo', $schedules);
+        $this->assertContains('Desayuno', $schedules);
+        $this->assertContains('Cena', $schedules);
+    }
+
+    public function test_a_deleted_food_variant_remains_in_the_filter_when_a_ticket_references_it(): void
+    {
+        $tenant = $this->createFiestaFutbolInfantilTenant();
+        $this->grantTicketsMenu($tenant);
+        $admin = $this->createAdminAppUser($tenant);
+        Sanctum::actingAs($admin);
+
+        $food = CatalogItem::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->where('slug', 'comida')
+            ->with([
+                'itemAttributes.attribute.options',
+                'variants.definitions.itemAttribute.attribute.options',
+                'variants.eventDates',
+                'variants.eventDate',
+            ])
+            ->firstOrFail();
+        $historicalVariant = $food->variants->first(function ($variant): bool {
+            return $variant->selectedEventDates()->first()?->date->format('d/m') === '12/10'
+                && $variant->selectionValues()->get('horario') === 'Cena';
+        });
+        $this->assertNotNull($historicalVariant);
+
+        $ticket = Ticket::query()->create([
+            'tenant_code' => $tenant->codigo,
+            'ticket' => (string) Str::uuid(),
+            'user_id' => $admin->id,
+            'source_catalog_item_id' => $food->id,
+            'source_variant_id' => $historicalVariant->id,
+        ]);
+
+        $catalogService = app(CatalogService::class);
+        foreach ($food->variants as $variant) {
+            $catalogService->deleteVariant($variant);
+        }
+
+        $this->assertTrue(CatalogItem::withTrashed()->findOrFail($food->id)->trashed());
+
+        $response = $this->getJson('/api/v1/adminapp/forms/tickets-filter')->assertOk();
+        $foodCategory = collect($response->json('data.fields.0.options'))->firstWhere('value', 'comidas');
+        $products = collect($foodCategory['children']['options']);
+
+        $this->assertCount(1, $products);
+        $this->assertSame('12/10', $products->first()['label']);
+        $this->assertSame(
+            ['Cena'],
+            collect($products->first()['children']['options'])->pluck('label')->all(),
+        );
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets?'.http_build_query([
+            'category' => 'comidas',
+            'product' => $products->first()['value'],
+            'type' => 'Cena',
+        ]))
+            ->assertOk()
+            ->assertJsonCount(1, 'data')
+            ->assertJsonPath('data.0.id', $ticket->id);
+    }
+
+    private function createFiestaFutbolInfantilTenant(): Tenant
+    {
+        $tenant = $this->createTenant('fiesta_futbol_infantil');
+        $this->seed([AttributeSeeder::class, FiestaFutbolInfantilProductSeeder::class]);
+
+        return $tenant->refresh();
+    }
+
+    private function createTenant(string $code): Tenant
+    {
+        $headerLogo = $this->createAttachment("{$code}-header.png");
+        $footerLogo = $this->createAttachment("{$code}-footer.png");
+
+        return Tenant::query()->create([
+            'codigo' => $code,
+            'nombre' => ucfirst($code),
+            'dominio' => "{$code}.test",
+            'primary_color' => '#111111',
+            'secondary_color' => '#222222',
+            'danger_color' => '#333333',
+            'success_color' => '#444444',
+            'header_bg_color' => '#ffffff',
+            'footer_bg_color' => '#ffffff',
+            'header_logo_id' => $headerLogo->id,
+            'footer_logo_id' => $footerLogo->id,
+        ]);
+    }
+
+    private function createAttachment(string $filename): Attachment
+    {
+        return Attachment::query()->create([
+            'path' => "tests/{$filename}",
+            'filename' => $filename,
+            'type' => AttachmentType::Image,
+            'mime_type' => 'image/png',
+        ]);
+    }
+
+    private function createAdminAppUser(Tenant $tenant): User
+    {
+        return User::factory()->create([
+            'rol_codigo' => RoleCode::AdminApp->value,
+            'tenant_codigo' => $tenant->codigo,
+        ]);
+    }
+
+    private function grantTicketsMenu(Tenant $tenant): void
+    {
+        $menu = Menu::query()->create([
+            'code' => 'adminapp.tickets',
+            'label' => 'Tickets',
+            'route' => '/admin/tickets',
+        ]);
+
+        $tenant->menues()->attach($menu->code);
+    }
+}

tests/Feature/Forms/AdminAppTicketFormControllerTest.php

@@ -0,0 +1,155 @@
+<?php
+
+namespace Tests\Feature\Forms;
+
+use App\Domains\Attachable\Enums\AttachmentType;
+use App\Domains\Attachable\Models\Attachment;
+use App\Domains\Auth\Models\User;
+use App\Domains\Authorization\Enums\RoleCode;
+use App\Domains\Tenant\Models\Tenant;
+use Database\Seeders\AttributeSeeder;
+use Database\Seeders\AuthorizationSeeder;
+use Database\Seeders\FiestaFutbolInfantilProductSeeder;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class AdminAppTicketFormControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->seed(AuthorizationSeeder::class);
+    }
+
+    public function test_authentication_is_required(): void
+    {
+        $this->getJson('/api/v1/adminapp/forms/fiesta-futbol-infantil/ticket')
+            ->assertUnauthorized();
+    }
+
+    public function test_it_returns_nested_ticket_options_using_the_frontend_presentation_mapping(): void
+    {
+        $headerLogo = $this->createAttachment('header.png');
+        $footerLogo = $this->createAttachment('footer.png');
+        $tenant = Tenant::query()->create([
+            'codigo' => 'fiesta_futbol_infantil',
+            'nombre' => 'Fiesta Fútbol Infantil',
+            'dominio' => 'fiesta-futbol-infantil.test',
+            'primary_color' => '#00973F',
+            'secondary_color' => '#A0A0A0',
+            'danger_color' => '#FF8888',
+            'success_color' => '#198754',
+            'header_bg_color' => '#ffffff',
+            'footer_bg_color' => '#015327',
+            'header_logo_id' => $headerLogo->id,
+            'footer_logo_id' => $footerLogo->id,
+        ]);
+        $this->seed([AttributeSeeder::class, FiestaFutbolInfantilProductSeeder::class]);
+
+        Sanctum::actingAs(User::factory()->create([
+            'rol_codigo' => RoleCode::AdminApp->value,
+            'tenant_codigo' => $tenant->codigo,
+        ]));
+
+        $response = $this->getJson('/api/v1/adminapp/forms/fiesta-futbol-infantil/ticket')
+            ->assertOk()
+            ->assertExactJson([
+                'data' => [
+                    'statuses' => [
+                        ['value' => 'active', 'label' => 'Activo'],
+                        ['value' => 'used', 'label' => 'Usado'],
+                        ['value' => 'expired', 'label' => 'Vencido'],
+                    ],
+                    'categories' => [
+                        [
+                            'value' => 'entradas',
+                            'label' => 'Entradas',
+                            'products' => [[
+                                'value' => 'abono',
+                                'label' => 'Abono',
+                                'types' => [],
+                            ]],
+                        ],
+                        [
+                            'value' => 'alojamientos',
+                            'label' => 'Camping',
+                            'products' => [
+                                ['value' => 'Carpa', 'label' => 'Carpa', 'types' => []],
+                                ['value' => 'Motorhome', 'label' => 'Motorhome', 'types' => []],
+                            ],
+                        ],
+                        [
+                            'value' => 'comidas',
+                            'label' => 'Comida',
+                            'products' => [
+                                [
+                                    'value' => (string) $tenant->eventDates[0]->id,
+                                    'label' => '09/10',
+                                    'types' => [
+                                        ['value' => 'Desayuno', 'label' => 'Desayuno'],
+                                        ['value' => 'Almuerzo', 'label' => 'Almuerzo'],
+                                        ['value' => 'Cena', 'label' => 'Cena'],
+                                    ],
+                                ],
+                                [
+                                    'value' => (string) $tenant->eventDates[1]->id,
+                                    'label' => '10/10',
+                                    'types' => [
+                                        ['value' => 'Desayuno', 'label' => 'Desayuno'],
+                                        ['value' => 'Almuerzo', 'label' => 'Almuerzo'],
+                                        ['value' => 'Cena', 'label' => 'Cena'],
+                                    ],
+                                ],
+                                [
+                                    'value' => (string) $tenant->eventDates[2]->id,
+                                    'label' => '11/10',
+                                    'types' => [
+                                        ['value' => 'Desayuno', 'label' => 'Desayuno'],
+                                        ['value' => 'Almuerzo', 'label' => 'Almuerzo'],
+                                        ['value' => 'Cena', 'label' => 'Cena'],
+                                    ],
+                                ],
+                                [
+                                    'value' => (string) $tenant->eventDates[3]->id,
+                                    'label' => '12/10',
+                                    'types' => [
+                                        ['value' => 'Desayuno', 'label' => 'Desayuno'],
+                                        ['value' => 'Almuerzo', 'label' => 'Almuerzo'],
+                                        ['value' => 'Cena', 'label' => 'Cena'],
+                                    ],
+                                ],
+                            ],
+                        ],
+                        [
+                            'value' => 'merchandising',
+                            'label' => 'Merchandising',
+                            'products' => [[
+                                'value' => 'camiseta',
+                                'label' => 'Camiseta',
+                                'types' => [
+                                    ['value' => 'Verde', 'label' => 'Verde'],
+                                    ['value' => 'Blanco', 'label' => 'Blanco'],
+                                ],
+                            ]],
+                        ],
+                    ],
+                ],
+            ]);
+
+        $response->assertJsonMissingPath('data.categories.0.products.0.category');
+    }
+
+    private function createAttachment(string $filename): Attachment
+    {
+        return Attachment::query()->create([
+            'path' => "tests/{$filename}",
+            'filename' => $filename,
+            'type' => AttachmentType::Image,
+            'mime_type' => 'image/png',
+        ]);
+    }
+}

tests/Feature/Seeders/MenuSeederTest.php

@@ -34,6 +34,7 @@ class MenuSeederTest extends TestCase
             'adminapp.ventas' => ['Ventas', '/admin/ventas'],
         ];
         $fiestaCategoryMenus = [
+            'adminapp.tickets' => ['Tickets', '/admin/tickets'],
             'adminapp.fiesta-futbol-infantil.entradas' => ['Entradas', '/admin/entradas'],
             'adminapp.fiesta-futbol-infantil.alojamientos' => ['Alojamientos', '/admin/alojamientos'],
             'adminapp.fiesta-futbol-infantil.merchandising' => ['Merchandising', '/admin/merchandising'],
@@ -49,7 +50,11 @@ class MenuSeederTest extends TestCase
         $this->assertSame(Menu::CONTENT_TYPE_DYNAMIC, $adminApp->content_type);
         $this->assertSame('/', $adminApp->route);
         $this->assertSame(
-            array_keys([...$expectedMenus, ...$fiestaCategoryMenus]),
+            collect(array_keys([
+                ...$expectedMenus,
+                ...$fiestaCategoryMenus,
+                'adminapp.desfile.entradas' => ['Entradas', '/admin/desfile/entradas'],
+            ]))->sort()->values()->all(),
             $adminApp->children->pluck('code')->sort()->values()->all()
         );
         $this->assertTrue(

tests/Feature/Ticket/AdminAppTicketControllerTest.php

@@ -0,0 +1,360 @@
+<?php
+
+namespace Tests\Feature\Ticket;
+
+use App\Domains\Attachable\Enums\AttachmentType;
+use App\Domains\Attachable\Models\Attachment;
+use App\Domains\Auth\Models\User;
+use App\Domains\Authorization\Enums\RoleCode;
+use App\Domains\Catalog\Models\Attribute;
+use App\Domains\Catalog\Models\CatalogItem;
+use App\Domains\Catalog\Models\Inventory;
+use App\Domains\Catalog\Models\Variant;
+use App\Domains\Menu\Models\Menu;
+use App\Domains\Purchase\Models\Purchase;
+use App\Domains\Purchase\Models\PurchaseItem;
+use App\Domains\Shared\Enums\FieldType;
+use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Tenant\Models\WebsiteType;
+use App\Domains\Ticket\Models\Ticket;
+use Database\Seeders\AttributeSeeder;
+use Database\Seeders\AuthorizationSeeder;
+use Database\Seeders\FiestaFutbolInfantilProductSeeder;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Str;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class AdminAppTicketControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->seed(AuthorizationSeeder::class);
+        WebsiteType::query()->create(['codigo' => 'onticket', 'nombre' => 'OnTicket']);
+    }
+
+    public function test_authentication_is_required(): void
+    {
+        $this->getJson('/api/v1/adminapp/tenant/tickets')->assertUnauthorized();
+    }
+
+    public function test_the_tenant_must_have_the_tickets_menu(): void
+    {
+        $tenant = $this->createTenant('fiesta_futbol_infantil');
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets')->assertNotFound();
+    }
+
+    public function test_it_lists_only_tickets_from_the_authenticated_tenant(): void
+    {
+        $tenant = $this->createTenant('fiesta_futbol_infantil');
+        $otherTenant = $this->createTenant('other');
+        $admin = $this->createAdminAppUser($tenant);
+        $otherUser = $this->createAdminAppUser($otherTenant);
+        $this->grantTicketsMenu($tenant);
+        Sanctum::actingAs($admin);
+
+        $ticket = $this->createTicket($tenant, $admin);
+        $this->createTicket($otherTenant, $otherUser);
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets')
+            ->assertOk()
+            ->assertJsonCount(1, 'data')
+            ->assertJsonPath('data.0.id', $ticket->id)
+            ->assertJsonPath('data.0.tenant_code', $tenant->codigo)
+            ->assertJsonPath('meta.total', 1);
+    }
+
+    public function test_it_supports_id_and_uuid_search(): void
+    {
+        $tenant = $this->createTenant('fiesta_futbol_infantil');
+        $admin = $this->createAdminAppUser($tenant);
+        $this->grantTicketsMenu($tenant);
+        Sanctum::actingAs($admin);
+
+        $matching = $this->createTicket($tenant, $admin);
+        $this->createTicket($tenant, $admin);
+
+        $this->getJson("/api/v1/adminapp/tenant/tickets?q={$matching->id}")
+            ->assertOk()
+            ->assertJsonCount(1, 'data')
+            ->assertJsonPath('data.0.id', $matching->id);
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets?q='.substr($matching->ticket, 0, 8))
+            ->assertOk()
+            ->assertJsonCount(1, 'data')
+            ->assertJsonPath('data.0.ticket', $matching->ticket);
+    }
+
+    public function test_it_includes_tenant_scanned_and_total_ticket_counts(): void
+    {
+        $tenant = $this->createTenant('fiesta_futbol_infantil');
+        $otherTenant = $this->createTenant('other');
+        $admin = $this->createAdminAppUser($tenant);
+        $otherUser = $this->createAdminAppUser($otherTenant);
+        $this->grantTicketsMenu($tenant);
+        Sanctum::actingAs($admin);
+
+        $this->createTicket($tenant, $admin)->update(['used_at' => now()]);
+        $this->createTicket($tenant, $admin);
+        $this->createTicket($otherTenant, $otherUser)->update(['used_at' => now()]);
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets?q=does-not-match')
+            ->assertOk()
+            ->assertJsonCount(0, 'data')
+            ->assertJsonPath('scanned_tickets', 0)
+            ->assertJsonPath('total_tickets', 0);
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets')
+            ->assertOk()
+            ->assertJsonPath('scanned_tickets', 1)
+            ->assertJsonPath('total_tickets', 2);
+    }
+
+    public function test_it_returns_structured_variant_properties(): void
+    {
+        $tenant = $this->createTenant('fiesta_futbol_infantil');
+        $admin = $this->createAdminAppUser($tenant);
+        $this->grantTicketsMenu($tenant);
+        Sanctum::actingAs($admin);
+
+        $item = CatalogItem::query()->create([
+            'tenant_code' => $tenant->codigo,
+            'slug' => 'remera',
+            'nombre' => 'Remera',
+            'precio' => '8000.00',
+            'has_tickets' => true,
+        ]);
+        $attribute = Attribute::query()->create([
+            'tenant_codigo' => $tenant->codigo,
+            'codigo' => 'size',
+            'nombre' => 'Talle',
+            'type' => FieldType::Select,
+        ]);
+        $attribute->options()->create(['value' => 'xl', 'label' => 'XL']);
+        $itemAttribute = $item->itemAttributes()->create([
+            'attribute_id' => $attribute->id,
+            'sort_order' => 1,
+        ]);
+        $variant = Variant::query()->create([
+            'catalog_item_id' => $item->id,
+            'inventory_id' => Inventory::query()->create()->id,
+        ]);
+        $variant->definitions()->create([
+            'item_attribute_id' => $itemAttribute->id,
+            'value' => 'xl',
+        ]);
+        $purchase = Purchase::query()->create([
+            'tenant_codigo' => $tenant->codigo,
+            'user_id' => $admin->id,
+            'status' => Purchase::STATUS_PAID,
+            'nombre_apellido' => 'Nombre Apellido',
+            'total' => '8000.00',
+        ]);
+        PurchaseItem::query()->create([
+            'compra_id' => $purchase->id,
+            'source_catalog_item_id' => $item->id,
+            'source_variant_id' => $variant->id,
+            'nombre' => 'Remera',
+            'descripcion' => '',
+            'slug' => 'remera',
+            'item_nombre' => 'Remera',
+            'cantidad' => 1,
+            'precio_unitario' => '8000.00',
+            'total' => '8000.00',
+        ]);
+        $ticket = $this->createTicket($tenant, $admin, [
+            'source_purchase_id' => $purchase->id,
+            'source_catalog_item_id' => $item->id,
+            'source_variant_id' => $variant->id,
+            'scanner_user_id' => $admin->id,
+            'used_at' => now(),
+        ]);
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets')
+            ->assertOk()
+            ->assertJsonPath('data.0.id', $ticket->id)
+            ->assertJsonPath('data.0.order_number', $purchase->id)
+            ->assertJsonPath('data.0.product', 'Remera')
+            ->assertJsonPath('data.0.amount', '8000.00')
+            ->assertJsonPath('data.0.status', Ticket::STATUS_USED)
+            ->assertJsonPath('data.0.scanned_by', $admin->nombre_apellido)
+            ->assertJsonPath('data.0.variant_properties.0.code', 'size')
+            ->assertJsonPath('data.0.variant_properties.0.label', 'Talle')
+            ->assertJsonPath('data.0.variant_properties.0.values.0.value', 'xl')
+            ->assertJsonPath('data.0.variant_properties.0.values.0.label', 'XL');
+    }
+
+    public function test_it_applies_the_ticket_filter_form_values(): void
+    {
+        $tenant = $this->createTenant('fiesta_futbol_infantil');
+        $admin = $this->createAdminAppUser($tenant);
+        $this->grantTicketsMenu($tenant);
+        $this->seed([AttributeSeeder::class, FiestaFutbolInfantilProductSeeder::class]);
+        Sanctum::actingAs($admin);
+
+        $date = $tenant->eventDates()->orderByDesc('date')->firstOrFail();
+        $food = CatalogItem::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->where('slug', 'comida')
+            ->with([
+                'variants.definitions.itemAttribute.attribute.options',
+                'variants.eventDates',
+                'variants.eventDate',
+            ])
+            ->firstOrFail();
+        $dinner = $food->variants->first(fn (Variant $variant): bool => $variant
+            ->selectedEventDates()->contains('id', $date->id)
+            && $variant->selectionValues()->get('horario') === 'Cena');
+        $lunch = $food->variants->first(fn (Variant $variant): bool => $variant
+            ->selectedEventDates()->contains('id', $date->id)
+            && $variant->selectionValues()->get('horario') === 'Almuerzo');
+        $this->assertNotNull($dinner);
+        $this->assertNotNull($lunch);
+
+        $matchingPurchase = $this->createPurchase($tenant, $admin, '2026-08-20 10:00:00');
+        $otherPurchase = $this->createPurchase($tenant, $admin, '2026-08-21 10:00:00');
+        $matching = $this->createTicket($tenant, $admin, [
+            'source_purchase_id' => $matchingPurchase->id,
+            'source_catalog_item_id' => $food->id,
+            'source_variant_id' => $dinner->id,
+            'used_at' => now(),
+        ]);
+        $this->createTicket($tenant, $admin, [
+            'source_purchase_id' => $matchingPurchase->id,
+            'source_catalog_item_id' => $food->id,
+            'source_variant_id' => $lunch->id,
+            'used_at' => now(),
+        ]);
+        $this->createTicket($tenant, $admin, [
+            'source_purchase_id' => $otherPurchase->id,
+            'source_catalog_item_id' => $food->id,
+            'source_variant_id' => $dinner->id,
+            'used_at' => now(),
+        ]);
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets?'.http_build_query([
+            'category' => 'comidas',
+            'product' => (string) $date->id,
+            'type' => 'Cena',
+            'date' => '2026-08-20',
+            'status' => Ticket::STATUS_USED,
+        ]))
+            ->assertOk()
+            ->assertJsonCount(1, 'data')
+            ->assertJsonPath('data.0.id', $matching->id)
+            ->assertJsonPath('scanned_tickets', 1)
+            ->assertJsonPath('total_tickets', 1);
+    }
+
+    public function test_it_filters_computed_active_and_expired_statuses(): void
+    {
+        $tenant = $this->createTenant('fiesta_futbol_infantil');
+        $admin = $this->createAdminAppUser($tenant);
+        $this->grantTicketsMenu($tenant);
+        $this->seed([AttributeSeeder::class, FiestaFutbolInfantilProductSeeder::class]);
+        Sanctum::actingAs($admin);
+
+        $food = CatalogItem::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->where('slug', 'comida')
+            ->with('variants')
+            ->firstOrFail();
+        $expired = $this->createTicket($tenant, $admin, [
+            'source_catalog_item_id' => $food->id,
+            'source_variant_id' => $food->variants->firstOrFail()->id,
+        ]);
+        $active = $this->createTicket($tenant, $admin);
+
+        $this->travelTo('2026-10-20 12:00:00');
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets?status=expired')
+            ->assertOk()
+            ->assertJsonCount(1, 'data')
+            ->assertJsonPath('data.0.id', $expired->id);
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets?status=active')
+            ->assertOk()
+            ->assertJsonCount(1, 'data')
+            ->assertJsonPath('data.0.id', $active->id);
+    }
+
+    private function createTenant(string $code): Tenant
+    {
+        $headerLogo = $this->createAttachment("{$code}-header.png");
+        $footerLogo = $this->createAttachment("{$code}-footer.png");
+
+        return Tenant::query()->create([
+            'codigo' => $code,
+            'nombre' => ucfirst($code),
+            'dominio' => "{$code}.test",
+            'website_type_code' => 'onticket',
+            'primary_color' => '#111111',
+            'secondary_color' => '#222222',
+            'danger_color' => '#333333',
+            'success_color' => '#444444',
+            'header_bg_color' => '#ffffff',
+            'footer_bg_color' => '#ffffff',
+            'header_logo_id' => $headerLogo->id,
+            'footer_logo_id' => $footerLogo->id,
+        ]);
+    }
+
+    private function createAttachment(string $filename): Attachment
+    {
+        return Attachment::query()->create([
+            'path' => "test/{$filename}",
+            'filename' => $filename,
+            'type' => AttachmentType::Image,
+            'mime_type' => 'image/png',
+        ]);
+    }
+
+    private function createAdminAppUser(Tenant $tenant): User
+    {
+        return User::factory()->create([
+            'rol_codigo' => RoleCode::AdminApp->value,
+            'tenant_codigo' => $tenant->codigo,
+        ]);
+    }
+
+    private function createPurchase(Tenant $tenant, User $user, string $createdAt): Purchase
+    {
+        $purchase = Purchase::query()->create([
+            'tenant_codigo' => $tenant->codigo,
+            'user_id' => $user->id,
+            'status' => Purchase::STATUS_PAID,
+            'nombre_apellido' => $user->nombre_apellido,
+            'total' => '0.00',
+        ]);
+        $purchase->forceFill(['created_at' => $createdAt, 'updated_at' => $createdAt])->saveQuietly();
+
+        return $purchase;
+    }
+
+    private function grantTicketsMenu(Tenant $tenant): void
+    {
+        $menu = Menu::query()->create([
+            'code' => 'adminapp.tickets',
+            'label' => 'Tickets',
+            'route' => '/admin/tickets',
+        ]);
+
+        $tenant->menues()->attach($menu->code);
+    }
+
+    /** @param array<string, mixed> $attributes */
+    private function createTicket(Tenant $tenant, User $user, array $attributes = []): Ticket
+    {
+        return Ticket::query()->create(array_merge([
+            'tenant_code' => $tenant->codigo,
+            'ticket' => (string) Str::uuid(),
+            'user_id' => $user->id,
+        ], $attributes));
+    }
+}

tests/TestCase.php

@@ -8,17 +8,22 @@ use RuntimeException;
 
 abstract class TestCase extends BaseTestCase
 {
+    /**
+     * Boot the application only when the test database is explicitly isolated.
+     */
     public function createApplication(): Application
     {
         $app = parent::createApplication();
-        $connection = (string) $app['config']->get('database.default');
-        $database = (string) $app['config']->get("database.connections.{$connection}.database");
-        $usesInMemorySqlite = $connection === 'sqlite' && $database === ':memory:';
 
-        if (! $usesInMemorySqlite && ! str_ends_with(strtolower($database), '_test')) {
-            throw new RuntimeException(
-                "Unsafe test database [{$database}]. Tests may only use an in-memory SQLite database or a database ending in _test.",
-            );
+        $database = (string) $app['config']->get(
+            'database.connections.'.$app['config']->get('database.default').'.database'
+        );
+
+        if (! preg_match('/^shopit_(?:test|testing)(?:_\d+)?$/', $database)) {
+            throw new RuntimeException(sprintf(
+                'Refusing to run tests against database [%s]. Use [shopit_test] or [shopit_testing].',
+                $database !== '' ? $database : '(empty)'
+            ));
         }
 
         return $app;