feat(entry): enhance variant filtering in all method to exclude replaced and disabled variants

This reverts commit 3a4f6b64d2.

.env.example

@@ -8,6 +8,8 @@ PURCHASE_CHECKOUT_EXPIRATION_MINUTES=30
 PURCHASE_QR_EXPIRATION_MINUTES=15
 PURCHASE_TELEPAGOS_EXPIRATION_MINUTES=30
 PURCHASE_TRANSFER_EXPIRATION_MINUTES=1440
+PURCHASE_TRANSFER_CANDIDATE_AMOUNT_TOLERANCE_PERCENTAGE=5
+STOCK_RESERVATION_EXPIRATION_MINUTES=30
 FRONTEND_URLS=http://localhost:4200
 
 APP_LOCALE=es
@@ -30,11 +32,20 @@ AUTH_LOGIN_ATTEMPT_WINDOW_MINUTES=30
 AUTH_LOGIN_LOCK_MINUTES=15
 AUTH_LOGIN_RATE_LIMIT_PER_MINUTE=10
 AUTH_LOGIN_IP_RATE_LIMIT_PER_MINUTE=30
+AUTH_PASSWORD_RESET_EXPIRATION_MINUTES=60
 
-LOG_CHANNEL=stack
+LOG_CHANNEL=daily
 LOG_STACK=single
 LOG_DEPRECATIONS_CHANNEL=null
 LOG_LEVEL=debug
+LOG_DAILY_DAYS=14
+TELEPAGOS_LOG_LEVEL=info
+TELEPAGOS_LOG_DAYS=30
+COMMANDS_LOG_LEVEL=info
+COMMANDS_LOG_DAYS=30
+EMAILS_LOG_LEVEL=info
+EMAILS_LOG_DAYS=30
+EMAIL_DELIVERY_LEASE_SECONDS=300
 
 DB_CONNECTION=mysql
 DB_HOST=127.0.0.1

AGENTS.md

@@ -1,5 +1,11 @@
 # Project Conventions
 
+## Test database safety
+
+- Tests must use SQLite `:memory:` through `tests/bootstrap.php` and `Tests\TestCase`.
+- Never run tests, `migrate:fresh`, `migrate:refresh`, or `db:wipe` against a persistent database, including the developer's `shopit` database.
+- Never bypass the connection safety guard to resolve test failures. Use `php tests/verify-database-safety.php` to verify isolation without queries or migrations.
+
 ## Architecture
 
 This project uses a domain-oriented structure under `app/Domains`.

app/Domains/Administrator/Controllers/AdminAppAdministratorController.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Domains\Administrator\Controllers;
+
+use App\Domains\Administrator\Requests\StoreAdministratorRequest;
+use App\Domains\Administrator\Requests\UpdateAdministratorRequest;
+use App\Domains\Administrator\Resources\AdministratorResource;
+use App\Domains\Administrator\Services\AdministratorService;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
+use Symfony\Component\HttpFoundation\Response;
+
+class AdminAppAdministratorController extends Controller
+{
+    public function __construct(private readonly AdministratorService $administratorService) {}
+
+    public function index(Request $request): AnonymousResourceCollection
+    {
+        return AdministratorResource::collection($this->administratorService->list(
+            $request->user()->tenant()->firstOrFail(),
+            $request->string('search')->trim()->toString() ?: null,
+        ));
+    }
+
+    public function store(StoreAdministratorRequest $request): AdministratorResource
+    {
+        return AdministratorResource::make($this->administratorService->create(
+            $request->user()->tenant()->firstOrFail(),
+            $request->validated(),
+        ));
+    }
+
+    public function update(UpdateAdministratorRequest $request, int $administrator): AdministratorResource
+    {
+        return AdministratorResource::make($this->administratorService->update(
+            $request->user()->tenant()->firstOrFail(),
+            $administrator,
+            $request->validated(),
+        ));
+    }
+
+    public function destroy(Request $request, int $administrator): Response
+    {
+        $this->administratorService->delete($request->user()->tenant()->firstOrFail(), $administrator, $request->user());
+
+        return response()->noContent();
+    }
+}

app/Domains/Administrator/Requests/StoreAdministratorRequest.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Domains\Administrator\Requests;
+
+use App\Domains\Authorization\Enums\RoleCode;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class StoreAdministratorRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return $this->user()?->rol_codigo === RoleCode::AdminApp->value;
+    }
+
+    protected function prepareForValidation(): void
+    {
+        if (is_string($this->input('email'))) {
+            $this->merge(['email' => mb_strtolower(trim($this->input('email')))]);
+        }
+    }
+
+    /** @return array<string, mixed> */
+    public function rules(): array
+    {
+
+        return [
+            'nombre_apellido' => ['required', 'string', 'max:255'],
+            'dni' => ['required', 'string', 'max:50'],
+            'email' => [
+                'required',
+                'email',
+                'max:255',
+                Rule::unique('users', 'active_email')->where('rol_codigo', RoleCode::AdminApp->value)->whereNull('deleted_at'),
+            ],
+        ];
+    }
+}

app/Domains/Administrator/Requests/UpdateAdministratorRequest.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Domains\Administrator\Requests;
+
+use App\Domains\Authorization\Enums\RoleCode;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class UpdateAdministratorRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return $this->user()?->rol_codigo === RoleCode::AdminApp->value;
+    }
+
+    protected function prepareForValidation(): void
+    {
+        if (is_string($this->input('email'))) {
+            $this->merge(['email' => mb_strtolower(trim($this->input('email')))]);
+        }
+    }
+
+    /** @return array<string, mixed> */
+    public function rules(): array
+    {
+        $administratorId = (int) $this->route('administrator');
+
+        return [
+            'nombre_apellido' => ['required', 'string', 'max:255'],
+            'dni' => ['required', 'string', 'max:50'],
+            'email' => [
+                'required',
+                'email',
+                'max:255',
+                Rule::unique('users', 'active_email')->where('rol_codigo', RoleCode::AdminApp->value)
+                    ->whereNull('deleted_at')
+                    ->ignore($administratorId),
+            ],
+        ];
+    }
+}

app/Domains/Administrator/Resources/AdministratorResource.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Domains\Administrator\Resources;
+
+use App\Domains\Auth\Models\User;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/** @mixin User */
+class AdministratorResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'nombre_apellido' => $this->nombre_apellido,
+            'dni' => $this->dni,
+            'email' => $this->email,
+            'rol_codigo' => $this->rol_codigo,
+            'role' => $this->whenLoaded('role', fn () => [
+                'codigo' => $this->role?->codigo,
+                'nombre' => $this->role?->nombre,
+            ]),
+        ];
+    }
+}

app/Domains/Administrator/Services/AdministratorService.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace App\Domains\Administrator\Services;
+
+use App\Domains\Auth\Models\ResetPasswordAttempt;
+use App\Domains\Auth\Models\User;
+use App\Domains\Auth\Services\ResetPasswordAttemptService;
+use App\Domains\Authorization\Enums\RoleCode;
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Str;
+use Illuminate\Validation\ValidationException;
+
+class AdministratorService
+{
+    public function __construct(private readonly ResetPasswordAttemptService $resetPasswordAttemptService) {}
+
+    /** @return Collection<int, User> */
+    public function list(Tenant $tenant, ?string $search = null): Collection
+    {
+        return $this->query($tenant)->with('role')
+            ->when($search, fn (Builder $query, string $search) => $query->where(function (Builder $query) use ($search): void {
+                $query->where('nombre_apellido', 'like', "%{$search}%")
+                    ->orWhere('dni', 'like', "%{$search}%")
+                    ->orWhere('email', 'like', "%{$search}%");
+            }))
+            ->orderBy('nombre_apellido')->get();
+    }
+
+    /** @param array<string, mixed> $data */
+    public function create(Tenant $tenant, array $data): User
+    {
+        return DB::transaction(function () use ($tenant, $data): User {
+            $administrator = User::query()->create([
+                ...$this->attributes($data),
+                'password' => Str::random(64),
+                'rol_codigo' => RoleCode::AdminApp->value,
+                'tenant_codigo' => $tenant->codigo,
+            ]);
+            $this->resetPasswordAttemptService->createForAdminAppEmail(
+                $administrator->email,
+                ResetPasswordAttempt::REASON_ADMINISTRATOR_CREATED,
+            );
+
+            return $administrator->load('role');
+        });
+    }
+
+    /** @param array<string, mixed> $data */
+    public function update(Tenant $tenant, int $administratorId, array $data): User
+    {
+        return DB::transaction(function () use ($tenant, $administratorId, $data): User {
+            $administrator = $this->query($tenant)->lockForUpdate()->findOrFail($administratorId);
+            $administrator->update($this->attributes($data));
+
+            return $administrator->load('role');
+        });
+    }
+
+    public function delete(Tenant $tenant, int $administratorId, User $actor): void
+    {
+        DB::transaction(function () use ($tenant, $administratorId, $actor): void {
+            // Serialize deletions for this tenant, including requests already authenticated
+            // when another administrator removes their account.
+            Tenant::query()->whereKey($tenant->getKey())->lockForUpdate()->firstOrFail();
+            $administrator = $this->query($tenant)->lockForUpdate()->findOrFail($administratorId);
+            if ($administrator->is($actor)) {
+                throw ValidationException::withMessages(['administrator' => 'No podés eliminar tu propio usuario.']);
+            }
+            $activeAdministrators = $this->query($tenant)->lockForUpdate()->get();
+            if ($activeAdministrators->count() <= 1) {
+                throw ValidationException::withMessages(['administrator' => 'El tenant debe conservar al menos un administrador.']);
+            }
+            abort_unless($activeAdministrators->contains('id', $actor->id), 403);
+            $administrator->tokens()->delete();
+            $administrator->delete();
+        });
+    }
+
+    private function query(Tenant $tenant): Builder
+    {
+        return User::query()->where('tenant_codigo', $tenant->codigo)
+            ->where('rol_codigo', RoleCode::AdminApp->value);
+    }
+
+    /** @param array<string, mixed> $data
+     * @return array<string, mixed>
+     */
+    private function attributes(array $data): array
+    {
+        return [
+            ...Arr::only($data, ['nombre_apellido', 'dni']),
+            'email' => mb_strtolower(trim((string) $data['email'])),
+        ];
+    }
+}

app/Domains/Administrator/documentacion/README.md

@@ -0,0 +1,63 @@
+# Administradores de AdminApp
+
+CRUD de usuarios con rol `adminapp`, limitado al tenant del usuario autenticado.
+Todos los administradores del tenant pueden gestionar esta sección.
+
+## Endpoints
+
+Base: `/api/v1/adminapp/tenant/administrators`.
+Requieren `auth:sanctum` y `adminapp.tenant`.
+
+- `GET /`: listado ordenado por nombre; acepta `search` por nombre, DNI o email.
+- `POST /`: alta; responde `201` con `data`.
+- `PUT /{administrator}`: actualización de los tres campos; responde `200` con `data`.
+- `DELETE /{administrator}`: baja lógica; responde `204`.
+
+Alta y actualización reciben:
+
+```json
+{
+  "nombre_apellido": "Ada Lovelace",
+  "dni": "12345678",
+  "email": "ada@example.test"
+}
+```
+
+Nombre (hasta 255 caracteres), DNI (hasta 50) y email (hasta 255) son obligatorios.
+El email se normaliza a minúsculas antes de validar y debe ser único entre
+usuarios activos, sin importar su tenant o rol. Se permite reutilizar el email
+de un usuario eliminado. Rol y tenant no son editables desde esta API.
+
+Las respuestas incluyen `id`, `nombre_apellido`, `dni`, `email`, `rol_codigo`
+y `role` (`codigo`, `nombre`). Nunca incluyen contraseña ni datos de escaneo.
+
+## Alta y acceso
+
+Se genera una contraseña aleatoria y un intento de establecimiento de contraseña
+con motivo `administrator_created`, reutilizando `createForAdminAppEmail`.
+El evento usa el canal `adminapp`; el listener existente envía el email después
+del commit mediante la cola `emails`. Requiere la configuración de correo,
+dominio AdminApp y worker existentes. No se envían contraseñas en texto plano.
+
+## Eliminación y aislamiento
+
+Las consultas de usuarios se limitan por tenant y rol `adminapp`. IDs ajenos,
+usuarios eliminados y usuarios de otros roles devuelven `404`.
+La validación de campos devuelve `422`; falta de autenticación, `401`, y rol
+no autorizado, `403`.
+
+No se permite eliminar al propio usuario ni dejar al tenant sin administradores
+(`422`, error `administrator`). La eliminación bloquea la fila del tenant dentro
+de una transacción para serializar bajas concurrentes. También verifica que el
+actor siga activo, revoca tokens y aplica el borrado lógico existente en `users`.
+
+No agrega tablas ni migraciones. No modifica el CRUD de escáneres ni el frontend.
+
+## Verificación
+
+`php artisan test tests/Feature/Administrator/AdministratorControllerTest.php`
+
+Las pruebas cubren CRUD, normalización y unicidad del email, establecimiento de
+contraseña, restricciones de rol y tenant, baja lógica, tokens y protecciones de
+eliminación. El caso de petición autenticada antes de la baja del actor se simula;
+no es una prueba con conexiones concurrentes reales.

app/Domains/Administrator/routes/api.php

@@ -0,0 +1,10 @@
+<?php
+
+use App\Domains\Administrator\Controllers\AdminAppAdministratorController;
+use Illuminate\Support\Facades\Route;
+
+Route::prefix('v1/adminapp/tenant')
+    ->middleware(['auth:sanctum', 'adminapp.tenant'])
+    ->group(function (): void {
+        Route::apiResource('administrators', AdminAppAdministratorController::class)->except('show');
+    });

app/Domains/Auth/Controllers/ResetPasswordController.php

@@ -5,6 +5,7 @@ namespace App\Domains\Auth\Controllers;
 use App\Domains\Auth\Models\ResetPasswordAttempt;
 use App\Domains\Auth\Requests\ResetPasswordRequest;
 use App\Domains\Auth\Services\ResetPasswordAttemptService;
+use App\Domains\Authorization\Enums\RoleCode;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Validation\ValidationException;
@@ -26,6 +27,7 @@ class ResetPasswordController extends Controller
             $data['email'],
             $data['codigo'],
             $data['password'],
