test(catalog): cover global availability decisions

app/Domains/Catalog/Controllers/CatalogController.php

@@ -123,6 +123,10 @@ class CatalogController extends Controller
             $variantId === null ? null : (int) $variantId,
         );
         $allowances->attach(collect([$item]), $this->userId($request));
+        abort_unless($allowances->availability(
+            $item->availableStock(),
+            $item->getAttribute('remaining_user_quota'),
+        )->isVisible(), 404);
 
         return CatalogItemDetailResource::make($item);
     }

app/Domains/Catalog/Enums/AvailabilityEffect.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Domains\Catalog\Enums;
+
+enum AvailabilityEffect: string
+{
+    case Hide = 'hide';
+    case Restrict = 'restrict';
+    case Notice = 'notice';
+}

app/Domains/Catalog/Enums/CatalogAction.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Domains\Catalog\Enums;
+
+enum CatalogAction: string
+{
+    case SelectVariant = 'select_variant';
+    case ChangeQuantity = 'change_quantity';
+    case AddToCart = 'add_to_cart';
+    case BuyNow = 'buy_now';
+}

app/Domains/Catalog/Models/CatalogItem.php

@@ -27,7 +27,6 @@ use Illuminate\Support\Collection;
     'type',
     'slug',
     'nombre',
-    'group_order',
     'descripcion',
     'precio',
     'inventory_policy',
@@ -48,7 +47,6 @@ class CatalogItem extends Model
         'inventory_policy' => InventoryPolicy::Tracked->value,
         'inventory_subject' => InventorySubject::Product->value,
         'has_tickets' => false,
-        'group_order' => 0,
     ];
 
     protected function casts(): array
@@ -58,7 +56,6 @@ class CatalogItem extends Model
             'brand_id' => 'integer',
             'inventory_id' => 'integer',
             'type' => CatalogItemType::class,
-            'group_order' => 'integer',
             'precio' => 'decimal:2',
             'inventory_policy' => InventoryPolicy::class,
             'inventory_subject' => InventorySubject::class,

app/Domains/Catalog/Models/Category.php

@@ -15,6 +15,7 @@ use Illuminate\Database\Eloquent\Relations\HasMany;
     'tenant_code',
     'categoria_id',
     'nombre',
+    'is_enabled',
 ])]
 class Category extends Model
 {
@@ -22,6 +23,10 @@ class Category extends Model
 
     protected $table = 'categorias';
 
+    protected $attributes = [
+        'is_enabled' => true,
+    ];
+
     /**
      * @return array<string, string>
      */
@@ -29,6 +34,7 @@ class Category extends Model
     {
         return [
             'categoria_id' => 'integer',
+            'is_enabled' => 'boolean',
         ];
     }
 

app/Domains/Catalog/Requests/StoreCatalogItemRequest.php

@@ -51,7 +51,6 @@ class StoreCatalogItemRequest extends FormRequest
                 ),
             ],
             'nombre' => ['required', 'string', 'max:255'],
-            'group_order' => ['sometimes', 'integer', 'min:0'],
             'descripcion' => ['sometimes', 'nullable', 'string'],
             'precio' => ['required', 'numeric', 'min:0'],
             'inventory_policy' => [Rule::prohibitedIf($isBundle), 'sometimes', Rule::enum(InventoryPolicy::class)],

app/Domains/Catalog/Resources/CatalogFeaturedItemResource.php

@@ -38,19 +38,13 @@ class CatalogFeaturedItemResource extends JsonResource
             'nombre' => $catalogItem->nombre,
             'descripcion' => $catalogItem->descripcion,
             'precio' => $catalogItem->precio,
-            'maximum_addable_quantity' => $this->maximumAddable(
-                $availableStock,
-                $remainingUserQuota,
-            ),
-            'unavailable_message' => $this->unavailableMessage(
-                $availableStock,
-                $remainingUserQuota,
-            ),
+            'availability' => $this->availability($availableStock, $remainingUserQuota),
             'variants' => $catalogItem->variants
-                ->map(function (Variant $variant) use ($catalogItem, $remainingUserQuota): array {
+                ->map(function (Variant $variant) use ($catalogItem): array {
                     $variantStock = $catalogItem->inventory_policy === InventoryPolicy::Unlimited
                         ? null
                         : $variant->inventory->availableStock();
+                    $availability = $this->availability($variantStock, null);
 
                     return [
                         'id' => $variant->id,
@@ -60,17 +54,11 @@ class CatalogFeaturedItemResource extends JsonResource
                         'event_dates' => $variant->selectedEventDates()->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
                         'descripcion' => $variant->getDescription(),
                         'precio' => number_format($variant->getPrice(), 2, '.', ''),
-                        'maximum_addable_quantity' => $this->maximumAddable(
-                            $variantStock,
-                            $remainingUserQuota,
-                        ),
-                        'unavailable_message' => $this->unavailableMessage(
-                            $variantStock,
-                            $remainingUserQuota,
-                        ),
+                        'availability' => $availability,
                         'values' => $variant->selectorOptions($catalogItem->itemAttributes),
                     ];
                 })
+                ->filter(fn (array $variant): bool => $variant['availability']['state'] === 'visible')
                 ->values(),
         ];
 
@@ -90,8 +78,7 @@ class CatalogFeaturedItemResource extends JsonResource
             'descripcion' => $catalogItem->descripcion,
             'precio' => $catalogItem->precio,
             'image' => $this->firstImageUrl($catalogItem),
-            'maximum_addable_quantity' => $this->maximumAddable($availableStock, $remainingUserQuota),
-            'unavailable_message' => $this->unavailableMessage($availableStock, $remainingUserQuota),
+            'availability' => $this->availability($availableStock, $remainingUserQuota),
         ];
     }
 
@@ -107,8 +94,7 @@ class CatalogFeaturedItemResource extends JsonResource
             'nombre' => $catalogItem->nombre,
             'precio' => $catalogItem->precio,
             'image' => $this->firstImageUrl($catalogItem),
-            'maximum_addable_quantity' => $this->maximumAddable($availableStock, $remainingUserQuota),
-            'unavailable_message' => $this->unavailableMessage($availableStock, $remainingUserQuota),
+            'availability' => $this->availability($availableStock, $remainingUserQuota),
         ];
     }
 
@@ -122,15 +108,13 @@ class CatalogFeaturedItemResource extends JsonResource
         return $attachment?->getTemporaryUrl(1440);
     }
 
-    private function maximumAddable(?int $stock, ?int $remainingUserQuota): ?int
-    {
+    /** @return array<string, mixed> */
+    private function availability(
+        ?int $stock,
+        ?int $remainingUserQuota,
+    ): array {
         return app(CatalogItemAllowanceService::class)
-            ->maximumAddableQuantity($stock, $remainingUserQuota);
-    }
-
-    private function unavailableMessage(?int $stock, ?int $remainingUserQuota): ?string
-    {
-        return app(CatalogItemAllowanceService::class)
-            ->unavailableMessage($stock, $remainingUserQuota);
+            ->availability($stock, $remainingUserQuota)
+            ->toArray();
     }
 }

app/Domains/Catalog/Resources/CatalogItemDetailResource.php

@@ -38,20 +38,14 @@ class CatalogItemDetailResource extends JsonResource
             'max_units_per_user' => $this->max_units_per_user,
             'has_tickets' => $this->has_tickets,
             'attributes' => $this->attributesData(),
-            'maximum_addable_quantity' => $this->when(
-                $selectedVariant === null,
-                fn () => $this->maximumAddable($this->availableStock()),
-            ),
-            'unavailable_message' => $this->when(
-                $selectedVariant === null,
-                fn () => $this->unavailableMessage($this->availableStock()),
-            ),
+            'availability' => $this->availability($this->availableStock()),
             'images' => $this->when(
                 $selectedVariant === null,
                 fn () => $this->imageUrls($this->attachments),
             ),
             'variants' => $this->variants
                 ->map(fn (Variant $variant): array => $this->variantData($variant))
+                ->filter(fn (array $variant): bool => $variant['availability']['state'] === 'visible')
                 ->values(),
             'selected_variant' => $this->when(
                 $selectedVariant !== null,
@@ -164,6 +158,10 @@ class CatalogItemDetailResource extends JsonResource
         $values = $variant->selectionOptions($this->itemAttributes);
         $eventDates = $variant->selectedEventDates();
         $variantStock = $this->variantStock($variant);
+        $availability = $this->availability(
+            $variantStock,
+            false,
+        );
 
         return [
             'id' => $variant->id,
@@ -173,8 +171,7 @@ class CatalogItemDetailResource extends JsonResource
             'event_dates' => $eventDates->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
             'descripcion' => $variant->getDescription(),
             'precio' => number_format($variant->getPrice(), 2, '.', ''),
-            'maximum_addable_quantity' => $this->maximumAddable($variantStock),
-            'unavailable_message' => $this->unavailableMessage($variantStock),
+            'availability' => $availability,
             'values' => $values,
         ];
     }
@@ -194,19 +191,14 @@ class CatalogItemDetailResource extends JsonResource
             : $variant->inventory->availableStock();
     }
 
-    private function maximumAddable(?int $stock): ?int
-    {
-        return app(CatalogItemAllowanceService::class)->maximumAddableQuantity(
+    /** @return array<string, mixed> */
+    private function availability(
+        ?int $stock,
+        bool $includeUserQuota = true,
+    ): array {
+        return app(CatalogItemAllowanceService::class)->availability(
             $stock,
-            $this->getAttribute('remaining_user_quota'),
-        );
-    }
-
-    private function unavailableMessage(?int $stock): ?string
-    {
-        return app(CatalogItemAllowanceService::class)->unavailableMessage(
-            $stock,
-            $this->getAttribute('remaining_user_quota'),
-        );
+            $includeUserQuota ? $this->getAttribute('remaining_user_quota') : null,
+        )->toArray();
     }
 }

app/Domains/Catalog/Resources/CatalogSearchItemResource.php

@@ -28,13 +28,16 @@ class CatalogSearchItemResource extends JsonResource
             'descripcion' => $this->descripcion,
             'precio' => $this->precio,
             'image' => $attachment?->getTemporaryUrl(1440),
-            'maximum_addable_quantity' => $this->maximumAddable($availableStock),
-            'unavailable_message' => $this->unavailableMessage($availableStock),
+            'availability' => $this->availability($availableStock),
             'variants' => $this->variants
                 ->map(function (Variant $variant): array {
                     $variantStock = $this->inventory_policy === InventoryPolicy::Unlimited
                         ? null
                         : $variant->inventory?->availableStock();
+                    $availability = $this->availability(
+                        $variantStock,
+                        false,
+                    );
 
                     return [
                         'id' => $variant->id,
@@ -44,28 +47,23 @@ class CatalogSearchItemResource extends JsonResource
                         'event_dates' => $variant->selectedEventDates()->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
                         'descripcion' => $variant->getDescription(),
                         'precio' => number_format($variant->getPrice(), 2, '.', ''),
-                        'maximum_addable_quantity' => $this->maximumAddable($variantStock),
-                        'unavailable_message' => $this->unavailableMessage($variantStock),
+                        'availability' => $availability,
                         'values' => $variant->selectorOptions($this->itemAttributes),
                     ];
                 })
+                ->filter(fn (array $variant): bool => $variant['availability']['state'] === 'visible')
                 ->values(),
         ];
     }
 
-    private function maximumAddable(?int $stock): ?int
-    {
-        return app(CatalogItemAllowanceService::class)->maximumAddableQuantity(
+    /** @return array<string, mixed> */
+    private function availability(
+        ?int $stock,
+        bool $includeUserQuota = true,
+    ): array {
+        return app(CatalogItemAllowanceService::class)->availability(
             $stock,
-            $this->getAttribute('remaining_user_quota'),
-        );
-    }
-
-    private function unavailableMessage(?int $stock): ?string
-    {
-        return app(CatalogItemAllowanceService::class)->unavailableMessage(
-            $stock,
-            $this->getAttribute('remaining_user_quota'),
-        );
+            $includeUserQuota ? $this->getAttribute('remaining_user_quota') : null,
+        )->toArray();
     }
 }

app/Domains/Catalog/Services/AvailabilityDecision.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace App\Domains\Catalog\Services;
+
+use App\Domains\Catalog\Enums\CatalogAction;
+
+final readonly class AvailabilityDecision
+{
+    /**
+     * @param  list<CatalogAction>  $allowedActions
+     * @param  list<array{code: string, message: string}>  $reasons
+     */
+    private function __construct(
+        private bool $visible,
+        private ?int $maximumQuantity,
+        private array $allowedActions,
+        private array $reasons,
+    ) {}
+
+    /** @param list<array{code: string, message: string}> $reasons */
+    public static function hidden(array $reasons): self
+    {
+        return new self(false, null, [], $reasons);
+    }
+
+    /**
+     * @param  list<CatalogAction>  $allowedActions
+     * @param  list<array{code: string, message: string}>  $reasons
+     */
+    public static function visible(
+        ?int $maximumQuantity,
+        array $allowedActions,
+        array $reasons,
+    ): self {
+        return new self(true, $maximumQuantity, $allowedActions, $reasons);
+    }
+
+    public function isVisible(): bool
+    {
+        return $this->visible;
+    }
+
+    /** @return array<string, mixed> */
+    public function toArray(): array
+    {
+        if (! $this->visible) {
+            return [
+                'state' => 'hidden',
+                'reasons' => $this->reasons,
+            ];
+        }
+
+        return [
+            'state' => 'visible',
+            'maximum_quantity' => $this->maximumQuantity,
+            'allowed_actions' => array_map(
+                fn (CatalogAction $action): string => $action->value,
+                $this->allowedActions,
+            ),
+            'reasons' => $this->reasons,
+        ];
+    }
+}

app/Domains/Catalog/Services/AvailabilityPolicyResolver.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Domains\Catalog\Services;
+
+use App\Domains\Catalog\Enums\AvailabilityEffect;
+use App\Domains\Catalog\Enums\CatalogAction;
+
+final class AvailabilityPolicyResolver
+{
+    /** @return array{effect: AvailabilityEffect, denied_actions: list<CatalogAction>} */
+    public function resolve(string $restrictionCode): array
+    {
+        /** @var array{effect?: string, denied_actions?: list<string>} $configured */
+        $configured = config("catalog.availability.rules.{$restrictionCode}", []);
+
+        return [
+            'effect' => AvailabilityEffect::from(
+                $configured['effect'] ?? AvailabilityEffect::Notice->value,
+            ),
+            'denied_actions' => array_map(
+                fn (string $action): CatalogAction => CatalogAction::from($action),
+                $configured['denied_actions'] ?? [],
+            ),
+        ];
+    }
+}

app/Domains/Catalog/Services/CatalogItemAllowanceService.php

@@ -2,6 +2,8 @@
 
 namespace App\Domains\Catalog\Services;
 
+use App\Domains\Catalog\Enums\AvailabilityEffect;
+use App\Domains\Catalog\Enums\CatalogAction;
 use App\Domains\Catalog\Models\CatalogItem;
 use App\Domains\Purchase\Services\UserPurchaseLimitService;
 use Illuminate\Support\Collection;
@@ -14,6 +16,7 @@ class CatalogItemAllowanceService
 
     public function __construct(
         private readonly UserPurchaseLimitService $purchaseLimits,
+        private readonly AvailabilityPolicyResolver $policies,
     ) {}
 
     /** @param Collection<int, CatalogItem> $catalogItems */
@@ -42,16 +45,82 @@ class CatalogItemAllowanceService
         return min($availableStock, $remainingUserQuota);
     }
 
-    public function unavailableMessage(?int $availableStock, ?int $remainingUserQuota): ?string
-    {
+    public function availability(
+        ?int $availableStock,
+        ?int $remainingUserQuota,
+    ): AvailabilityDecision {
+        $reasons = [];
+
         if ($remainingUserQuota !== null && $remainingUserQuota <= 0) {
-            return self::USER_QUOTA_REACHED_MESSAGE;
+            $reasons[] = [
+                'code' => 'user_quota_reached',
+                'message' => self::USER_QUOTA_REACHED_MESSAGE,
+            ];
         }
 
         if ($availableStock !== null && $availableStock <= 0) {
-            return self::OUT_OF_STOCK_MESSAGE;
+            $reasons[] = [
+                'code' => 'out_of_stock',
+                'message' => self::OUT_OF_STOCK_MESSAGE,
+            ];
         }
 
-        return null;
+        return $this->decision(
+            $this->maximumAddableQuantity($availableStock, $remainingUserQuota),
+            $reasons,
+        );
+    }
+
+    public function purchaseLimitExceededAvailability(
+        int $maximumQuantity,
+        string $message,
+    ): AvailabilityDecision {
+        $reasons = [];
+
+        if ($maximumQuantity <= 0) {
+            $reasons[] = [
+                'code' => 'user_quota_reached',
+                'message' => self::USER_QUOTA_REACHED_MESSAGE,
+            ];
+        } else {
+            $reasons[] = [
+                'code' => 'requested_quantity_exceeds_user_quota',
+                'message' => $message,
+            ];
+        }
+
+        return $this->decision($maximumQuantity, $reasons);
+    }
+
+    /**
+     * @param  list<array{code: string, message: string}>  $reasons
+     */
+    private function decision(?int $maximumQuantity, array $reasons): AvailabilityDecision
+    {
+        /** @var list<string> $configuredActions */
+        $configuredActions = config('catalog.availability.default_actions', []);
+        $allowedActions = collect($configuredActions)
+            ->map(fn (string $action): CatalogAction => CatalogAction::from($action));
+
+        foreach ($reasons as $reason) {
+            $policy = $this->policies->resolve($reason['code']);
+
+            if ($policy['effect'] === AvailabilityEffect::Hide) {
+                return AvailabilityDecision::hidden($reasons);
+            }
+
+            if ($policy['effect'] === AvailabilityEffect::Restrict) {
+                $deniedActions = $policy['denied_actions'];
+                $allowedActions = $allowedActions->reject(
+                    fn (CatalogAction $action): bool => in_array($action, $deniedActions, true),
+                );
+            }
+        }
+
+        return AvailabilityDecision::visible(
+            $maximumQuantity,
+            $allowedActions->values()->all(),
+            $reasons,
+        );
     }
 }