+            RoleCode::from($request->route('reset_role', RoleCode::User->value)),
         )) {
             throw ValidationException::withMessages([
                 'codigo' => __('api.auth.password_reset_invalid'),

app/Domains/Auth/Controllers/ValidateResetPasswordAttemptController.php

@@ -5,6 +5,7 @@ namespace App\Domains\Auth\Controllers;
 use App\Domains\Auth\Models\ResetPasswordAttempt;
 use App\Domains\Auth\Requests\ValidateResetPasswordAttemptRequest;
 use App\Domains\Auth\Services\ResetPasswordAttemptService;
+use App\Domains\Authorization\Enums\RoleCode;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Validation\ValidationException;
@@ -22,10 +23,19 @@ class ValidateResetPasswordAttemptController extends Controller
     {
         $data = $request->validated();
 
-        if (! $this->resetPasswordAttemptService->validateCode(
+        $result = $this->resetPasswordAttemptService->validateCode(
             $data['email'],
             $data['codigo'],
-        )) {
+            RoleCode::from($request->route('reset_role', RoleCode::User->value)),
+        );
+
+        if ($result === ResetPasswordAttemptService::CODE_EXPIRED) {
+            throw ValidationException::withMessages([
+                'codigo' => __('api.auth.reset_code_expired'),
+            ]);
+        }
+
+        if ($result !== ResetPasswordAttemptService::CODE_VALID) {
             throw ValidationException::withMessages([
                 'codigo' => __('api.auth.reset_code_invalid'),
             ]);

app/Domains/Auth/Models/ResetPasswordAttempt.php

@@ -7,7 +7,7 @@ use Illuminate\Database\Eloquent\Attributes\Hidden;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
-#[Fillable(['user_id', 'codigo', 'reason', 'status'])]
+#[Fillable(['user_id', 'codigo', 'reason', 'status', 'expires_at'])]
 #[Hidden(['codigo'])]
 class ResetPasswordAttempt extends Model
 {
@@ -17,6 +17,8 @@ class ResetPasswordAttempt extends Model
 
     public const REASON_STAFF_CREATED = 'staff_created';
 
+    public const REASON_ADMINISTRATOR_CREATED = 'administrator_created';
+
     public const STATUS_PENDING = 'pending';
 
     public const STATUS_VALIDATED = 'validated';
@@ -31,6 +33,7 @@ class ResetPasswordAttempt extends Model
     {
         return [
             'user_id' => 'integer',
+            'expires_at' => 'datetime',
         ];
     }
 

app/Domains/Auth/Models/User.php

@@ -5,7 +5,9 @@ namespace App\Domains\Auth\Models;
 use App\Domains\Authorization\Enums\RoleCode;
 use App\Domains\Authorization\Models\Role;
 use App\Domains\Catalog\Models\Category;
+use App\Domains\Event\Models\EventDateChangeView;
 use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticket\Models\ScanAttempt;
 use Database\Factories\UserFactory;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Attributes\Hidden;
@@ -13,16 +15,17 @@ use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\BelongsToMany;
 use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\SoftDeletes;
 use Illuminate\Foundation\Auth\User as Authenticatable;
 use Illuminate\Notifications\Notifiable;
 use Laravel\Sanctum\HasApiTokens;
 
 #[Fillable(['nombre_apellido', 'email', 'password', 'dni', 'telefono', 'google_id', 'rol_codigo', 'tenant_codigo'])]
-#[Hidden(['password', 'remember_token'])]
+#[Hidden(['password', 'remember_token', 'active_email', 'active_google_id'])]
 class User extends Authenticatable
 {
     /** @use HasFactory<UserFactory> */
-    use HasApiTokens, HasFactory, Notifiable;
+    use HasApiTokens, HasFactory, Notifiable, SoftDeletes;
 
     protected $attributes = [
         'rol_codigo' => RoleCode::User->value,
@@ -45,6 +48,18 @@ class User extends Authenticatable
         return $this->hasMany(LoginAttempt::class);
     }
 
+    /** @return HasMany<ScanAttempt, $this> */
+    public function scanAttempts(): HasMany
+    {
+        return $this->hasMany(ScanAttempt::class, 'scanner_user_id');
+    }
+
+    /** @return HasMany<EventDateChangeView, $this> */
+    public function eventDateChangeViews(): HasMany
+    {
+        return $this->hasMany(EventDateChangeView::class);
+    }
+
     /**
      * @return BelongsTo<Role, $this>
      */

app/Domains/Auth/Requests/RegisterUserRequest.php

@@ -2,6 +2,7 @@
 
 namespace App\Domains\Auth\Requests;
 
+use App\Domains\Authorization\Enums\RoleCode;
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\Rule;
 use Illuminate\Validation\Rules\Password;
@@ -13,15 +14,26 @@ class RegisterUserRequest extends FormRequest
         return true;
     }
 
-    /**
-     * @return array<string, mixed>
-     */
+    protected function prepareForValidation(): void
+    {
+        if (is_string($this->input('email'))) {
+            $this->merge(['email' => mb_strtolower(trim($this->input('email')))]);
+        }
+    }
+
+    /** @return array<string, mixed> */
     public function rules(): array
     {
         return [
             'tenant_codigo' => ['nullable', 'string', Rule::exists('tenants', 'codigo')],
             'nombre_apellido' => ['required', 'string', 'max:255'],
-            'email' => ['required', 'string', 'email', 'max:255', Rule::unique('users', 'email')],
+            'email' => [
+                'required',
+                'string',
+                'email',
+                'max:255',
+                Rule::unique('users', 'active_email')->where('rol_codigo', RoleCode::User->value)->whereNull('deleted_at'),
+            ],
             'password' => ['required', 'string', 'confirmed', Password::min(8)->mixedCase()->symbols()],
             'dni' => ['nullable', 'string', 'max:255'],
             'telefono' => ['nullable', 'string', 'max:255'],

app/Domains/Auth/Requests/UpdateProfileRequest.php

@@ -4,6 +4,7 @@ namespace App\Domains\Auth\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\Rule;
+use Illuminate\Validation\Rules\Password;
 
 class UpdateProfileRequest extends FormRequest
 {
@@ -12,6 +13,13 @@ class UpdateProfileRequest extends FormRequest
         return true;
     }
 
+    protected function prepareForValidation(): void
+    {
+        if (is_string($this->input('email'))) {
+            $this->merge(['email' => mb_strtolower(trim($this->input('email')))]);
+        }
+    }
+
     public function rules(): array
     {
         return [
@@ -19,11 +27,13 @@ class UpdateProfileRequest extends FormRequest
             'email' => [
                 'required',
                 'email',
-                Rule::unique('users', 'email')->ignore($this->user()->id),
+                Rule::unique('users', 'active_email')->where('rol_codigo', $this->user()->rol_codigo)
+                    ->whereNull('deleted_at')
+                    ->ignore($this->user()->id),
             ],
             'dni' => ['nullable', 'string', 'regex:/^[0-9]{7,8}$/'],
             'telefono' => ['nullable', 'string', 'regex:/^\+?[0-9\s\-]+$/'],
-            'password' => ['nullable', 'string', \Illuminate\Validation\Rules\Password::min(8)->mixedCase()->symbols()],
+            'password' => ['nullable', 'string', Password::min(8)->mixedCase()->symbols()],
         ];
     }
 }

app/Domains/Auth/Resources/UserResource.php

@@ -24,6 +24,11 @@ class UserResource extends JsonResource
             'telefono' => $this->telefono,
             'rol_codigo' => $this->rol_codigo,
             'tenant_codigo' => $this->tenant_codigo,
+            'categories' => $this->whenLoaded('scanCategories', fn () => $this->scanCategories
+                ->map(fn ($category) => [
+                    'id' => $category->id,
+                    'nombre' => $category->nombre,
+                ])->values()),
         ];
     }
 }

app/Domains/Auth/Services/AdminCredentialVerifier.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Auth\Services;
+
+use App\Domains\Auth\Models\User;
+use App\Domains\Authorization\Enums\RoleCode;
+use Illuminate\Support\Facades\Hash;
+
+class AdminCredentialVerifier
+{
+    public function verify(string $email, string $password): bool
+    {
+        $admin = User::query()
+            ->where('active_email', mb_strtolower(trim($email)))
+            ->where('rol_codigo', RoleCode::Admin->value)
+            ->first();
+
+        return $admin !== null
+            && ! $admin->locked_until?->isFuture()
+            && Hash::check($password, $admin->getAuthPassword());
+    }
+}

app/Domains/Auth/Services/GoogleAuthService.php

@@ -3,6 +3,7 @@
 namespace App\Domains\Auth\Services;
 
 use App\Domains\Auth\Models\User;
+use App\Domains\Authorization\Enums\RoleCode;
 use App\Domains\Notification\Events\UserRegistered;
 use App\Domains\Tenant\Models\Tenant;
 use App\Domains\Tenant\Support\TenantDomainNormalizer;
@@ -124,12 +125,12 @@ class GoogleAuthService
             ]);
         }
 
-        $user = User::query()->where('google_id', $googleId)->first();
+        $user = User::query()->where('rol_codigo', RoleCode::User->value)->where('google_id', $googleId)->first();
         if ($user) {
             return $user;
         }
 
-        $user = User::query()->where('email', $email)->first();
+        $user = User::query()->where('rol_codigo', RoleCode::User->value)->where('active_email', mb_strtolower(trim($email)))->first();
         if ($user) {
             $user->forceFill(['google_id' => $googleId])->save();
 
@@ -155,16 +156,19 @@ class GoogleAuthService
         $parts = parse_url($returnUrl);
         if (! is_array($parts)
             || ! isset($parts['scheme'], $parts['host'])
-            || isset($parts['user'], $parts['pass'], $parts['query'], $parts['fragment'])
-            || ($parts['path'] ?? '') !== '') {
+            || isset($parts['user'], $parts['pass'], $parts['query'], $parts['fragment'])) {
             return false;
         }
 
         $scheme = strtolower($parts['scheme']);
         $host = TenantDomainNormalizer::normalize($parts['host']);
         $tenantDomain = TenantDomainNormalizer::normalize($tenant->dominio);
+        $returnPath = TenantDomainNormalizer::normalizePath($parts['path'] ?? '/');
 
-        if ($host === null || $tenantDomain === null || $host !== $tenantDomain) {
+        if ($host === null
+            || $tenantDomain === null
+            || $host !== $tenantDomain
+            || $returnPath !== $tenant->base_path) {
             return false;
         }
 

app/Domains/Auth/Services/PasswordLoginService.php

@@ -85,7 +85,7 @@ class PasswordLoginService
             null,
             $ipAddress,
             $userAgent,
-            null,
+            RoleCode::Scanner,
             true,
             PermissionCode::ScanTickets->value,
             PasswordResetRequested::CHANNEL_SCANNER,
@@ -120,7 +120,7 @@ class PasswordLoginService
             $passwordResetChannel,
         ): array {
             $user = User::query()
-                ->where('email', $normalizedEmail)
+                ->where('active_email', $normalizedEmail)
                 ->when(
                     $requiredRole !== null,
                     fn ($query) => $query->where('rol_codigo', $requiredRole->value),

app/Domains/Auth/Services/ResetPasswordAttemptService.php

@@ -12,6 +12,12 @@ use Throwable;
 
 class ResetPasswordAttemptService
 {
+    public const CODE_VALID = 'valid';
+
+    public const CODE_INVALID = 'invalid';
+
+    public const CODE_EXPIRED = 'expired';
+
     public function createForEmail(
         string $email,
         string $tenantCode,
@@ -22,7 +28,8 @@ class ResetPasswordAttemptService
         try {
             $attemptId = DB::transaction(function () use ($email, $emailFingerprint, $reason): ?int {
                 $user = User::query()
-                    ->where('email', $email)
+                    ->where('active_email', mb_strtolower(trim($email)))
+                    ->where('rol_codigo', RoleCode::User->value)
                     ->lockForUpdate()
                     ->first();
 
@@ -59,7 +66,7 @@ class ResetPasswordAttemptService
         try {
             $result = DB::transaction(function () use ($email, $emailFingerprint, $reason): ?array {
                 $user = User::query()
-                    ->where('email', $email)
+                    ->where('active_email', mb_strtolower(trim($email)))
                     ->where('rol_codigo', RoleCode::AdminApp->value)
                     ->whereNotNull('tenant_codigo')
                     ->lockForUpdate()
@@ -107,7 +114,7 @@ class ResetPasswordAttemptService
         try {
             $result = DB::transaction(function () use ($email, $emailFingerprint, $reason): ?array {
                 $user = User::query()
-                    ->where('email', $email)
+                    ->where('active_email', mb_strtolower(trim($email)))
                     ->where('rol_codigo', RoleCode::Scanner->value)
                     ->whereNotNull('tenant_codigo')
                     ->lockForUpdate()
@@ -146,14 +153,15 @@ class ResetPasswordAttemptService
         );
     }
 
-    public function validateCode(string $email, string $code): bool
+    public function validateCode(string $email, string $code, RoleCode $role = RoleCode::User): string
     {
         $emailFingerprint = $this->emailFingerprint($email);
 
         try {
-            return DB::transaction(function () use ($email, $code, $emailFingerprint): bool {
+            return DB::transaction(function () use ($email, $code, $emailFingerprint, $role): string {
                 $user = User::query()
-                    ->where('email', $email)
+                    ->where('active_email', mb_strtolower(trim($email)))
+                    ->where('rol_codigo', $role->value)
                     ->lockForUpdate()
                     ->first();
 
@@ -169,14 +177,27 @@ class ResetPasswordAttemptService
                         'email_fingerprint' => $emailFingerprint,
                     ]);
 
-                    return false;
+                    return self::CODE_INVALID;
+                }
+
+                if ($attempt->expires_at?->isPast()) {
+                    $attempt->update([
+                        'status' => ResetPasswordAttempt::STATUS_EXPIRED,
+                    ]);
+
+                    Log::info('Password reset code validation failed: attempt expired.', [
+                        'email_fingerprint' => $emailFingerprint,
+                        'attempt_id' => $attempt->getKey(),
+                    ]);
+
+                    return self::CODE_EXPIRED;
                 }
 
                 $attempt->update([
                     'status' => ResetPasswordAttempt::STATUS_VALIDATED,
                 ]);
 
-                return true;
+                return self::CODE_VALID;
             });
         } catch (Throwable $exception) {
             Log::error('Failed to validate password reset code.', [
@@ -188,14 +209,15 @@ class ResetPasswordAttemptService
         }
     }
 
-    public function resetPassword(string $email, string $code, string $password): bool
+    public function resetPassword(string $email, string $code, string $password, RoleCode $role = RoleCode::User): bool
     {
         $emailFingerprint = $this->emailFingerprint($email);
 
         try {
-            return DB::transaction(function () use ($email, $code, $password, $emailFingerprint): bool {
+            return DB::transaction(function () use ($email, $code, $password, $emailFingerprint, $role): bool {
                 $user = User::query()
-                    ->where('email', $email)
+                    ->where('active_email', mb_strtolower(trim($email)))
+                    ->where('rol_codigo', $role->value)
                     ->lockForUpdate()
                     ->first();
 
@@ -214,6 +236,19 @@ class ResetPasswordAttemptService
                     return false;
                 }
 
+                if ($attempt->expires_at?->isPast()) {
+                    $attempt->update([
+                        'status' => ResetPasswordAttempt::STATUS_EXPIRED,
+                    ]);
+
+                    Log::info('Password reset failed: attempt expired.', [
+                        'email_fingerprint' => $emailFingerprint,
+                        'attempt_id' => $attempt->getKey(),
+                    ]);
+
+                    return false;
+                }
+
                 $user->password = $password;
                 $user->failed_login_attempts = 0;
                 $user->last_failed_login_at = null;
@@ -270,6 +305,7 @@ class ResetPasswordAttemptService
             'codigo' => $this->generateCode(),
             'reason' => $reason,
             'status' => ResetPasswordAttempt::STATUS_PENDING,
+            'expires_at' => now()->addMinutes((int) config('auth.passwords.users.expire')),
         ]);
 
         return $attempt->getKey();

app/Domains/Auth/Services/ScannerContextService.php

@@ -19,6 +19,16 @@ class ScannerContextService
 
         $user->setRelation('tenant', $tenant);
 
+        if ($tenant->requiresScannerCategoryValidation()) {
+            $categories = $user->scanCategories()
+                ->orderBy('nombre')
+                ->get();
+
+            if ($categories->isNotEmpty()) {
+                $user->setRelation('scanCategories', $categories);
+            }
+        }
+
         return $user;
     }
 }

app/Domains/Auth/routes/adminapp.php

@@ -12,8 +12,10 @@ Route::prefix('v1/adminapp')->group(function (): void {
     Route::post('password/reset-attempts', CreateAdminAppResetPasswordAttemptController::class)
         ->middleware('throttle:5,1');
     Route::post('password/reset-attempts/validate', ValidateResetPasswordAttemptController::class)
+        ->defaults('reset_role', 'adminapp')
         ->middleware('throttle:10,1');
     Route::post('password/reset', ResetPasswordController::class)
+        ->defaults('reset_role', 'adminapp')
         ->middleware('throttle:5,1');
     Route::middleware(['auth:sanctum', 'adminapp.tenant'])
         ->get('me', AdminAppMeController::class);

app/Domains/Auth/routes/scanner.php

@@ -12,8 +12,10 @@ Route::prefix('v1/scanner')->group(function (): void {
     Route::post('password/reset-attempts', CreateScannerResetPasswordAttemptController::class)
         ->middleware('throttle:5,1');
     Route::post('password/reset-attempts/validate', ValidateResetPasswordAttemptController::class)
+        ->defaults('reset_role', 'scanner')
         ->middleware('throttle:10,1');
     Route::post('password/reset', ResetPasswordController::class)
+        ->defaults('reset_role', 'scanner')
         ->middleware('throttle:5,1');
     Route::middleware(['auth:sanctum', 'scanner.tenant'])
         ->get('me', ScannerMeController::class);

app/Domains/Bootstrap/Resources/AdminAppBootstrapResource.php

@@ -17,6 +17,7 @@ class AdminAppBootstrapResource extends JsonResource
 
         return [
             'website_type_code' => $websiteType->codigo,
+            'site_title' => $websiteType->site_title,
             'primary_color' => $websiteType->primary_color,
             'secondary_color' => $websiteType->secondary_color,
             'danger_color' => $websiteType->danger_color,
@@ -30,6 +31,7 @@ class AdminAppBootstrapResource extends JsonResource
             'login_header_footer_color' => $websiteType->login_header_footer_color,
             'site_logo' => $websiteType->siteLogo?->getTemporaryUrl(1440),
             'footer_logo' => $websiteType->footerLogo?->getTemporaryUrl(1440),
+            'favicon' => $websiteType->favicon?->getTemporaryUrl(1440),
         ];
     }
 }

app/Domains/Bootstrap/Services/AdminAppBootstrapService.php

@@ -11,7 +11,7 @@ class AdminAppBootstrapService
     {
         return [
             'website_type' => WebsiteType::query()
-                ->with(['siteLogo', 'footerLogo'])
+                ->with(['siteLogo', 'footerLogo', 'favicon'])
                 ->where('dominio', $domain)
                 ->firstOrFail(),
         ];

app/Domains/Bootstrap/Services/ScannerBootstrapService.php

@@ -11,7 +11,7 @@ class ScannerBootstrapService
     {
         return [
             'website_type' => WebsiteType::query()
-                ->with(['siteLogo', 'footerLogo'])
+                ->with(['siteLogo', 'footerLogo', 'favicon'])
                 ->where('scanner_domain', $domain)
                 ->firstOrFail(),
         ];

app/Domains/Bootstrap/Services/TenantBootstrapService.php

@@ -14,14 +14,15 @@ class TenantBootstrapService
 
     public function get(string $domain, string $path = '/'): Tenant
     {
-        $candidateKeys = TenantDomainNormalizer::tenantKeyCandidates($domain, $path);
-        $tenantsByDomain = Tenant::query()
-            ->whereIn('dominio', $candidateKeys)
+        $candidateBasePaths = TenantDomainNormalizer::basePathCandidates($path);
+        $tenantsByBasePath = Tenant::query()
+            ->where('dominio', $domain)
+            ->whereIn('base_path', $candidateBasePaths)
             ->get()
-            ->keyBy('dominio');
+            ->keyBy('base_path');
 
-        $tenant = collect($candidateKeys)
-            ->map(fn (string $candidate): ?Tenant => $tenantsByDomain->get($candidate))
+        $tenant = collect($candidateBasePaths)
+            ->map(fn (string $candidate): ?Tenant => $tenantsByBasePath->get($candidate))
             ->first(fn (?Tenant $candidate): bool => $candidate !== null);
 
         if (! $tenant instanceof Tenant) {
@@ -31,6 +32,7 @@ class TenantBootstrapService
         return $this->tenantInformationService->load(
             $tenant,
             [
+                'eventDateChanges',
                 'menues' => fn ($query) => $query->whereHas(
                     'roles',
                     fn ($query) => $query->where('codigo', RoleCode::User->value)

app/Domains/Cart/Models/Cart.php

@@ -5,8 +5,11 @@ namespace App\Domains\Cart\Models;
 use App\Domains\Auth\Models\User;
 use App\Domains\Catalog\Models\CatalogItem;
 use App\Domains\Catalog\Models\Inventory;
+use App\Domains\Catalog\Models\StockReservation;
 use App\Domains\Catalog\Models\Variant;
 use App\Domains\Catalog\Services\CatalogInventoryService;
+use App\Domains\Catalog\Services\StockReservationService;
+use App\Domains\Purchase\Models\Purchase;
 use App\Domains\Purchase\Services\UserPurchaseLimitService;
 use App\Domains\Tenant\Models\Tenant;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
@@ -24,6 +27,9 @@ use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
     'user_id',
     'guest_token',
     'status',
+    'origin',
+    'current_purchase_id',
+    'current_stock_reservation_id',
 ])]
 class Cart extends Model
 {
@@ -32,10 +38,26 @@ class Cart extends Model
 
     protected $table = 'carritos';
 
+    public const STATUS_ACTIVE = 'active';
+
+    public const STATUS_CHECKOUT = 'checkout';
+
+    public const STATUS_CONVERTED = 'converted';
+
+    public const STATUS_EXPIRED = 'expired';
+
+    public const STATUS_ABANDONED = 'abandoned';
+
+    public const ORIGIN_USER = 'user';
+
+    public const ORIGIN_DIRECT_CHECKOUT = 'direct_checkout';
+
     protected function casts(): array
     {
         return [
             'user_id' => 'integer',
+            'current_purchase_id' => 'integer',
+            'current_stock_reservation_id' => 'integer',
         ];
     }
 
@@ -63,6 +85,27 @@ class Cart extends Model
         return $this->hasMany(CartItem::class, 'cart_id');
     }
 
+    /** @return HasMany<Purchase, $this> */
+    public function purchases(): HasMany
+    {
+        return $this->hasMany(Purchase::class, 'cart_id');
+    }
+
+    /** @return BelongsTo<Purchase, $this> */
+    public function currentPurchase(): BelongsTo
+    {
+        return $this->belongsTo(Purchase::class, 'current_purchase_id');
+    }
+
+    /** @return BelongsTo<StockReservation, $this> */
+    public function currentStockReservation(): BelongsTo
+    {
+        return $this->belongsTo(
+            StockReservation::class,
+            'current_stock_reservation_id',
+        );
+    }
+
     public function getTotalAmount(): float
     {
         $items = $this->relationLoaded('items')
@@ -85,14 +128,20 @@ class Cart extends Model
         }
 
         return DB::transaction(function () use ($catalogItemId, $variantId, $quantity): CartItem {
-            self::query()->whereKey($this->getKey())->lockForUpdate()->firstOrFail();
+            $this->invalidateCurrentCheckout();
+            app(StockReservationService::class)->assertCartReservationUsable($this);
             $selectedItem = $this->resolveScopedItem($catalogItemId, $variantId, true);
             $cartQuantity = (int) $this->items()
                 ->where('catalog_item_id', $catalogItemId)
                 ->sum('cantidad');
-            $this->assertUserPurchaseLimit($selectedItem, $cartQuantity + $quantity);
             $inventoryService = app(CatalogInventoryService::class);
             $availableQuantity = $inventoryService->availableQuantity($selectedItem);
+            $this->assertUserPurchaseLimit(
+                $selectedItem,
+                $cartQuantity + $quantity,
+                heldQuantity: $cartQuantity,
+                maximumAddableCeiling: $availableQuantity,
+            );
 
             if ($availableQuantity !== null && $availableQuantity < $quantity) {
                 throw ValidationException::withMessages([
@@ -118,7 +167,7 @@ class Cart extends Model
                 $item->save();
             }
 
-            $inventoryService->reserve($selectedItem, $quantity);
+            app(StockReservationService::class)->syncCart($this);
 
             return $item->fresh();
         });
@@ -129,6 +178,7 @@ class Cart extends Model
         int $quantity,
         ?int $variantId = null,
         bool $updateVariant = false,
+        ?int $excludedPurchaseId = null,
     ): CartItem {
         if ($quantity <= 0) {
             throw ValidationException::withMessages([
@@ -141,7 +191,11 @@ class Cart extends Model
             $quantity,
             $variantId,
             $updateVariant,
+            $excludedPurchaseId,
         ): CartItem {
+            $this->invalidateCurrentCheckout();
+            app(StockReservationService::class)->assertCartReservationUsable($this);
+
             /** @var CartItem $item */
             $item = $this->items()
                 ->where('id', $cartItemId)
@@ -165,12 +219,15 @@ class Cart extends Model
                     ->where('catalog_item_id', $item->catalog_item_id)
                     ->whereKeyNot($item->getKey())
                     ->sum('cantidad');
+                $nextAvailableQuantity = $inventoryService->availableQuantity($nextSelection);
                 $this->assertUserPurchaseLimit(
                     $nextSelection,
                     $otherVariantsQuantity + $quantity,
+                    $excludedPurchaseId,
+                    $otherVariantsQuantity + $item->cantidad,
+                    $nextAvailableQuantity,
                 );
 
-                $inventoryService->release($currentSelection, $item->cantidad);
                 $availableQuantity = $inventoryService->availableQuantity($nextSelection);
 
                 if ($availableQuantity !== null && $availableQuantity < $quantity) {
@@ -186,12 +243,11 @@ class Cart extends Model
                     ->lockForUpdate()
                     ->first();
 
-                $inventoryService->reserve($nextSelection, $quantity);
-
                 if ($targetItem !== null) {
                     $targetItem->cantidad += $quantity;
                     $targetItem->save();
                     $item->delete();
+                    app(StockReservationService::class)->syncCart($this);
 
                     return $targetItem->fresh();
                 }
@@ -199,11 +255,13 @@ class Cart extends Model
                 $item->variant_id = $variantId;
                 $item->cantidad = $quantity;
                 $item->save();
+                app(StockReservationService::class)->syncCart($this);
 
                 return $item->fresh();
             }
 
             $delta = $quantity - $item->cantidad;
+            $availableQuantity = $inventoryService->availableQuantity($currentSelection);
 
             if ($delta > 0) {
                 $otherVariantsQuantity = (int) $this->items()
@@ -213,11 +271,12 @@ class Cart extends Model
                 $this->assertUserPurchaseLimit(
                     $currentSelection,
                     $otherVariantsQuantity + $quantity,
+                    $excludedPurchaseId,
+                    $otherVariantsQuantity + $item->cantidad,
+                    $availableQuantity,
                 );
             }
 
-            $availableQuantity = $inventoryService->availableQuantity($currentSelection);
-
             if ($delta > 0 && $availableQuantity !== null && $availableQuantity < $delta) {
                 $maxAvailable = $availableQuantity + $item->cantidad;
                 throw ValidationException::withMessages([
@@ -227,14 +286,7 @@ class Cart extends Model
 
             $item->cantidad = $quantity;
             $item->save();
-
-            if ($delta > 0) {
-                $inventoryService->reserve($currentSelection, $delta);
-            }
-
-            if ($delta < 0) {
-                $inventoryService->release($currentSelection, abs($delta));
-            }
+            app(StockReservationService::class)->syncCart($this);
 
             return $item->fresh();
         });
@@ -243,25 +295,79 @@ class Cart extends Model
     public function removeItem(int $cartItemId): void
     {
         DB::transaction(function () use ($cartItemId): void {
+            $this->invalidateCurrentCheckout();
+            app(StockReservationService::class)->assertCartReservationUsable($this);
+
             /** @var CartItem $item */
             $item = $this->items()
                 ->where('id', $cartItemId)
                 ->lockForUpdate()
                 ->firstOrFail();
 
-            $selectedItem = $this->resolveScopedItem(
-                $item->catalog_item_id,
-                $item->variant_id,
-                true,
-            );
-            app(CatalogInventoryService::class)->release(
-                $selectedItem,
-                $item->cantidad,
-            );
             $item->delete();
+            app(StockReservationService::class)->syncCart($this);
         });
     }
 
+    private function invalidateCurrentCheckout(): void
+    {
+        $candidatePurchaseId = self::query()
+            ->whereKey($this->getKey())
+            ->value('current_purchase_id');
+        $currentPurchase = $candidatePurchaseId === null
+            ? null
+            : Purchase::query()->lockForUpdate()->find($candidatePurchaseId);
+
+        /** @var self $cart */
+        $cart = self::query()->lockForUpdate()->findOrFail($this->getKey());
+
+        if ($cart->current_purchase_id !== $candidatePurchaseId) {
+            if ($cart->current_purchase_id !== null) {
+                throw ValidationException::withMessages([
+                    'cart' => __('api.purchase.checkout_in_progress'),
+                ]);
+            }
+
+            $this->current_purchase_id = null;
+
+            return;
+        }
+
+        if ($currentPurchase === null) {
+            return;
+        }
+
+        if ($currentPurchase->status === Purchase::STATUS_PAID) {
+            throw ValidationException::withMessages([
+                'cart' => __('api.cart.editing_disabled'),
+            ]);
+        }
+
+        if (in_array($currentPurchase->status, [
+            Purchase::STATUS_CREATED,
+            Purchase::STATUS_PENDING_PAYMENT,
+        ], true)) {
+            app(StockReservationService::class)->returnToCart($currentPurchase, $cart);
+            $currentPurchase->update([
+                'status' => Purchase::STATUS_SUPERSEDED,
+            ]);
+
+            $this->current_purchase_id = null;
+
+            return;
+        }
+
+        app(StockReservationService::class)->releaseForPurchase(
+            $currentPurchase,
+            reason: StockReservationService::REASON_PURCHASE_SUPERSEDED,
+        );
+        self::query()
+            ->whereKey($cart->getKey())
+            ->where('current_purchase_id', $currentPurchase->getKey())
+            ->update(['current_purchase_id' => null]);
+        $this->current_purchase_id = null;
+    }
+
     protected function resolveScopedItem(
         int $catalogItemId,
         ?int $variantId,
@@ -294,6 +400,17 @@ class Cart extends Model
                 ]);
             }
 
+            if ($catalogItem->bundleComponents()
+                ->whereNotNull('component_variant_id')
+                ->whereHas('variant', fn ($query) => $query
+                    ->whereNotNull('sales_disabled_at')
+                    ->orWhereNotNull('replaced_by_variant_id'))
+                ->exists()) {
+                throw ValidationException::withMessages([
+                    'catalog_item_id' => [__('api.cart.bundle_component_unavailable')],
+                ]);
+            }
+
             return $catalogItem;
         }
 
@@ -324,6 +441,12 @@ class Cart extends Model
             throw new NotFoundHttpException('Variant not found for catalog item.');
         }
 
+        if (! $variant->isSellable()) {
+            throw ValidationException::withMessages([
+                'variant_id' => [__('api.cart.variant_unavailable')],
+            ]);
+        }
+
         $inventory = $this->resolveInventory($variant->inventory_id, $lockForUpdate);
         $variant->setRelation('catalogItem', $catalogItem);
         $variant->setRelation('inventory', $inventory);
@@ -334,6 +457,9 @@ class Cart extends Model
     private function assertUserPurchaseLimit(
         CatalogItem|Variant $selectedItem,
         int $cartQuantity,
+        ?int $excludedPurchaseId = null,
+        int $heldQuantity = 0,
+        ?int $maximumAddableCeiling = null,
     ): void {
         if ($this->user_id === null) {
             return;
@@ -347,6 +473,10 @@ class Cart extends Model
             $catalogItem,
             $this->user_id,
             $cartQuantity,
+            $excludedPurchaseId,
+            $this->getKey(),
+            $heldQuantity,
+            $maximumAddableCeiling,
             field: 'cantidad',
         );
     }

app/Domains/Cart/Resources/CartItemResource.php

@@ -4,6 +4,8 @@ namespace App\Domains\Cart\Resources;
 
 use App\Domains\Cart\Models\CartItem;
 use App\Domains\Catalog\Enums\InventoryPolicy;
+use App\Domains\Catalog\Models\Variant;
+use App\Domains\Tenant\Models\Tenant;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 
@@ -19,12 +21,16 @@ class CartItemResource extends JsonResource
     {
         $selectedItem = $this->selectedItem();
         $imageUrl = null;
+        $tenant = $request->route('tenant');
+        $displayImage = ! $tenant instanceof Tenant || $tenant->display_cart_item_images;
+        $includeVariants = $tenant instanceof Tenant
+            && $tenant->cart_editing_policy->allowsVariantChanges();
 
-        if ($selectedItem?->relationLoaded('attachments')) {
+        if ($displayImage && $selectedItem?->relationLoaded('attachments')) {
             $imageUrl = $selectedItem->attachments->first()?->getTemporaryUrl(1440);
         }
 
-        if ($imageUrl === null && $this->catalogItem?->relationLoaded('attachments')) {
+        if ($displayImage && $imageUrl === null && $this->catalogItem?->relationLoaded('attachments')) {
             $imageUrl = $this->catalogItem->attachments->first()?->getTemporaryUrl(1440);
         }
 
@@ -36,14 +42,27 @@ class CartItemResource extends JsonResource
             'variant_id' => $this->variant_id,
             'nombre' => $selectedItem?->getName(),
             'imagen' => $imageUrl,
-            'variant' => $this->variant === null ? null : [
-                'id' => $this->variant->id,
-                'precio' => $this->formatMoney($this->variant->getPrice()),
-                'stock_tecnico' => $this->catalogItem->inventory_policy === InventoryPolicy::Unlimited
-                    ? null
-                    : $this->variant->inventory->availableStock(),
-                'values' => $this->variant->selectorOptions($this->catalogItem->itemAttributes),
-            ],
+            'variant' => $this->variant === null ? null : $this->variantData($this->variant),
+            'variants' => $this->when(
+                $includeVariants,
+                fn () => $this->catalogItem
+                    ->visibleVariants($this->variant_id)
+                    ->map(fn (Variant $variant): array => $this->variantData($variant))
+                    ->values(),
+            ),
+        ];
+    }
+
+    /** @return array<string, mixed> */
+    protected function variantData(Variant $variant): array
+    {
+        return [
+            'id' => $variant->id,
+            'precio' => $this->formatMoney($variant->precio ?? $this->catalogItem->precio),
+            'stock_tecnico' => $this->catalogItem->inventory_policy === InventoryPolicy::Unlimited
+                ? null
+                : $variant->inventory->availableStock(),
+            'values' => $variant->selectorOptions($this->catalogItem->itemAttributes),
         ];
     }
 

app/Domains/Cart/Services/CartService.php

@@ -4,10 +4,14 @@ namespace App\Domains\Cart\Services;
 
 use App\Domains\Auth\Models\User;
 use App\Domains\Cart\Models\Cart;
+use App\Domains\Catalog\Exceptions\StockReservationExpiredException;
+use App\Domains\Catalog\Services\ExpireStockReservationsService;
 use App\Domains\Tenant\Models\Tenant;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Str;
+use Illuminate\Validation\ValidationException;
 use Symfony\Component\HttpFoundation\Cookie;
 use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 
@@ -21,13 +25,13 @@ class CartService
             return $this->makeEmptyCart($tenant);
         }
 
-        $cart = $this->findCart($tenant, $resolvedIdentity['identity']);
+        $cart = $this->resolveCart($tenant, $resolvedIdentity['identity']);
 
         if ($cart === null) {
             return $this->makeEmptyCart($tenant);
         }
 
-        return $this->loadCart($cart);
+        return $this->loadCart($cart, $tenant);
     }
 
     /**
@@ -46,7 +50,7 @@ class CartService
         $cart->addItem($catalogItemId, $variantId, $quantity);
 
         return [
-            'cart' => $this->loadCart($cart),
+            'cart' => $this->loadCart($cart, $tenant),
             'guest_token' => $resolvedIdentity['generated_guest_token'],
         ];
     }
@@ -59,34 +63,58 @@ class CartService
         ?int $variantId,
         bool $updateVariant,
     ): Cart {
+        if ($updateVariant && ! $tenant->cart_editing_policy->allowsVariantChanges()) {
+            throw ValidationException::withMessages([
+                'variant_id' => __('api.cart.variant_change_disabled'),
+            ]);
+        }
+
+        if (! $updateVariant && ! $tenant->cart_editing_policy->allowsQuantityChanges()) {
+            throw ValidationException::withMessages([
+                'cantidad' => __('api.cart.editing_disabled'),
+            ]);
+        }
+
         $identity = $this->requireIdentity($request);
         $cart = $this->findCartOrFail($tenant, $identity);
         $cart->updateItem($cartItemId, $quantity, $variantId, $updateVariant);
 
-        return $this->loadCart($cart);
+        return $this->loadCart($cart, $tenant);
     }
 
     public function removeItem(Tenant $tenant, Request $request, int $cartItemId): Cart
     {
+        if (! $tenant->cart_editing_policy->allowsRemoval()) {
+            throw ValidationException::withMessages([
+                'cart_item' => __('api.cart.editing_disabled'),
+            ]);
+        }
+
         $identity = $this->requireIdentity($request);
         $cart = $this->findCartOrFail($tenant, $identity);
         $cart->removeItem($cartItemId);
 
-        return $this->loadCart($cart);
+        return $this->loadCart($cart, $tenant);
     }
 
     public function makeGuestTokenCookie(string $guestToken): Cookie
     {
-        return cookie(
-            'guest_token',
-            $guestToken,
-            60 * 24 * 180,
-            '/',
-            config('session.domain'),
-            (bool) config('session.secure'),
-            true,
-            false,
-            config('session.same_site'),
+        $secure = (bool) config('session.secure');
+        $sameSite = config('session.same_site');
+        $partitioned = (bool) config('session.partitioned')
+            || ($secure && strtolower((string) $sameSite) === 'none');
+
+        return Cookie::create(
+            name: 'guest_token',
+            value: $guestToken,
+            expire: now()->addDays(180),
+            path: '/',
+            domain: config('session.domain'),
+            secure: $secure,
+            httpOnly: true,
+            raw: false,
+            sameSite: $sameSite,
+            partitioned: $partitioned,
         );
     }
 
@@ -94,7 +122,7 @@ class CartService
     {
         $cart = new Cart([
             'tenant_codigo' => $tenant->codigo,
-            'status' => 'active',
+            'status' => Cart::STATUS_ACTIVE,
         ]);
 
         $cart->setRelation('items', collect());
@@ -102,9 +130,9 @@ class CartService
         return $cart;
     }
 
-    protected function loadCart(Cart $cart): Cart
+    protected function loadCart(Cart $cart, Tenant $tenant): Cart
     {
-        return $cart->fresh()->load([
+        $relations = [
             'items.catalogItem.attachments',
             'items.catalogItem.inventory',
             'items.catalogItem.itemAttributes.attribute',
@@ -113,7 +141,21 @@ class CartService
             'items.variant.definitions.itemAttribute.attribute.options',
             'items.variant.eventDates',
             'items.variant.eventDate',
-        ]);
+        ];
+
+        if ($tenant->cart_editing_policy->allowsVariantChanges()) {
+            $relations = [
+                ...$relations,
+                'items.catalogItem.variants' => fn ($query) => $query->orderBy('id'),
+                'items.catalogItem.variants.inventory',
+                'items.catalogItem.variants.definitions' => fn ($query) => $query->orderBy('id'),
+                'items.catalogItem.variants.definitions.itemAttribute.attribute.options',
+                'items.catalogItem.variants.eventDates',
+                'items.catalogItem.variants.eventDate',
+            ];
+        }
+
+        return $cart->fresh()->load($relations);
     }
 
     /**
@@ -181,12 +223,14 @@ class CartService
     {
         return Cart::query()
             ->where('tenant_codigo', $tenant->codigo)
-            ->where('status', 'active')
+            ->where('origin', Cart::ORIGIN_USER)
+            ->whereIn('status', [Cart::STATUS_ACTIVE, Cart::STATUS_EXPIRED])
             ->when(
                 $identity['user_id'] !== null,
                 fn ($query) => $query->where('user_id', $identity['user_id']),
                 fn ($query) => $query->where('guest_token', $identity['guest_token']),
             )
+            ->orderByRaw('CASE WHEN status = ? THEN 0 ELSE 1 END', [Cart::STATUS_ACTIVE])
             ->first();
     }
 
@@ -195,7 +239,7 @@ class CartService
      */
     protected function findCartOrFail(Tenant $tenant, array $identity): Cart
     {
-        $cart = $this->findCart($tenant, $identity);
+        $cart = $this->resolveCart($tenant, $identity, replaceExpired: false);
 
         if ($cart === null) {
             throw new NotFoundHttpException('Cart not found.');
@@ -208,10 +252,73 @@ class CartService
      * @param  array{user_id: ?int, guest_token: ?string}  $identity
      */
     protected function findOrCreateCart(Tenant $tenant, array $identity): Cart
+    {
+        return $this->resolveCart($tenant, $identity)
+            ?? $this->createCart($tenant, $identity);
+    }
+
+    /**
+     * @param  array{user_id: ?int, guest_token: ?string}  $identity
+     */
+    protected function resolveCart(
+        Tenant $tenant,
+        array $identity,
+        bool $replaceExpired = true,
+    ): ?Cart {
+        $cart = $this->findCart($tenant, $identity);
+
+        if ($cart?->status === Cart::STATUS_ACTIVE
+            && $cart->current_stock_reservation_id !== null
+            && app(ExpireStockReservationsService::class)
+                ->expireIfOverdue($cart->current_stock_reservation_id)) {
+            $cart = $this->findCart($tenant, $identity);
+        }
+
+        if ($cart?->status === Cart::STATUS_EXPIRED) {
+            if (! $replaceExpired) {
+                throw new StockReservationExpiredException;
+            }
+
+            return $this->replaceExpiredCart($cart, $tenant, $identity);
+        }
+
+        if ($cart !== null) {
+            return $cart;
+        }
+
+        return null;
+    }
+
+    /**
+     * @param  array{user_id: ?int, guest_token: ?string}  $identity
+     */
+    protected function replaceExpiredCart(Cart $expiredCart, Tenant $tenant, array $identity): Cart
+    {
+        return DB::transaction(function () use ($expiredCart, $tenant, $identity): Cart {
+            /** @var Cart|null $lockedCart */
+            $lockedCart = Cart::query()->lockForUpdate()->find($expiredCart->getKey());
+
+            if ($lockedCart?->status === Cart::STATUS_EXPIRED) {
+                $lockedCart->update([
+                    'status' => Cart::STATUS_ABANDONED,
+                    'current_purchase_id' => null,
+                ]);
+            }
+
+            return $this->findCart($tenant, $identity)
+                ?? $this->createCart($tenant, $identity);
+        });
+    }
+
+    /**
+     * @param  array{user_id: ?int, guest_token: ?string}  $identity
+     */
+    protected function createCart(Tenant $tenant, array $identity): Cart
     {
         $attributes = [
             'tenant_codigo' => $tenant->codigo,
-            'status' => 'active',
+            'status' => Cart::STATUS_ACTIVE,
+            'origin' => Cart::ORIGIN_USER,
         ];
 
         if ($identity['user_id'] !== null) {

app/Domains/Cart/Services/CartVariantReplacementService.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace App\Domains\Cart\Services;
+
+use App\Domains\Cart\Models\Cart;
+use App\Domains\Cart\Models\CartItem;
+use App\Domains\Catalog\Models\Variant;
+use App\Domains\Catalog\Services\CatalogInventoryService;
+use Illuminate\Validation\ValidationException;
+
+class CartVariantReplacementService
+{
+    public function __construct(private readonly CatalogInventoryService $inventory) {}
+
+    public function replaceHistoricalVariants(Cart $cart): void
+    {
+        $items = $cart->items()
+            ->whereNotNull('variant_id')
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get();
+
+        foreach ($items as $item) {
+            $variant = Variant::query()->lockForUpdate()->find($item->variant_id);
+
+            if ($variant === null) {
+                throw $this->unavailableVariant();
+            }
+
+            $replacement = $this->latestReplacement($variant);
+
+            if ($replacement->is($variant)) {
+                if (! $variant->isSellable()) {
+                    throw $this->unavailableVariant();
+                }
+
+                continue;
+            }
+
+            if (! $replacement->isSellable()) {
+                throw $this->unavailableVariant();
+            }
+
+            /** @var CartItem|null $targetItem */
+            $targetItem = $cart->items()
+                ->whereKeyNot($item->getKey())
+                ->where('catalog_item_id', $item->catalog_item_id)
+                ->where('variant_id', $replacement->getKey())
+                ->lockForUpdate()
+                ->first();
+
+            $replacementQuantity = $item->cantidad + ($targetItem?->cantidad ?? 0);
+            if ($replacement->inventory_id !== $variant->inventory_id) {
+                $available = $this->inventory->availableQuantity($replacement);
+
+                if ($available !== null && $available < $replacementQuantity) {
+                    throw $this->unavailableVariant();
+                }
+            }
+
+            if ($targetItem !== null) {
+                $targetItem->cantidad += $item->cantidad;
+                $targetItem->save();
+                $item->delete();
+
+                continue;
+            }
+
+            $item->update(['variant_id' => $replacement->getKey()]);
+        }
+    }
+
+    private function latestReplacement(Variant $variant): Variant
+    {
+        $current = $variant;
+        $visited = [];
+
+        while ($current->replaced_by_variant_id !== null) {
+            if (isset($visited[$current->getKey()])) {
+                throw $this->unavailableVariant();
+            }
+
+            $visited[$current->getKey()] = true;
+            $current = Variant::query()
+                ->lockForUpdate()
+                ->find($current->replaced_by_variant_id)
+                ?? throw $this->unavailableVariant();
+        }
+
+        return $current;
+    }
+
+    private function unavailableVariant(): ValidationException
+    {
+        return ValidationException::withMessages([
+            'cart_id' => [__('api.cart.cart_variant_unavailable')],
+        ]);
+    }
+}

app/Domains/Cart/Services/GuestCartMergeService.php

@@ -34,6 +34,10 @@ class GuestCartMergeService
                 ->first();
 
             if ($userCart !== null) {
+                $userCart->items()
+                    ->orderBy('id')
+                    ->pluck('id')
+                    ->each(fn (int $itemId) => $userCart->removeItem($itemId));
                 $userCart->update([
                     'status' => 'converted',
                 ]);

app/Domains/Cart/documentacion/README.md

@@ -6,8 +6,8 @@ Gestiona el carrito activo de un tenant tanto para visitantes como para usuarios
 
 ## Modelo
 
-- `Cart`: pertenece a un tenant y opcionalmente a un usuario; calcula el total y permite agregar, actualizar o quitar ítems.
-- `CartItem`: referencia un `CatalogItem` y, opcionalmente, una `Variant`; expone la selección efectiva.
+- `Cart`: pertenece a un tenant y opcionalmente a un usuario; calcula el total, permite agregar, actualizar o quitar ítems y apunta a su reserva de stock vigente mediante `current_stock_reservation_id`.
+- `CartItem`: referencia un `CatalogItem` y, opcionalmente, una `Variant`; sólo persiste la selección y cantidad, y expone siempre los datos vigentes del catálogo.
 
 ## Servicios
 
@@ -30,3 +30,9 @@ Bajo `/tenants/{tenant:codigo}`:
 ## Dependencias y reglas
 
 Depende de `Catalog` para productos y variantes, de `Tenant` para aislar datos y de `Auth` cuando existe usuario. Toda operación debe comprobar que carrito e ítem pertenecen al tenant actual.
+
+Un carrito puede pasar a `checkout`. Las compras directas usan un carrito técnico con `origin=direct_checkout`; los carritos normales conservan `origin=user` y pueden restaurarse al cancelar o vencer la compra.
+
+Cada edición sincroniza una única reserva para el carrito completo. Si varios ítems o bundles consumen el mismo inventario, se persiste una sola línea con la cantidad agregada. Al editar durante checkout, la compra anterior queda `superseded`, se desvincula y el carrito conserva la misma reserva activa con sus líneas actualizadas.
+
+El comando unificado `php artisan reservations:expire` recorre una sola vez las reservas activas cuyo `expires_at` haya vencido. Cuando pertenecen a un carrito, conserva la reserva y sus líneas como historial, libera el stock como conjunto y cambia el carrito asociado a `expired` sin eliminar sus ítems. Al volver a resolver ese carrito desde la API, el anterior pasa automáticamente a `abandoned` y se crea uno activo y vacío para la misma identidad. El cliente nunca necesita reiniciarlo explícitamente. La API también materializa este vencimiento al acceder al carrito aunque el comando programado todavía no haya corrido.

app/Domains/Catalog/Controllers/CatalogController.php

@@ -17,17 +17,20 @@ use App\Domains\Catalog\Resources\CatalogItemDetailResource;
 use App\Domains\Catalog\Resources\CatalogItemResource;
 use App\Domains\Catalog\Resources\CatalogSearchItemResource;
 use App\Domains\Catalog\Resources\CatalogVariantOptionsResource;
+use App\Domains\Catalog\Services\CatalogItemAllowanceService;
 use App\Domains\Catalog\Services\CatalogService;
 use App\Domains\Catalog\Services\FeaturedGroupService;
 use App\Domains\Catalog\Services\VariantSelectionService;
 use App\Domains\Tenant\Models\Tenant;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
+use Illuminate\Support\Facades\Auth;
 
 class CatalogController extends Controller
 {
-    public function index(Tenant $tenant, FeaturedGroupService $featuredGroupService): JsonResponse
+    public function index(Request $request, Tenant $tenant, FeaturedGroupService $featuredGroupService): JsonResponse
     {
         $featuredGroups = FeaturedGroup::query()
             ->where('tenant_code', $tenant->codigo)
@@ -37,7 +40,7 @@ class CatalogController extends Controller
         return response()->json($featuredGroups->map(
             fn (FeaturedGroup $featuredGroup): array => (new CatalogFeaturedGroupResource(
                 $featuredGroup,
-                $featuredGroupService->itemsResponse($featuredGroup, 1),
+                $featuredGroupService->itemsResponse($featuredGroup, 1, $this->userId($request)),
             ))->resolve()
         ));
     }
@@ -46,15 +49,17 @@ class CatalogController extends Controller
         SearchCatalogItemsRequest $request,
         Tenant $tenant,
         CatalogService $catalogService,
+        CatalogItemAllowanceService $allowances,
     ): AnonymousResourceCollection {
-        return CatalogSearchItemResource::collection(
-            $catalogService->search(
-                $tenant,
-                $request->validated('q'),
-                $tenant->search_items_per_page,
-                (int) $request->validated('page', 1),
-            )
+        $items = $catalogService->search(
+            $tenant,
+            $request->validated('q'),
+            $tenant->search_items_per_page,
+            (int) $request->validated('page', 1),
         );
+        $allowances->attach($items->getCollection(), $this->userId($request));
+
+        return CatalogSearchItemResource::collection($items);
     }
 
     public function category(
@@ -62,17 +67,19 @@ class CatalogController extends Controller
         Tenant $tenant,
         Category $category,
         CatalogService $catalogService,
+        CatalogItemAllowanceService $allowances,
     ): AnonymousResourceCollection {
         abort_unless($category->tenant_code === $tenant->codigo, 404);
 
-        return CatalogSearchItemResource::collection(
-            $catalogService->categoryItems(
-                $tenant,
-                $category,
-                $tenant->search_items_per_page,
-                (int) $request->validated('page', 1),
-            )
-        )->additional([
+        $items = $catalogService->categoryItems(
+            $tenant,
+            $category,
+            $tenant->search_items_per_page,
+            (int) $request->validated('page', 1),
+        );
+        $allowances->attach($items->getCollection(), $this->userId($request));
+
+        return CatalogSearchItemResource::collection($items)->additional([
             'category' => [
                 'id' => $category->id,
                 'nombre' => $category->nombre,
@@ -93,7 +100,11 @@ class CatalogController extends Controller
 
         $page = (int) $request->validated('page', 1);
 
-        return response()->json($featuredGroupService->itemsResponse($featuredGroup, $page));
+        return response()->json($featuredGroupService->itemsResponse(
+            $featuredGroup,
+            $page,
+            $this->userId($request),
+        ));
     }
 
     public function show(
@@ -101,17 +112,19 @@ class CatalogController extends Controller
         Tenant $tenant,
         CatalogItem $catalogItem,
         CatalogService $catalogService,
+        CatalogItemAllowanceService $allowances,
     ): CatalogItemDetailResource {
         abort_unless($catalogItem->tenant_code === $tenant->codigo, 404);
 
         $variantId = $request->validated('variant_id');
 
-        return CatalogItemDetailResource::make(
-            $catalogService->getDetail(
-                $catalogItem,
-                $variantId === null ? null : (int) $variantId,
-            )
+        $item = $catalogService->getDetail(
+            $catalogItem,
+            $variantId === null ? null : (int) $variantId,
         );
+        $allowances->attach(collect([$item]), $this->userId($request));
+
+        return CatalogItemDetailResource::make($item);
     }
 
     public function variantOptions(
@@ -164,4 +177,11 @@ class CatalogController extends Controller
             ->response()
             ->setStatusCode(201);
     }
+
+    private function userId(Request $request): ?int
+    {
+        $userId = $request->user()?->getAuthIdentifier() ?? Auth::guard('sanctum')->id();
+
+        return $userId === null ? null : (int) $userId;
+    }
 }

app/Domains/Catalog/Exceptions/StockReservationExpiredException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Domains\Catalog\Exceptions;
+
+use RuntimeException;
+
+class StockReservationExpiredException extends RuntimeException
+{
+    public function __construct()
+    {
+        parent::__construct(__('api.cart.reservation_expired'));
+    }
+}

app/Domains/Catalog/Models/Attribute.php

@@ -59,6 +59,8 @@ class Attribute extends Model
     public function eventDates(): HasMany
     {
         return $this->hasMany(EventDate::class, 'tenant_code', 'tenant_codigo')
+            ->whereNull('rescheduled_to_event_date_id')
+            ->whereNull('suspended_at')
             ->orderBy('date')
             ->orderBy('time_start');
     }

app/Domains/Catalog/Models/CatalogItem.php

@@ -27,6 +27,7 @@ use Illuminate\Support\Collection;
     'type',
     'slug',
     'nombre',
+    'group_order',
     'descripcion',
     'precio',
     'inventory_policy',
@@ -47,6 +48,7 @@ class CatalogItem extends Model
         'inventory_policy' => InventoryPolicy::Tracked->value,
         'inventory_subject' => InventorySubject::Product->value,
         'has_tickets' => false,
+        'group_order' => 0,
     ];
 
     protected function casts(): array
@@ -56,6 +58,7 @@ 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,
@@ -172,17 +175,45 @@ class CatalogItem extends Model
     }
 
     /** @param Builder<CatalogItem> $query */
-    public function scopeWhereVariantsAvailable(Builder $query): Builder
+    public function scopeWhereAvailable(Builder $query): Builder
     {
         return $query->where(function (Builder $query): void {
             $query
-                ->whereDoesntHave('variants')
-                ->orWhere('catalog_items.inventory_policy', InventoryPolicy::Unlimited->value)
+                ->where(function (Builder $unlimitedQuery): void {
+                    $unlimitedQuery
+                        ->where('catalog_items.inventory_policy', InventoryPolicy::Unlimited->value)
+                        ->where(function (Builder $selectionQuery): void {
+                            $selectionQuery
+                                ->whereDoesntHave('variants')
+                                ->orWhereHas('variants', fn (Builder $variantQuery): Builder => $variantQuery
+                                    ->whereNull('sales_disabled_at')
+                                    ->whereNull('replaced_by_variant_id'));
+                        });
+                })
                 ->orWhereHas(
-                    'variants.inventory',
-                    fn (Builder $inventoryQuery): Builder => $inventoryQuery
-                        ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock')
-                );
+                    'variants',
+                    fn (Builder $variantQuery): Builder => $variantQuery
+                        ->whereNull('sales_disabled_at')
+                        ->whereNull('replaced_by_variant_id')
+                        ->whereHas(
+                            'inventory',
+                            fn (Builder $inventoryQuery): Builder => $inventoryQuery
+                                ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock')
+                        )
+                )
+                ->orWhere(function (Builder $directItemQuery): void {
+                    $directItemQuery
+                        ->whereDoesntHave('variants')
+                        ->where(function (Builder $inventoryQuery): void {
+                            $inventoryQuery
+                                ->whereNull('catalog_items.inventory_id')
+                                ->orWhereHas(
+                                    'inventory',
+                                    fn (Builder $availableInventoryQuery): Builder => $availableInventoryQuery
+                                        ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock')
+                                );
+                        });
+                });
         });
     }
 
@@ -190,9 +221,12 @@ class CatalogItem extends Model
     public function visibleVariants(?int $includedVariantId = null): Collection
     {
         return $this->variants
-            ->filter(fn (Variant $variant): bool => ($includedVariantId !== null && $variant->id === $includedVariantId)
-                || $this->inventory_policy === InventoryPolicy::Unlimited
-                || ($variant->inventory?->availableStock() ?? 0) > 0)
+            ->filter(fn (Variant $variant): bool => $variant->hasOnlyActiveEventDates()
+                && (($includedVariantId !== null && $variant->id === $includedVariantId)
+                    || ($variant->isSellable() && (
+                        $this->inventory_policy === InventoryPolicy::Unlimited
+                        || ($variant->inventory?->availableStock() ?? 0) > 0
+                    ))))
             ->values();
     }
 

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/Models/FeaturedGroup.php

@@ -11,9 +11,11 @@ use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Support\Str;
 
 #[Fillable([
     'tenant_code',
+    'code',
     'source_type',
     'category_id',
     'product_layout',
@@ -33,6 +35,29 @@ class FeaturedGroup extends Model
         'source_type' => FeaturedGroupSource::Manual->value,
     ];
 
+    protected static function booted(): void
+    {
+        static::creating(function (FeaturedGroup $featuredGroup): void {
+            if (filled($featuredGroup->code)) {
+                return;
+            }
+
+            $baseCode = Str::slug($featuredGroup->group_name) ?: 'group';
+            $code = $baseCode;
+            $suffix = 2;
+
+            while (static::query()
+                ->where('tenant_code', $featuredGroup->tenant_code)
+                ->where('code', $code)
+                ->exists()) {
+                $code = "{$baseCode}-{$suffix}";
+                $suffix++;
+            }
+
+            $featuredGroup->code = $code;
+        });
+    }
+
     protected function casts(): array
     {
         return [

app/Domains/Catalog/Models/Inventory.php

@@ -5,6 +5,7 @@ namespace App\Domains\Catalog\Models;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Database\Eloquent\Relations\HasOne;
 
 #[Fillable([
@@ -41,10 +42,16 @@ class Inventory extends Model
         return $this->hasOne(CatalogItem::class);
     }
 
-    /** @return HasOne<Variant, $this> */
-    public function variant(): HasOne
+    /** @return HasMany<Variant, $this> */
+    public function variants(): HasMany
     {
-        return $this->hasOne(Variant::class);
+        return $this->hasMany(Variant::class);
+    }
+
+    /** @return HasMany<StockReservationLine, $this> */
+    public function stockReservationLines(): HasMany
+    {
+        return $this->hasMany(StockReservationLine::class);
     }
 
     public function availableStock(): int

app/Domains/Catalog/Models/ItemAttribute.php

@@ -14,6 +14,7 @@ use Illuminate\Database\Eloquent\Relations\HasMany;
     'allow_multi_select',
     'sort_order',
     'show_in_selector',
+    'ticket_label',
 ])]
 class ItemAttribute extends Model
 {

app/Domains/Catalog/Models/StockReservation.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Domains\Catalog\Models;
+
+use App\Domains\Cart\Models\Cart;
+use App\Domains\Purchase\Models\Purchase;
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasOne;
+
+#[Fillable([
+    'status',
+    'expires_at',
+    'committed_at',
+    'released_at',
+    'expired_at',
+    'release_reason',
+])]
+class StockReservation extends Model
+{
+    public const STATUS_ACTIVE = 'active';
+
+    public const STATUS_COMMITTED = 'committed';
+
+    public const STATUS_RELEASED = 'released';
+
+    public const STATUS_EXPIRED = 'expired';
+
+    protected function casts(): array
+    {
+        return [
+            'expires_at' => 'datetime',
+            'committed_at' => 'datetime',
+            'released_at' => 'datetime',
+            'expired_at' => 'datetime',
+        ];
+    }
+
+    /** @return HasMany<StockReservationLine, $this> */
+    public function lines(): HasMany
+    {
+        return $this->hasMany(StockReservationLine::class);
+    }
+
+    /** @return HasOne<Cart, $this> */
+    public function currentCart(): HasOne
+    {
+        return $this->hasOne(Cart::class, 'current_stock_reservation_id');
+    }
+
+    /** @return HasOne<Purchase, $this> */
+    public function purchase(): HasOne
+    {
+        return $this->hasOne(Purchase::class);
+    }
+}

app/Domains/Catalog/Models/StockReservationLine.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Domains\Catalog\Models;
+
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+#[Fillable([
+    'stock_reservation_id',
+    'inventory_id',
+    'quantity',
+    'tracks_inventory',
+])]
+class StockReservationLine extends Model
+{
+    protected function casts(): array
+    {
+        return [
+            'stock_reservation_id' => 'integer',
+            'inventory_id' => 'integer',
+            'quantity' => 'integer',
+            'tracks_inventory' => 'boolean',
+        ];
+    }
+
+    /** @return BelongsTo<StockReservation, $this> */
+    public function reservation(): BelongsTo
+    {
+        return $this->belongsTo(StockReservation::class, 'stock_reservation_id');
+    }
+
+    /** @return BelongsTo<Inventory, $this> */
+    public function inventory(): BelongsTo
+    {
+        return $this->belongsTo(Inventory::class);
+    }
+}

app/Domains/Catalog/Models/Variant.php

@@ -20,6 +20,8 @@ use Illuminate\Support\Str;
     'catalog_item_id',
     'event_date_id',
     'inventory_id',
+    'replaced_by_variant_id',
+    'sales_disabled_at',
     'descripcion',
     'precio',
 ])]
@@ -37,6 +39,8 @@ class Variant extends Model
             'catalog_item_id' => 'integer',
             'event_date_id' => 'integer',
             'inventory_id' => 'integer',
+            'replaced_by_variant_id' => 'integer',
+            'sales_disabled_at' => 'datetime',
             'precio' => 'decimal:2',
         ];
     }
@@ -76,6 +80,39 @@ class Variant extends Model
         return $this->belongsTo(Inventory::class);
     }
 
+    /** @return BelongsTo<Variant, $this> */
+    public function replacement(): BelongsTo
+    {
+        return $this->belongsTo(self::class, 'replaced_by_variant_id');
+    }
+
+    /** @return HasMany<Variant, $this> */
+    public function replacedVariants(): HasMany
+    {
+        return $this->hasMany(self::class, 'replaced_by_variant_id');
+    }
+
+    public function isSellable(): bool
+    {
+        return $this->sales_disabled_at === null
+            && $this->replaced_by_variant_id === null
+            && $this->hasOnlyActiveEventDates();
+    }
+
+    public function hasOnlyActiveEventDates(): bool
+    {
+        if (! $this->exists
+            && $this->event_date_id === null
+            && ! $this->relationLoaded('eventDates')) {
+            return true;
+        }
+
+        return $this->selectedEventDates()->every(
+            fn (EventDate $eventDate): bool => $eventDate->rescheduled_to_event_date_id === null
+                && $eventDate->suspended_at === null,
+        );
+    }
+
     /** @return HasMany<VariantDefinition, $this> */
     public function definitions(): HasMany
     {

app/Domains/Catalog/Requests/StoreCatalogItemRequest.php

@@ -51,6 +51,7 @@ 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/AdminApp/OnTicketFeaturedGroupResource.php

@@ -15,6 +15,7 @@ class OnTicketFeaturedGroupResource extends JsonResource
     {
         return [
             'id' => $this->id,
+            'code' => $this->code,
             'category_id' => $this->category_id,
             'category_name' => $this->category->nombre,
             'group_name' => $this->group_name,

app/Domains/Catalog/Resources/CatalogFeaturedGroupResource.php

@@ -20,6 +20,7 @@ class CatalogFeaturedGroupResource extends JsonResource
     {
         return [
             'id' => $this->id,
+            'code' => $this->code,
             'title' => $this->group_name,
             'layout' => $this->product_layout->value,
             'group_layout' => $this->group_layout->value,

app/Domains/Catalog/Resources/CatalogFeaturedItemResource.php

@@ -7,6 +7,7 @@ use App\Domains\Catalog\Enums\ProductLayout;
 use App\Domains\Catalog\Models\CatalogItem;
 use App\Domains\Catalog\Models\FeaturedGroup;
 use App\Domains\Catalog\Models\Variant;
+use App\Domains\Catalog\Services\CatalogItemAllowanceService;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 
@@ -28,27 +29,48 @@ class CatalogFeaturedItemResource extends JsonResource
             return $this->ticketSelectorData($catalogItem);
         }
 
+        $remainingUserQuota = $catalogItem->getAttribute('remaining_user_quota');
+        $availableStock = $catalogItem->availableStock();
+
         $data = [
             'id' => $catalogItem->id,
             'type' => $catalogItem->type->value,
             'nombre' => $catalogItem->nombre,
             'descripcion' => $catalogItem->descripcion,
             'precio' => $catalogItem->precio,
-            'stock_tecnico' => $catalogItem->availableStock(),
+            'maximum_addable_quantity' => $this->maximumAddable(
+                $availableStock,
+                $remainingUserQuota,
+            ),
+            'unavailable_message' => $this->unavailableMessage(
+                $availableStock,
+                $remainingUserQuota,
+            ),
             'variants' => $catalogItem->visibleVariants()
-                ->map(fn (Variant $variant): array => [
-                    'id' => $variant->id,
-                    'event_date_id' => $variant->event_date_id,
-                    'event_date' => $variant->eventDate?->date?->format('Y-m-d'),
-                    'event_date_ids' => $variant->selectedEventDates()->pluck('id')->values(),
-                    'event_dates' => $variant->selectedEventDates()->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
-                    'descripcion' => $variant->getDescription(),
-                    'precio' => number_format($variant->getPrice(), 2, '.', ''),
-                    'stock_tecnico' => $catalogItem->inventory_policy === InventoryPolicy::Unlimited
+                ->map(function (Variant $variant) use ($catalogItem, $remainingUserQuota): array {
+                    $variantStock = $catalogItem->inventory_policy === InventoryPolicy::Unlimited
                         ? null
-                        : $variant->inventory->availableStock(),
-                    'values' => $variant->selectorOptions($catalogItem->itemAttributes),
-                ])
+                        : $variant->inventory->availableStock();
+
+                    return [
+                        'id' => $variant->id,
+                        'event_date_id' => $variant->event_date_id,
+                        'event_date' => $variant->eventDate?->date?->format('Y-m-d'),
+                        'event_date_ids' => $variant->selectedEventDates()->pluck('id')->values(),
+                        '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,
+                        ),
+                        'values' => $variant->selectorOptions($catalogItem->itemAttributes),
+                    ];
+                })
                 ->values(),
         ];
 
@@ -58,6 +80,9 @@ class CatalogFeaturedItemResource extends JsonResource
     /** @return array<string, mixed> */
     private function ticketSelectorData(CatalogItem $catalogItem): array
     {
+        $availableStock = $catalogItem->availableStock();
+        $remainingUserQuota = $catalogItem->getAttribute('remaining_user_quota');
+
         return [
             'id' => $catalogItem->id,
             'type' => $catalogItem->type->value,
@@ -65,28 +90,47 @@ 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),
         ];
     }
 
     /** @return array<string, mixed> */
     private function columnWithImageData(CatalogItem $catalogItem): array
     {
+        $availableStock = $catalogItem->availableStock();
+        $remainingUserQuota = $catalogItem->getAttribute('remaining_user_quota');
+
         return [
             'id' => $catalogItem->id,
             'type' => $catalogItem->type->value,
             'nombre' => $catalogItem->nombre,
             'precio' => $catalogItem->precio,
             'image' => $this->firstImageUrl($catalogItem),
+            'maximum_addable_quantity' => $this->maximumAddable($availableStock, $remainingUserQuota),
+            'unavailable_message' => $this->unavailableMessage($availableStock, $remainingUserQuota),
         ];
     }
 
     private function firstImageUrl(CatalogItem $catalogItem): ?string
     {
         $attachment = $catalogItem->attachments->first()
-            ?? $catalogItem->variants
+            ?? $catalogItem->visibleVariants()
                 ->flatMap(fn (Variant $variant) => $variant->attachments)
                 ->first();
 
         return $attachment?->getTemporaryUrl(1440);
     }
+
+    private function maximumAddable(?int $stock, ?int $remainingUserQuota): ?int
+    {
+        return app(CatalogItemAllowanceService::class)
+            ->maximumAddableQuantity($stock, $remainingUserQuota);
+    }
+
+    private function unavailableMessage(?int $stock, ?int $remainingUserQuota): ?string
+    {
+        return app(CatalogItemAllowanceService::class)
+            ->unavailableMessage($stock, $remainingUserQuota);
+    }
 }

app/Domains/Catalog/Resources/CatalogItemDetailResource.php

@@ -6,6 +6,7 @@ use App\Domains\Catalog\Enums\InventoryPolicy;
 use App\Domains\Catalog\Models\CatalogItem;
 use App\Domains\Catalog\Models\ItemAttribute;
 use App\Domains\Catalog\Models\Variant;
+use App\Domains\Catalog\Services\CatalogItemAllowanceService;
 use App\Domains\Shared\Enums\FieldType;
 use App\Domains\Ticket\Resources\ValidityTimeResource;
 use Illuminate\Http\Request;
@@ -37,15 +38,19 @@ class CatalogItemDetailResource extends JsonResource
             'max_units_per_user' => $this->max_units_per_user,
             'has_tickets' => $this->has_tickets,
             'attributes' => $this->attributesData(),
-            'stock_tecnico' => $this->when(
+            'maximum_addable_quantity' => $this->when(
                 $selectedVariant === null,
-                fn () => $this->availableStock(),
+                fn () => $this->maximumAddable($this->availableStock()),
+            ),
+            'unavailable_message' => $this->when(
+                $selectedVariant === null,
+                fn () => $this->unavailableMessage($this->availableStock()),
             ),
             'images' => $this->when(
                 $selectedVariant === null,
                 fn () => $this->imageUrls($this->attachments),
             ),
-            'variants' => $this->visibleVariants()
+            'variants' => $this->variants
                 ->map(fn (Variant $variant): array => $this->variantData($variant))
                 ->values(),
             'selected_variant' => $this->when(
@@ -85,6 +90,7 @@ class CatalogItemDetailResource extends JsonResource
             'nombre' => $attribute->nombre,
             'sort_order' => $itemAttribute->sort_order,
             'show_in_selector' => $itemAttribute->show_in_selector,
+            'ticket_label' => $itemAttribute->ticket_label,
             'is_required' => $attribute->is_required,
             'allow_multi_select' => $itemAttribute->allow_multi_select,
             'metadata_schema' => $attribute->metadata_schema,
@@ -157,6 +163,7 @@ class CatalogItemDetailResource extends JsonResource
     {
         $values = $variant->selectionOptions($this->itemAttributes);
         $eventDates = $variant->selectedEventDates();
+        $variantStock = $this->variantStock($variant);
 
         return [
             'id' => $variant->id,
@@ -166,7 +173,8 @@ 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, '.', ''),
-            'stock_tecnico' => $this->variantStock($variant),
+            'maximum_addable_quantity' => $this->maximumAddable($variantStock),
+            'unavailable_message' => $this->unavailableMessage($variantStock),
             'values' => $values,
         ];
     }
@@ -185,4 +193,20 @@ class CatalogItemDetailResource extends JsonResource
             ? null
             : $variant->inventory->availableStock();
     }
+
+    private function maximumAddable(?int $stock): ?int
+    {
+        return app(CatalogItemAllowanceService::class)->maximumAddableQuantity(
+            $stock,
+            $this->getAttribute('remaining_user_quota'),
+        );
+    }
+
+    private function unavailableMessage(?int $stock): ?string
+    {
+        return app(CatalogItemAllowanceService::class)->unavailableMessage(
+            $stock,
+            $this->getAttribute('remaining_user_quota'),
+        );
+    }
 }

app/Domains/Catalog/Resources/CatalogSearchItemResource.php

@@ -5,6 +5,7 @@ namespace App\Domains\Catalog\Resources;
 use App\Domains\Catalog\Enums\InventoryPolicy;
 use App\Domains\Catalog\Models\CatalogItem;
 use App\Domains\Catalog\Models\Variant;
+use App\Domains\Catalog\Services\CatalogItemAllowanceService;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 
@@ -14,8 +15,10 @@ class CatalogSearchItemResource extends JsonResource
     /** @return array<string, mixed> */
     public function toArray(Request $request): array
     {
+        $availableStock = $this->availableStock();
+        $visibleVariants = $this->visibleVariants();
         $attachment = $this->attachments->first()
-            ?? $this->variants
+            ?? $visibleVariants
                 ->flatMap(fn (Variant $variant) => $variant->attachments)
                 ->first();
 
@@ -26,22 +29,44 @@ class CatalogSearchItemResource extends JsonResource
             'descripcion' => $this->descripcion,
             'precio' => $this->precio,
             'image' => $attachment?->getTemporaryUrl(1440),
-            'stock_tecnico' => $this->availableStock(),
-            'variants' => $this->visibleVariants()
-                ->map(fn (Variant $variant): array => [
-                    'id' => $variant->id,
-                    'event_date_id' => $variant->event_date_id,
-                    'event_date' => $variant->eventDate?->date?->format('Y-m-d'),
-                    'event_date_ids' => $variant->selectedEventDates()->pluck('id')->values(),
-                    'event_dates' => $variant->selectedEventDates()->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
-                    'descripcion' => $variant->getDescription(),
-                    'precio' => number_format($variant->getPrice(), 2, '.', ''),
-                    'stock_tecnico' => $this->inventory_policy === InventoryPolicy::Unlimited
+            'maximum_addable_quantity' => $this->maximumAddable($availableStock),
+            'unavailable_message' => $this->unavailableMessage($availableStock),
+            'variants' => $visibleVariants
+                ->map(function (Variant $variant): array {
+                    $variantStock = $this->inventory_policy === InventoryPolicy::Unlimited
                         ? null
-                        : $variant->inventory?->availableStock(),
-                    'values' => $variant->selectorOptions($this->itemAttributes),
-                ])
+                        : $variant->inventory?->availableStock();
+
+                    return [
+                        'id' => $variant->id,
+                        'event_date_id' => $variant->event_date_id,
+                        'event_date' => $variant->eventDate?->date?->format('Y-m-d'),
+                        'event_date_ids' => $variant->selectedEventDates()->pluck('id')->values(),
+                        '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),
+                        'values' => $variant->selectorOptions($this->itemAttributes),
+                    ];
+                })
                 ->values(),
         ];
     }
+
+    private function maximumAddable(?int $stock): ?int
+    {
+        return app(CatalogItemAllowanceService::class)->maximumAddableQuantity(
+            $stock,
+            $this->getAttribute('remaining_user_quota'),
+        );
+    }
+
+    private function unavailableMessage(?int $stock): ?string
+    {
+        return app(CatalogItemAllowanceService::class)->unavailableMessage(
+            $stock,
+            $this->getAttribute('remaining_user_quota'),
+        );
+    }
 }

app/Domains/Catalog/Services/CatalogInventoryService.php

@@ -12,6 +12,37 @@ use Illuminate\Support\Facades\DB;
 
 class CatalogInventoryService
 {
+    /** @return array<int, int> */
+    public function requirementsFor(CatalogItem|Variant $selection, int $quantity = 1): array
+    {
+        if ($quantity <= 0) {
+            throw new \InvalidArgumentException('La cantidad debe ser mayor a cero.');
+        }
+
+        return array_map(
+            fn (array $requirement): int => $requirement['quantity'] * $quantity,
+            $this->inventoryRequirements($selection),
+        );
+    }
+
+    /**
+     * @return array<int, array{quantity: int, tracks_inventory: bool}>
+     */
+    public function detailedRequirementsFor(CatalogItem|Variant $selection, int $quantity = 1): array
+    {
+        if ($quantity <= 0) {
+            throw new \InvalidArgumentException('La cantidad debe ser mayor a cero.');
+        }
+
+        return array_map(
+            fn (array $requirement): array => [
+                ...$requirement,
+                'quantity' => $requirement['quantity'] * $quantity,
+            ],
+            $this->inventoryRequirements($selection),
+        );
+    }
+
     public function availableQuantity(CatalogItem|Variant $selection): ?int
     {
         if ($selection instanceof CatalogItem
@@ -32,9 +63,14 @@ class CatalogInventoryService
 
             $selection->loadMissing('variants.inventory');
 
-            return $selection->variants->sum(
-                fn (Variant $variant): int => $variant->inventory->availableStock(),
-            );
+            return $selection->variants
+                ->filter(fn (Variant $variant): bool => $variant->isSellable())
+                ->unique(fn (Variant $variant): string => $variant->inventory_id === null
+                    ? 'object:'.spl_object_id($variant->inventory)
+                    : 'id:'.$variant->inventory_id)
+                ->sum(
+                    fn (Variant $variant): int => $variant->inventory->availableStock(),
+                );
         }
 
         $requirements = $this->inventoryRequirements($selection);

app/Domains/Catalog/Services/CatalogItemAllowanceService.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Domains\Catalog\Services;
+
+use App\Domains\Catalog\Models\CatalogItem;
+use App\Domains\Purchase\Services\UserPurchaseLimitService;
+use Illuminate\Support\Collection;
+
+class CatalogItemAllowanceService
+{
+    private const USER_QUOTA_REACHED_MESSAGE = 'Alcanzaste el cupo máximo permitido para este producto.';
+
+    private const OUT_OF_STOCK_MESSAGE = 'Este producto no tiene stock disponible.';
+
+    public function __construct(
+        private readonly UserPurchaseLimitService $purchaseLimits,
+    ) {}
+
+    /** @param Collection<int, CatalogItem> $catalogItems */
+    public function attach(Collection $catalogItems, ?int $userId): void
+    {
+        $remaining = $this->purchaseLimits->remainingByCatalogItem($catalogItems, $userId);
+
+        foreach ($catalogItems as $catalogItem) {
+            $catalogItem->setAttribute(
+                'remaining_user_quota',
+                $remaining->get($catalogItem->getKey()),
+            );
+        }
+    }
+
+    public function maximumAddableQuantity(?int $availableStock, ?int $remainingUserQuota): ?int
+    {
+        if ($availableStock === null) {
+            return $remainingUserQuota;
+        }
+
+        if ($remainingUserQuota === null) {
+            return $availableStock;
+        }
+
+        return min($availableStock, $remainingUserQuota);
+    }
+
+    public function unavailableMessage(?int $availableStock, ?int $remainingUserQuota): ?string
+    {
+        if ($remainingUserQuota !== null && $remainingUserQuota <= 0) {
+            return self::USER_QUOTA_REACHED_MESSAGE;
+        }
+
+        if ($availableStock !== null && $availableStock <= 0) {
+            return self::OUT_OF_STOCK_MESSAGE;
+        }
+
+        return null;
+    }
+}

app/Domains/Catalog/Services/CatalogService.php

@@ -38,6 +38,7 @@ class CatalogService
             $attributeCodes = $data['attribute_codes'] ?? [];
             $multiSelectAttributeCodes = $data['multi_select_attribute_codes'] ?? [];
             $hiddenAttributeCodes = $data['hidden_attribute_codes'] ?? [];
+            $ticketAttributeLabels = $data['ticket_attribute_labels'] ?? [];
             $components = $data['components'] ?? [];
             $hasDirectStock = array_key_exists('real_stock', $data);
             $realStock = (int) ($data['real_stock'] ?? 0);
@@ -73,6 +74,14 @@ class CatalogService
                 ]);
             }
 
+            if (array_diff(array_keys($ticketAttributeLabels), $attributeCodes) !== []) {
+                throw ValidationException::withMessages([
+                    'ticket_attribute_labels' => [
+                        __('api.catalog.ticket_label_attribute_not_on_item'),
+                    ],
+                ]);
+            }
+
             $this->validateUniqueVariantCombinations($variants, $attributeCodes);
 
             if ($type === CatalogItemType::Bundle) {
@@ -98,6 +107,7 @@ class CatalogService
                 $data['attribute_codes'],
                 $data['multi_select_attribute_codes'],
                 $data['hidden_attribute_codes'],
+                $data['ticket_attribute_labels'],
                 $data['components'],
                 $data['real_stock'],
                 $data['reserved_stock'],
@@ -124,6 +134,7 @@ class CatalogService
                     $attributeCodes,
                     $multiSelectAttributeCodes,
                     $hiddenAttributeCodes,
+                    $ticketAttributeLabels,
                 )
                 : [];
 
@@ -194,6 +205,14 @@ class CatalogService
         ]);
 
         $visibleVariants = $catalogItem->visibleVariants();
+        if ($catalogItem->type === CatalogItemType::Standard
+            && ($catalogItem->inventory_id !== null || $catalogItem->variants->isNotEmpty())
+            && (($catalogItem->variants->isNotEmpty() && $visibleVariants->isEmpty())
+                || ! $catalogItem->isAvailable())) {
+            throw new NotFoundHttpException('Catalog item is out of stock.');
+        }
+
+        $catalogItem->setRelation('variants', $visibleVariants);
         $selectedVariant = $variantId === null
             ? $visibleVariants->first()
             : $visibleVariants->firstWhere('id', $variantId);
@@ -220,7 +239,7 @@ class CatalogService
 
         $paginator = CatalogItem::query()
             ->where('tenant_code', $tenant->codigo)
-            ->whereVariantsAvailable()
+            ->whereAvailable()
             ->where(function (Builder $query) use ($containsPattern): void {
                 $query
                     ->whereRaw('LOWER(nombre) LIKE ?', [$containsPattern])
@@ -270,7 +289,7 @@ class CatalogService
         return CatalogItem::query()
             ->where('tenant_code', $tenant->codigo)
             ->where('category_id', $category->id)
-            ->whereVariantsAvailable()
+            ->whereAvailable()
             ->with([
                 'attachments',
                 'inventory',
@@ -306,9 +325,13 @@ class CatalogService
                 ->findOrFail($variant->catalog_item_id);
             $variant->delete();
 
-            if (! $catalogItem->variants()->exists()) {
+            $sellableVariants = $catalogItem->variants()
+                ->whereNull('sales_disabled_at')
+                ->whereNull('replaced_by_variant_id');
+
+            if (! (clone $sellableVariants)->exists()) {
                 $this->delete($catalogItem);
-            } elseif (($minimumPrice = $catalogItem->variants()->min('precio')) !== null) {
+            } elseif (($minimumPrice = (clone $sellableVariants)->min('precio')) !== null) {
                 $catalogItem->update(['precio' => $minimumPrice]);
             }
 
@@ -381,7 +404,11 @@ class CatalogService
                 ]);
             }
 
-            if ($variantId !== null && ! $componentItem->variants()->whereKey($variantId)->exists()) {
+            if ($variantId !== null && ! $componentItem->variants()
+                ->whereKey($variantId)
+                ->whereNull('sales_disabled_at')
+                ->whereNull('replaced_by_variant_id')
+                ->exists()) {
                 throw ValidationException::withMessages([
                     "components.{$index}.variant_id" => [
                         __('api.catalog.component_variant_invalid'),
@@ -461,6 +488,7 @@ class CatalogService
      * @param  array<int, string>  $attributeCodes
      * @param  array<int, string>  $multiSelectAttributeCodes
      * @param  array<int, string>  $hiddenAttributeCodes
+     * @param  array<string, string>  $ticketAttributeLabels
      * @return array<string, ItemAttribute>
      */
     private function createItemAttributes(
@@ -468,6 +496,7 @@ class CatalogService
         array $attributeCodes,
         array $multiSelectAttributeCodes = [],
         array $hiddenAttributeCodes = [],
+        array $ticketAttributeLabels = [],
     ): array {
         $itemAttributes = [];
         $attributeCodes = array_values(array_unique($attributeCodes));
@@ -492,6 +521,7 @@ class CatalogService
                 'attribute_id' => $attribute->id,
                 'allow_multi_select' => in_array($attributeCode, $multiSelectAttributeCodes, true),
                 'show_in_selector' => ! in_array($attributeCode, $hiddenAttributeCodes, true),
+                'ticket_label' => $ticketAttributeLabels[$attributeCode] ?? null,
             ]);
 
             $itemAttributes[$attributeCode] = $itemAttribute;

app/Domains/Catalog/Services/ExpireStockReservationsService.php

@@ -0,0 +1,185 @@
+<?php
+
+namespace App\Domains\Catalog\Services;
+
+use App\Domains\Cart\Models\Cart;
+use App\Domains\Catalog\Models\StockReservation;
+use App\Domains\Purchase\Models\Purchase;
+use App\Domains\Purchase\Services\Checkout\ReleaseCheckoutService;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+use RuntimeException;
+use Throwable;
+
+class ExpireStockReservationsService
+{
+    private const BATCH_SIZE = 500;
+
+    public function __construct(
+        private readonly ReleaseCheckoutService $purchases,
+        private readonly StockReservationService $reservations,
+    ) {}
+
+    /**
+     * @return array{purchases: int, cart_reservations: int, orphan_reservations: int, failed: int}
+     */
+    public function expireOverdue(): array
+    {
+        $summary = [
+            'purchases' => 0,
+            'cart_reservations' => 0,
+            'orphan_reservations' => 0,
+            'failed' => 0,
+        ];
+        $lastReservationId = 0;
+
+        do {
+            $reservationIds = StockReservation::query()
+                ->where('status', StockReservation::STATUS_ACTIVE)
+                ->whereNotNull('expires_at')
+                ->where('expires_at', '<=', now())
+                ->where('id', '>', $lastReservationId)
+                ->orderBy('id')
+                ->limit(self::BATCH_SIZE)
+                ->pluck('id');
+
+            foreach ($reservationIds as $reservationId) {
+                $lastReservationId = (int) $reservationId;
+
+                try {
+                    $owner = $this->expireReservation($lastReservationId);
+                    if ($owner !== null) {
+                        $summary[$owner]++;
+                    }
+                } catch (Throwable $exception) {
+                    $summary['failed']++;
+                    Log::channel('commands')->error('Failed to expire overdue stock reservation.', [
+                        'command' => 'reservations:expire',
+                        'stock_reservation_id' => $lastReservationId,
+                        'exception' => $exception,
+                    ]);
+                }
+            }
+        } while ($reservationIds->count() === self::BATCH_SIZE);
+
+        Log::channel('commands')->info('Stock reservation cleanup completed.', [
+            'command' => 'reservations:expire',
+            'expired_purchases' => $summary['purchases'],
+            'expired_cart_reservations' => $summary['cart_reservations'],
+            'expired_orphan_reservations' => $summary['orphan_reservations'],
+            'failed_reservations' => $summary['failed'],
+            'total_expired' => $summary['purchases']
+                + $summary['cart_reservations']
+                + $summary['orphan_reservations'],
+        ]);
+
+        return $summary;
+    }
+
+    public function expireIfOverdue(int $reservationId): bool
+    {
+        /** @var StockReservation|null $reservation */
+        $reservation = StockReservation::query()->find($reservationId);
+        if ($reservation?->status === StockReservation::STATUS_EXPIRED) {
+            return true;
+        }
+        if (! $this->isOverdue($reservation)) {
+            return false;
+        }
+
+        return $this->expireReservation($reservationId) !== null;
+    }
+
+    /** @return 'purchases'|'cart_reservations'|'orphan_reservations'|null */
+    private function expireReservation(int $reservationId): ?string
+    {
+        $purchaseId = Purchase::query()
+            ->where('stock_reservation_id', $reservationId)
+            ->value('id');
+        if ($purchaseId !== null) {
+            return $this->expirePurchase((int) $purchaseId);
+        }
+
+        $cartId = Cart::query()
+            ->where('current_stock_reservation_id', $reservationId)
+            ->where('status', 'active')
+            ->value('id');
+        if ($cartId !== null) {
+            return $this->expireCart((int) $cartId, $reservationId);
+        }
+
+        return $this->expireOrphan($reservationId);
+    }
+
+    /** @return 'purchases'|null */
+    private function expirePurchase(int $purchaseId): ?string
+    {
+        /** @var Purchase|null $purchase */
+        $purchase = Purchase::query()->find($purchaseId);
+        if ($purchase === null) {
+            return null;
+        }
+
+        $purchase = $this->purchases->expire($purchase);
+        if ($purchase->status === Purchase::STATUS_EXPIRED) {
+            return 'purchases';
+        }
+
+        $reservation = $purchase->stockReservation;
+        if ($this->isOverdue($reservation)) {
+            throw new RuntimeException('An overdue active reservation belongs to a purchase that cannot expire.');
+        }
+
+        return null;
+    }
+
+    /** @return 'cart_reservations'|null */
+    private function expireCart(int $cartId, int $reservationId): ?string
+    {
+        return DB::transaction(function () use ($cartId, $reservationId): ?string {
+            /** @var Cart|null $cart */
+            $cart = Cart::query()
+                ->whereKey($cartId)
+                ->where('current_stock_reservation_id', $reservationId)
+                ->where('status', Cart::STATUS_ACTIVE)
+                ->lockForUpdate()
+                ->first();
+            if ($cart === null) {
+                return null;
+            }
+
+            /** @var StockReservation|null $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->find($reservationId);
+            if (! $this->isOverdue($reservation)) {
+                return null;
+            }
+
+            $this->reservations->expire($reservation);
+            $cart->update(['status' => Cart::STATUS_EXPIRED]);
+
+            return 'cart_reservations';
+        });
+    }
+
+    /** @return 'orphan_reservations'|null */
+    private function expireOrphan(int $reservationId): ?string
+    {
+        /** @var StockReservation|null $reservation */
+        $reservation = StockReservation::query()->find($reservationId);
+        if (! $this->isOverdue($reservation)) {
+            return null;
+        }
+
+        $this->reservations->expire($reservation);
+
+        return 'orphan_reservations';
+    }
+
+    private function isOverdue(?StockReservation $reservation): bool
+    {
+        return $reservation !== null
+            && $reservation->status === StockReservation::STATUS_ACTIVE
+            && $reservation->expires_at !== null
+            && ! $reservation->expires_at->isFuture();
+    }
+}

app/Domains/Catalog/Services/FeaturedGroupService.php

@@ -15,7 +15,11 @@ class FeaturedGroupService
     private const ITEMS_PER_PAGE = 12;
 
     /** @return array<array-key, mixed> */
-    public function itemsResponse(FeaturedGroup $featuredGroup, int $page): array
+    public function __construct(
+        private readonly CatalogItemAllowanceService $allowances,
+    ) {}
+
+    public function itemsResponse(FeaturedGroup $featuredGroup, int $page, ?int $userId = null): array
     {
         if ($featuredGroup->group_layout !== GroupLayout::Paginated) {
             $query = $this->itemsQuery($featuredGroup);
@@ -26,12 +30,14 @@ class FeaturedGroupService
 
             $items = $query->get();
             $this->attachGroup($items, $featuredGroup);
+            $this->allowances->attach($items, $userId);
 
             return CatalogFeaturedItemResource::collection($items)->resolve();
         }
 
         $paginator = $this->paginateItems($featuredGroup, $page);
         $this->attachGroup($paginator->getCollection(), $featuredGroup);
+        $this->allowances->attach($paginator->getCollection(), $userId);
 
         return CatalogFeaturedItemResource::collection($paginator)
             ->response()
@@ -43,7 +49,16 @@ class FeaturedGroupService
     {
         $query = CatalogItem::query()
             ->where('catalog_items.tenant_code', $featuredGroup->tenant_code)
-            ->whereVariantsAvailable()
+            ->whereAvailable()
+            ->where(function (Builder $query): void {
+                $query
+                    ->whereDoesntHave('category')
+                    ->orWhereHas(
+                        'category',
+                        fn (Builder $categoryQuery): Builder => $categoryQuery
+                            ->where('is_enabled', true),
+                    );
+            })
             ->with([
                 'inventory',
                 'attachments',
@@ -67,7 +82,9 @@ class FeaturedGroupService
             FeaturedGroupSource::Category => $query
                 ->where('catalog_items.category_id', $featuredGroup->category_id)
                 ->orderBy('catalog_items.id'),
-            FeaturedGroupSource::All => $query->orderBy('catalog_items.id'),
+            FeaturedGroupSource::All => $query
+                ->orderBy('catalog_items.group_order')
+                ->orderBy('catalog_items.id'),
         };
     }
 

app/Domains/Catalog/Services/StockReservationService.php

@@ -0,0 +1,493 @@
+<?php
+
+namespace App\Domains\Catalog\Services;
+
+use App\Domains\Cart\Models\Cart;
+use App\Domains\Cart\Models\CartItem;
+use App\Domains\Catalog\Exceptions\StockReservationExpiredException;
+use App\Domains\Catalog\Models\Inventory;
+use App\Domains\Catalog\Models\StockReservation;
+use App\Domains\Catalog\Models\StockReservationLine;
+use App\Domains\Purchase\Models\Purchase;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
+
+class StockReservationService
+{
+    public const REASON_CART_EMPTY = 'cart_empty';
+
+    public const REASON_CART_CHANGED = 'cart_changed';
+
+    public const REASON_PURCHASE_SUPERSEDED = 'purchase_superseded';
+
+    public const REASON_PURCHASE_CANCELLED = 'purchase_cancelled';
+
+    public const REASON_PAYMENT_REJECTED = 'payment_rejected';
+
+    public const REASON_MANUAL_RELEASE = 'manual_release';
+
+    public function __construct(
+        private readonly CatalogInventoryService $inventory,
+    ) {}
+
+    public function syncCart(Cart $cart): ?StockReservation
+    {
+        return DB::transaction(function () use ($cart): ?StockReservation {
+            /** @var Cart $lockedCart */
+            $lockedCart = Cart::query()->lockForUpdate()->findOrFail($cart->getKey());
+            $items = $lockedCart->items()->orderBy('id')->lockForUpdate()->get();
+            $this->loadSelections($items);
+            $requirements = $this->requirementsForItems($items);
+
+            $reservation = $lockedCart->current_stock_reservation_id === null
+                ? null
+                : StockReservation::query()->lockForUpdate()->find($lockedCart->current_stock_reservation_id);
+
+            if ($reservation !== null) {
+                $this->assertUsableCartReservation($reservation);
+            }
+
+            if ($requirements === []) {
+                if ($reservation !== null && $reservation->status === StockReservation::STATUS_ACTIVE) {
+                    $this->finalizeLocked(
+                        $reservation,
+                        StockReservation::STATUS_RELEASED,
+                        self::REASON_CART_EMPTY,
+                    );
+                }
+
+                $lockedCart->update(['current_stock_reservation_id' => null]);
+                $cart->current_stock_reservation_id = null;
+
+                return null;
+            }
+
+            if ($reservation === null) {
+                $reservation = StockReservation::query()->create([
+                    'status' => StockReservation::STATUS_ACTIVE,
+                    'expires_at' => $this->expiration(),
+                ]);
+                $lockedCart->update(['current_stock_reservation_id' => $reservation->getKey()]);
+            }
+
+            if (Purchase::query()->where('stock_reservation_id', $reservation->getKey())->exists()) {
+                throw new \InvalidArgumentException('La reserva vinculada a una compra no se puede modificar.');
+            }
+
+            $currentLines = StockReservationLine::query()
+                ->where('stock_reservation_id', $reservation->getKey())
+                ->orderBy('inventory_id')
+                ->lockForUpdate()
+                ->get()
+                ->keyBy('inventory_id');
+            $inventoryIds = collect(array_keys($requirements))
+                ->merge($currentLines->keys())
+                ->map(fn ($id): int => (int) $id)
+                ->unique()
+                ->sort()
+                ->values();
+            $inventories = Inventory::query()
+                ->whereKey($inventoryIds)
+                ->orderBy('id')
+                ->lockForUpdate()
+                ->get()
+                ->keyBy('id');
+
+            foreach ($inventoryIds as $inventoryId) {
+                $inventory = $inventories->get($inventoryId)
+                    ?? throw new \InvalidArgumentException('No se encontró el inventario requerido.');
+                $previous = (int) ($currentLines->get($inventoryId)?->quantity ?? 0);
+                $required = (int) ($requirements[$inventoryId]['quantity'] ?? 0);
+                $delta = $required - $previous;
+
+                if ($delta > 0
+                    && $requirements[$inventoryId]['tracks_inventory']
+                    && $inventory->availableStock() < $delta) {
+                    throw new \InvalidArgumentException('No hay suficiente stock disponible para reservar el carrito.');
+                }
+
+                if ($delta < 0 && $inventory->reserved_stock < abs($delta)) {
+                    throw new \InvalidArgumentException('La reserva de stock del carrito es inconsistente.');
+                }
+            }
+
+            foreach ($inventoryIds as $inventoryId) {
+                /** @var Inventory $inventory */
+                $inventory = $inventories->get($inventoryId);
+                $line = $currentLines->get($inventoryId);
+                $previous = (int) ($line?->quantity ?? 0);
+                $required = (int) ($requirements[$inventoryId]['quantity'] ?? 0);
+                $delta = $required - $previous;
+
+                if ($delta > 0) {
+                    $inventory->reserve($delta, $requirements[$inventoryId]['tracks_inventory']);
+                } elseif ($delta < 0) {
+                    $inventory->release(abs($delta));
+                }
+
+                if ($required === 0) {
+                    $line?->delete();
+
+                    continue;
+                }
+
+                StockReservationLine::query()->updateOrCreate(
+                    [
+                        'stock_reservation_id' => $reservation->getKey(),
+                        'inventory_id' => $inventoryId,
+                    ],
+                    [
+                        'quantity' => $required,
+                        'tracks_inventory' => $requirements[$inventoryId]['tracks_inventory'],
+                    ],
+                );
+            }
+
+            $reservation->update([
+                'expires_at' => $this->expiration(),
+                'release_reason' => null,
+            ]);
+            $cart->current_stock_reservation_id = $reservation->getKey();
+
+            return $reservation->fresh('lines');
+        });
+    }
+
+    public function attachToPurchase(
+        Cart $cart,
+        Purchase $purchase,
+        Carbon $expiresAt,
+    ): StockReservation {
+        return DB::transaction(function () use ($cart, $purchase, $expiresAt): StockReservation {
+            /** @var Cart $lockedCart */
+            $lockedCart = Cart::query()->lockForUpdate()->findOrFail($cart->getKey());
+            /** @var Purchase $lockedPurchase */
+            $lockedPurchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+
+            if ($lockedCart->current_stock_reservation_id === null) {
+                throw new \InvalidArgumentException('El carrito no tiene una reserva de stock activa.');
+            }
+
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->findOrFail($lockedCart->current_stock_reservation_id);
+            $this->assertUsableCartReservation($reservation);
+
+            $linkedPurchase = Purchase::query()
+                ->where('stock_reservation_id', $reservation->getKey())
+                ->whereKeyNot($lockedPurchase->getKey())
+                ->exists();
+            if ($linkedPurchase) {
+                throw new \InvalidArgumentException('La reserva de stock ya pertenece a otra compra.');
+            }
+
+            $lockedPurchase->update(['stock_reservation_id' => $reservation->getKey()]);
+            $reservation->update(['expires_at' => $expiresAt]);
+            $purchase->stock_reservation_id = $reservation->getKey();
+            $cart->current_stock_reservation_id = $reservation->getKey();
+
+            return $reservation->fresh('lines');
+        });
+    }
+
+    public function commit(Purchase $purchase): void
+    {
+        DB::transaction(function () use ($purchase): void {
+            /** @var Purchase $purchase */
+            $purchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+            if ($purchase->stock_reservation_id === null) {
+                throw new \InvalidArgumentException('La compra no tiene una reserva de stock.');
+            }
+
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->findOrFail($purchase->stock_reservation_id);
+            if ($reservation->status === StockReservation::STATUS_COMMITTED) {
+                return;
+            }
+            if ($reservation->status !== StockReservation::STATUS_ACTIVE) {
+                throw new \InvalidArgumentException('La reserva de stock no está activa.');
+            }
+            if ($reservation->expires_at !== null && ! $reservation->expires_at->isFuture()) {
+                throw new StockReservationExpiredException;
+            }
+
+            $lines = $this->lockLines($reservation);
+            if ($lines->isEmpty()) {
+                throw new \InvalidArgumentException('La reserva de stock no tiene inventarios.');
+            }
+
+            $inventories = $this->lockInventories($lines);
+            foreach ($lines as $line) {
+                $inventory = $inventories->get($line->inventory_id)
+                    ?? throw new \InvalidArgumentException('No se encontró el inventario reservado.');
+                if ($inventory->reserved_stock < $line->quantity
+                    || ($line->tracks_inventory && $inventory->real_stock < $line->quantity)) {
+                    throw new \InvalidArgumentException('La reserva de stock no alcanza para confirmar la compra.');
+                }
+            }
+
+            foreach ($lines as $line) {
+                $inventories->get($line->inventory_id)->buy(
+                    (int) $line->quantity,
+                    (bool) $line->tracks_inventory,
+                );
+            }
+
+            $reservation->update([
+                'status' => StockReservation::STATUS_COMMITTED,
+                'expires_at' => null,
+                'committed_at' => now(),
+                'released_at' => null,
+                'expired_at' => null,
+                'release_reason' => null,
+            ]);
+        });
+    }
+
+    public function releaseForPurchase(
+        Purchase $purchase,
+        string $status = StockReservation::STATUS_RELEASED,
+        ?string $reason = null,
+    ): void {
+        DB::transaction(function () use ($purchase, $status, $reason): void {
+            /** @var Purchase $purchase */
+            $purchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+            if ($purchase->stock_reservation_id === null) {
+                return;
+            }
+
+            /** @var StockReservation|null $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->find($purchase->stock_reservation_id);
+            if ($reservation !== null) {
+                $this->finalizeLocked($reservation, $status, $reason);
+            }
+        });
+    }
+
+    public function returnToCart(Purchase $purchase, Cart $cart): StockReservation
+    {
+        return DB::transaction(function () use ($purchase, $cart): StockReservation {
+            /** @var Purchase $purchase */
+            $purchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+            /** @var Cart $cart */
+            $cart = Cart::query()->lockForUpdate()->findOrFail($cart->getKey());
+
+            if ($purchase->stock_reservation_id === null
+                || $cart->current_stock_reservation_id !== $purchase->stock_reservation_id) {
+                throw new \InvalidArgumentException('La compra y el carrito no comparten la reserva activa.');
+            }
+
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()
+                ->lockForUpdate()
+                ->findOrFail($purchase->stock_reservation_id);
+            $this->assertUsableCartReservation($reservation);
+
+            $purchase->update(['stock_reservation_id' => null]);
+            $cart->update(['current_purchase_id' => null]);
+            $reservation->update(['expires_at' => $this->expiration()]);
+
+            return $reservation->fresh('lines');
+        });
+    }
+
+    public function assertCartReservationUsable(Cart $cart): void
+    {
+        DB::transaction(function () use ($cart): void {
+            /** @var Cart $cart */
+            $cart = Cart::query()->lockForUpdate()->findOrFail($cart->getKey());
+            if ($cart->current_stock_reservation_id === null) {
+                return;
+            }
+
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()
+                ->lockForUpdate()
+                ->findOrFail($cart->current_stock_reservation_id);
+            $this->assertUsableCartReservation($reservation);
+        });
+    }
+
+    public function releaseCurrentCartReservation(
+        Cart $cart,
+        string $reason = self::REASON_CART_CHANGED,
+    ): void {
+        DB::transaction(function () use ($cart, $reason): void {
+            /** @var Cart $cart */
+            $cart = Cart::query()->lockForUpdate()->findOrFail($cart->getKey());
+            if ($cart->current_stock_reservation_id === null) {
+                return;
+            }
+
+            /** @var StockReservation|null $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->find($cart->current_stock_reservation_id);
+            if ($reservation !== null) {
+                $this->finalizeLocked($reservation, StockReservation::STATUS_RELEASED, $reason);
+            }
+            $cart->update(['current_stock_reservation_id' => null]);
+        });
+    }
+
+    public function expire(StockReservation $reservation): void
+    {
+        DB::transaction(function () use ($reservation): void {
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->findOrFail($reservation->getKey());
+            if ($reservation->status !== StockReservation::STATUS_ACTIVE
+                || $reservation->expires_at === null
+                || $reservation->expires_at->isFuture()) {
+                return;
+            }
+
+            $this->finalizeLocked($reservation, StockReservation::STATUS_EXPIRED, null);
+        });
+    }
+
+    public function clearExpirationForReview(Purchase $purchase): void
+    {
+        DB::transaction(function () use ($purchase): void {
+            /** @var Purchase $purchase */
+            $purchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+            if ($purchase->stock_reservation_id === null) {
+                throw new \InvalidArgumentException('La compra no tiene una reserva de stock.');
+            }
+
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()
+                ->lockForUpdate()
+                ->findOrFail($purchase->stock_reservation_id);
+            if ($reservation->status !== StockReservation::STATUS_ACTIVE) {
+                throw new \InvalidArgumentException('La reserva de stock no está activa.');
+            }
+            if ($reservation->expires_at !== null && ! $reservation->expires_at->isFuture()) {
+                throw new StockReservationExpiredException;
+            }
+
+            $reservation->update(['expires_at' => null]);
+        });
+    }
+
+    /**
+     * @param  Collection<int, CartItem>  $items
+     * @return array<int, array{quantity: int, tracks_inventory: bool}>
+     */
+    private function requirementsForItems(Collection $items): array
+    {
+        $requirements = [];
+        foreach ($items as $item) {
+            $selection = $item->selectedItem();
+            if ($selection === null) {
+                throw new \InvalidArgumentException('El carrito contiene un item de catálogo inexistente.');
+            }
+
+            foreach ($this->inventory->detailedRequirementsFor($selection, (int) $item->cantidad) as $inventoryId => $requirement) {
+                if (isset($requirements[$inventoryId])) {
+                    $requirements[$inventoryId]['quantity'] += $requirement['quantity'];
+                    $requirements[$inventoryId]['tracks_inventory'] =
+                        $requirements[$inventoryId]['tracks_inventory'] || $requirement['tracks_inventory'];
+
+                    continue;
+                }
+
+                $requirements[$inventoryId] = $requirement;
+            }
+        }
+
+        ksort($requirements);
+
+        return $requirements;
+    }
+
+    /** @param Collection<int, CartItem> $items */
+    private function loadSelections(Collection $items): void
+    {
+        $items->load([
+            'catalogItem.inventory',
+            'catalogItem.bundleComponents.catalogItem.inventory',
+            'catalogItem.bundleComponents.variant.inventory',
+            'catalogItem.bundleComponents.variant.catalogItem',
+            'variant.inventory',
+            'variant.catalogItem',
+        ]);
+    }
+
+    /** @return Collection<int, StockReservationLine> */
+    private function lockLines(StockReservation $reservation): Collection
+    {
+        return StockReservationLine::query()
+            ->where('stock_reservation_id', $reservation->getKey())
+            ->orderBy('inventory_id')
+            ->lockForUpdate()
+            ->get();
+    }
+
+    /**
+     * @param  Collection<int, StockReservationLine>  $lines
+     * @return Collection<int, Inventory>
+     */
+    private function lockInventories(Collection $lines): Collection
+    {
+        return Inventory::query()
+            ->whereKey($lines->pluck('inventory_id'))
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get()
+            ->keyBy('id');
+    }
+
+    private function finalizeLocked(
+        StockReservation $reservation,
+        string $status,
+        ?string $reason,
+    ): void {
+        if ($reservation->status !== StockReservation::STATUS_ACTIVE) {
+            return;
+        }
+        if (! in_array($status, [StockReservation::STATUS_RELEASED, StockReservation::STATUS_EXPIRED], true)) {
+            throw new \InvalidArgumentException('El estado final de la reserva no es válido.');
+        }
+
+        $lines = $this->lockLines($reservation);
+        $inventories = $this->lockInventories($lines);
+        foreach ($lines as $line) {
+            $inventory = $inventories->get($line->inventory_id)
+                ?? throw new \InvalidArgumentException('No se encontró el inventario reservado.');
+            $inventory->release((int) $line->quantity);
+        }
+
+        $now = now();
+        $reservation->update([
+            'status' => $status,
+            'expires_at' => null,
+            'released_at' => $status === StockReservation::STATUS_RELEASED ? $now : null,
+            'expired_at' => $status === StockReservation::STATUS_EXPIRED ? $now : null,
+            'release_reason' => $status === StockReservation::STATUS_RELEASED ? $reason : null,
+        ]);
+
+        if ($status === StockReservation::STATUS_RELEASED) {
+            Cart::query()
+                ->where('current_stock_reservation_id', $reservation->getKey())
+                ->update(['current_stock_reservation_id' => null]);
+        }
+    }
+
+    private function assertUsableCartReservation(StockReservation $reservation): void
+    {
+        if ($reservation->status === StockReservation::STATUS_EXPIRED
+            || ($reservation->expires_at !== null && ! $reservation->expires_at->isFuture())) {
+            throw new StockReservationExpiredException;
+        }
+
+        if ($reservation->status !== StockReservation::STATUS_ACTIVE
+            || $reservation->expires_at === null) {
+            throw new \InvalidArgumentException('La reserva de stock no está disponible para operar el carrito.');
+        }
+    }
+
+    private function expiration(): Carbon
+    {
+        return now()->addMinutes(
+            max(1, (int) config('catalog.stock_reservation_expiration_minutes', 30)),
+        );
+    }
+}

app/Domains/Catalog/Services/VariantReplacementService.php

@@ -0,0 +1,260 @@
+<?php
+
+namespace App\Domains\Catalog\Services;
+
+use App\Domains\Catalog\Models\BundleComponent;
+use App\Domains\Catalog\Models\Inventory;
+use App\Domains\Catalog\Models\StockReservation;
+use App\Domains\Catalog\Models\StockReservationLine;
+use App\Domains\Catalog\Models\Variant;
+use App\Domains\Event\Models\EventDate;
+use Illuminate\Support\Collection;
+
+class VariantReplacementService
+{
+    /** @return Collection<int, Variant> */
+    public function replaceEventDate(EventDate $source, EventDate $destination): Collection
+    {
+        $variants = Variant::query()
+            ->whereNull('sales_disabled_at')
+            ->whereNull('replaced_by_variant_id')
+            ->where(function ($query) use ($source): void {
+                $query->where('event_date_id', $source->getKey())
+                    ->orWhereHas('eventDates', fn ($eventDates) => $eventDates
+                        ->where('event_dates.id', $source->getKey()));
+            })
+            ->with(['eventDates', 'eventDate', 'definitions', 'allAttachments'])
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get();
+
+        return $variants->map(function (Variant $variant) use ($source, $destination): Variant {
+            $destinationDateIds = $variant->selectedEventDates()
+                ->pluck('id')
+                ->map(fn ($id): int => (int) $id === (int) $source->getKey()
+                    ? (int) $destination->getKey()
+                    : (int) $id)
+                ->unique()
+                ->sort()
+                ->values();
+
+            $replacement = $this->findEquivalent($variant, $destinationDateIds)
+                ?? $this->cloneWithDates($variant, $destinationDateIds);
+
+            $variant->update([
+                'replaced_by_variant_id' => $replacement->getKey(),
+                'sales_disabled_at' => now(),
+            ]);
+
+            BundleComponent::query()
+                ->where('component_variant_id', $variant->getKey())
+                ->update(['component_variant_id' => $replacement->getKey()]);
+
+            return $replacement;
+        })->values();
+    }
+
+    public function disableForSuspension(EventDate $eventDate): void
+    {
+        $variants = Variant::query()
+            ->whereNull('sales_disabled_at')
+            ->whereNull('replaced_by_variant_id')
+            ->where(function ($query) use ($eventDate): void {
+                $query->where('event_date_id', $eventDate->getKey())
+                    ->orWhereHas('eventDates', fn ($eventDates) => $eventDates
+                        ->where('event_dates.id', $eventDate->getKey()));
+            })
+            ->with(['eventDates', 'eventDate', 'definitions', 'allAttachments'])
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get();
+
+        foreach ($variants as $variant) {
+            $remainingDateIds = $variant->selectedEventDates()
+                ->filter(fn (EventDate $date): bool => $date->suspended_at === null
+                    && $date->rescheduled_to_event_date_id === null)
+                ->pluck('id')
+                ->map(fn ($id): int => (int) $id)
+                ->unique()
+                ->sort()
+                ->values();
+
+            if ($remainingDateIds->isEmpty()) {
+                $variant->update(['sales_disabled_at' => now()]);
+
+                continue;
+            }
+
+            $replacement = $this->findEquivalent($variant, $remainingDateIds);
+            if ($replacement === null) {
+                $replacement = $this->cloneWithDates($variant, $remainingDateIds);
+            } else {
+                $this->mergeInventoryInto($variant, $replacement);
+            }
+
+            $variant->update([
+                'replaced_by_variant_id' => $replacement->getKey(),
+                'sales_disabled_at' => now(),
+            ]);
+
+            BundleComponent::query()
+                ->where('component_variant_id', $variant->getKey())
+                ->update(['component_variant_id' => $replacement->getKey()]);
+        }
+    }
+
+    /** @param Collection<int, int> $eventDateIds */
+    private function findEquivalent(Variant $source, Collection $eventDateIds): ?Variant
+    {
+        $definitionSignature = $this->definitionSignature($source);
+        $dateSignature = $eventDateIds->map(fn ($id): int => (int) $id)->sort()->values()->all();
+
+        return Variant::query()
+            ->where('catalog_item_id', $source->catalog_item_id)
+            ->whereKeyNot($source->getKey())
+            ->whereNull('sales_disabled_at')
+            ->whereNull('replaced_by_variant_id')
+            ->with(['eventDates', 'eventDate', 'definitions'])
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get()
+            ->first(fn (Variant $candidate): bool => $this->definitionSignature($candidate) === $definitionSignature
+                && $candidate->selectedEventDates()
+                    ->pluck('id')
+                    ->map(fn ($id): int => (int) $id)
+                    ->sort()
+                    ->values()
+                    ->all() === $dateSignature
+            );
+    }
+
+    /** @param Collection<int, int> $eventDateIds */
+    private function cloneWithDates(Variant $source, Collection $eventDateIds): Variant
+    {
+        $replacementInventory = $this->cloneInventory($source);
+        $replacement = $source->replicate([
+            'event_date_id',
+            'inventory_id',
+            'replaced_by_variant_id',
+            'sales_disabled_at',
+        ]);
+        $replacement->inventory_id = $replacementInventory->getKey();
+        $replacement->event_date_id = $eventDateIds->count() === 1
+            ? $eventDateIds->first()
+            : null;
+        $replacement->save();
+        $replacement->eventDates()->sync($eventDateIds->all());
+
+        $replacement->definitions()->createMany(
+            $source->definitions
+                ->map(fn ($definition): array => [
+                    'item_attribute_id' => $definition->item_attribute_id,
+                    'value' => $definition->value,
+                ])
+                ->all(),
+        );
+
+        $attachments = $source->allAttachments
+            ->mapWithKeys(fn ($attachment): array => [
+                $attachment->getKey() => [
+                    'orden' => $attachment->pivot->orden,
+                    'is_enabled' => $attachment->pivot->is_enabled,
+                ],
+            ])
+            ->all();
+        $replacement->allAttachments()->sync($attachments);
+
+        return $replacement->load(['eventDates', 'eventDate', 'definitions', 'allAttachments']);
+    }
+
+    private function cloneInventory(Variant $source): Inventory
+    {
+        $activeLines = StockReservationLine::query()
+            ->where('inventory_id', $source->inventory_id)
+            ->whereHas('reservation', fn ($reservation) => $reservation
+                ->where('status', StockReservation::STATUS_ACTIVE))
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get();
+        $sourceInventory = Inventory::query()
+            ->whereKey($source->inventory_id)
+            ->lockForUpdate()
+            ->firstOrFail();
+        $reservedStock = (int) $activeLines->sum('quantity');
+
+        if ($sourceInventory->reserved_stock !== $reservedStock) {
+            throw new \LogicException('El inventario reservado de la variante es inconsistente.');
+        }
+
+        $replacementInventory = Inventory::query()->create([
+            'sold_units' => $sourceInventory->sold_units,
+            'reserved_stock' => $reservedStock,
+            'real_stock' => $sourceInventory->real_stock,
+        ]);
+
+        if ($activeLines->isNotEmpty()) {
+            StockReservationLine::query()
+                ->whereKey($activeLines->modelKeys())
+                ->update(['inventory_id' => $replacementInventory->getKey()]);
+        }
+        $sourceInventory->update(['reserved_stock' => 0]);
+
+        return $replacementInventory;
+    }
+
+    private function mergeInventoryInto(Variant $source, Variant $destination): void
+    {
+        if ($source->inventory_id === $destination->inventory_id) {
+            return;
+        }
+
+        $inventories = Inventory::query()
+            ->whereKey([$source->inventory_id, $destination->inventory_id])
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get()
+            ->keyBy('id');
+        $sourceInventory = $inventories->get($source->inventory_id);
+        $destinationInventory = $inventories->get($destination->inventory_id);
+        if ($sourceInventory === null || $destinationInventory === null) {
+            throw new \LogicException('No se encontró el inventario de una variante.');
+        }
+
+        $activeLines = StockReservationLine::query()
+            ->where('inventory_id', $source->inventory_id)
+            ->whereHas('reservation', fn ($reservation) => $reservation
+                ->where('status', StockReservation::STATUS_ACTIVE))
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get();
+        if ($sourceInventory->reserved_stock !== (int) $activeLines->sum('quantity')) {
+            throw new \LogicException('El inventario reservado de la variante es inconsistente.');
+        }
+
+        $destinationInventory->update([
+            'real_stock' => $destinationInventory->real_stock + $sourceInventory->real_stock,
+            'reserved_stock' => $destinationInventory->reserved_stock + $sourceInventory->reserved_stock,
+            'sold_units' => $destinationInventory->sold_units + $sourceInventory->sold_units,
+        ]);
+        if ($activeLines->isNotEmpty()) {
+            StockReservationLine::query()
+                ->whereKey($activeLines->modelKeys())
+                ->update(['inventory_id' => $destinationInventory->getKey()]);
+        }
+        $sourceInventory->update([
+            'real_stock' => 0,
+            'reserved_stock' => 0,
+            'sold_units' => 0,
+        ]);
+    }
+
+    /** @return list<string> */
+    private function definitionSignature(Variant $variant): array
+    {
+        return $variant->definitions
+            ->map(fn ($definition): string => $definition->item_attribute_id.'\0'.$definition->value)
+            ->sort()
+            ->values()
+            ->all();
+    }
+}

app/Domains/Catalog/documentacion/README.md

@@ -9,6 +9,7 @@ Modela y publica la oferta comercial del tenant: productos, variantes, categorí
 - `CatalogItem` es la raíz del producto y se relaciona con tenant, categoría, marca, inventario, variantes, atributos, adjuntos y grupos destacados.
 - `Variant`, `ItemAttribute`, `Attribute`, `AttributeOption` y `VariantDefinition` describen opciones comercializables.
 - `Inventory` administra stock disponible, reservado y comprado.
+- `StockReservation` representa la reserva completa de un carrito o checkout, con estados `active`, `committed`, `released` y `expired`. Su `expires_at` es el único reloj del bloqueo. Al expirar, también pasan a `expired` la compra pagable y el carrito asociados dentro de la misma transacción. Sus estados terminales nunca se reactivan ni se reemplazan implícitamente. Sus `StockReservationLine` agregan la cantidad requerida por inventario, incluso cuando varios ítems o bundles consumen el mismo stock.
 - `Category` soporta jerarquía y categorías globales o propias del tenant.
 - `FeaturedGroup` y `FeaturedItem` organizan secciones destacadas.
 - `BundleComponent` representa los componentes de un paquete.
@@ -17,6 +18,8 @@ Modela y publica la oferta comercial del tenant: productos, variantes, categorí
 
 - `CatalogService`: alta, búsqueda, detalle, listado por categoría y eliminación.
 - `CatalogInventoryService`: consulta, reserva, libera y confirma inventario.
+- `StockReservationService`: sincroniza el carrito como conjunto, bloquea todos sus inventarios en orden estable y mantiene el ledger agregado consistente con `Inventory.reserved_stock`.
+- `ExpireStockReservationsService`: detecta en un único recorrido reservas vencidas de compras, carritos y huérfanas, y delega los efectos comerciales sin mezclar esas reglas con la liberación física del inventario.
 - `FeaturedGroupService`: pagina los ítems destacados para la tienda.
 - `OnTicketFeaturedGroupService`: administra grupos destacados del panel para sitios de tickets.
 

app/Domains/Client/Controllers/ClientController.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace App\Domains\Client\Controllers;
+
+use App\Domains\Client\Models\Client;
+use App\Domains\Client\Requests\StoreClientRequest;
+use App\Domains\Client\Requests\UpdateClientRequest;
+use App\Domains\Client\Resources\ClientResource;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Response;
+
+class ClientController extends Controller
+{
+    public function index(): JsonResponse
+    {
+        return ClientResource::collection(
+            Client::query()->with('tenants')->latest()->paginateFromRequest()
+        )->response();
+    }
+
+    public function store(StoreClientRequest $request): JsonResponse
+    {
+        return ClientResource::make(
+            Client::query()->create($request->validated())->load('tenants')
+        )->response()->setStatusCode(201);
+    }
+
+    public function show(Client $client): ClientResource
+    {
+        return ClientResource::make($client->load('tenants'));
+    }
+
+    public function update(UpdateClientRequest $request, Client $client): ClientResource
+    {
+        $client->update($request->validated());
+
+        return ClientResource::make($client->fresh()->load('tenants'));
+    }
+
+    public function destroy(Client $client): Response
+    {
+        $client->delete();
+
+        return response()->noContent();
+    }
+}

app/Domains/Client/Models/Client.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Domains\Client\Models;
+
+use App\Domains\Integration\Models\ClientIntegration;
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+#[Fillable(['code', 'name'])]
+class Client extends Model
+{
+    public function getRouteKeyName(): string
+    {
+        return 'code';
+    }
+
+    /** @return HasMany<Tenant, $this> */
+    public function tenants(): HasMany
+    {
+        return $this->hasMany(Tenant::class);
+    }
+
+    /** @return HasMany<ClientIntegration, $this> */
+    public function integrations(): HasMany
+    {
+        return $this->hasMany(ClientIntegration::class);
+    }
+}

app/Domains/Client/Requests/StoreClientRequest.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Client\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class StoreClientRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'code' => ['required', 'string', 'max:255', Rule::unique('clients', 'code')],
+            'name' => ['required', 'string', 'max:255'],
+        ];
+    }
+}

app/Domains/Client/Requests/UpdateClientRequest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Domains\Client\Requests;
+
+use App\Domains\Client\Models\Client;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class UpdateClientRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        /** @var Client|null $client */
+        $client = $this->route('client');
+
+        return [
+            'code' => ['sometimes', 'string', 'max:255', Rule::unique('clients', 'code')->ignore($client?->id)],
+            'name' => ['sometimes', 'string', 'max:255'],
+        ];
+    }
+}

app/Domains/Client/Resources/ClientResource.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Domains\Client\Resources;
+
+use App\Domains\Client\Models\Client;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/** @mixin Client */
+class ClientResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'code' => $this->code,
+            'name' => $this->name,
+            'tenants' => $this->whenLoaded('tenants', fn () => $this->tenants->map(fn ($tenant): array => [
+                'id' => $tenant->id,
+                'codigo' => $tenant->codigo,
+                'nombre' => $tenant->nombre,
+                'dominio' => $tenant->dominio,
+            ])),
+        ];
+    }
+}

app/Domains/Client/routes/api.php

@@ -0,0 +1,6 @@
+<?php
+
+use App\Domains\Client\Controllers\ClientController;
+use Illuminate\Support\Facades\Route;
+
+Route::apiResource('clients', ClientController::class);

app/Domains/Desfile/Services/InvitationPurchaseProvisioner.php

@@ -0,0 +1,443 @@
+<?php
+
+namespace App\Domains\Desfile\Services;
+
+use DateTimeInterface;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Schema;
+use Illuminate\Support\Str;
+use RuntimeException;
+
+class InvitationPurchaseProvisioner
+{
+    public const TENANT_CODE = 'desfile_pura_tendencia';
+
+    public const USER_EMAIL = 'invitados@puratendencia.com';
+
+    private const PAYMENT_METHOD = 'invitation';
+
+    /**
+     * @var list<array{sector: string, row: int, first_seat: int, last_seat: int, type: string}>
+     */
+    private const ALLOCATIONS = [
+        ['sector' => 'A', 'row' => 1, 'first_seat' => 1, 'last_seat' => 16, 'type' => 'NORMAL'],
+        ['sector' => 'A', 'row' => 3, 'first_seat' => 1, 'last_seat' => 14, 'type' => 'NORMAL'],
+        ['sector' => 'C', 'row' => 1, 'first_seat' => 1, 'last_seat' => 17, 'type' => 'VIP + LUNCH'],
+        ['sector' => 'C', 'row' => 3, 'first_seat' => 6, 'last_seat' => 7, 'type' => 'NORMAL'],
+    ];
+
+    /**
+     * @param  list<array{sector: string, row: int, first_seat: int, last_seat: int, type: string}>|null  $allocations
+     */
+    public function provision(?array $allocations = null): void
+    {
+        if (! $this->prerequisitesExist()) {
+            return;
+        }
+
+        DB::transaction(function () use ($allocations): void {
+            $now = now();
+            $userId = $this->userId($now);
+            $purchaseId = $this->purchaseId($userId, $now);
+            $catalogItem = DB::table('catalog_items')
+                ->where('tenant_code', self::TENANT_CODE)
+                ->where('slug', 'entrada')
+                ->first();
+
+            if ($catalogItem === null) {
+                throw new RuntimeException('No se encontró el catálogo de entradas del desfile.');
+            }
+
+            foreach ($allocations ?? self::ALLOCATIONS as $allocation) {
+                foreach (range($allocation['first_seat'], $allocation['last_seat']) as $seat) {
+                    $variant = $this->variant(
+                        (int) $catalogItem->id,
+                        $allocation['sector'],
+                        $allocation['row'],
+                        $seat,
+                        $allocation['type'],
+                    );
+
+                    $purchaseItemId = $this->createPurchaseItem(
+                        $purchaseId,
+                        $catalogItem,
+                        $variant,
+                        $allocation['sector'],
+                        $allocation['row'],
+                        $seat,
+                        $allocation['type'],
+                        $now,
+                    );
+                    $this->createTicketAndCommitStock(
+                        $purchaseId,
+                        $purchaseItemId,
+                        $userId,
+                        (int) $catalogItem->id,
+                        $variant,
+                        $now,
+                    );
+                }
+            }
+        });
+    }
+
+    private function prerequisitesExist(): bool
+    {
+        if (! DB::table('tenants')->where('codigo', self::TENANT_CODE)->exists()) {
+            return false;
+        }
+
+        if (! DB::table('roles')->where('codigo', 'user')->exists()) {
+            throw new RuntimeException('No se encontró el rol de usuario común.');
+        }
+
+        if (! DB::table('catalog_items')
+            ->where('tenant_code', self::TENANT_CODE)
+            ->where('slug', 'entrada')
+            ->exists()) {
+            throw new RuntimeException('No se encontró el catálogo de entradas del desfile.');
+        }
+
+        return true;
+    }
+
+    private function userId(DateTimeInterface $now): int
+    {
+        $user = DB::table('users')
+            ->where('active_email', self::USER_EMAIL)
+            ->where('rol_codigo', 'user')
+            ->whereNull('deleted_at')
+            ->first();
+
+        if ($user !== null) {
+            if ($user->tenant_codigo !== self::TENANT_CODE) {
+                throw new RuntimeException('El email de invitados ya pertenece a otro tenant.');
+            }
+
+            DB::table('users')->where('id', $user->id)->update([
+                'rol_codigo' => 'user',
+                'nombre_apellido' => 'Invitados Pura Tendencia',
+                'updated_at' => $now,
+            ]);
+
+            return (int) $user->id;
+        }
+
+        return DB::table('users')->insertGetId([
+            'rol_codigo' => 'user',
+            'tenant_codigo' => self::TENANT_CODE,
+            'nombre_apellido' => 'Invitados Pura Tendencia',
+            'email' => self::USER_EMAIL,
+            'email_verified_at' => $now,
+            'password' => Hash::make(Str::random(64)),
+            'dni' => null,
+            'telefono' => null,
+            'remember_token' => null,
+            'created_at' => $now,
+            'updated_at' => $now,
+        ]);
+    }
+
+    private function purchaseId(int $userId, DateTimeInterface $now): int
+    {
+        $purchaseId = DB::table('compras')
+            ->where('tenant_codigo', self::TENANT_CODE)
+            ->where('user_id', $userId)
+            ->where('payment_method', self::PAYMENT_METHOD)
+            ->value('id');
+
+        if ($purchaseId !== null) {
+            DB::table('compras')->where('id', $purchaseId)->update([
+                'status' => 'paid',
+                'total' => 0,
+                'updated_at' => $now,
+            ]);
+
+            return (int) $purchaseId;
+        }
+
+        return DB::table('compras')->insertGetId([
+            'tenant_codigo' => self::TENANT_CODE,
+            'user_id' => $userId,
+            'cart_id' => null,
+            'status' => 'paid',
+            'payment_method' => self::PAYMENT_METHOD,
+            'total' => 0,
+            'dni' => null,
+            'transfer_payer_dni' => null,
+            'telefono' => null,
+            'nombre_apellido' => 'Invitados Pura Tendencia',
+            'email' => self::USER_EMAIL,
+            'created_at' => $now,
+            'updated_at' => $now,
+        ]);
+    }
+
+    private function variant(
+        int $catalogItemId,
+        string $sector,
+        int $row,
+        int $seat,
+        string $type,
+    ): object {
+        $variant = $this->findVariant($catalogItemId, $sector, $row, $seat);
+
+        if ($variant === null) {
+            $variant = $this->createVariant($catalogItemId, $sector, $row, $seat, $type);
+        }
+
+        $this->ensureAttributeOptions($catalogItemId, [
+            'tipo' => $type,
+            'sector' => $sector,
+            'fila' => (string) $row,
+            'asiento' => (string) $seat,
+        ]);
+
+        $typeValueId = DB::table('variant_values as variant_value')
+            ->join('item_attributes as item_attribute', 'item_attribute.id', '=', 'variant_value.item_attribute_id')
+            ->join('attribute', 'attribute.id', '=', 'item_attribute.attribute_id')
+            ->where('variant_value.variant_id', $variant->id)
+            ->where('attribute.codigo', 'tipo')
+            ->value('variant_value.id');
+
+        if ($typeValueId === null) {
+            throw new RuntimeException("La variante {$variant->id} no tiene definido el tipo de entrada.");
+        }
+
+        DB::table('variant_values')->where('id', $typeValueId)->update(['value' => $type]);
+        DB::table('variantes')->where('id', $variant->id)->update([
+            'descripcion' => "Sector {$sector} - Fila {$row} - Asiento {$seat} - {$type}",
+        ]);
+
+        return DB::table('variantes')->where('id', $variant->id)->first();
+    }
+
+    /** @param array<string, string> $values */
+    private function ensureAttributeOptions(int $catalogItemId, array $values): void
+    {
+        $attributes = DB::table('item_attributes')
+            ->join('attribute', 'attribute.id', '=', 'item_attributes.attribute_id')
+            ->where('item_attributes.catalog_item_id', $catalogItemId)
+            ->pluck('attribute.id', 'attribute.codigo');
+
+        foreach ($values as $code => $value) {
+            $attributeId = $attributes[$code] ?? null;
+
+            if ($attributeId === null) {
+                throw new RuntimeException("Falta el atributo {$code} en el catálogo de entradas.");
+            }
+
+            if (DB::table('attribute_options')
+                ->where('attribute_id', $attributeId)
+                ->where('value', $value)
+                ->exists()) {
+                continue;
+            }
+
+            $lastSortOrder = (int) DB::table('attribute_options')
+                ->where('attribute_id', $attributeId)
+                ->max('sort_order');
+
+            DB::table('attribute_options')->insert([
+                'attribute_id' => $attributeId,
+                'validity_time_id' => null,
+                'value' => $value,
+                'label' => $value,
+                'sort_order' => $lastSortOrder + 1,
+                'metadata' => null,
+                'created_at' => now(),
+                'updated_at' => now(),
+            ]);
+        }
+    }
+
+    private function findVariant(int $catalogItemId, string $sector, int $row, int $seat): ?object
+    {
+        $query = DB::table('variantes')->where('catalog_item_id', $catalogItemId);
+
+        foreach (['sector' => $sector, 'fila' => (string) $row, 'asiento' => (string) $seat] as $code => $value) {
+            $query->whereExists(fn ($subquery) => $subquery
+                ->selectRaw('1')
+                ->from('variant_values as selected_value')
+                ->join('item_attributes as selected_item_attribute', 'selected_item_attribute.id', '=', 'selected_value.item_attribute_id')
+                ->join('attribute as selected_attribute', 'selected_attribute.id', '=', 'selected_item_attribute.attribute_id')
+                ->whereColumn('selected_value.variant_id', 'variantes.id')
+                ->where('selected_attribute.codigo', $code)
+                ->where('selected_value.value', $value));
+        }
+
+        return $query->first();
+    }
+
+    private function createVariant(
+        int $catalogItemId,
+        string $sector,
+        int $row,
+        int $seat,
+        string $type,
+    ): object {
+        $itemAttributes = DB::table('item_attributes')
+            ->join('attribute', 'attribute.id', '=', 'item_attributes.attribute_id')
+            ->where('item_attributes.catalog_item_id', $catalogItemId)
+            ->pluck('item_attributes.id', 'attribute.codigo');
+
+        foreach (['tipo', 'sector', 'fila', 'asiento'] as $requiredCode) {
+            if (! isset($itemAttributes[$requiredCode])) {
+                throw new RuntimeException("Falta el atributo {$requiredCode} en el catálogo de entradas.");
+            }
+        }
+
+        $inventoryId = DB::table('inventories')->insertGetId([
+            'sold_units' => 0,
+            'reserved_stock' => 0,
+            'real_stock' => 1,
+        ]);
+        $variantId = DB::table('variantes')->insertGetId([
+            'catalog_item_id' => $catalogItemId,
+            'event_date_id' => null,
+            'inventory_id' => $inventoryId,
+            'descripcion' => "Sector {$sector} - Fila {$row} - Asiento {$seat} - {$type}",
+            'precio' => $this->catalogPrice($sector, $row),
+        ]);
+
+        foreach (['tipo' => $type, 'sector' => $sector, 'fila' => (string) $row, 'asiento' => (string) $seat] as $code => $value) {
+            DB::table('variant_values')->insert([
+                'variant_id' => $variantId,
+                'item_attribute_id' => $itemAttributes[$code],
+                'value' => $value,
+                'created_at' => now(),
+                'updated_at' => now(),
+            ]);
+        }
+
+        return DB::table('variantes')->where('id', $variantId)->first();
+    }
+
+    private function catalogPrice(string $sector, int $row): int
+    {
+        $prices = in_array($sector, ['A', 'C'], true)
+            ? [1 => 250000, 2 => 200000, 3 => 100000, 4 => 75000, 5 => 50000]
+            : [1 => 240000, 2 => 190000, 3 => 90000, 4 => 65000, 5 => 40000];
+
+        return $prices[$row];
+    }
+
+    private function createPurchaseItem(
+        int $purchaseId,
+        object $catalogItem,
+        object $variant,
+        string $sector,
+        int $row,
+        int $seat,
+        string $type,
+        DateTimeInterface $now,
+    ): int {
+        $existingId = DB::table('compra_items')
+            ->where('compra_id', $purchaseId)
+            ->where('source_variant_id', $variant->id)
+            ->value('id');
+        if ($existingId !== null) {
+            return (int) $existingId;
+        }
+
+        $attributes = [
+            ['name' => 'Tipo', 'value' => $type],
+            ['name' => 'Sector', 'value' => $sector],
+            ['name' => 'Fila', 'value' => (string) $row],
+            ['name' => 'Asiento', 'value' => (string) $seat],
+        ];
+
+        return DB::table('compra_items')->insertGetId([
+            'compra_id' => $purchaseId,
+            'source_catalog_item_id' => $catalogItem->id,
+            'source_variant_id' => $variant->id,
+            'image_attachment_id' => DB::table('catalog_items_attachments')
+                ->where('catalog_item_id', $catalogItem->id)
+                ->whereNull('variant_id')
+                ->orderBy('orden')
+                ->value('attachment_id'),
+            'nombre' => $catalogItem->nombre,
+            'descripcion' => $variant->descripcion,
+            'slug' => $catalogItem->slug,
+            'item_nombre' => "Entrada (Sector {$sector}, Fila {$row}, Asiento {$seat})",
+            'variant_attributes' => json_encode($attributes, JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR),
+            'cantidad' => 1,
+            'precio_unitario' => 0,
+            'discount_total' => 0,
+            'tax_total' => 0,
+            'total' => 0,
+            'created_at' => $now,
+            'updated_at' => $now,
+        ]);
+    }
+
+    private function createTicketAndCommitStock(
+        int $purchaseId,
+        int $purchaseItemId,
+        int $userId,
+        int $catalogItemId,
+        object $variant,
+        DateTimeInterface $now,
+    ): void {
+        $purchaseReference = Schema::hasColumn('tickets', 'source_purchase_item_id')
+            ? ['source_purchase_item_id' => $purchaseItemId]
+            : ['source_purchase_id' => $purchaseId];
+
+        if (DB::table('tickets')
+            ->where($purchaseReference)
+            ->where('source_variant_id', $variant->id)
+            ->exists()) {
+            return;
+        }
+
+        $inventory = DB::table('inventories')->where('id', $variant->inventory_id)->lockForUpdate()->first();
+
+        if ($inventory === null || $inventory->real_stock < 1 || $inventory->reserved_stock > 0) {
+            throw new RuntimeException("El asiento {$variant->descripcion} ya no está disponible.");
+        }
+
+        DB::table('inventories')->where('id', $inventory->id)->update([
+            'real_stock' => $inventory->real_stock - 1,
+            'sold_units' => $inventory->sold_units + 1,
+        ]);
+
+        $reservationId = DB::table('compras')->where('id', $purchaseId)->value('stock_reservation_id');
+        if ($reservationId === null) {
+            $reservationId = DB::table('stock_reservations')->insertGetId([
+                'status' => 'committed',
+                'committed_at' => $now,
+                'released_at' => null,
+                'expired_at' => null,
+                'release_reason' => null,
+                'created_at' => $now,
+                'updated_at' => $now,
+            ]);
+            DB::table('compras')->where('id', $purchaseId)->update([
+                'stock_reservation_id' => $reservationId,
+            ]);
+        }
+
+        DB::table('stock_reservation_lines')->insert([
+            'stock_reservation_id' => $reservationId,
+            'inventory_id' => $inventory->id,
+            'quantity' => 1,
+            'tracks_inventory' => true,
+            'created_at' => $now,
+            'updated_at' => $now,
+        ]);
+
+        DB::table('tickets')->insert([
+            'tenant_code' => self::TENANT_CODE,
+            'ticket' => (string) Str::uuid(),
+            'name' => null,
+            'description' => null,
+            ...$purchaseReference,
+            'source_catalog_item_id' => $catalogItemId,
+            'source_variant_id' => $variant->id,
+            'used_at' => null,
+            'scanner_user_id' => null,
+            'user_id' => $userId,
+        ]);
+    }
+}

app/Domains/Event/Controllers/AdminApp/EventController.php

@@ -2,7 +2,11 @@
 
 namespace App\Domains\Event\Controllers\AdminApp;
 
+use App\Domains\Event\Models\EventDate;
+use App\Domains\Event\Requests\RescheduleEventDateRequest;
+use App\Domains\Event\Requests\StoreEventDateRequest;
 use App\Domains\Event\Requests\UpdateEventRequest;
+use App\Domains\Event\Resources\EventDateResource;
 use App\Domains\Event\Resources\EventResource;
 use App\Domains\Event\Services\EventService;
 use App\Http\Controllers\Controller;
@@ -28,4 +32,39 @@ class EventController extends Controller
             )
         );
     }
+
+    public function storeDate(StoreEventDateRequest $request): EventDateResource
+    {
+        return EventDateResource::make(
+            $this->eventService->createDateForTenant(
+                $request->user()->tenant()->firstOrFail(),
+                $request->validated(),
+            )
+        );
+    }
+
+    public function rescheduleDate(
+        RescheduleEventDateRequest $request,
+        EventDate $eventDate,
+    ): EventDateResource {
+        return EventDateResource::make(
+            $this->eventService->rescheduleDateForTenant(
+                $request->user()->tenant()->firstOrFail(),
+                $eventDate,
+                $request->validated(),
+                $request->user(),
+            )
+        );
+    }
+
+    public function suspendDate(Request $request, EventDate $eventDate): EventDateResource
+    {
+        return EventDateResource::make(
+            $this->eventService->suspendDateForTenant(
+                $request->user()->tenant()->firstOrFail(),
+                $eventDate,
+                $request->user(),
+            )
+        );
+    }
 }

app/Domains/Event/Controllers/EventDateNoticeController.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Event\Controllers;
+
+use App\Domains\Event\Resources\EventDateNoticeResource;
+use App\Domains\Event\Services\EventDateNoticeService;
+use App\Domains\Tenant\Models\Tenant;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
+
+class EventDateNoticeController extends Controller
+{
+    public function __construct(private readonly EventDateNoticeService $noticeService) {}
+
+    public function claim(Request $request, Tenant $tenant): AnonymousResourceCollection
+    {
+        return EventDateNoticeResource::collection(
+            $this->noticeService->claimFor($request->user(), $tenant)
+        );
+    }
+}

app/Domains/Event/Enums/EventDateChangeType.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace App\Domains\Event\Enums;
+
+enum EventDateChangeType: string
+{
+    case Rescheduled = 'rescheduled';
+    case Suspended = 'suspended';
+}

app/Domains/Event/Enums/EventDateStatus.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace App\Domains\Event\Enums;
+
+enum EventDateStatus: string
+{
+    case Rescheduled = 'rescheduled';
+    case Suspended = 'suspended';
+    case Scheduled = 'scheduled';
+    case InProgress = 'in_progress';
+    case Completed = 'completed';
+}

app/Domains/Event/Events/EventDateRescheduled.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Event\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+
+class EventDateRescheduled
+{
+    use Dispatchable;
+
+    /**
+     * @param  list<array{purchase_id: int, ticket_ids: list<int>}>  $purchaseTickets
+     */
+    public function __construct(
+        public readonly string $tenantCode,
+        public readonly int $sourceEventDateId,
+        public readonly int $destinationEventDateId,
+        public readonly string $previousDate,
+        public readonly string $newDate,
+        public readonly array $purchaseTickets,
+    ) {}
+}

app/Domains/Event/Events/EventDateSuspended.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Domains\Event\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+
+class EventDateSuspended
+{
+    use Dispatchable;
+
+    /**
+     * @param  list<array{purchase_id: int, ticket_ids: list<int>}>  $purchaseTickets
+     */
+    public function __construct(
+        public readonly string $tenantCode,
+        public readonly int $eventDateId,
+        public readonly string $date,
+        public readonly array $purchaseTickets,
+    ) {}
+}

app/Domains/Event/Models/EventDate.php

@@ -3,6 +3,7 @@
 namespace App\Domains\Event\Models;
 
 use App\Domains\Catalog\Models\Variant;
+use App\Domains\Event\Enums\EventDateStatus;
 use App\Domains\Event\Services\EventDateTextFormatter;
 use App\Domains\Tenant\Models\Tenant;
 use App\Domains\Ticket\Enums\ValidityTimeType;
@@ -21,6 +22,8 @@ use Illuminate\Support\Carbon;
     'date',
     'time_start',
     'time_end',
+    'rescheduled_to_event_date_id',
+    'suspended_at',
 ])]
 class EventDate extends Model
 {
@@ -28,6 +31,8 @@ class EventDate extends Model
 
     public $timestamps = false;
 
+    protected $appends = ['status'];
+
     protected static function booted(): void
     {
         static::creating(fn (self $eventDate) => $eventDate->syncValidityTime());
@@ -52,6 +57,8 @@ class EventDate extends Model
         return [
             'date' => 'date:Y-m-d',
             'validity_time_id' => 'integer',
+            'rescheduled_to_event_date_id' => 'integer',
+            'suspended_at' => 'datetime',
         ];
     }
 
@@ -67,6 +74,30 @@ class EventDate extends Model
         return $this->belongsTo(ValidityTime::class);
     }
 
+    /** @return BelongsTo<EventDate, $this> */
+    public function rescheduledTo(): BelongsTo
+    {
+        return $this->belongsTo(self::class, 'rescheduled_to_event_date_id');
+    }
+
+    /** @return HasMany<EventDate, $this> */
+    public function rescheduledFrom(): HasMany
+    {
+        return $this->hasMany(self::class, 'rescheduled_to_event_date_id');
+    }
+
+    /** @return HasMany<EventDateChange, $this> */
+    public function changeHistory(): HasMany
+    {
+        return $this->hasMany(EventDateChange::class, 'source_event_date_id');
+    }
+
+    /** @return HasMany<EventDateChange, $this> */
+    public function destinationChangeHistory(): HasMany
+    {
+        return $this->hasMany(EventDateChange::class, 'destination_event_date_id');
+    }
+
     /** @return HasMany<Variant, $this> */
     public function variants(): HasMany
     {
@@ -91,7 +122,32 @@ class EventDate extends Model
 
     public function endsAt(): CarbonInterface
     {
-        return Carbon::parse($this->date->format('Y-m-d').' '.$this->time_end);
+        $endsAt = Carbon::parse($this->date->format('Y-m-d').' '.$this->time_end);
+
+        return $endsAt->lessThanOrEqualTo($this->startsAt())
+            ? $endsAt->addDay()
+            : $endsAt;
+    }
+
+    public function getStatusAttribute(): EventDateStatus
+    {
+        if ($this->rescheduled_to_event_date_id !== null) {
+            return EventDateStatus::Rescheduled;
+        }
+
+        if ($this->suspended_at !== null) {
+            return EventDateStatus::Suspended;
+        }
+
+        if (now()->lt($this->startsAt())) {
+            return EventDateStatus::Scheduled;
+        }
+
+        if (now()->lt($this->endsAt())) {
+            return EventDateStatus::InProgress;
+        }
+
+        return EventDateStatus::Completed;
     }
 
     private function syncTenantDateText(): void
@@ -104,7 +160,10 @@ class EventDate extends Model
 
         $tenant->update([
             'event_date_text' => app(EventDateTextFormatter::class)->format(
-                $tenant->eventDates()->pluck('date')
+                $tenant->eventDates()
+                    ->whereNull('rescheduled_to_event_date_id')
+                    ->whereNull('suspended_at')
+                    ->pluck('date')
             ),
         ]);
     }
@@ -114,10 +173,6 @@ class EventDate extends Model
         $startsAt = $this->startsAt();
         $expiresAt = $this->endsAt();
 
-        if ($expiresAt->lessThanOrEqualTo($startsAt)) {
-            $expiresAt = $expiresAt->addDay();
-        }
-
         $attributes = [
             'type' => ValidityTimeType::FixedWindow,
             'start_time' => null,

app/Domains/Event/Models/EventDateChange.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace App\Domains\Event\Models;
+
+use App\Domains\Auth\Models\User;
+use App\Domains\Event\Enums\EventDateChangeType;
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+#[Fillable([
+    'tenant_code',
+    'change_type',
+    'source_event_date_id',
+    'destination_event_date_id',
+    'created_by_user_id',
+    'previous_date',
+    'new_date',
+])]
+class EventDateChange extends Model
+{
+    public $timestamps = false;
+
+    protected function casts(): array
+    {
+        return [
+            'change_type' => EventDateChangeType::class,
+            'source_event_date_id' => 'integer',
+            'destination_event_date_id' => 'integer',
+            'created_by_user_id' => 'integer',
+            'previous_date' => 'date:Y-m-d',
+            'new_date' => 'date:Y-m-d',
+            'created_at' => 'datetime',
+        ];
+    }
+
+    /** @return BelongsTo<Tenant, $this> */
+    public function tenant(): BelongsTo
+    {
+        return $this->belongsTo(Tenant::class, 'tenant_code', 'codigo');
+    }
+
+    /** @return BelongsTo<EventDate, $this> */
+    public function sourceEventDate(): BelongsTo
+    {
+        return $this->belongsTo(EventDate::class, 'source_event_date_id');
+    }
+
+    /** @return BelongsTo<EventDate, $this> */
+    public function destinationEventDate(): BelongsTo
+    {
+        return $this->belongsTo(EventDate::class, 'destination_event_date_id');
+    }
+
+    /** @return BelongsTo<User, $this> */
+    public function createdBy(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'created_by_user_id')->withTrashed();
+    }
+
+    /** @return HasMany<EventDateChangeView, $this> */
+    public function views(): HasMany
+    {
+        return $this->hasMany(EventDateChangeView::class);
+    }
+}

app/Domains/Event/Models/EventDateChangeView.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Domains\Event\Models;
+
+use App\Domains\Auth\Models\User;
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+#[Fillable([
+    'user_id',
+    'event_date_change_id',
+    'display_count',
+    'last_displayed_at',
+])]
+class EventDateChangeView extends Model
+{
+    protected $table = 'user_event_date_change_views';
+
+    protected function casts(): array
+    {
+        return [
+            'user_id' => 'integer',
+            'event_date_change_id' => 'integer',
+            'display_count' => 'integer',
+            'last_displayed_at' => 'datetime',
+        ];
+    }
+
+    /** @return BelongsTo<User, $this> */
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+
+    /** @return BelongsTo<EventDateChange, $this> */
+    public function eventDateChange(): BelongsTo
+    {
+        return $this->belongsTo(EventDateChange::class);
+    }
+}

app/Domains/Event/Requests/RescheduleEventDateRequest.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Domains\Event\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class RescheduleEventDateRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /** @return array<string, mixed> */
+    public function rules(): array
+    {
+        return [
+            'date' => ['required', 'date_format:Y-m-d'],
+        ];
+    }
+}

app/Domains/Event/Requests/StoreEventDateRequest.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Domains\Event\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreEventDateRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /** @return array<string, mixed> */
+    public function rules(): array
+    {
+        return [
+            'date' => ['required', 'date_format:Y-m-d'],
+            'start_time' => ['required', 'date_format:H:i'],
+            'end_time' => ['required', 'date_format:H:i'],
+        ];
+    }
+}

app/Domains/Event/Requests/UpdateEventRequest.php

@@ -19,11 +19,6 @@ class UpdateEventRequest extends FormRequest
         return [
             'title' => ['required', 'string', 'max:255'],
             'location' => ['required', 'string', 'max:255'],
-            'dates' => ['required', 'array', 'min:1'],
-            'dates.*' => ['required', 'array:date,start_time,end_time'],
-            'dates.*.date' => ['required', 'date_format:Y-m-d', 'distinct'],
-            'dates.*.start_time' => ['required', 'date_format:H:i'],
-            'dates.*.end_time' => ['required', 'date_format:H:i'],
             'social_media' => ['sometimes', 'array'],
             'social_media.*' => ['required', 'array:code,url,orden'],
             'social_media.*.code' => [
@@ -38,6 +33,16 @@ class UpdateEventRequest extends FormRequest
             'contact.whatsapp_url' => ['nullable', 'url', 'max:2048'],
             'contact.instagram_url' => ['nullable', 'url', 'max:2048'],
             'contact.facebook_url' => ['nullable', 'url', 'max:2048'],
+            'allow_ticket_refund' => ['sometimes', 'boolean'],
+            'allow_ticket_total_refund' => ['sometimes', 'boolean'],
+            'allow_ticket_partial_refund' => ['sometimes', 'boolean'],
+            'ticket_partial_refund_percentage' => [
+                'sometimes',
+                'numeric',
+                'decimal:0,2',
+                'min:0',
+                'max:99.99',
+            ],
         ];
     }
 