app/Domains/Catalog/Services/CatalogService.php

@@ -22,7 +22,10 @@ use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 
 class CatalogService
 {
-    public function __construct(protected AttachmentService $attachmentService) {}
+    public function __construct(
+        protected AttachmentService $attachmentService,
+        private readonly VisibleCatalogItemsQuery $visibleCatalogItems,
+    ) {}
 
     /**
      * @param  array<string, mixed>  $data
@@ -229,7 +232,7 @@ class CatalogService
         $containsPattern = "%{$normalizedTerm}%";
         $startsWithPattern = "{$normalizedTerm}%";
 
-        $paginator = CatalogItem::query()
+        $query = CatalogItem::query()
             ->where('tenant_code', $tenant->codigo)
             ->where(function (Builder $query) use ($containsPattern): void {
                 $query
@@ -257,7 +260,10 @@ class CatalogService
                 'variants.definitions.itemAttribute.attribute.options',
                 'bundleComponents.catalogItem',
                 'bundleComponents.variant.catalogItem',
-            ])
+            ]);
+
+        $paginator = $this->visibleCatalogItems
+            ->apply($query)
             ->orderByRaw(
                 'CASE WHEN LOWER(nombre) = ? THEN 0 WHEN LOWER(nombre) LIKE ? THEN 1 ELSE 2 END',
                 [$normalizedTerm, $startsWithPattern],
@@ -277,7 +283,7 @@ class CatalogService
         int $perPage,
         int $page,
     ): LengthAwarePaginator {
-        return CatalogItem::query()
+        $query = CatalogItem::query()
             ->where('tenant_code', $tenant->codigo)
             ->where('category_id', $category->id)
             ->with([
@@ -291,7 +297,10 @@ class CatalogService
                 'variants.definitions.itemAttribute.attribute.options',
                 'bundleComponents.catalogItem',
                 'bundleComponents.variant.catalogItem',
-            ])
+            ]);
+
+        return $this->visibleCatalogItems
+            ->apply($query)
             ->orderBy('nombre')
             ->paginate(perPage: $perPage, pageName: 'page', page: $page);
     }

app/Domains/Catalog/Services/FeaturedGroupService.php

@@ -17,6 +17,7 @@ class FeaturedGroupService
     /** @return array<array-key, mixed> */
     public function __construct(
         private readonly CatalogItemAllowanceService $allowances,
+        private readonly VisibleCatalogItemsQuery $visibleCatalogItems,
     ) {}
 
     public function itemsResponse(FeaturedGroup $featuredGroup, int $page, ?int $userId = null): array
@@ -49,6 +50,15 @@ class FeaturedGroupService
     {
         $query = CatalogItem::query()
             ->where('catalog_items.tenant_code', $featuredGroup->tenant_code)
+            ->where(function (Builder $query): void {
+                $query
+                    ->whereDoesntHave('category')
+                    ->orWhereHas(
+                        'category',
+                        fn (Builder $categoryQuery): Builder => $categoryQuery
+                            ->where('is_enabled', true),
+                    );
+            })
             ->with([
                 'inventory',
                 'attachments',
@@ -62,6 +72,8 @@ class FeaturedGroupService
                 'bundleComponents.variant.catalogItem',
             ]);
 
+        $query = $this->visibleCatalogItems->apply($query);
+
         return match ($featuredGroup->source_type) {
             FeaturedGroupSource::Manual => $query
                 ->select('catalog_items.*')
@@ -72,9 +84,7 @@ class FeaturedGroupService
             FeaturedGroupSource::Category => $query
                 ->where('catalog_items.category_id', $featuredGroup->category_id)
                 ->orderBy('catalog_items.id'),
-            FeaturedGroupSource::All => $query
-                ->orderBy('catalog_items.group_order')
-                ->orderBy('catalog_items.id'),
+            FeaturedGroupSource::All => $query->orderBy('catalog_items.id'),
         };
     }
 

app/Domains/Catalog/Services/VariantSelectionService.php

@@ -10,6 +10,10 @@ use Illuminate\Support\Collection;
 
 class VariantSelectionService
 {
+    public function __construct(
+        private readonly CatalogItemAllowanceService $allowances,
+    ) {}
+
     /**
      * @param  array<string, mixed>  $selectedValues
      * @return array<string, mixed>
@@ -188,13 +192,17 @@ class VariantSelectionService
     /** @return array<string, mixed> */
     private function variantData(CatalogItem $catalogItem, Variant $variant): array
     {
+        $availableStock = $catalogItem->inventory_policy === InventoryPolicy::Unlimited
+            ? null
+            : $variant->inventory?->availableStock();
+
         return [
             'id' => $variant->id,
             'descripcion' => $variant->getDescription(),
             'precio' => number_format($variant->getPrice(), 2, '.', ''),
-            'stock_tecnico' => $catalogItem->inventory_policy === InventoryPolicy::Unlimited
-                ? null
-                : $variant->inventory?->availableStock(),
+            'availability' => $this->allowances
+                ->availability($availableStock, null)
+                ->toArray(),
             'values' => $variant->selectorOptions($catalogItem->itemAttributes),
         ];
     }

app/Domains/Catalog/Services/VisibleCatalogItemsQuery.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace App\Domains\Catalog\Services;
+
+use App\Domains\Catalog\Enums\AvailabilityEffect;
+use App\Domains\Catalog\Enums\CatalogItemType;
+use App\Domains\Catalog\Enums\InventoryPolicy;
+use App\Domains\Catalog\Models\CatalogItem;
+use Illuminate\Database\Eloquent\Builder;
+
+final class VisibleCatalogItemsQuery
+{
+    public function __construct(
+        private readonly AvailabilityPolicyResolver $policies,
+    ) {}
+
+    /** @param Builder<CatalogItem> $query */
+    public function apply(Builder $query): Builder
+    {
+        if ($this->policies->resolve('out_of_stock')['effect'] !== AvailabilityEffect::Hide) {
+            return $query;
+        }
+
+        return $query->where(function (Builder $query): void {
+            $query
+                ->where(fn (Builder $query) => $this->applyStandardItemAvailability($query))
+                ->orWhere(fn (Builder $query) => $this->applyBundleAvailability($query));
+        });
+    }
+
+    /** @param Builder<CatalogItem> $query */
+    private function applyStandardItemAvailability(Builder $query): Builder
+    {
+        return $query
+            ->where('catalog_items.type', CatalogItemType::Standard->value)
+            ->where(function (Builder $query): void {
+                $query
+                    ->where('catalog_items.inventory_policy', InventoryPolicy::Unlimited->value)
+                    ->orWhereHas(
+                        'inventory',
+                        fn (Builder $query): Builder => $query
+                            ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock'),
+                    )
+                    ->orWhereHas(
+                        'variants.inventory',
+                        fn (Builder $query): Builder => $query
+                            ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock'),
+                    );
+            });
+    }
+
+    /** @param Builder<CatalogItem> $query */
+    private function applyBundleAvailability(Builder $query): Builder
+    {
+        return $query
+            ->where('catalog_items.type', CatalogItemType::Bundle->value)
+            ->whereRaw(<<<'SQL'
+                NOT EXISTS (
+                    SELECT 1
+                    FROM bundle_components AS availability_components
+                    INNER JOIN catalog_items AS availability_items
+                        ON availability_items.id = availability_components.component_catalog_item_id
+                    LEFT JOIN variantes AS availability_variants
+                        ON availability_variants.id = availability_components.component_variant_id
+                    INNER JOIN inventories AS availability_inventories
+                        ON availability_inventories.id = COALESCE(
+                            availability_variants.inventory_id,
+                            availability_items.inventory_id
+                        )
+                    WHERE availability_components.bundle_catalog_item_id = catalog_items.id
+                        AND availability_items.inventory_policy = ?
+                    GROUP BY availability_inventories.id,
+                        availability_inventories.real_stock,
+                        availability_inventories.reserved_stock
+                    HAVING availability_inventories.real_stock
+                        - availability_inventories.reserved_stock
+                        < SUM(availability_components.quantity)
+                )
+                SQL, [InventoryPolicy::Tracked->value]);
+    }
+}

app/Domains/FiestaFutbolInfantil/Controllers/CategoryVisibilityController.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Domains\FiestaFutbolInfantil\Controllers;
+
+use App\Domains\FiestaFutbolInfantil\Enums\FiestaCategory;
+use App\Domains\FiestaFutbolInfantil\Requests\UpdateCategoryVisibilityRequest;
+use App\Domains\FiestaFutbolInfantil\Services\CategoryVisibilityService;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class CategoryVisibilityController extends Controller
+{
+    public function __construct(private readonly CategoryVisibilityService $visibilityService) {}
+
+    public function show(Request $request): JsonResponse
+    {
+        $category = $this->category($request);
+        $tenant = $request->user()->tenant()->firstOrFail();
+
+        return response()->json([
+            'data' => [
+                'is_enabled' => $this->visibilityService->isEnabled($tenant, $category),
+            ],
+        ]);
+    }
+
+    public function update(UpdateCategoryVisibilityRequest $request): JsonResponse
+    {
+        $category = $this->category($request);
+        $tenant = $request->user()->tenant()->firstOrFail();
+        $model = $this->visibilityService->update(
+            $tenant,
+            $category,
+            $request->boolean('is_enabled'),
+        );
+
+        return response()->json([
+            'data' => [
+                'is_enabled' => $model->is_enabled,
+            ],
+            'message' => $model->is_enabled
+                ? 'Mostrar en sitio web se activo correctamente'
+                : 'Mostrar en sitio web se desactivo correctamente',
+        ]);
+    }
+
+    private function category(Request $request): FiestaCategory
+    {
+        return FiestaCategory::from((string) $request->route('category'));
+    }
+}

app/Domains/FiestaFutbolInfantil/Enums/FiestaCategory.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Domains\FiestaFutbolInfantil\Enums;
+
+enum FiestaCategory: string
+{
+    case Entries = 'entries';
+    case Foods = 'foods';
+    case Accommodations = 'accommodations';
+    case Merchandise = 'merchandise';
+
+    public function categoryName(): string
+    {
+        return match ($this) {
+            self::Entries => 'Entradas',
+            self::Foods => 'Comidas',
+            self::Accommodations => 'Alojamientos',
+            self::Merchandise => 'Merchandising',
+        };
+    }
+}

app/Domains/FiestaFutbolInfantil/Requests/UpdateCategoryVisibilityRequest.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Domains\FiestaFutbolInfantil\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class UpdateCategoryVisibilityRequest extends FormRequest
+{
+    /** @return array<string, mixed> */
+    public function rules(): array
+    {
+        return [
+            'is_enabled' => ['required', 'boolean'],
+        ];
+    }
+}

app/Domains/FiestaFutbolInfantil/Services/CategoryVisibilityService.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Domains\FiestaFutbolInfantil\Services;
+
+use App\Domains\Catalog\Models\Category;
+use App\Domains\FiestaFutbolInfantil\Enums\FiestaCategory;
+use App\Domains\Tenant\Models\Tenant;
+
+class CategoryVisibilityService
+{
+    public function isEnabled(Tenant $tenant, FiestaCategory $category): bool
+    {
+        return Category::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->where('nombre', $category->categoryName())
+            ->value('is_enabled') ?? true;
+    }
+
+    public function update(Tenant $tenant, FiestaCategory $category, bool $isEnabled): Category
+    {
+        $model = Category::query()->firstOrCreate([
+            'tenant_code' => $tenant->codigo,
+            'nombre' => $category->categoryName(),
+        ]);
+        $model->update(['is_enabled' => $isEnabled]);
+
+        return $model;
+    }
+}

app/Domains/FiestaFutbolInfantil/routes/api.php

@@ -1,6 +1,7 @@
 <?php
 
 use App\Domains\FiestaFutbolInfantil\Controllers\AccommodationController;
+use App\Domains\FiestaFutbolInfantil\Controllers\CategoryVisibilityController;
 use App\Domains\FiestaFutbolInfantil\Controllers\EntryController;
 use App\Domains\FiestaFutbolInfantil\Controllers\FoodController;
 use App\Domains\FiestaFutbolInfantil\Controllers\MerchandiseController;
@@ -9,6 +10,20 @@ use Illuminate\Support\Facades\Route;
 Route::prefix('v1/adminapp/tenant')
     ->middleware(['auth:sanctum', 'adminapp.tenant'])
     ->group(function (): void {
+        $visibilityRoutes = static function (string $endpoint, string $category, string $menuCode): void {
+            Route::get("{$endpoint}/visibility", [CategoryVisibilityController::class, 'show'])
+                ->defaults('category', $category)
+                ->middleware("tenant.menu:{$menuCode}");
+            Route::patch("{$endpoint}/visibility", [CategoryVisibilityController::class, 'update'])
+                ->defaults('category', $category)
+                ->middleware("tenant.menu:{$menuCode}");
+        };
+
+        $visibilityRoutes('entries', 'entries', 'adminapp.fiesta-futbol-infantil.entradas');
+        $visibilityRoutes('foods', 'foods', 'adminapp.fiesta-futbol-infantil.comida');
+        $visibilityRoutes('accommodations', 'accommodations', 'adminapp.fiesta-futbol-infantil.alojamientos');
+        $visibilityRoutes('merchandise', 'merchandise', 'adminapp.fiesta-futbol-infantil.merchandising');
+
         Route::get('entries', [EntryController::class, 'index'])
             ->middleware('tenant.menu:adminapp.fiesta-futbol-infantil.entradas')
             ->name('adminapp.fiesta-futbol-infantil.entries.index');

app/Domains/Purchase/Controllers/PurchaseController.php

@@ -24,13 +24,22 @@ class PurchaseController extends Controller
 {
     public function index(Request $request, Tenant $tenant): JsonResponse
     {
+        $statusParam = $request->query('status');
+        $statuses = is_string($statusParam)
+            ? collect(explode(',', $statusParam))
+                ->map(fn (string $status): string => trim($status))
+                ->filter()
+                ->unique()
+                ->values()
+                ->all()
+            : [];
+
         return PurchaseResource::collection(
             Purchase::query()
                 ->where('tenant_codigo', $tenant->codigo)
                 ->where('user_id', $request->user()->id)
-                ->when($request->query('status'), function ($query, $status) {
-                    $query->where('status', $status);
-                })
+                ->when($statuses !== [], fn ($query) => $query->whereIn('status', $statuses))
+                ->orderBy('status')
                 ->latest()
                 ->paginateFromRequest()
         )->response();

bootstrap/app.php

@@ -1,6 +1,7 @@
 <?php
 
 use App\Domains\Auth\Exceptions\AccountLockedException;
+use App\Domains\Catalog\Services\CatalogItemAllowanceService;
 use App\Domains\Purchase\Exceptions\InsufficientStockException;
 use App\Domains\Purchase\Exceptions\PurchaseExpiredException;
 use App\Domains\Purchase\Exceptions\PurchaseLimitExceededException;
@@ -100,7 +101,11 @@ return Application::configure(basePath: dirname(__DIR__))
                 'errors' => $exception->errors(),
                 'catalog_item_id' => $exception->catalogItemId,
                 'catalog_item_name' => $exception->catalogItemName,
-                'maximum_addable_quantity' => $exception->maximumAddableQuantity,
+                'availability' => app(CatalogItemAllowanceService::class)
+                    ->purchaseLimitExceededAvailability(
+                        $exception->maximumAddableQuantity,
+                        $exception->getMessage(),
+                    )->toArray(),
             ], 422);
         });
         $exceptions->render(function (PurchaseExpiredException $exception, Request $request) {

config/catalog.php

@@ -2,4 +2,33 @@
 
 return [
     'stock_reservation_expiration_minutes' => (int) env('STOCK_RESERVATION_EXPIRATION_MINUTES', 30),
+    'availability' => [
+        'default_actions' => [
+            'select_variant',
+            'change_quantity',
+            'add_to_cart',
+            'buy_now',
+        ],
+        'rules' => [
+            'user_quota_reached' => [
+                'effect' => 'restrict',
+                'denied_actions' => [
+                    'select_variant',
+                    'change_quantity',
+                    'add_to_cart',
+                    'buy_now',
+                ],
+            ],
+            'out_of_stock' => [
+                'effect' => 'hide',
+            ],
+            'requested_quantity_exceeds_user_quota' => [
+                'effect' => 'restrict',
+                'denied_actions' => [
+                    'add_to_cart',
+                    'buy_now',
+                ],
+            ],
+        ],
+    ],
 ];

database/migrations/2026_08_24_000000_add_is_enabled_to_categorias_table.php

@@ -0,0 +1,22 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('categorias', function (Blueprint $table): void {
+            $table->boolean('is_enabled')->default(true)->after('nombre');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('categorias', function (Blueprint $table): void {
+            $table->dropColumn('is_enabled');
+        });
+    }
+};

database/migrations/2026_08_25_000000_add_group_order_to_catalog_items.php

@@ -1,53 +0,0 @@
-<?php
-
-use Illuminate\Database\Migrations\Migration;
-use Illuminate\Database\Schema\Blueprint;
-use Illuminate\Support\Facades\DB;
-use Illuminate\Support\Facades\Schema;
-
-return new class extends Migration
-{
-    public function up(): void
-    {
-        Schema::table('catalog_items', function (Blueprint $table): void {
-            $table->unsignedInteger('group_order')->default(0)->after('nombre');
-        });
-
-        $footballOrder = [
-            1 => [
-                'slugs' => ['camiseta', 'camiseta-oficial-fnfi'],
-                'names' => ['Camiseta', 'CAMISETA OFICIAL FNFI'],
-            ],
-            2 => [
-                'slugs' => ['alojamiento', 'camping'],
-                'names' => ['Alojamiento', 'CAMPING'],
-            ],
-            3 => [
-                'slugs' => ['abono'],
-                'names' => ['Abono', 'ABONO'],
-            ],
-            4 => [
-                'slugs' => ['comida'],
-                'names' => ['Comida', 'COMIDA'],
-            ],
-        ];
-
-        foreach ($footballOrder as $order => $identifiers) {
-            DB::table('catalog_items')
-                ->where('tenant_code', 'fiesta_futbol_infantil')
-                ->where(function ($query) use ($identifiers): void {
-                    $query
-                        ->whereIn('slug', $identifiers['slugs'])
-                        ->orWhereIn('nombre', $identifiers['names']);
-                })
-                ->update(['group_order' => $order]);
-        }
-    }
-
-    public function down(): void
-    {
-        Schema::table('catalog_items', function (Blueprint $table): void {
-            $table->dropColumn('group_order');
-        });
-    }
-};

database/seeders/FiestaFutbolInfantilProductSeeder.php

@@ -78,7 +78,6 @@ class FiestaFutbolInfantilProductSeeder extends Seeder
         $this->createProduct($tenant, [
             'slug' => 'camiseta',
             'nombre' => 'Camiseta',
-            'group_order' => 1,
             'category_id' => $categories['merchandising']->id,
             'precio' => 18000,
             'attribute_codes' => ['color', 'talle'],
@@ -93,7 +92,6 @@ class FiestaFutbolInfantilProductSeeder extends Seeder
         $this->createProduct($tenant, [
             'slug' => 'alojamiento',
             'nombre' => 'Alojamiento',
-            'group_order' => 2,
             'category_id' => $categories['alojamientos']->id,
             'precio' => 35000,
             'attribute_codes' => ['tipo_alojamiento'],
@@ -106,7 +104,6 @@ class FiestaFutbolInfantilProductSeeder extends Seeder
         $this->createProduct($tenant, [
             'slug' => 'comida',
             'nombre' => 'Comida',
-            'group_order' => 4,
             'category_id' => $categories['comidas']->id,
             'precio' => 4000,
             'attribute_codes' => ['event_date', 'horario', 'servicio'],
@@ -129,7 +126,6 @@ class FiestaFutbolInfantilProductSeeder extends Seeder
         $this->createProduct($tenant, [
             'slug' => 'abono',
             'nombre' => 'Abono',
-            'group_order' => 3,
             'category_id' => $categories['entradas']->id,
             'precio' => 40000,
             'has_tickets' => true,

tests/Feature/Cart/CartControllerTest.php

@@ -246,7 +246,7 @@ class CartControllerTest extends TestCase
             ->assertJsonPath('code', 'purchase.limit_exceeded')
             ->assertJsonPath('catalog_item_id', $item->id)
             ->assertJsonPath('catalog_item_name', $item->nombre)
-            ->assertJsonPath('maximum_addable_quantity', 1)
+            ->assertJsonPath('availability.maximum_quantity', 1)
             ->assertJsonPath(
                 'message',
                 "Podés agregar hasta 1 unidad más de “{$item->nombre}”.",

tests/Feature/Catalog/BundleCatalogItemTest.php

@@ -267,7 +267,7 @@ class BundleCatalogItemTest extends TestCase
         $this->getJson("/api/tenants/{$this->tenant->codigo}/catalog-items/{$bundleId}")
             ->assertOk()
             ->assertJsonPath('data.type', CatalogItemType::Bundle->value)
-            ->assertJsonPath('data.maximum_addable_quantity', 4)
+            ->assertJsonPath('data.availability.maximum_quantity', 4)
             ->assertJsonMissingPath('data.stock_tecnico')
             ->assertJsonCount(1, 'data.components')
             ->assertJsonPath('data.components.0.catalog_item_id', $component->id)

tests/Feature/Catalog/CatalogControllerTest.php

@@ -41,7 +41,7 @@ class CatalogControllerTest extends TestCase
         $directItem = $this->createItem($tenant, 'Direct', $directInventory);
         $row->featuredItems()->create(['catalog_item_id' => $directItem->id]);
 
-        $variantItem = $this->createItem($tenant, 'Variants');
+        $variantItem = $this->createItem($tenant, 'Variants', withoutInventory: true);
         $firstInventory = Inventory::query()->create([
             'real_stock' => 5,
             'reserved_stock' => 1,
@@ -56,7 +56,7 @@ class CatalogControllerTest extends TestCase
         ]);
         $variantItem->variants()->create(['inventory_id' => $firstInventory->id]);
         $variantItem->variants()->create(['inventory_id' => $secondInventory->id]);
-        $unavailableVariant = $variantItem->variants()->create([
+        $variantItem->variants()->create([
             'inventory_id' => $unavailableInventory->id,
         ]);
         $cart->featuredItems()->create(['catalog_item_id' => $variantItem->id]);
@@ -72,18 +72,14 @@ class CatalogControllerTest extends TestCase
             ->assertJsonPath('0.items.0.nombre', 'Variants')
             ->assertJsonPath('0.items.0.descripcion', 'Variants description')
             ->assertJsonPath('0.items.0.precio', '100.00')
-            ->assertJsonPath('0.items.0.maximum_addable_quantity', 7)
-            ->assertJsonCount(3, '0.items.0.variants')
-            ->assertJsonPath('0.items.0.variants.0.maximum_addable_quantity', 4)
-            ->assertJsonPath('0.items.0.variants.1.maximum_addable_quantity', 3)
-            ->assertJsonPath('0.items.0.variants.2.id', $unavailableVariant->id)
-            ->assertJsonPath('0.items.0.variants.2.maximum_addable_quantity', 0)
-            ->assertJsonPath(
-                '0.items.0.variants.2.unavailable_message',
-                'Este producto no tiene stock disponible.',
-            )
+            ->assertJsonPath('0.items.0.availability.state', 'visible')
+            ->assertJsonPath('0.items.0.availability.maximum_quantity', 7)
+            ->assertJsonCount(2, '0.items.0.variants')
+            ->assertJsonPath('0.items.0.variants.0.availability.maximum_quantity', 4)
+            ->assertJsonPath('0.items.0.variants.0.availability.state', 'visible')
+            ->assertJsonPath('0.items.0.variants.1.availability.maximum_quantity', 3)
             ->assertJsonPath('1.title', 'Row')
-            ->assertJsonPath('1.items.data.0.maximum_addable_quantity', 8)
+            ->assertJsonPath('1.items.data.0.availability.maximum_quantity', 8)
             ->assertJsonMissingPath('1.items.data.0.stock_tecnico')
             ->assertJsonCount(0, '1.items.data.0.variants');
     }
@@ -98,7 +94,7 @@ class CatalogControllerTest extends TestCase
             groupLayout: GroupLayout::Simple,
         );
         $user = User::factory()->create();
-        $item = $this->createItem($tenant, 'Limited variants');
+        $item = $this->createItem($tenant, 'Limited variants', withoutInventory: true);
         $item->update(['max_units_per_user' => 3]);
         $firstVariant = $item->variants()->create([
             'inventory_id' => Inventory::query()->create(['real_stock' => 10])->id,
@@ -119,21 +115,21 @@ class CatalogControllerTest extends TestCase
         $this->actingAs($user, 'sanctum')
             ->getJson("/api/tenants/{$tenant->codigo}/catalog")
             ->assertOk()
-            ->assertJsonPath('0.items.0.variants.0.maximum_addable_quantity', 0)
-            ->assertJsonPath('0.items.0.variants.1.maximum_addable_quantity', 0)
+            ->assertJsonPath('0.items.0.availability.maximum_quantity', 0)
+            ->assertJsonPath('0.items.0.availability.allowed_actions', [])
             ->assertJsonPath(
-                '0.items.0.variants.0.unavailable_message',
-                'Alcanzaste el cupo máximo permitido para este producto.',
-            )
-            ->assertJsonPath(
-                '0.items.0.variants.1.unavailable_message',
+                '0.items.0.availability.reasons.0.message',
                 'Alcanzaste el cupo máximo permitido para este producto.',
             )
+            ->assertJsonPath('0.items.0.variants.0.availability.maximum_quantity', 8)
+            ->assertJsonPath('0.items.0.variants.1.availability.maximum_quantity', 9)
+            ->assertJsonCount(0, '0.items.0.variants.0.availability.reasons')
+            ->assertJsonCount(0, '0.items.0.variants.1.availability.reasons')
             ->assertJsonMissingPath('0.items.0.variants.0.stock_tecnico')
             ->assertJsonMissingPath('0.items.0.variants.1.stock_tecnico');
     }
 
-    public function test_it_includes_out_of_stock_items_with_an_unavailable_message(): void
+    public function test_it_hides_out_of_stock_items_before_building_the_group_response(): void
     {
         $tenant = $this->createTenant('catalog-available-variants');
         $group = $this->createGroup(
@@ -143,7 +139,7 @@ class CatalogControllerTest extends TestCase
             groupLayout: GroupLayout::SimpleVertical,
         );
 
-        $unavailableItem = $this->createItem($tenant, 'Unavailable');
+        $unavailableItem = $this->createItem($tenant, 'Unavailable', withoutInventory: true);
         $unavailableInventory = Inventory::query()->create([
             'real_stock' => 4,
             'reserved_stock' => 4,
@@ -151,7 +147,7 @@ class CatalogControllerTest extends TestCase
         $unavailableItem->variants()->create(['inventory_id' => $unavailableInventory->id]);
         $group->featuredItems()->create(['catalog_item_id' => $unavailableItem->id]);
 
-        $availableItem = $this->createItem($tenant, 'Available');
+        $availableItem = $this->createItem($tenant, 'Available', withoutInventory: true);
         $availableInventory = Inventory::query()->create([
             'real_stock' => 4,
             'reserved_stock' => 3,
@@ -161,15 +157,9 @@ class CatalogControllerTest extends TestCase
 
         $this->getJson("/api/tenants/{$tenant->codigo}/catalog")
             ->assertOk()
-            ->assertJsonCount(2, '0.items')
-            ->assertJsonPath('0.items.0.nombre', 'Unavailable')
-            ->assertJsonPath('0.items.0.maximum_addable_quantity', 0)
-            ->assertJsonPath(
-                '0.items.0.unavailable_message',
-                'Este producto no tiene stock disponible.',
-            )
-            ->assertJsonPath('0.items.1.nombre', 'Available')
-            ->assertJsonPath('0.items.1.unavailable_message', null);
+            ->assertJsonCount(1, '0.items')
+            ->assertJsonPath('0.items.0.nombre', 'Available')
+            ->assertJsonCount(0, '0.items.0.availability.reasons');
     }
 
     public function test_column_with_image_uses_item_image_then_variant_image_then_null(): void
@@ -186,8 +176,8 @@ class CatalogControllerTest extends TestCase
             'order' => 0,
         ]);
 
-        $variantItem = $this->createItem($tenant, 'Variant image');
-        $variantInventory = Inventory::query()->create();
+        $variantItem = $this->createItem($tenant, 'Variant image', withoutInventory: true);
+        $variantInventory = Inventory::query()->create(['real_stock' => 1]);
         $variant = $variantItem->variants()->create(['inventory_id' => $variantInventory->id]);
         $variantImage = $this->createAttachment('variant');
         $variant->attachments()->attach($variantImage, ['orden' => 0]);
@@ -354,10 +344,8 @@ class CatalogControllerTest extends TestCase
         ]);
 
         $food = $this->createItem($tenant, 'Hamburger');
-        $food->update(['group_order' => 2]);
         $food->category()->associate($category)->save();
-        $parking = $this->createItem($tenant, 'Parking');
-        $parking->update(['group_order' => 1]);
+        $this->createItem($tenant, 'Parking');
 
         $this->getJson("/api/tenants/{$tenant->codigo}/catalog")
             ->assertOk()
@@ -366,12 +354,56 @@ class CatalogControllerTest extends TestCase
             ->assertJsonPath('0.items.0.nombre', 'Hamburger')
             ->assertJsonPath('1.title', 'All products')
             ->assertJsonCount(2, '1.items.data')
-            ->assertJsonPath('1.items.data.0.nombre', 'Parking')
-            ->assertJsonPath('1.items.data.1.nombre', 'Hamburger')
-            ->assertJsonMissingPath('1.items.data.0.group_order')
             ->assertJsonPath('1.items.meta.total', 2);
     }
 
+    public function test_index_excludes_items_from_disabled_categories(): void
+    {
+        $tenant = $this->createTenant('catalog-disabled-category');
+        $group = $this->createGroup(
+            $tenant,
+            ProductLayout::Row,
+            'All products',
+            groupLayout: GroupLayout::Simple,
+        );
+        $enabledCategory = Category::query()->create([
+            'tenant_code' => $tenant->codigo,
+            'nombre' => 'Enabled',
+        ]);
+        $disabledCategory = Category::query()->create([
+            'tenant_code' => $tenant->codigo,
+            'nombre' => 'Disabled',
+            'is_enabled' => false,
+        ]);
+
+        $enabledItem = $this->createItem($tenant, 'Enabled item');
+        $enabledItem->category()->associate($enabledCategory)->save();
+        $disabledItem = $this->createItem($tenant, 'Disabled item');
+        $disabledItem->category()->associate($disabledCategory)->save();
+        $uncategorizedItem = $this->createItem($tenant, 'Uncategorized item');
+
+        foreach ([$enabledItem, $disabledItem, $uncategorizedItem] as $order => $item) {
+            $group->featuredItems()->create([
+                'catalog_item_id' => $item->id,
+                'order' => $order,
+            ]);
+        }
+
+        $this->getJson("/api/tenants/{$tenant->codigo}/catalog")
+            ->assertOk()
+            ->assertJsonCount(2, '0.items')
+            ->assertJsonPath('0.items.0.nombre', 'Enabled item')
+            ->assertJsonPath('0.items.1.nombre', 'Uncategorized item')
+            ->assertJsonMissing(['nombre' => 'Disabled item']);
+
+        $this->getJson(
+            "/api/tenants/{$tenant->codigo}/catalog/featured-groups/{$group->id}/items"
+        )
+            ->assertOk()
+            ->assertJsonCount(2)
+            ->assertJsonMissing(['nombre' => 'Disabled item']);
+    }
+
     private function createGroup(
         Tenant $tenant,
         ProductLayout $layout,
@@ -392,7 +424,12 @@ class CatalogControllerTest extends TestCase
         Tenant $tenant,
         string $name,
         ?Inventory $inventory = null,
+        bool $withoutInventory = false,
     ): CatalogItem {
+        $inventory ??= $withoutInventory
+            ? null
+            : Inventory::query()->create(['real_stock' => 10]);
+
         return CatalogItem::query()->create([
             'tenant_code' => $tenant->codigo,
             'inventory_id' => $inventory?->id,

tests/Feature/Catalog/CatalogItemControllerTest.php

@@ -31,7 +31,6 @@ class CatalogItemControllerTest extends TestCase
         $response = $this->postJson("/api/tenants/{$tenant->codigo}/catalog-items", [
             'slug' => 'shirt',
             'nombre' => 'Shirt',
-            'group_order' => 7,
             'precio' => 100,
             'max_units_per_user' => 4,
             'attribute_codes' => [$attribute->codigo],
@@ -48,7 +47,6 @@ class CatalogItemControllerTest extends TestCase
         $response
             ->assertCreated()
             ->assertJsonPath('data.nombre', 'Shirt')
-            ->assertJsonMissingPath('data.group_order')
             ->assertJsonPath('data.max_units_per_user', 4)
             ->assertJsonCount(2, 'data.images')
             ->assertJsonCount(1, 'data.variants')
@@ -59,7 +57,6 @@ class CatalogItemControllerTest extends TestCase
 
         $this->assertSame([0, 1], $item->attachments()->get()->pluck('pivot.orden')->all());
         $this->assertSame(4, $item->max_units_per_user);
-        $this->assertSame(7, $item->group_order);
         $this->assertSame([0], $variant->attachments()->get()->pluck('pivot.orden')->all());
         $this->assertDatabaseHas('catalog_items_attachments', [
             'catalog_item_id' => $item->id,

tests/Feature/Catalog/CatalogItemDetailControllerTest.php

@@ -40,7 +40,7 @@ class CatalogItemDetailControllerTest extends TestCase
 
         $response
             ->assertOk()
-            ->assertJsonPath('data.maximum_addable_quantity', 7)
+            ->assertJsonPath('data.availability.maximum_quantity', 7)
             ->assertJsonMissingPath('data.stock_tecnico')
             ->assertJsonCount(0, 'data.variants')
             ->assertJsonCount(1, 'data.images');
@@ -48,7 +48,18 @@ class CatalogItemDetailControllerTest extends TestCase
         $this->assertStringContainsString($itemImage->path, $response->json('data.images.0'));
     }
 
-    public function test_it_lists_unavailable_variants_and_selects_the_first_available_one(): void
+    public function test_it_does_not_return_an_out_of_stock_product_detail(): void
+    {
+        $tenant = $this->createTenant('detail-hidden');
+        $inventory = Inventory::query()->create(['real_stock' => 0]);
+        $item = $this->createItem($tenant, 'Hidden item', $inventory);
+
+        $this->getJson(
+            "/api/tenants/{$tenant->codigo}/catalog-items/{$item->id}",
+        )->assertNotFound();
+    }
+
+    public function test_it_hides_unavailable_variants_and_selects_the_first_available_one(): void
     {
         Storage::fake('s3');
         $tenant = $this->createTenant('detail-default');
@@ -69,16 +80,11 @@ class CatalogItemDetailControllerTest extends TestCase
 
         $response
             ->assertOk()
-            ->assertJsonCount(2, 'data.variants')
-            ->assertJsonPath('data.variants.0.id', $firstVariant->id)
-            ->assertJsonPath('data.variants.0.maximum_addable_quantity', 0)
-            ->assertJsonPath(
-                'data.variants.0.unavailable_message',
-                'Este producto no tiene stock disponible.',
-            )
-            ->assertJsonPath('data.variants.1.id', $secondVariant->id)
+            ->assertJsonCount(1, 'data.variants')
+            ->assertJsonPath('data.variants.0.id', $secondVariant->id)
+            ->assertJsonPath('data.variants.0.availability.state', 'visible')
             ->assertJsonPath('data.selected_variant.id', $secondVariant->id)
-            ->assertJsonPath('data.selected_variant.maximum_addable_quantity', 6)
+            ->assertJsonPath('data.selected_variant.availability.maximum_quantity', 6)
             ->assertJsonMissingPath('data.selected_variant.stock_tecnico')
             ->assertJsonCount(1, 'data.selected_variant.images');
         $response
@@ -133,11 +139,11 @@ class CatalogItemDetailControllerTest extends TestCase
         $response
             ->assertOk()
             ->assertJsonPath('data.variants.0.id', $firstVariant->id)
-            ->assertJsonPath('data.variants.0.maximum_addable_quantity', 4)
+            ->assertJsonPath('data.variants.0.availability.maximum_quantity', 4)
             ->assertJsonPath('data.variants.0.values.size.value', 'S')
             ->assertJsonPath('data.variants.0.values.size.label', 'Small')
             ->assertJsonPath('data.variants.1.id', $secondVariant->id)
-            ->assertJsonPath('data.variants.1.maximum_addable_quantity', 7)
+            ->assertJsonPath('data.variants.1.availability.maximum_quantity', 7)
             ->assertJsonPath('data.variants.1.values.size.value', 'M')
             ->assertJsonPath('data.variants.1.values.size.label', 'Medium')
             ->assertJsonPath('data.attributes.0.codigo', 'size')
@@ -145,7 +151,7 @@ class CatalogItemDetailControllerTest extends TestCase
             ->assertJsonPath('data.attributes.0.options.1.value', 'M')
             ->assertJsonCount(2, 'data.attributes.0.options')
             ->assertJsonPath('data.selected_variant.id', $secondVariant->id)
-            ->assertJsonPath('data.selected_variant.maximum_addable_quantity', 7)
+            ->assertJsonPath('data.selected_variant.availability.maximum_quantity', 7)
             ->assertJsonPath('data.selected_variant.values.size.value', 'M')
             ->assertJsonPath('data.selected_variant.values.size.label', 'Medium')
             ->assertJsonCount(1, 'data.selected_variant.images');
@@ -185,9 +191,9 @@ class CatalogItemDetailControllerTest extends TestCase
         $this->getJson("/api/tenants/{$tenant->codigo}/catalog-items/{$item->id}")
             ->assertOk()
             ->assertJsonPath('data.selected_variant.id', $variant->id)
-            ->assertJsonPath('data.selected_variant.maximum_addable_quantity', null)
+            ->assertJsonPath('data.selected_variant.availability.maximum_quantity', null)
             ->assertJsonMissingPath('data.stock_tecnico')
-            ->assertJsonPath('data.variants.0.maximum_addable_quantity', null)
+            ->assertJsonPath('data.variants.0.availability.maximum_quantity', null)
             ->assertJsonMissingPath('data.selected_variant.stock_tecnico')
             ->assertJsonMissingPath('data.variants.0.stock_tecnico');
     }
@@ -354,6 +360,9 @@ class CatalogItemDetailControllerTest extends TestCase
             ->assertJsonPath('data.resolved_variant', null)
             ->assertJsonCount(3, 'data.variants')
             ->assertJsonPath('data.variants.0.id', $first->id)
+            ->assertJsonPath('data.variants.0.availability.state', 'visible')
+            ->assertJsonPath('data.variants.0.availability.maximum_quantity', 1)
+            ->assertJsonPath('data.variants.0.availability.allowed_actions.2', 'add_to_cart')
             ->assertJsonPath('data.variants.0.values.sector.value', 'A')
             ->assertJsonPath('data.variants.0.values.seat.value', '1')
             ->assertJsonCount(2, 'data.selectors')
@@ -421,7 +430,9 @@ class CatalogItemDetailControllerTest extends TestCase
             ->assertOk()
             ->assertJsonPath('data.selected_values.sector', 'VIP')
             ->assertJsonPath('data.selected_values.seat', 'A-12')
-            ->assertJsonPath('data.resolved_variant.id', $variant->id);
+            ->assertJsonPath('data.resolved_variant.id', $variant->id)
+            ->assertJsonPath('data.resolved_variant.availability.state', 'hidden')
+            ->assertJsonMissingPath('data.resolved_variant.availability.allowed_actions');
     }
 
     private function createItem(

tests/Feature/Catalog/CatalogSchemaTest.php

@@ -5,6 +5,7 @@ namespace Tests\Feature\Catalog;
 use App\Domains\Attachable\Enums\AttachmentType;
 use App\Domains\Attachable\Models\Attachment;
 use App\Domains\Catalog\Models\CatalogItem;
+use App\Domains\Catalog\Models\Category;
 use App\Domains\Catalog\Models\Inventory;
 use App\Domains\Tenant\Models\Tenant;
 use Illuminate\Foundation\Testing\RefreshDatabase;
@@ -15,6 +16,21 @@ class CatalogSchemaTest extends TestCase
 {
     use RefreshDatabase;
 
+    public function test_categories_are_enabled_by_default(): void
+    {
+        $this->assertTrue(Schema::hasColumn('categorias', 'is_enabled'));
+
+        $category = Category::query()->create([
+            'nombre' => 'Enabled category',
+        ]);
+
+        $this->assertTrue($category->is_enabled);
+        $this->assertDatabaseHas('categorias', [
+            'id' => $category->id,
+            'is_enabled' => true,
+        ]);
+    }
+
     public function test_legacy_product_tables_are_replaced_by_catalog_tables(): void
     {
         $this->assertFalse(Schema::hasTable('productos'));

tests/Feature/Catalog/CatalogSearchTest.php

@@ -62,6 +62,8 @@ class CatalogSearchTest extends TestCase
             $this->createCatalogItem($tenant, "Running {$number}");
         }
         $exactMatch = $this->createCatalogItem($tenant, 'Running');
+        $outOfStockMatch = $this->createCatalogItem($tenant, 'Running unavailable');
+        $outOfStockMatch->inventory->update(['real_stock' => 0]);
         $this->createCatalogItem($tenant, 'Unrelated');
         $this->createCatalogItem($otherTenant, 'Running foreign');
 
@@ -76,6 +78,7 @@ class CatalogSearchTest extends TestCase
             ->assertJsonPath('meta.total', 6)
             ->assertJsonCount(4, 'data')
             ->assertJsonPath('data.0.id', $exactMatch->id)
+            ->assertJsonMissing(['nombre' => 'Running unavailable'])
             ->assertJsonMissing(['nombre' => 'Running foreign'])
             ->assertJsonMissing(['nombre' => 'Unrelated']);
     }

tests/Feature/FiestaFutbolInfantil/EntryControllerTest.php

@@ -38,6 +38,59 @@ class EntryControllerTest extends TestCase
             ->assertUnauthorized();
     }
 
+    public function test_category_visibility_can_be_read_and_updated_for_every_fiesta_menu(): void
+    {
+        $tenant = $this->createFiestaTenant();
+        $categories = [
+            'entries' => ['Entradas', 'adminapp.fiesta-futbol-infantil.entradas'],
+            'foods' => ['Comidas', 'adminapp.fiesta-futbol-infantil.comida'],
+            'accommodations' => ['Alojamientos', 'adminapp.fiesta-futbol-infantil.alojamientos'],
+            'merchandise' => ['Merchandising', 'adminapp.fiesta-futbol-infantil.merchandising'],
+        ];
+
+        foreach ($categories as [$label, $menuCode]) {
+            $menu = Menu::query()->firstOrCreate(
+                ['code' => $menuCode],
+                ['label' => $label, 'route' => '/admin'],
+            );
+            $tenant->menues()->syncWithoutDetaching([$menu->code]);
+        }
+
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        foreach ($categories as $endpoint => [$categoryName]) {
+            $this->getJson("/api/v1/adminapp/tenant/{$endpoint}/visibility")
+                ->assertOk()
+                ->assertJsonPath('data.is_enabled', true);
+
+            $this->patchJson("/api/v1/adminapp/tenant/{$endpoint}/visibility", [
+                'is_enabled' => false,
+            ])
+                ->assertOk()
+                ->assertJsonPath('data.is_enabled', false)
+                ->assertJsonPath(
+                    'message',
+                    'Mostrar en sitio web se desactivo correctamente',
+                );
+
+            $this->patchJson("/api/v1/adminapp/tenant/{$endpoint}/visibility", [
+                'is_enabled' => true,
+            ])
+                ->assertOk()
+                ->assertJsonPath('data.is_enabled', true)
+                ->assertJsonPath(
+                    'message',
+                    'Mostrar en sitio web se activo correctamente',
+                );
+
+            $this->assertDatabaseHas('categorias', [
+                'tenant_code' => $tenant->codigo,
+                'nombre' => $categoryName,
+                'is_enabled' => true,
+            ]);
+        }
+    }
+
     public function test_it_creates_multiple_entries_with_dates_and_tracked_inventory(): void
     {
         $tenant = $this->createFiestaTenant();

tests/Feature/Purchase/StorePurchaseTest.php

@@ -394,7 +394,7 @@ class StorePurchaseTest extends TestCase
             ->assertJsonPath('code', 'purchase.limit_exceeded')
             ->assertJsonPath('catalog_item_id', $variant->catalog_item_id)
             ->assertJsonPath('catalog_item_name', $variant->catalogItem->nombre)
-            ->assertJsonPath('maximum_addable_quantity', 1);
+            ->assertJsonPath('availability.maximum_quantity', 1);
 
         $this->actingAs($otherUser, 'sanctum')
             ->postJson('/api/tenants/sonder/compras/start-checkout', [
@@ -1230,6 +1230,52 @@ class StorePurchaseTest extends TestCase
             ->assertJsonPath('data.0.total', '100.00');
     }
 
+    public function test_purchase_index_filters_multiple_comma_separated_statuses_and_orders_by_status_ascending_then_date(): void
+    {
+        $this->createTenant('sonder', 'Sonder', 'sonder.com.ar');
+        $user = User::factory()->create();
+
+        $olderPaid = Purchase::query()->create([
+            'tenant_codigo' => 'sonder',
+            'user_id' => $user->id,
+            'status' => Purchase::STATUS_PAID,
+            'total' => '10.00',
+        ]);
+        $newerInReview = Purchase::query()->create([
+            'tenant_codigo' => 'sonder',
+            'user_id' => $user->id,
+            'status' => Purchase::STATUS_IN_REVIEW,
+            'total' => '20.00',
+        ]);
+        $newerPaid = Purchase::query()->create([
+            'tenant_codigo' => 'sonder',
+            'user_id' => $user->id,
+            'status' => Purchase::STATUS_PAID,
+            'total' => '30.00',
+        ]);
+        Purchase::query()->create([
+            'tenant_codigo' => 'sonder',
+            'user_id' => $user->id,
+            'status' => Purchase::STATUS_CANCELLED,
+            'total' => '40.00',
+        ]);
+
+        $olderPaid->forceFill(['created_at' => now()->subDays(3)])->saveQuietly();
+        $newerInReview->forceFill(['created_at' => now()])->saveQuietly();
+        $newerPaid->forceFill(['created_at' => now()->subDay()])->saveQuietly();
+
+        $this->actingAs($user, 'sanctum')
+            ->getJson('/api/tenants/sonder/compras?status=paid,%20in_review,paid')
+            ->assertOk()
+            ->assertJsonCount(3, 'data')
+            ->assertJsonPath('data.0.id', $newerInReview->id)
+            ->assertJsonPath('data.0.status', Purchase::STATUS_IN_REVIEW)
+            ->assertJsonPath('data.1.id', $newerPaid->id)
+            ->assertJsonPath('data.1.status', Purchase::STATUS_PAID)
+            ->assertJsonPath('data.2.id', $olderPaid->id)
+            ->assertJsonPath('data.2.status', Purchase::STATUS_PAID);
+    }
+
     public function test_it_rejects_a_cart_from_another_user(): void
     {
         $this->createTenant('sonder', 'Sonder', 'sonder.com.ar');

tests/Feature/Seeders/FiestaFutbolInfantilProductSeederTest.php

@@ -70,14 +70,6 @@ class FiestaFutbolInfantilProductSeederTest extends TestCase
             ['abono', 'alojamiento', 'camiseta', 'comida'],
             CatalogItem::query()->where('tenant_code', $tenant->codigo)->orderBy('slug')->pluck('slug')->all(),
         );
-        $this->assertSame(
-            ['camiseta', 'alojamiento', 'abono', 'comida'],
-            CatalogItem::query()
-                ->where('tenant_code', $tenant->codigo)
-                ->orderBy('group_order')
-                ->pluck('slug')
-                ->all(),
-        );
         $this->assertTrue(
             CatalogItem::query()
                 ->where('tenant_code', $tenant->codigo)

tests/Unit/Catalog/CatalogItemAllowanceServiceTest.php

@@ -2,42 +2,73 @@
 
 namespace Tests\Unit\Catalog;
 
+use App\Domains\Catalog\Services\AvailabilityPolicyResolver;
 use App\Domains\Catalog\Services\CatalogItemAllowanceService;
-use ReflectionClass;
+use App\Domains\Purchase\Services\UserPurchaseLimitService;
+use Mockery;
 use Tests\TestCase;
 
 class CatalogItemAllowanceServiceTest extends TestCase
 {
-    private CatalogItemAllowanceService $service;
-
-    protected function setUp(): void
+    public function test_a_hidden_decision_only_exposes_its_state_and_reasons(): void
     {
-        parent::setUp();
+        $availability = $this->service()->availability(0, 0)->toArray();
 
-        $this->service = (new ReflectionClass(CatalogItemAllowanceService::class))
-            ->newInstanceWithoutConstructor();
-    }
-
-    public function test_it_returns_the_user_quota_message_with_priority_over_stock(): void
-    {
+        $this->assertSame('hidden', $availability['state']);
         $this->assertSame(
-            'Alcanzaste el cupo máximo permitido para este producto.',
-            $this->service->unavailableMessage(0, 0),
+            ['user_quota_reached', 'out_of_stock'],
+            array_column($availability['reasons'], 'code'),
         );
+        $this->assertArrayNotHasKey('maximum_quantity', $availability);
+        $this->assertArrayNotHasKey('allowed_actions', $availability);
     }
 
-    public function test_it_returns_the_out_of_stock_message(): void
+    public function test_an_available_decision_keeps_all_actions(): void
     {
+        $availability = $this->service()->availability(5, 3)->toArray();
+
+        $this->assertSame('visible', $availability['state']);
+        $this->assertSame(3, $availability['maximum_quantity']);
+        $this->assertSame([], $availability['reasons']);
+        $this->assertSame([
+            'select_variant',
+            'change_quantity',
+            'add_to_cart',
+            'buy_now',
+        ], $availability['allowed_actions']);
+    }
+
+    public function test_reaching_the_user_quota_keeps_the_product_visible_without_actions(): void
+    {
+        $availability = $this->service()->availability(5, 0)->toArray();
+
+        $this->assertSame('visible', $availability['state']);
+        $this->assertSame([], $availability['allowed_actions']);
+        $this->assertSame('user_quota_reached', $availability['reasons'][0]['code']);
+    }
+
+    public function test_exceeding_the_remaining_quota_allows_the_quantity_to_be_corrected(): void
+    {
+        $availability = $this->service()
+            ->purchaseLimitExceededAvailability(1, 'Solo podés agregar una unidad.')
+            ->toArray();
+
+        $this->assertSame(1, $availability['maximum_quantity']);
         $this->assertSame(
-            'Este producto no tiene stock disponible.',
-            $this->service->unavailableMessage(0, null),
+            'requested_quantity_exceeds_user_quota',
+            $availability['reasons'][0]['code'],
         );
+        $this->assertSame([
+            'select_variant',
+            'change_quantity',
+        ], $availability['allowed_actions']);
     }
 
-    public function test_it_returns_no_message_when_the_item_is_available(): void
+    private function service(): CatalogItemAllowanceService
     {
-        $this->assertNull($this->service->unavailableMessage(1, null));
-        $this->assertNull($this->service->unavailableMessage(null, 1));
-        $this->assertNull($this->service->unavailableMessage(null, null));
+        return new CatalogItemAllowanceService(
+            Mockery::mock(UserPurchaseLimitService::class),
+            new AvailabilityPolicyResolver,
+        );
     }
 }

tests/Unit/Catalog/CatalogModelsTest.php

@@ -83,13 +83,11 @@ class CatalogModelsTest extends TestCase
     public function test_catalog_item_is_the_catalog_root(): void
     {
         $item = new CatalogItem;
-        $this->assertSame(0, $item->group_order);
         $item->setRawAttributes([
             'category_id' => '10',
             'brand_id' => '20',
             'inventory_id' => '30',
             'type' => CatalogItemType::Standard->value,
-            'group_order' => '4',
             'precio' => '12.50',
             'inventory_policy' => InventoryPolicy::Tracked->value,
             'inventory_subject' => InventorySubject::Seat->value,
@@ -102,7 +100,6 @@ class CatalogModelsTest extends TestCase
         $this->assertSame(20, $item->brand_id);
         $this->assertSame(30, $item->inventory_id);
         $this->assertSame(CatalogItemType::Standard, $item->type);
-        $this->assertSame(4, $item->group_order);
         $this->assertSame('12.50', $item->precio);
         $this->assertSame(InventoryPolicy::Tracked, $item->inventory_policy);
         $this->assertSame(InventorySubject::Seat, $item->inventory_subject);