@@ -54,6 +59,41 @@ class UpdateEventRequest extends FormRequest
                         'The social media field is required.'
                     );
                 }
+
+                if (! array_key_exists('allow_ticket_refund', $input)) {
+                    return;
+                }
+
+                foreach ([
+                    'allow_ticket_total_refund',
+                    'allow_ticket_partial_refund',
+                    'ticket_partial_refund_percentage',
+                ] as $field) {
+                    if (! array_key_exists($field, $input)) {
+                        $validator->errors()->add($field, 'El campo es obligatorio.');
+                    }
+                }
+
+                $totalEnabled = $this->boolean('allow_ticket_total_refund');
+                $partialEnabled = $this->boolean('allow_ticket_partial_refund');
+
+                $refundEnabled = $this->boolean('allow_ticket_refund');
+
+                if ($refundEnabled && ! $totalEnabled && ! $partialEnabled) {
+                    $validator->errors()->add(
+                        'allow_ticket_refund',
+                        'Seleccioná al menos un tipo de reembolso.'
+                    );
+                }
+
+                if ($refundEnabled
+                    && $partialEnabled
+                    && (float) ($input['ticket_partial_refund_percentage'] ?? 0) <= 0) {
+                    $validator->errors()->add(
+                        'ticket_partial_refund_percentage',
+                        'Ingresá un porcentaje mayor que cero para el reembolso parcial.'
+                    );
+                }
             },
         ];
     }

app/Domains/Event/Resources/EventDateChangeResource.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Domains\Event\Resources;
+
+use App\Domains\Event\Models\EventDateChange;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/** @mixin EventDateChange */
+class EventDateChangeResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        return [
+            'type' => $this->change_type->value,
+            'source_event_date_id' => $this->source_event_date_id,
+            'destination_event_date_id' => $this->destination_event_date_id,
+            'previous_date' => $this->previous_date->format('Y-m-d'),
+            'new_date' => $this->new_date?->format('Y-m-d'),
+            'occurred_at' => $this->created_at->toISOString(),
+        ];
+    }
+}

app/Domains/Event/Resources/EventDateNoticeResource.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Domains\Event\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class EventDateNoticeResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        return [
+            'type' => $this->resource['type'],
+            'change_ids' => $this->resource['change_ids'],
+            'title' => $this->resource['title'],
+            'message' => $this->resource['message'],
+        ];
+    }
+}

app/Domains/Event/Resources/EventDateResource.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Domains\Event\Resources;
+
+use App\Domains\Event\Models\EventDate;
+use App\Domains\Ticket\Resources\ValidityTimeResource;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/** @mixin EventDate */
+class EventDateResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'validity_time_id' => $this->validity_time_id,
+            'validity_time' => ValidityTimeResource::make($this->whenLoaded('validityTime')),
+            'date' => $this->date->format('Y-m-d'),
+            'start_time' => substr($this->time_start, 0, 5),
+            'end_time' => substr($this->time_end, 0, 5),
+            'status' => $this->status->value,
+            'rescheduled_to_event_date_id' => $this->rescheduled_to_event_date_id,
+            'suspended_at' => $this->suspended_at?->toISOString(),
+            'rescheduled_dates' => EventDateResource::collection(
+                $this->whenLoaded('adminRescheduledDates')
+            ),
+        ];
+    }
+}

app/Domains/Event/Resources/EventResource.php

@@ -2,8 +2,8 @@
 
 namespace App\Domains\Event\Resources;
 
+use App\Domains\Event\Services\EventDateGroupingService;
 use App\Domains\Tenant\Models\Tenant;
-use App\Domains\Ticket\Resources\ValidityTimeResource;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 
@@ -19,14 +19,13 @@ class EventResource extends JsonResource
             'id' => $this->id,
             'title' => $this->event_title,
             'location' => $this->event_location,
-            'dates' => $this->eventDates->map(fn ($eventDate): array => [
-                'id' => $eventDate->id,
-                'validity_time_id' => $eventDate->validity_time_id,
-                'validity_time' => ValidityTimeResource::make($eventDate->validityTime),
-                'date' => $eventDate->date->format('Y-m-d'),
-                'start_time' => substr($eventDate->time_start, 0, 5),
-                'end_time' => substr($eventDate->time_end, 0, 5),
-            ])->values(),
+            'allow_ticket_refund' => $this->allow_ticket_refund,
+            'allow_ticket_total_refund' => $this->allow_ticket_total_refund,
+            'allow_ticket_partial_refund' => $this->allow_ticket_partial_refund,
+            'ticket_partial_refund_percentage' => $this->ticket_partial_refund_percentage,
+            'dates' => EventDateResource::collection(
+                app(EventDateGroupingService::class)->group($this->eventDates)
+            ),
             'social_media' => $this->socialMedia->map(fn ($item): array => [
                 'code' => $item->code,
                 'url' => $item->pivot->url,

app/Domains/Event/Services/AffectedEventDatePurchaseResolver.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Domains\Event\Services;
+
+use App\Domains\Purchase\Models\Purchase;
+use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticket\Models\Ticket;
+use App\Domains\Ticket\Services\TicketValidityResolver;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Collection;
+
+class AffectedEventDatePurchaseResolver
+{
+    /**
+     * Finds active tickets belonging to paid purchases before an event-date mutation.
+     *
+     * @param  Collection<int, int>|list<int>  $eventDateIds
+     * @return list<array{purchase_id: int, ticket_ids: list<int>}>
+     */
+    public function resolve(Tenant $tenant, Collection|array $eventDateIds): array
+    {
+        $eventDateIds = collect($eventDateIds)->map(fn (mixed $id): int => (int) $id)->unique()->values();
+
+        if ($eventDateIds->isEmpty()) {
+            return [];
+        }
+
+        /** @var Collection<int, Ticket> $tickets */
+        $tickets = Ticket::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->whereHas('sourcePurchaseItem.purchase', fn (Builder $query) => $query
+                ->where('status', Purchase::STATUS_PAID))
+            ->whereHas('sourceVariant', function (Builder $query) use ($eventDateIds): void {
+                $query->whereIn('event_date_id', $eventDateIds)
+                    ->orWhereHas('eventDates', fn (Builder $eventDates) => $eventDates
+                        ->whereIn('event_dates.id', $eventDateIds));
+            })
+            ->with([
+                ...TicketValidityResolver::RELATIONS,
+                'sourcePurchaseItem.purchase',
+            ])
+            ->get()
+            ->filter(fn (Ticket $ticket): bool => $ticket->is_active())
+            ->values();
+
+        return $tickets
+            ->groupBy(fn (Ticket $ticket): int => (int) $ticket->sourcePurchaseItem->purchase->getKey())
+            ->map(function (Collection $purchaseTickets): array {
+                return [
+                    'purchase_id' => (int) $purchaseTickets->first()->sourcePurchaseItem->purchase->getKey(),
+                    'ticket_ids' => $purchaseTickets->modelKeys(),
+                ];
+            })
+            ->values()
+            ->all();
+    }
+}

app/Domains/Event/Services/EffectiveEventDateResolver.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Domains\Event\Services;
+
+use App\Domains\Event\Models\EventDate;
+
+class EffectiveEventDateResolver
+{
+    public function resolve(EventDate $eventDate): ?EventDate
+    {
+        $date = $this->resolveLatest($eventDate);
+
+        return $date !== null && $date->suspended_at === null ? $date : null;
+    }
+
+    /** Sigue las reprogramaciones para presentación, incluso si el destino está suspendido. */
+    public function resolveLatest(EventDate $eventDate): ?EventDate
+    {
+        $current = $eventDate;
+        $visited = [];
+
+        while (true) {
+            $identity = $current->getKey() === null
+                ? 'object:'.spl_object_id($current)
+                : 'key:'.$current->getKey();
+
+            if (isset($visited[$identity])) {
+                return null;
+            }
+
+            $visited[$identity] = true;
+
+            if ($current->rescheduled_to_event_date_id === null) {
+                return $current;
+            }
+
+            $current->loadMissing('rescheduledTo');
+            $current = $current->rescheduledTo;
+
+            if ($current === null) {
+                return null;
+            }
+        }
+    }
+}

app/Domains/Event/Services/EventDateGroupingService.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace App\Domains\Event\Services;
+
+use App\Domains\Event\Models\EventDate;
+use Illuminate\Database\Eloquent\Collection as EloquentCollection;
+use Illuminate\Support\Collection;
+
+class EventDateGroupingService
+{
+    /**
+     * Groups every historical date under its final active destination.
+     *
+     * @param  Collection<int, EventDate>  $dates
+     * @return Collection<int, EventDate>
+     */
+    public function group(Collection $dates): Collection
+    {
+        $byId = $dates->keyBy(fn (EventDate $date): int => (int) $date->getKey());
+        $groups = collect();
+
+        foreach ($dates as $date) {
+            $destination = $this->finalDestination($date, $byId);
+            $key = (int) $destination->getKey();
+
+            if (! $groups->has($key)) {
+                $groups->put($key, [
+                    'destination' => $destination,
+                    'rescheduled' => collect(),
+                ]);
+            }
+
+            if (! $date->is($destination)) {
+                $group = $groups->get($key);
+                $historicalDate = clone $date;
+                $historicalDate->setAttribute(
+                    'rescheduled_to_event_date_id',
+                    $destination->getKey(),
+                );
+                $group['rescheduled']->push($historicalDate);
+                $groups->put($key, $group);
+            }
+        }
+
+        return $groups
+            ->map(function (array $group): EventDate {
+                /** @var EventDate $destination */
+                $destination = clone $group['destination'];
+                /** @var Collection<int, EventDate> $rescheduled */
+                $rescheduled = $group['rescheduled'];
+                $destination->setRelation(
+                    'adminRescheduledDates',
+                    new EloquentCollection($rescheduled->sort($this->dateSorter())->values()->all()),
+                );
+
+                return $destination;
+            })
+            ->sort($this->dateSorter())
+            ->values();
+    }
+
+    /** @param Collection<int, EventDate> $byId */
+    private function finalDestination(EventDate $date, Collection $byId): EventDate
+    {
+        $current = $date;
+        $visited = collect();
+
+        while ($current->rescheduled_to_event_date_id !== null) {
+            $currentId = (int) $current->getKey();
+
+            if ($visited->contains($currentId)) {
+                break;
+            }
+
+            $visited->push($currentId);
+            $destination = $byId->get((int) $current->rescheduled_to_event_date_id);
+
+            if (! $destination instanceof EventDate) {
+                break;
+            }
+
+            $current = $destination;
+        }
+
+        return $current;
+    }
+
+    /** @return callable(EventDate, EventDate): int */
+    private function dateSorter(): callable
+    {
+        return fn (EventDate $left, EventDate $right): int => [
+            $left->date->format('Y-m-d'),
+            $left->time_start,
+            $left->getKey(),
+        ] <=> [
+            $right->date->format('Y-m-d'),
+            $right->time_start,
+            $right->getKey(),
+        ];
+    }
+}

app/Domains/Event/Services/EventDateInfoFormatter.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace App\Domains\Event\Services;
+
+use App\Domains\Event\Enums\EventDateChangeType;
+use App\Domains\Event\Models\EventDate;
+use App\Domains\Event\Models\EventDateChange;
+use Illuminate\Support\Collection;
+
+class EventDateInfoFormatter
+{
+    /** @param Collection<int, EventDateChange> $changes */
+    public function format(EventDate $eventDate, Collection $changes): ?string
+    {
+        $messages = collect();
+
+        if ($eventDate->suspended_at !== null) {
+            $messages->push('Esta fecha fue cancelada.');
+        }
+
+        $sourceDates = $this->reschedulesEndingAt($eventDate, $changes)
+            ->pluck('previous_date')
+            ->filter()
+            ->map(fn ($date): string => $date->format('d/m/Y'))
+            ->unique()
+            ->values();
+
+        if ($sourceDates->isNotEmpty()) {
+            $verb = $sourceDates->count() === 1 ? 'se reprogramó' : 'se reprogramaron';
+            $messages->push("{$sourceDates->join(', ', ' y ')} {$verb} para este día.");
+        }
+
+        return $messages->isEmpty() ? null : $messages->join(' ');
+    }
+
+    /**
+     * Includes direct and intermediate reschedules that ultimately end at the
+     * displayed event date, while preserving the original change order.
+     *
+     * @param  Collection<int, EventDateChange>  $changes
+     * @return Collection<int, EventDateChange>
+     */
+    private function reschedulesEndingAt(EventDate $eventDate, Collection $changes): Collection
+    {
+        $eventDateId = $eventDate->getKey();
+        $reschedules = $changes->where('change_type', EventDateChangeType::Rescheduled);
+
+        if ($eventDateId === null) {
+            return $reschedules->where('destination_event_date_id', null);
+        }
+
+        $destinationIds = [(int) $eventDateId => true];
+
+        do {
+            $foundAncestor = false;
+
+            foreach ($reschedules as $change) {
+                $destinationId = $change->destination_event_date_id;
+                $sourceId = $change->source_event_date_id;
+
+                if ($destinationId === null || $sourceId === null) {
+                    continue;
+                }
+
+                if (isset($destinationIds[(int) $destinationId]) && ! isset($destinationIds[(int) $sourceId])) {
+                    $destinationIds[(int) $sourceId] = true;
+                    $foundAncestor = true;
+                }
+            }
+        } while ($foundAncestor);
+
+        return $reschedules
+            ->filter(fn (EventDateChange $change): bool => $change->destination_event_date_id !== null
+                && isset($destinationIds[(int) $change->destination_event_date_id]));
+    }
+}

app/Domains/Event/Services/EventDateNoticeFormatter.php

@@ -0,0 +1,126 @@
+<?php
+
+namespace App\Domains\Event\Services;
+
+use App\Domains\Event\Enums\EventDateChangeType;
+use App\Domains\Event\Models\EventDateChange;
+use Illuminate\Support\Collection;
+
+class EventDateNoticeFormatter
+{
+    public function __construct(private readonly EventDateTextFormatter $dateTextFormatter) {}
+
+    /**
+     * @param  Collection<int, EventDateChange>  $changes
+     * @return list<array{
+     *     type: string,
+     *     change_ids: list<int>,
+     *     title: string,
+     *     message: list<array{text: string, bold: bool}>
+     * }>
+     */
+    public function format(Collection $changes): array
+    {
+        return collect([
+            $this->suspensionNotice(
+                $changes->where('change_type', EventDateChangeType::Suspended)
+            ),
+            $this->rescheduleNotice(
+                $changes->where('change_type', EventDateChangeType::Rescheduled)
+            ),
+        ])->filter()->values()->all();
+    }
+
+    /**
+     * @param  Collection<int, EventDateChange>  $changes
+     * @return array{type: string, change_ids: list<int>, title: string, message: list<array{text: string, bold: bool}>}|null
+     */
+    private function suspensionNotice(Collection $changes): ?array
+    {
+        $dates = $this->formatDates($changes, 'previous_date');
+
+        if ($dates === null) {
+            return null;
+        }
+
+        $plural = $changes->count() > 1;
+
+        return [
+            'type' => EventDateChangeType::Suspended->value,
+            'change_ids' => $this->changeIds($changes),
+            'title' => $plural ? 'FECHAS CANCELADAS!' : 'FECHA CANCELADA!',
+            'message' => [
+                ['text' => $plural ? 'Las fechas del ' : 'La fecha del ', 'bold' => false],
+                ['text' => $dates, 'bold' => true],
+                ['text' => $plural ? ' han sido canceladas.' : ' ha sido cancelada.', 'bold' => false],
+            ],
+        ];
+    }
+
+    /**
+     * @param  Collection<int, EventDateChange>  $changes
+     * @return array{type: string, change_ids: list<int>, title: string, message: list<array{text: string, bold: bool}>}|null
+     */
+    private function rescheduleNotice(Collection $changes): ?array
+    {
+        $changes = $changes->whereNotNull('new_date');
+        $sourceDates = $this->formatDates($changes, 'previous_date');
+        $destinationDates = $this->formatDates($changes, 'new_date');
+
+        if ($sourceDates === null || $destinationDates === null) {
+            return null;
+        }
+
+        $plural = $changes->count() > 1;
+        $message = [
+            ['text' => $plural ? 'Las fechas del ' : 'La fecha del ', 'bold' => false],
+            ['text' => $sourceDates, 'bold' => true],
+            [
+                'text' => $plural ? ' han sido reprogramadas para el ' : ' ha sido reprogramada para el ',
+                'bold' => false,
+            ],
+            ['text' => $destinationDates, 'bold' => true],
+        ];
+
+        if ($plural) {
+            $message[] = ['text' => ', ', 'bold' => false];
+            $message[] = ['text' => 'respectivamente', 'bold' => true];
+        }
+
+        $message[] = ['text' => '.', 'bold' => false];
+
+        return [
+            'type' => EventDateChangeType::Rescheduled->value,
+            'change_ids' => $this->changeIds($changes),
+            'title' => $plural ? 'FECHAS REPROGRAMADAS!' : 'FECHA REPROGRAMADA!',
+            'message' => $message,
+        ];
+    }
+
+    /**
+     * @param  Collection<int, EventDateChange>  $changes
+     */
+    private function formatDates(Collection $changes, string $attribute): ?string
+    {
+        return $this->dateTextFormatter->formatForSentence(
+            $changes
+                ->pluck($attribute)
+                ->filter()
+                ->map(fn ($date): string => $date->format('Y-m-d'))
+        );
+    }
+
+    /**
+     * @param  Collection<int, EventDateChange>  $changes
+     * @return list<int>
+     */
+    private function changeIds(Collection $changes): array
+    {
+        return $changes
+            ->pluck('id')
+            ->filter(fn ($id): bool => $id !== null)
+            ->map(fn ($id): int => (int) $id)
+            ->values()
+            ->all();
+    }
+}

app/Domains/Event/Services/EventDateNoticeService.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Domains\Event\Services;
+
+use App\Domains\Auth\Models\User;
+use App\Domains\Event\Models\EventDateChange;
+use App\Domains\Event\Models\EventDateChangeView;
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Support\Facades\DB;
+
+class EventDateNoticeService
+{
+    public const MAX_DISPLAYS = 3;
+
+    public function __construct(private readonly EventDateNoticeFormatter $formatter) {}
+
+    /**
+     * Claims one display of every pending change and returns them grouped by type.
+     *
+     * @return list<array{
+     *     type: string,
+     *     change_ids: list<int>,
+     *     title: string,
+     *     message: list<array{text: string, bold: bool}>
+     * }>
+     */
+    public function claimFor(User $user, Tenant $tenant): array
+    {
+        return DB::transaction(function () use ($user, $tenant): array {
+            $lockedUser = User::query()->whereKey($user->getKey())->lockForUpdate()->firstOrFail();
+
+            $changes = EventDateChange::query()
+                ->where('tenant_code', $tenant->codigo)
+                ->whereDoesntHave('views', fn ($query) => $query
+                    ->where('user_id', $lockedUser->getKey())
+                    ->where('display_count', '>=', self::MAX_DISPLAYS))
+                ->orderBy('created_at')
+                ->orderBy('id')
+                ->get();
+
+            $notices = $this->formatter->format($changes);
+            $claimedChangeIds = collect($notices)->pluck('change_ids')->flatten()->unique();
+
+            foreach ($claimedChangeIds as $changeId) {
+                $view = EventDateChangeView::query()->firstOrNew([
+                    'user_id' => $lockedUser->getKey(),
+                    'event_date_change_id' => $changeId,
+                ]);
+                $view->display_count = min(
+                    self::MAX_DISPLAYS,
+                    ((int) $view->display_count) + 1,
+                );
+                $view->last_displayed_at = now();
+                $view->save();
+            }
+
+            return $notices;
+        });
+    }
+}

app/Domains/Event/Services/EventDateTextFormatter.php

@@ -25,6 +25,21 @@ class EventDateTextFormatter
     /** @param iterable<string> $dates */
     public function format(iterable $dates): ?string
     {
+        return $this->formatWithOptions($dates, false, false);
+    }
+
+    /** @param iterable<string> $dates */
+    public function formatForSentence(iterable $dates): ?string
+    {
+        return $this->formatWithOptions($dates, true, true);
+    }
+
+    /** @param iterable<string> $dates */
+    private function formatWithOptions(
+        iterable $dates,
+        bool $padDays,
+        bool $includeYearPreposition,
+    ): ?string {
         $normalizedDates = collect($dates)
             ->map(fn (string $date): DateTimeImmutable => new DateTimeImmutable($date))
             ->unique(fn (DateTimeImmutable $date): string => $date->format('Y-m-d'))
@@ -37,12 +52,14 @@ class EventDateTextFormatter
 
         $years = $normalizedDates
             ->groupBy(fn (DateTimeImmutable $date): string => $date->format('Y'))
-            ->map(function ($yearDates, string $year): string {
+            ->map(function ($yearDates, string $year) use ($padDays, $includeYearPreposition): string {
                 $months = $yearDates
                     ->groupBy(fn (DateTimeImmutable $date): string => $date->format('n'))
-                    ->map(function ($monthDates, string $month): string {
+                    ->map(function ($monthDates, string $month) use ($padDays): string {
                         $days = $monthDates
-                            ->map(fn (DateTimeImmutable $date): string => (string) ((int) $date->format('j')))
+                            ->map(fn (DateTimeImmutable $date): string => $padDays
+                                ? $date->format('d')
+                                : (string) ((int) $date->format('j')))
                             ->values()
                             ->all();
 
@@ -51,7 +68,7 @@ class EventDateTextFormatter
                     ->values()
                     ->all();
 
-                return $this->join($months).' '.$year;
+                return $this->join($months).($includeYearPreposition ? ' de ' : ' ').$year;
             })
             ->values()
             ->all();

app/Domains/Event/Services/EventService.php

@@ -2,7 +2,17 @@
 
 namespace App\Domains\Event\Services;
 
+use App\Domains\Auth\Models\User;
+use App\Domains\Catalog\Models\Variant;
+use App\Domains\Catalog\Services\VariantReplacementService;
+use App\Domains\Event\Enums\EventDateChangeType;
+use App\Domains\Event\Events\EventDateRescheduled;
+use App\Domains\Event\Events\EventDateSuspended;
+use App\Domains\Event\Models\EventDate;
+use App\Domains\Event\Models\EventDateChange;
 use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticket\Models\Ticket;
+use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Validation\ValidationException;
 
@@ -14,6 +24,12 @@ class EventService
         'facebook_url' => 'facebook',
     ];
 
+    public function __construct(
+        private readonly EffectiveEventDateResolver $effectiveEventDateResolver,
+        private readonly AffectedEventDatePurchaseResolver $affectedPurchaseResolver,
+        private readonly VariantReplacementService $variantReplacementService,
+    ) {}
+
     public function forTenant(Tenant $tenant): Tenant
     {
         return $tenant->load(['eventDates.validityTime', 'socialMedia']);
@@ -27,9 +43,14 @@ class EventService
             $tenant->update([
                 'event_title' => $data['title'],
                 'event_location' => $data['location'],
+                ...array_intersect_key($data, array_flip([
+                    'allow_ticket_refund',
+                    'allow_ticket_total_refund',
+                    'allow_ticket_partial_refund',
+                    'ticket_partial_refund_percentage',
+                ])),
             ]);
 
-            $this->syncDates($tenant, $data['dates']);
             if (array_key_exists('social_media', $data)) {
                 $this->syncSocialMedia($tenant, $data['social_media']);
             } else {
@@ -40,41 +61,247 @@ class EventService
         });
     }
 
-    /** @param array<int, array{date: string, start_time: string, end_time: string}> $dates */
-    private function syncDates(Tenant $tenant, array $dates): void
+    /** @param array{date: string, start_time: string, end_time: string} $data */
+    public function createDateForTenant(Tenant $tenant, array $data): EventDate
     {
-        $existingDates = $tenant->eventDates()->get()->values();
+        return DB::transaction(function () use ($tenant, $data): EventDate {
+            $attributes = $this->dateAttributes($data);
 
-        foreach (array_values($dates) as $index => $date) {
-            $attributes = [
-                'date' => $date['date'],
-                'time_start' => $date['start_time'],
-                'time_end' => $date['end_time'],
-            ];
+            if ($tenant->eventDates()->where($attributes)->exists()) {
+                throw ValidationException::withMessages([
+                    'date' => ['La fecha y el horario ya existen.'],
+                ]);
+            }
 
-            $existingDate = $existingDates->get($index);
+            return $tenant->eventDates()->create($attributes)->load('validityTime');
+        });
+    }
 
-            if ($existingDate) {
-                $existingDate->update($attributes);
-            } else {
-                $tenant->eventDates()->create($attributes);
+    /** @param array{date: string} $data */
+    public function rescheduleDateForTenant(
+        Tenant $tenant,
+        EventDate $eventDate,
+        array $data,
+        ?User $createdBy = null,
+    ): EventDate {
+        return DB::transaction(function () use ($tenant, $eventDate, $data, $createdBy): EventDate {
+            $source = $this->lockedDateForTenant($tenant, $eventDate);
+
+            if ($source->suspended_at !== null) {
+                throw ValidationException::withMessages([
+                    'event_date' => ['No se puede reprogramar una fecha suspendida.'],
+                ]);
+            }
+
+            if ($source->rescheduled_to_event_date_id !== null) {
+                throw ValidationException::withMessages([
+                    'event_date' => ['La fecha ya fue reprogramada.'],
+                ]);
+            }
+
+            $destination = $tenant->eventDates()
+                ->whereDate('date', $data['date'])
+                ->lockForUpdate()
+                ->first();
+
+            if ($destination === null) {
+                $destination = $tenant->eventDates()->create([
+                    'date' => $data['date'],
+                    'time_start' => $source->time_start,
+                    'time_end' => $source->time_end,
+                ]);
+            }
+
+            if ($destination->is($source) || $this->chainContains($destination, $source)) {
+                throw ValidationException::withMessages([
+                    'date' => ['La reprogramación generaría una referencia circular.'],
+                ]);
+            }
+
+            $effectiveDestination = $this->effectiveEventDateResolver->resolve($destination);
+            if ($effectiveDestination === null) {
+                throw ValidationException::withMessages([
+                    'date' => ['La fecha de destino no es utilizable.'],
+                ]);
+            }
+
+            $purchaseTickets = $this->affectedPurchaseResolver->resolve(
+                $tenant,
+                $this->affectedDateIds($tenant, $source),
+            );
+            $source->update(['rescheduled_to_event_date_id' => $destination->getKey()]);
+            $this->variantReplacementService->replaceEventDate($source, $effectiveDestination);
+
+            EventDateChange::query()->create([
+                'tenant_code' => $tenant->codigo,
+                'change_type' => EventDateChangeType::Rescheduled,
+                'source_event_date_id' => $source->getKey(),
+                'destination_event_date_id' => $destination->getKey(),
+                'created_by_user_id' => $createdBy?->getKey(),
+                'previous_date' => $source->date->format('Y-m-d'),
+                'new_date' => $destination->date->format('Y-m-d'),
+            ]);
+
+            EventDateRescheduled::dispatch(
+                $tenant->codigo,
+                $source->getKey(),
+                $destination->getKey(),
+                $source->date->format('d/m/Y'),
+                $destination->date->format('d/m/Y'),
+                $purchaseTickets,
+            );
+
+            return $source->fresh(['validityTime', 'rescheduledTo.validityTime']);
+        });
+    }
+
+    public function suspendDateForTenant(
+        Tenant $tenant,
+        EventDate $eventDate,
+        ?User $createdBy = null,
+    ): EventDate {
+        return DB::transaction(function () use ($tenant, $eventDate, $createdBy): EventDate {
+            $date = $this->lockedDateForTenant($tenant, $eventDate);
+
+            if ($date->rescheduled_to_event_date_id !== null) {
+                throw ValidationException::withMessages([
+                    'event_date' => ['No se puede suspender una fecha que ya fue reprogramada.'],
+                ]);
+            }
+
+            if ($date->suspended_at !== null) {
+                return $date->load('validityTime');
+            }
+
+            $purchaseTickets = $this->affectedPurchaseResolver->resolve(
+                $tenant,
+                $this->affectedDateIds($tenant, $date),
+            );
+            $date->update(['suspended_at' => now()]);
+            $this->variantReplacementService->disableForSuspension($date);
+            $this->disableTicketsWithoutUsableDates($tenant, $date);
+
+            EventDateChange::query()->create([
+                'tenant_code' => $tenant->codigo,
+                'change_type' => EventDateChangeType::Suspended,
+                'source_event_date_id' => $date->getKey(),
+                'destination_event_date_id' => null,
+                'created_by_user_id' => $createdBy?->getKey(),
+                'previous_date' => $date->date->format('Y-m-d'),
+                'new_date' => null,
+            ]);
+
+            EventDateSuspended::dispatch(
+                $tenant->codigo,
+                $date->getKey(),
+                $date->date->format('d/m/Y'),
+                $purchaseTickets,
+            );
+
+            return $date->fresh('validityTime');
+        });
+    }
+
+    private function lockedDateForTenant(Tenant $tenant, EventDate $eventDate): EventDate
+    {
+        return $tenant->eventDates()
+            ->whereKey($eventDate->getKey())
+            ->lockForUpdate()
+            ->firstOrFail();
+    }
+
+    private function chainContains(EventDate $start, EventDate $expected): bool
+    {
+        $current = $start;
+        $visited = [];
+
+        while ($current->rescheduled_to_event_date_id !== null) {
+            if ($current->is($expected)) {
+                return true;
+            }
+
+            if (isset($visited[$current->getKey()])) {
+                return true;
+            }
+
+            $visited[$current->getKey()] = true;
+            $current = $current->rescheduledTo()->lockForUpdate()->first();
+
+            if ($current === null) {
+                return false;
             }
         }
 
-        $datesToDelete = $existingDates->slice(count($dates));
+        return $current->is($expected);
+    }
 
-        if ($datesToDelete->contains(fn ($eventDate): bool => $eventDate
-            ->selectedByVariants()
-            ->whereHas('sourceTickets')
-            ->exists()
-            || $eventDate->variants()->whereHas('sourceTickets')->exists())) {
-            throw ValidationException::withMessages([
-                'dates' => ['No se puede eliminar una fecha utilizada por tickets generados.'],
-            ]);
+    /** @return Collection<int, int> */
+    private function affectedDateIds(Tenant $tenant, EventDate $eventDate): Collection
+    {
+        $affectedDateIds = collect([$eventDate->getKey()]);
+        $frontier = $affectedDateIds;
+
+        while ($frontier->isNotEmpty()) {
+            $predecessors = $tenant->eventDates()
+                ->whereIn('rescheduled_to_event_date_id', $frontier)
+                ->pluck('id')
+                ->diff($affectedDateIds)
+                ->values();
+            $affectedDateIds = $affectedDateIds->merge($predecessors)->unique()->values();
+            $frontier = $predecessors;
         }
 
-        $datesToDelete->each->delete();
-        $tenant->unsetRelation('eventDates');
+        return $affectedDateIds;
+    }
+
+    private function disableTicketsWithoutUsableDates(Tenant $tenant, EventDate $suspendedDate): void
+    {
+        $affectedDateIds = $this->affectedDateIds($tenant, $suspendedDate);
+
+        $variants = Variant::withTrashed()
+            ->where(function ($query) use ($affectedDateIds): void {
+                $query->whereIn('event_date_id', $affectedDateIds)
+                    ->orWhereHas('eventDates', fn ($eventDates) => $eventDates
+                        ->whereIn('event_dates.id', $affectedDateIds));
+            })
+            ->with(['eventDates', 'eventDate'])
+            ->get();
+
+        foreach ($variants as $variant) {
+            $hasUsableDate = $variant->selectedEventDates()->contains(
+                fn (EventDate $candidate): bool => $this->effectiveEventDateResolver->resolve($candidate) !== null
+            );
+
+            if ($hasUsableDate) {
+                continue;
+            }
+
+            Ticket::query()
+                ->where('tenant_code', $tenant->codigo)
+                ->where('source_variant_id', $variant->getKey())
+                ->whereNull('disabled_at')
+                ->whereNull('cancelled_at')
+                ->whereNull('refunded_at')
+                ->lockForUpdate()
+                ->get()
+                ->each(function (Ticket $ticket): void {
+                    $ticket->markAsDisabled();
+                    $ticket->save();
+                });
+        }
+    }
+
+    /**
+     * @param  array{date: string, start_time: string, end_time: string}  $data
+     * @return array{date: string, time_start: string, time_end: string}
+     */
+    private function dateAttributes(array $data): array
+    {
+        return [
+            'date' => $data['date'],
+            'time_start' => $data['start_time'].':00',
+            'time_end' => $data['end_time'].':00',
+        ];
     }
 
     /** @param array<string, string|null> $contact */

app/Domains/Event/documentacion/README.md

@@ -8,6 +8,7 @@ Administra la configuración temporal de un tenant orientado a eventos y sus fec
 
 - `Models/EventDate.php`: fecha del evento con inicio, fin, tenant y variantes asociadas.
 - `Services/EventService.php`: obtiene y actualiza la configuración de evento del tenant.
+- `Services/EventDateNoticeService.php`: reclama y agrupa los cambios pendientes de cada usuario.
 - `Controllers/AdminApp/EventController.php`: consulta y modificación desde AdminApp.
 - `UpdateEventRequest`: valida datos y reglas cruzadas de fechas.
 - `EventResource`: serializa la configuración de salida.
@@ -19,10 +20,18 @@ Bajo `/v1/adminapp/tenant/event`, protegidos por `auth:sanctum` y `adminapp.tena
 - `GET`: obtiene la configuración.
 - `PUT`: actualiza la configuración.
 
+Para el storefront autenticado:
+
+- `POST /tenants/{tenant}/event-date-notices/claim`: devuelve hasta un aviso de suspensiones y otro de
+  reprogramaciones. Cada cambio se muestra como máximo tres veces por usuario.
+
 ## Dependencias
 
 Depende de `Tenant`. Las fechas se vinculan con variantes de `Catalog`, que a su vez pueden generar tickets.
 
 ## Consideraciones
 
-El archivo `routes/api.php` no publica operaciones adicionales. Al modificar fechas debe mantenerse la validación de orden y coherencia temporal de `UpdateEventRequest`.
+Los avisos se construyen dinámicamente después de excluir los cambios que el usuario ya vio
+tres veces. Al reclamar los avisos se incrementa una vez cada cambio incluido, aunque varios
+cambios aparezcan agrupados en el mismo mensaje. El reclamo bloquea al usuario durante la
+transacción para impedir que pestañas concurrentes superen el máximo.

app/Domains/Event/routes/adminapp.php

@@ -8,4 +8,7 @@ Route::prefix('v1/adminapp/tenant')
     ->group(function (): void {
         Route::get('event', [EventController::class, 'show']);
         Route::put('event', [EventController::class, 'update']);
+        Route::post('event-dates', [EventController::class, 'storeDate']);
+        Route::post('event-dates/{eventDate}/reschedule', [EventController::class, 'rescheduleDate']);
+        Route::post('event-dates/{eventDate}/suspend', [EventController::class, 'suspendDate']);
     });

app/Domains/Event/routes/api.php

@@ -1,3 +1,11 @@
 <?php
 
+use App\Domains\Event\Controllers\EventDateNoticeController;
+use Illuminate\Support\Facades\Route;
+
 require __DIR__.'/adminapp.php';
+
+Route::middleware('auth:sanctum')->post(
+    'tenants/{tenant:codigo}/event-date-notices/claim',
+    [EventDateNoticeController::class, 'claim'],
+);

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/Controllers/FoodController.php

@@ -2,6 +2,7 @@
 
 namespace App\Domains\FiestaFutbolInfantil\Controllers;
 
+use App\Domains\FiestaFutbolInfantil\Requests\UpdateHistoricalFoodStockRequest;
 use App\Domains\FiestaFutbolInfantil\Requests\UpsertFoodVariantsRequest;
 use App\Domains\FiestaFutbolInfantil\Resources\FoodResource;
 use App\Domains\FiestaFutbolInfantil\Services\FoodService;
@@ -32,6 +33,16 @@ class FoodController extends Controller
         );
     }
 
+    public function updateHistoricalStock(UpdateHistoricalFoodStockRequest $request): FoodResource
+    {
+        return FoodResource::make(
+            $this->foodService->updateHistoricalStock(
+                $request->user()->tenant()->firstOrFail(),
+                $request->validated('variants'),
+            )
+        );
+    }
+
     public function destroy(Request $request, int $food): Response
     {
         $this->foodService->delete(

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/Requests/UpdateHistoricalFoodStockRequest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Domains\FiestaFutbolInfantil\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class UpdateHistoricalFoodStockRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /** @return array<string, mixed> */
+    public function rules(): array
+    {
+        return [
+            'variants' => ['required', 'array', 'min:1', 'max:500'],
+            'variants.*' => ['required', 'array:id,stock'],
+            'variants.*.id' => ['required', 'integer', 'distinct'],
+            'variants.*.stock' => ['required', 'integer', 'min:0'],
+        ];
+    }
+}

app/Domains/FiestaFutbolInfantil/Resources/EntryResource.php

@@ -5,6 +5,7 @@ namespace App\Domains\FiestaFutbolInfantil\Resources;
 use App\Domains\Catalog\Models\CatalogItem;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
+use Illuminate\Validation\ValidationException;
 
 /** @mixin CatalogItem */
 class EntryResource extends JsonResource
@@ -12,7 +13,20 @@ class EntryResource extends JsonResource
     /** @return array<string, mixed> */
     public function toArray(Request $request): array
     {
-        $variant = $this->variants->sole();
+        $variants = $this->variants->whereNull('replaced_by_variant_id');
+
+        if ($variants->count() !== 1) {
+            throw ValidationException::withMessages([
+                'entries' => [sprintf(
+                    'La entrada %s tiene %d variantes sin reemplazar (IDs: %s). Se esperaba una.',
+                    $this->id,
+                    $variants->count(),
+                    $variants->pluck('id')->implode(', '),
+                )],
+            ]);
+        }
+
+        $variant = $variants->first();
 
         return [
             'id' => $this->id,

app/Domains/FiestaFutbolInfantil/Resources/FoodResource.php

@@ -3,8 +3,14 @@
 namespace App\Domains\FiestaFutbolInfantil\Resources;
 
 use App\Domains\Catalog\Models\CatalogItem;
+use App\Domains\Catalog\Models\Variant;
+use App\Domains\Event\Enums\EventDateChangeType;
+use App\Domains\Event\Enums\EventDateStatus;
+use App\Domains\Event\Models\EventDate;
+use App\Domains\Event\Models\EventDateChange;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
+use Illuminate\Support\Collection;
 
 /** @mixin CatalogItem */
 class FoodResource extends JsonResource
@@ -17,27 +23,134 @@ class FoodResource extends JsonResource
                 'id' => null,
                 'name' => 'Comida',
                 'variants' => [],
+                'history' => [],
             ];
         }
 
+        $currentVariants = $this->variants
+            ->filter(fn (Variant $variant): bool => $this->isCurrent($variant));
+        $historicalVariants = $this->variants
+            ->filter(fn (Variant $variant): bool => $this->isHistorical($variant));
+
         return [
             'id' => $this->id,
             'name' => $this->nombre,
-            'variants' => $this->variants->map(function ($variant): array {
-                $values = $variant->selectionValues();
-                $eventDate = $variant->selectedEventDates()->first();
-
-                return [
-                    'id' => $variant->id,
-                    'event_date_id' => $eventDate?->id,
-                    'event_date' => $eventDate?->date?->format('Y-m-d'),
-                    'schedule' => $values->get('horario'),
-                    'service' => $values->get('servicio'),
-                    'description' => $variant->descripcion,
-                    'stock' => $variant->inventory->real_stock,
-                    'price' => number_format($variant->getPrice(), 2, '.', ''),
-                ];
-            })->values(),
+            'variants' => $currentVariants->map($this->variantData(...))->values(),
+            'history' => $this->historyData($historicalVariants),
         ];
     }
+
+    private function isCurrent(Variant $variant): bool
+    {
+        if ($variant->sales_disabled_at !== null || $variant->replaced_by_variant_id !== null) {
+            return false;
+        }
+
+        $status = $variant->selectedEventDates()->first()?->status;
+
+        return $status === null || in_array(
+            $status,
+            [EventDateStatus::Scheduled, EventDateStatus::InProgress],
+            true,
+        );
+    }
+
+    private function isHistorical(Variant $variant): bool
+    {
+        return in_array(
+            $variant->selectedEventDates()->first()?->status,
+            [
+                EventDateStatus::Rescheduled,
+                EventDateStatus::Suspended,
+                EventDateStatus::Completed,
+            ],
+            true,
+        );
+    }
+
+    /** @return array<string, mixed> */
+    private function variantData(Variant $variant): array
+    {
+        $values = $variant->selectionValues();
+        $eventDate = $variant->selectedEventDates()->first();
+
+        return [
+            'id' => $variant->id,
+            'event_date_id' => $eventDate?->id,
+            'event_date' => $eventDate?->date?->format('Y-m-d'),
+            'schedule' => $values->get('horario'),
+            'service' => $values->get('servicio'),
+            'description' => $variant->descripcion,
+            'stock' => $variant->inventory->real_stock,
+            'price' => number_format($variant->getPrice(), 2, '.', ''),
+        ];
+    }
+
+    /**
+     * @param  Collection<int, Variant>  $variants
+     * @return Collection<int, array<string, mixed>>
+     */
+    private function historyData(Collection $variants): Collection
+    {
+        return $variants
+            ->filter(fn (Variant $variant): bool => $variant->selectedEventDates()->first() !== null)
+            ->groupBy(fn (Variant $variant): int => (int) $variant->selectedEventDates()->first()->id)
+            ->map(function (Collection $dateVariants): array {
+                /** @var EventDate $eventDate */
+                $eventDate = $dateVariants->first()->selectedEventDates()->first();
+                $status = $this->historicalStatus($eventDate);
+                $change = $this->changeForStatus($eventDate, $status);
+
+                return [
+                    'id' => $eventDate->id,
+                    'change_id' => $change?->id,
+                    'status' => $status->value,
+                    'status_text' => match ($status) {
+                        EventDateStatus::Rescheduled => 'REPROGRAMADA',
+                        EventDateStatus::Suspended => 'CANCELADA',
+                        EventDateStatus::Completed => 'FINALIZADA',
+                        default => '',
+                    },
+                    'event_date_id' => $eventDate->id,
+                    'event_date' => $eventDate->date->format('Y-m-d'),
+                    'replacement_event_date_id' => $status === EventDateStatus::Rescheduled
+                        ? ($change?->destination_event_date_id
+                            ?? $eventDate->rescheduled_to_event_date_id)
+                        : null,
+                    'replacement_event_date' => $status === EventDateStatus::Rescheduled
+                        ? ($change?->new_date?->format('Y-m-d')
+                            ?? $eventDate->rescheduledTo?->date?->format('Y-m-d'))
+                        : null,
+                    'occurred_at' => ($change?->created_at ?? $eventDate->endsAt())->toISOString(),
+                    'variants' => $dateVariants->map($this->variantData(...))->values(),
+                ];
+            })
+            ->sortByDesc('occurred_at')
+            ->values();
+    }
+
+    private function historicalStatus(EventDate $eventDate): EventDateStatus
+    {
+        return match ($eventDate->status) {
+            EventDateStatus::Rescheduled => EventDateStatus::Rescheduled,
+            EventDateStatus::Suspended => EventDateStatus::Suspended,
+            default => EventDateStatus::Completed,
+        };
+    }
+
+    private function changeForStatus(
+        EventDate $eventDate,
+        EventDateStatus $status,
+    ): ?EventDateChange {
+        $changeType = match ($status) {
+            EventDateStatus::Rescheduled => EventDateChangeType::Rescheduled,
+            EventDateStatus::Suspended => EventDateChangeType::Suspended,
+            default => null,
+        };
+
+        return $changeType === null
+            ? null
+            : $eventDate->changeHistory
+                ->first(fn (EventDateChange $change): bool => $change->change_type === $changeType);
+    }
 }