feat(refund): implement backfill command for historical ticket refunds reconciliation

app/Domains/Cart/Services/InvalidateEventDateCartsService.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace App\Domains\Cart\Services;
+
+use App\Domains\Cart\Models\Cart;
+use App\Domains\Catalog\Models\StockReservation;
+use App\Domains\Catalog\Services\StockReservationService;
+use App\Domains\Purchase\Models\Purchase;
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
+
+class InvalidateEventDateCartsService
+{
+    public function __construct(private readonly StockReservationService $reservations) {}
+
+    /** @param Collection<int, int> $eventDateIds */
+    public function invalidate(
+        Tenant $tenant,
+        Collection $eventDateIds,
+        string $reason = StockReservationService::REASON_EVENT_DATE_RESCHEDULED,
+    ): void {
+        DB::transaction(function () use ($tenant, $eventDateIds, $reason): void {
+            $carts = Cart::query()
+                ->where('tenant_codigo', $tenant->codigo)
+                ->where('status', Cart::STATUS_ACTIVE)
+                ->whereNull('current_purchase_id')
+                ->whereHas('currentStockReservation', fn ($reservation) => $reservation
+                    ->where('status', StockReservation::STATUS_ACTIVE))
+                ->whereHas('items.variant', fn ($variant) => $variant
+                    ->withTrashed()
+                    ->where(fn ($dates) => $dates
+                        ->whereIn('event_date_id', $eventDateIds)
+                        ->orWhereHas('eventDates', fn ($date) => $date
+                            ->whereIn('event_dates.id', $eventDateIds))))
+                ->orderBy('id')
+                ->lockForUpdate()
+                ->get();
+
+            foreach ($carts as $cart) {
+                // Checkout keeps the cart and purchase attached to the same reservation.
+                if (Purchase::query()
+                    ->where('stock_reservation_id', $cart->current_stock_reservation_id)
+                    ->exists()) {
+                    continue;
+                }
+
+                $this->reservations->releaseCurrentCartReservation(
+                    $cart,
+                    $reason,
+                );
+
+                // Reuse the existing expired-cart flow: stale mutations receive the
+                // expiration response and the next GET replaces the whole cart.
+                $cart->update(['status' => Cart::STATUS_EXPIRED]);
+            }
+        });
+    }
+}

app/Domains/Catalog/Models/Inventory.php

@@ -10,6 +10,7 @@ use Illuminate\Database\Eloquent\Relations\HasOne;
 
 #[Fillable([
     'sold_units',
+    'refunded_units',
     'reserved_stock',
     'real_stock',
 ])]
@@ -23,6 +24,7 @@ class Inventory extends Model
 
     protected $attributes = [
         'sold_units' => 0,
+        'refunded_units' => 0,
         'reserved_stock' => 0,
         'real_stock' => 0,
     ];
@@ -31,6 +33,7 @@ class Inventory extends Model
     {
         return [
             'sold_units' => 'integer',
+            'refunded_units' => 'integer',
             'reserved_stock' => 'integer',
             'real_stock' => 'integer',
         ];

app/Domains/Catalog/Services/StockReservationService.php

@@ -19,6 +19,10 @@ class StockReservationService
 
     public const REASON_CART_CHANGED = 'cart_changed';
 
+    public const REASON_EVENT_DATE_RESCHEDULED = 'event_date_rescheduled';
+
+    public const REASON_EVENT_DATE_SUSPENDED = 'event_date_suspended';
+
     public const REASON_PURCHASE_SUPERSEDED = 'purchase_superseded';
 
     public const REASON_PURCHASE_CANCELLED = 'purchase_cancelled';

app/Domains/Catalog/Services/VariantReplacementService.php

@@ -188,6 +188,7 @@ class VariantReplacementService
 
         $replacementInventory = Inventory::query()->create([
             'sold_units' => $sourceInventory->sold_units,
+            'refunded_units' => $sourceInventory->refunded_units,
             'reserved_stock' => $reservedStock,
             'real_stock' => $sourceInventory->real_stock,
         ]);
@@ -235,6 +236,7 @@ class VariantReplacementService
             'real_stock' => $destinationInventory->real_stock + $sourceInventory->real_stock,
             'reserved_stock' => $destinationInventory->reserved_stock + $sourceInventory->reserved_stock,
             'sold_units' => $destinationInventory->sold_units + $sourceInventory->sold_units,
+            'refunded_units' => $destinationInventory->refunded_units + $sourceInventory->refunded_units,
         ]);
         if ($activeLines->isNotEmpty()) {
             StockReservationLine::query()
@@ -245,6 +247,7 @@ class VariantReplacementService
             'real_stock' => 0,
             'reserved_stock' => 0,
             'sold_units' => 0,
+            'refunded_units' => 0,
         ]);
     }
 

app/Domains/Event/Models/EventDate.php

@@ -4,6 +4,7 @@ namespace App\Domains\Event\Models;
 
 use App\Domains\Catalog\Models\Variant;
 use App\Domains\Event\Enums\EventDateStatus;
+use App\Domains\Event\Services\EffectiveEventDateResolver;
 use App\Domains\Event\Services\EventDateTextFormatter;
 use App\Domains\Tenant\Models\Tenant;
 use App\Domains\Ticket\Enums\ValidityTimeType;
@@ -80,6 +81,11 @@ class EventDate extends Model
         return $this->belongsTo(self::class, 'rescheduled_to_event_date_id');
     }
 
+    public function effectiveDate(): ?self
+    {
+        return app(EffectiveEventDateResolver::class)->resolve($this);
+    }
+
     /** @return HasMany<EventDate, $this> */
     public function rescheduledFrom(): HasMany
     {

app/Domains/Event/Services/EventService.php

@@ -3,7 +3,9 @@
 namespace App\Domains\Event\Services;
 
 use App\Domains\Auth\Models\User;
+use App\Domains\Cart\Services\InvalidateEventDateCartsService;
 use App\Domains\Catalog\Models\Variant;
+use App\Domains\Catalog\Services\StockReservationService;
 use App\Domains\Catalog\Services\VariantReplacementService;
 use App\Domains\Event\Enums\EventDateChangeType;
 use App\Domains\Event\Events\EventDateRescheduled;
@@ -28,6 +30,7 @@ class EventService
         private readonly EffectiveEventDateResolver $effectiveEventDateResolver,
         private readonly AffectedEventDatePurchaseResolver $affectedPurchaseResolver,
         private readonly VariantReplacementService $variantReplacementService,
+        private readonly InvalidateEventDateCartsService $invalidateEventDateCarts,
     ) {}
 
     public function forTenant(Tenant $tenant): Tenant
@@ -125,9 +128,11 @@ class EventService
                 ]);
             }
 
+            $affectedDateIds = $this->affectedDateIds($tenant, $source);
+            $this->invalidateEventDateCarts->invalidate($tenant, $affectedDateIds);
             $purchaseTickets = $this->affectedPurchaseResolver->resolve(
                 $tenant,
-                $this->affectedDateIds($tenant, $source),
+                $affectedDateIds,
             );
             $source->update(['rescheduled_to_event_date_id' => $destination->getKey()]);
             $this->variantReplacementService->replaceEventDate($source, $effectiveDestination);
@@ -173,10 +178,13 @@ class EventService
                 return $date->load('validityTime');
             }
 
-            $purchaseTickets = $this->affectedPurchaseResolver->resolve(
+            $affectedDateIds = $this->affectedDateIds($tenant, $date);
+            $this->invalidateEventDateCarts->invalidate(
                 $tenant,
-                $this->affectedDateIds($tenant, $date),
+                $affectedDateIds,
+                StockReservationService::REASON_EVENT_DATE_SUSPENDED,
             );
+            $purchaseTickets = $this->affectedPurchaseResolver->resolve($tenant, $affectedDateIds);
             $date->update(['suspended_at' => now()]);
             $this->variantReplacementService->disableForSuspension($date);
             $this->disableTicketsWithoutUsableDates($tenant, $date);

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,11 +13,27 @@ class EntryResource extends JsonResource
     /** @return array<string, mixed> */
     public function toArray(Request $request): array
     {
+        $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,
             'title' => $this->nombre,
             'description' => $this->descripcion,
-            'variants' => $this->variants->toArray(),
+            'event_date_ids' => $variant->selectedEventDates()->pluck('id')->values(),
+            'stock' => $variant->inventory->real_stock,
             'price' => $this->precio,
         ];
     }

app/Domains/FiestaFutbolInfantil/Services/EntryService.php

@@ -24,7 +24,13 @@ class EntryService
         return CatalogItem::query()
             ->where('tenant_code', $tenant->codigo)
             ->whereHas('category', fn ($query) => $query->where('nombre', 'Entradas'))
+            ->whereHas('variants', fn ($query) => $query
+                ->whereNull('replaced_by_variant_id')
+                ->whereNull('sales_disabled_at'))
             ->with([
+                'variants' => fn ($query) => $query
+                    ->whereNull('replaced_by_variant_id')
+                    ->whereNull('sales_disabled_at'),
                 'variants.inventory',
                 'variants.eventDate',
                 'variants.eventDates',

app/Domains/FiestaFutbolInfantil/Services/FoodService.php

@@ -177,6 +177,7 @@ class FoodService
 
         $historicalInventory = Inventory::query()->create([
             'sold_units' => $inventory->sold_units,
+            'refunded_units' => $inventory->refunded_units,
             'reserved_stock' => 0,
             'real_stock' => $inventory->real_stock,
         ]);

app/Domains/Forms/Services/TicketFilterFormService.php

@@ -124,7 +124,10 @@ class TicketFilterFormService
                 'required' => false,
                 'default' => null,
                 'placeholder' => 'Estado',
-                'options' => Ticket::statusOptions(),
+                'options' => array_values(array_filter(
+                    Ticket::statusOptions(),
+                    fn (array $option): bool => $option['value'] !== Ticket::STATUS_CANCELLED,
+                )),
             ],
         ];
     }

app/Domains/Notification/Services/NotificationMailService.php

@@ -297,7 +297,7 @@ class NotificationMailService
                         ->forTenant($tenantCode)
                         ->send(
                             $recipient,
-                            "Tu evento fue reprogramado - Compra #{$purchase->getKey()}",
+                            "Tu evento fue reprogramado - N° de Orden #{$purchase->getKey()}",
                             view('mail.notifications.event-date-rescheduled', compact(
                                 'purchase', 'previousDate', 'newDate', 'tickets'
                             ))->render(),
@@ -398,7 +398,7 @@ class NotificationMailService
                         ->forTenant($tenantCode)
                         ->send(
                             $recipient,
-                            "Una fecha de tu evento fue suspendida - Compra #{$purchase->getKey()}",
+                            "Una fecha de tu evento fue suspendida - N° de Orden #{$purchase->getKey()}",
                             view('mail.notifications.event-date-suspended', compact(
                                 'purchase', 'date', 'disabledTickets', 'activeTickets'
                             ))->render(),

app/Domains/Purchase/Services/Checkout/ReleaseCheckoutService.php

@@ -3,6 +3,7 @@
 namespace App\Domains\Purchase\Services\Checkout;
 
 use App\Domains\Cart\Models\Cart;
+use App\Domains\Cart\Models\CartItem;
 use App\Domains\Catalog\Models\StockReservation;
 use App\Domains\Catalog\Services\StockReservationService;
 use App\Domains\Purchase\Exceptions\PurchaseExpiredException;
@@ -91,7 +92,16 @@ class ReleaseCheckoutService
                     Purchase::STATUS_CREATED,
                     Purchase::STATUS_PENDING_PAYMENT,
                 ], true)) {
-                $this->reservations->returnToCart($purchase, $cart);
+                if ($this->hasUnavailableVariants($cart)) {
+                    $this->releasePurchaseReservations($purchase, $targetStatus, $cart);
+                    $cart->update([
+                        'status' => Cart::STATUS_EXPIRED,
+                        'current_purchase_id' => null,
+                        'current_stock_reservation_id' => null,
+                    ]);
+                } else {
+                    $this->reservations->returnToCart($purchase, $cart);
+                }
                 $purchase->update(['status' => Purchase::STATUS_CANCELLED]);
 
                 return $this->loadPurchase($purchase);
@@ -115,6 +125,17 @@ class ReleaseCheckoutService
         });
     }
 
+    private function hasUnavailableVariants(Cart $cart): bool
+    {
+        return $cart->items()
+            ->whereNotNull('variant_id')
+            ->with(['variant.eventDate', 'variant.eventDates'])
+            ->lockForUpdate()
+            ->get()
+            ->contains(fn (CartItem $item): bool => $item->variant === null
+                || ! $item->variant->isSellable());
+    }
+
     private function releasePurchaseReservations(
         Purchase $purchase,
         string $targetStatus,

app/Domains/Purchase/Services/TenantTransactionResetService.php

@@ -65,9 +65,10 @@ class TenantTransactionResetService
             DB::table('inventories')
                 ->whereIn('id', $scope['inventory_ids'])
                 ->update([
-                    'real_stock' => DB::raw('real_stock + sold_units'),
+                    'real_stock' => DB::raw('real_stock + sold_units - refunded_units'),
                     'reserved_stock' => 0,
                     'sold_units' => 0,
+                    'refunded_units' => 0,
                 ]);
 
             return $summary;

app/Domains/Ticket/Services/AdminAppTicketRowService.php

@@ -3,6 +3,7 @@
 namespace App\Domains\Ticket\Services;
 
 use App\Domains\Catalog\Models\ItemAttribute;
+use App\Domains\Event\Models\EventDate;
 use App\Domains\Ticket\Models\Ticket;
 use Illuminate\Support\Collection;
 
@@ -11,12 +12,12 @@ class AdminAppTicketRowService
     private const FIESTA_FUTBOL_INFANTIL = 'fiesta_futbol_infantil';
 
     private const CATEGORY_PRESENTATIONS = [
-        'alojamientos' => ['category' => 'Camping', 'product' => 'tipo_alojamiento', 'type' => null, 'date' => null, 'size' => null],
+        'alojamientos' => ['category' => 'Camping', 'product' => 'tipo_alojamiento', 'type' => null, 'size' => null],
-        'camping' => ['category' => null, 'product' => 'tipo_alojamiento', 'type' => null, 'date' => null, 'size' => null],
+        'camping' => ['category' => null, 'product' => 'tipo_alojamiento', 'type' => null, 'size' => null],
-        'entradas' => ['category' => null, 'product' => 'product', 'type' => null, 'date' => null, 'size' => null],
+        'entradas' => ['category' => null, 'product' => 'product', 'type' => null, 'size' => null],
-        'comidas' => ['category' => 'Comida', 'product' => 'horario', 'type' => 'servicio', 'date' => 'event_date', 'size' => null],
+        'comidas' => ['category' => 'Comida', 'product' => 'horario', 'type' => 'servicio', 'size' => null],
-        'comida' => ['category' => null, 'product' => 'horario', 'type' => 'servicio', 'date' => 'event_date', 'size' => null],
+        'comida' => ['category' => null, 'product' => 'horario', 'type' => 'servicio', 'size' => null],
-        'merchandising' => ['category' => null, 'product' => 'product', 'type' => 'color', 'date' => null, 'size' => 'talle'],
+        'merchandising' => ['category' => null, 'product' => 'product', 'type' => 'color', 'size' => 'talle'],
     ];
 
     /** @return array<string, mixed> */
@@ -111,13 +112,14 @@ class AdminAppTicketRowService
     private function presentation(Ticket $ticket, array $details): array
     {
         $sourceCategory = trim((string) ($ticket->sourceCatalogItem?->category?->nombre ?? '')) ?: '-';
+        $effectiveDates = $this->effectiveEventDateLabels($ticket) ?: '-';
 
         if ($ticket->tenant_code !== self::FIESTA_FUTBOL_INFANTIL) {
             return [
                 'category' => $sourceCategory,
                 'product' => (string) ($details['product'] ?: $ticket->name ?: '-'),
                 'type' => $this->allPropertyLabels($details) ?: '-',
-                'date' => '-',
+                'date' => $effectiveDates,
                 'size' => '-',
             ];
         }
@@ -128,7 +130,7 @@ class AdminAppTicketRowService
                 'category' => $sourceCategory,
                 'product' => (string) ($details['product'] ?: $ticket->name ?: '-'),
                 'type' => $this->allPropertyLabels($details) ?: '-',
-                'date' => '-',
+                'date' => $effectiveDates,
                 'size' => '-',
             ];
         }
@@ -141,29 +143,30 @@ class AdminAppTicketRowService
             'type' => $configuration['type'] === null
                 ? '-'
                 : ($this->propertyLabels($details, $configuration['type']) ?: '-'),
-            'date' => $configuration['date'] === null
+            'date' => $effectiveDates,
-                ? '-'
-                : ($this->propertyLabels($details, $configuration['date']) ?: '-'),
             'size' => $configuration['size'] === null
                 ? '-'
                 : ($this->propertyLabels($details, $configuration['size']) ?: '-'),
         ];
     }
 
+    private function effectiveEventDateLabels(Ticket $ticket): string
+    {
+        return $ticket->sourceVariant?->selectedEventDates()
+            ->map(fn (EventDate $date): ?EventDate => $date->effectiveDate())
+            ->filter()
+            ->unique(fn (EventDate $date): int => $date->getKey())
+            ->sortBy(fn (EventDate $date): string => $date->date->format('Y-m-d'))
+            ->map(fn (EventDate $date): string => $date->date->format('d/m'))
+            ->implode(', ') ?? '';
+    }
+
     /** @param array<string, mixed> $details */
     private function propertyLabels(array $details, string $code): string
     {
         $property = collect($details['variant_properties'] ?? [])->firstWhere('code', $code);
         $labels = collect($property['values'] ?? [])->pluck('label')->filter();
 
-        if ($code === 'event_date') {
-            $labels = $labels->map(function (string $label): string {
-                [$day, $month] = array_pad(explode('/', $label), 2, null);
-
-                return $day !== null && $month !== null ? "{$day}/{$month}" : $label;
-            });
-        }
-
         return $labels->implode(', ');
     }
 

app/Domains/Ticket/Services/AdminAppTicketService.php

@@ -3,6 +3,9 @@
 namespace App\Domains\Ticket\Services;
 
 use App\Domains\Auth\Models\User;
+use App\Domains\Catalog\Enums\InventoryPolicy;
+use App\Domains\Catalog\Models\Inventory;
+use App\Domains\Catalog\Models\Variant;
 use App\Domains\Purchase\Models\PurchaseItem;
 use App\Domains\Purchase\Services\PurchaseRefundSummaryService;
 use App\Domains\Tenant\Models\Tenant;
@@ -223,10 +226,57 @@ class AdminAppTicketService
                 'amount' => number_format($refundAmount, 2, '.', ''),
             ]);
 
+            $this->restoreInventory($ticket, $purchaseItem);
+
             return $ticket->refresh()->load(self::RELATIONS);
         });
     }
 
+    private function restoreInventory(Ticket $ticket, PurchaseItem $purchaseItem): void
+    {
+        $catalogItem = $ticket->sourceCatalogItem;
+        if ($catalogItem === null) {
+            throw ValidationException::withMessages([
+                'ticket' => 'El ticket no tiene un producto con inventario reponible.',
+            ]);
+        }
+
+        // Bundle components need a per-ticket allocation before they can be restored.
+        if ($catalogItem->isBundle() || $purchaseItem->sourceCatalogItem?->isBundle()) {
+            return;
+        }
+
+        $inventoryId = $catalogItem->inventory_id;
+        if ($ticket->source_variant_id !== null) {
+            $variant = Variant::withTrashed()->find($ticket->source_variant_id);
+            if ($variant === null) {
+                throw ValidationException::withMessages(['ticket' => 'No se encontró la variante del ticket.']);
+            }
+
+            // A replacement can move the sellable inventory to a newer variant.
+            $visited = [];
+            while ($variant->replaced_by_variant_id !== null) {
+                if (isset($visited[$variant->id])) {
+                    throw new \LogicException('La cadena de reemplazos de variantes es circular.');
+                }
+                $visited[$variant->id] = true;
+                $variant = Variant::withTrashed()->findOrFail($variant->replaced_by_variant_id);
+            }
+            $inventoryId = $variant->inventory_id;
+        }
+
+        $inventory = Inventory::query()->lockForUpdate()->find($inventoryId);
+        if ($inventory === null) {
+            throw ValidationException::withMessages(['ticket' => 'No se encontró el inventario del ticket.']);
+        }
+
+        if ($catalogItem->inventory_policy === InventoryPolicy::Tracked) {
+            $inventory->real_stock++;
+        }
+        $inventory->refunded_units++;
+        $inventory->save();
+    }
+
     private function refundedAmountForPurchaseItem(PurchaseItem $purchaseItem): float
     {
         return round((float) TicketRefund::query()

app/Domains/Ticket/Services/BackfillRefundedUnitsService.php

@@ -0,0 +1,121 @@
+<?php
+
+namespace App\Domains\Ticket\Services;
+
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+use RuntimeException;
+
+class BackfillRefundedUnitsService
+{
+    /** @return array<string, int> */
+    public function run(): array
+    {
+        $summary = DB::transaction(function (): array {
+            if (DB::table('inventories')->where('refunded_units', '>', 0)->exists()) {
+                throw new RuntimeException('El backfill requiere que refunded_units sea cero en todos los inventarios.');
+            }
+
+            $counts = [];
+            $variants = [];
+            $refundsSeen = 0;
+            $bundlesSkipped = 0;
+
+            DB::table('ticket_refunds as refunds')
+                ->join('tickets', 'tickets.id', '=', 'refunds.ticket_id')
+                ->join('compra_items as purchase_items', 'purchase_items.id', '=', 'refunds.purchase_item_id')
+                ->leftJoin('catalog_items as purchase_catalog', 'purchase_catalog.id', '=', 'purchase_items.source_catalog_item_id')
+                ->leftJoin('catalog_items as ticket_catalog', 'ticket_catalog.id', '=', 'tickets.source_catalog_item_id')
+                ->select([
+                    'refunds.id',
+                    'refunds.ticket_id',
+                    'tickets.source_variant_id',
+                    'ticket_catalog.inventory_id',
+                    'ticket_catalog.inventory_policy',
+                    'ticket_catalog.type as ticket_catalog_type',
+                    'purchase_catalog.type as purchase_catalog_type',
+                ])
+                ->chunkById(500, function ($refunds) use (&$counts, &$variants, &$refundsSeen, &$bundlesSkipped): void {
+                    foreach ($refunds as $refund) {
+                        $refundsSeen++;
+                        if ($refund->ticket_catalog_type === 'bundle' || $refund->purchase_catalog_type === 'bundle') {
+                            $bundlesSkipped++;
+
+                            continue;
+                        }
+
+                        if ($refund->inventory_policy === null) {
+                            throw new RuntimeException("El reembolso {$refund->id} no tiene un producto de catálogo asociado.");
+                        }
+
+                        $inventoryId = $refund->source_variant_id === null
+                            ? $refund->inventory_id
+                            : $this->currentVariantInventoryId((int) $refund->source_variant_id, $variants);
+
+                        if ($inventoryId === null) {
+                            throw new RuntimeException("El reembolso {$refund->id} no tiene un inventario asociado.");
+                        }
+
+                        $counts[$inventoryId]['refunded'] = ($counts[$inventoryId]['refunded'] ?? 0) + 1;
+                        if ($refund->inventory_policy === 'tracked') {
+                            $counts[$inventoryId]['stock'] = ($counts[$inventoryId]['stock'] ?? 0) + 1;
+                        }
+                    }
+                }, 'refunds.id', 'id');
+
+            foreach ($counts as $inventoryId => $count) {
+                $updates = ['refunded_units' => DB::raw('refunded_units + '.$count['refunded'])];
+                if (($count['stock'] ?? 0) > 0) {
+                    $updates['real_stock'] = DB::raw('real_stock + '.$count['stock']);
+                }
+
+                if (DB::table('inventories')->where('id', $inventoryId)->update($updates) !== 1) {
+                    throw new RuntimeException("No se encontró el inventario {$inventoryId} para reponerlo.");
+                }
+            }
+
+            $refundedUnitsAdded = array_sum(array_column($counts, 'refunded'));
+
+            return [
+                'refunds_seen' => $refundsSeen,
+                'refunds_applied' => $refundedUnitsAdded,
+                'bundles_skipped' => $bundlesSkipped,
+                'inventories_updated' => count($counts),
+                'refunded_units_added' => $refundedUnitsAdded,
+                'real_stock_added' => array_sum(array_column($counts, 'stock')),
+            ];
+        });
+
+        Log::info('inventory.refunded_units_backfill.completed', $summary);
+
+        return $summary;
+    }
+
+    /** @param array<int, object|null> $variants */
+    private function currentVariantInventoryId(int $variantId, array &$variants): ?int
+    {
+        $visited = [];
+
+        while (true) {
+            if (isset($visited[$variantId])) {
+                throw new RuntimeException("La cadena de reemplazos de la variante {$variantId} es circular.");
+            }
+            $visited[$variantId] = true;
+
+            if (! array_key_exists($variantId, $variants)) {
+                $variants[$variantId] = DB::table('variantes')
+                    ->where('id', $variantId)
+                    ->first(['inventory_id', 'replaced_by_variant_id']);
+            }
+            $variant = $variants[$variantId];
+            if ($variant === null) {
+                throw new RuntimeException("No se encontró la variante {$variantId} de un ticket reembolsado.");
+            }
+            if ($variant->replaced_by_variant_id === null) {
+                return $variant->inventory_id === null ? null : (int) $variant->inventory_id;
+            }
+
+            $variantId = (int) $variant->replaced_by_variant_id;
+        }
+    }
+}

database/migrations/2026_09_16_000000_add_refunded_units_to_inventories.php

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

database/migrations/2026_09_16_000100_backfill_refunded_units.php

@@ -0,0 +1,16 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        // Historical reconciliation runs explicitly via tickets:backfill-refunded-units.
+    }
+
+    public function down(): void
+    {
+        // Reconciliation cannot be reversed without auditing stock.
+    }
+};

resources/views/mail/notifications/event-date-rescheduled.blade.php

@@ -8,7 +8,7 @@
 <p><strong>Tickets afectados</strong></p>
 <ul>
     @foreach ($tickets as $ticket)
-        <li>{{ $ticket->name }} · #{{ $ticket->id }}</li>
+        <li>{{ $ticket->name }} · N° de Ticket #{{ $ticket->id }}</li>
     @endforeach
 </ul>
-<p style="color: #64748b; font-size: 13px;">Compra #{{ $purchase->id }}</p>
+<p style="color: #64748b; font-size: 13px;">N° de Orden #{{ $purchase->id }}</p>

resources/views/mail/notifications/event-date-suspended.blade.php

@@ -5,7 +5,7 @@
     <p>Los siguientes tickets quedaron inhabilitados porque no tienen otra fecha disponible:</p>
     <ul>
         @foreach ($disabledTickets as $ticket)
-            <li>{{ $ticket->name }} · #{{ $ticket->id }}</li>
+            <li>{{ $ticket->name }} · N° de Ticket #{{ $ticket->id }}</li>
         @endforeach
     </ul>
     <p>Para conocer las alternativas o condiciones de devolución, comunicate con la organización.</p>
@@ -15,9 +15,9 @@
     <p>Estos tickets conservan otras fechas disponibles:</p>
     <ul>
         @foreach ($activeTickets as $ticket)
-            <li>{{ $ticket->name }} · #{{ $ticket->id }}</li>
+            <li>{{ $ticket->name }} · N° de Ticket #{{ $ticket->id }}</li>
         @endforeach
     </ul>
 @endif
 
-<p style="color: #64748b; font-size: 13px;">Compra #{{ $purchase->id }}</p>
+<p style="color: #64748b; font-size: 13px;">N° de Orden #{{ $purchase->id }}</p>

routes/console.php

@@ -3,6 +3,7 @@
 use App\Domains\Auth\Services\AdminCredentialVerifier;
 use App\Domains\Catalog\Services\ExpireStockReservationsService;
 use App\Domains\Purchase\Services\TenantTransactionResetService;
+use App\Domains\Ticket\Services\BackfillRefundedUnitsService;
 use App\Domains\Ticket\Services\LoadTestTicketDatasetService;
 use Illuminate\Foundation\Inspiring;
 use Illuminate\Support\Facades\Artisan;
@@ -13,6 +14,27 @@ Artisan::command('inspire', function () {
     $this->comment(Inspiring::quote());
 })->purpose('Display an inspiring quote');
 
+Artisan::command('tickets:backfill-refunded-units', function (BackfillRefundedUnitsService $service): int {
+    try {
+        $summary = $service->run();
+    } catch (Throwable $exception) {
+        $this->error($exception->getMessage());
+
+        return self::FAILURE;
+    }
+
+    $this->info(sprintf(
+        'Refund backfill: %d applied, %d bundles skipped, %d inventories updated, +%d refunded_units, +%d real_stock',
+        $summary['refunds_applied'],
+        $summary['bundles_skipped'],
+        $summary['inventories_updated'],
+        $summary['refunded_units_added'],
+        $summary['real_stock_added'],
+    ));
+
+    return self::SUCCESS;
+})->purpose('Reconcile historical ticket refunds with inventory after reviewing existing refunded units');
+
 Artisan::command('reservations:expire', function (): void {
     $expired = app(ExpireStockReservationsService::class)->expireOverdue();
 

tests/Feature/Event/AdminAppEventControllerTest.php

@@ -6,6 +6,7 @@ use App\Domains\Attachable\Enums\AttachmentType;
 use App\Domains\Attachable\Models\Attachment;
 use App\Domains\Auth\Models\User;
 use App\Domains\Authorization\Enums\RoleCode;
+use App\Domains\Cart\Models\Cart;
 use App\Domains\Catalog\Models\CatalogItem;
 use App\Domains\Catalog\Models\Inventory;
 use App\Domains\Catalog\Models\StockReservation;
@@ -25,6 +26,7 @@ use Illuminate\Support\Facades\Event;
 use Illuminate\Support\Str;
 use Illuminate\Validation\ValidationException;
 use Laravel\Sanctum\Sanctum;
+use PHPUnit\Framework\Attributes\DataProvider;
 use Tests\TestCase;
 
 class AdminAppEventControllerTest extends TestCase
@@ -421,6 +423,54 @@ class AdminAppEventControllerTest extends TestCase
         );
     }
 
+    public static function cartInvalidatingDateChanges(): array
+    {
+        return [
+            'reschedule' => ['reschedule', ['date' => '2027-10-20'], 'event_date_rescheduled'],
+            'suspend' => ['suspend', [], 'event_date_suspended'],
+        ];
+    }
+
+    #[DataProvider('cartInvalidatingDateChanges')]
+    public function test_date_changes_invalidate_reserved_carts(string $action, array $payload, string $reason): void
+    {
+        Event::fake([EventDateRescheduled::class, EventDateSuspended::class]);
+        $tenant = $this->createActiveEvent($this->createTenant('acme'), 'Festival Acme');
+        $source = $tenant->eventDates()->create([
+            'date' => '2027-10-09', 'time_start' => '09:00', 'time_end' => '18:30',
+        ]);
+        $variant = $this->createVariant($tenant, $source->id);
+        $variant->inventory->update(['real_stock' => 5, 'reserved_stock' => 2]);
+        $reservation = StockReservation::query()->create([
+            'status' => StockReservation::STATUS_ACTIVE, 'expires_at' => now()->addHour(),
+        ]);
+        StockReservationLine::query()->create([
+            'stock_reservation_id' => $reservation->id, 'inventory_id' => $variant->inventory_id,
+            'quantity' => 2, 'tracks_inventory' => true,
+        ]);
+        $admin = $this->createAdminAppUser($tenant);
+        $cart = Cart::query()->create([
+            'tenant_codigo' => $tenant->codigo, 'user_id' => $admin->id,
+            'status' => Cart::STATUS_ACTIVE, 'origin' => Cart::ORIGIN_USER,
+            'current_stock_reservation_id' => $reservation->id,
+        ]);
+        $cart->items()->create([
+            'catalog_item_id' => $variant->catalog_item_id, 'variant_id' => $variant->id, 'cantidad' => 2,
+        ]);
+        Sanctum::actingAs($admin);
+
+        $this->postJson("/api/v1/adminapp/tenant/event-dates/{$source->id}/{$action}", $payload)->assertOk();
+
+        $this->assertSame(Cart::STATUS_EXPIRED, $cart->fresh()->status);
+        $this->assertSame(StockReservation::STATUS_RELEASED, $reservation->fresh()->status);
+        $this->assertSame($reason, $reservation->fresh()->release_reason);
+        $this->assertSame(0, $variant->fresh()->inventory->reserved_stock);
+        if ($action === 'reschedule') {
+            $this->assertSame(0, $variant->fresh()->replacement->inventory->reserved_stock);
+        }
+        $this->getJson('/api/tenants/acme/cart')->assertOk()->assertJsonCount(0, 'data.items');
+    }
+
     public function test_rescheduling_reuses_an_equivalent_destination_variant(): void
     {
         Event::fake([EventDateRescheduled::class]);

tests/Feature/Forms/AdminAppTicketFilterFormControllerTest.php

@@ -79,7 +79,6 @@ class AdminAppTicketFilterFormControllerTest extends TestCase
                                 ['value' => 'used', 'label' => 'Usado'],
                                 ['value' => 'expired', 'label' => 'Vencido'],
                                 ['value' => 'disabled', 'label' => 'Inhabilitado'],
-                                ['value' => 'cancelled', 'label' => 'Cancelado'],
                                 ['value' => 'refunded', 'label' => 'Reembolsado'],
                             ],
                         ],

tests/Feature/Notification/NotificationMailServiceTest.php

@@ -352,11 +352,12 @@ class NotificationMailServiceTest extends TestCase
         Mail::assertSent(Mailable::class, function (Mailable $mail) use ($purchase, $firstTicket, $secondTicket): bool {
             $mail->assertTo('checkout@example.com');
 
-            return $mail->subject === "Tu evento fue reprogramado - Compra #{$purchase->id}"
+            return $mail->subject === "Tu evento fue reprogramado - N° de Orden #{$purchase->id}"
                 && str_contains($mail->render(), '09/10/2027')
                 && str_contains($mail->render(), '20/10/2027')
-                && str_contains($mail->render(), '#'.$firstTicket->id)
+                && str_contains($mail->render(), 'N° de Ticket #'.$firstTicket->id)
-                && str_contains($mail->render(), '#'.$secondTicket->id);
+                && str_contains($mail->render(), 'N° de Ticket #'.$secondTicket->id)
+                && str_contains($mail->render(), 'N° de Orden #'.$purchase->id);
         });
         $this->assertDatabaseHas('email_deliveries', [
             'idempotency_key' => "event-date-rescheduled:10:20:{$purchase->id}",

tests/Feature/Purchase/StorePurchaseTest.php

@@ -11,7 +11,9 @@ use App\Domains\Catalog\Models\CatalogItem;
 use App\Domains\Catalog\Models\Category;
 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 App\Domains\Purchase\Models\Purchase;
 use App\Domains\Purchase\Services\CheckoutService;
 use App\Domains\Purchase\Services\UserPurchaseLimitService;
@@ -20,6 +22,7 @@ use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\Queue;
 use Illuminate\Support\Str;
 use Illuminate\Validation\ValidationException;
+use PHPUnit\Framework\Attributes\DataProvider;
 use Tests\TestCase;
 
 class StorePurchaseTest extends TestCase
@@ -642,6 +645,80 @@ class StorePurchaseTest extends TestCase
         $this->assertSame(1, $activeCart->items()->count());
     }
 
+    /** @return array<string, array{string, string}> */
+    public static function unavailableCancellationCases(): array
+    {
+        return [
+            'created with disabled variant' => [Purchase::STATUS_CREATED, 'disabled'],
+            'pending payment with replaced variant' => [Purchase::STATUS_PENDING_PAYMENT, 'replaced'],
+            'pending payment with suspended date' => [Purchase::STATUS_PENDING_PAYMENT, 'suspended'],
+        ];
+    }
+
+    #[DataProvider('unavailableCancellationCases')]
+    public function test_cancelling_a_purchase_with_unavailable_variants_invalidates_the_whole_cart(
+        string $purchaseStatus,
+        string $change,
+    ): void {
+        $tenant = $this->createTenant('sonder', 'Sonder', 'sonder.com.ar');
+        $user = User::factory()->create();
+        $variant = $this->createVariantForTenant('sonder', 10, '50.00');
+        $otherVariant = $this->createVariantForTenant('sonder', 10, '25.00', 'other');
+        $cart = Cart::query()->create([
+            'tenant_codigo' => $tenant->codigo, 'user_id' => $user->id,
+            'status' => Cart::STATUS_ACTIVE, 'origin' => Cart::ORIGIN_USER,
+        ]);
+        $cart->addItem($variant->catalog_item_id, $variant->id, 2);
+        $cart->addItem($otherVariant->catalog_item_id, $otherVariant->id, 1);
+        $purchase = app(CheckoutService::class)->startCheckout($tenant, $user->id, ['cart_id' => $cart->id]);
+        $purchase->update(['status' => $purchaseStatus]);
+        $reservedInventoryId = $variant->inventory_id;
+
+        if ($change === 'replaced') {
+            // A reprogramming can move reservation lines away from the original variant.
+            $replacementInventory = Inventory::query()->create(['real_stock' => 10, 'reserved_stock' => 2]);
+            $replacement = Variant::query()->create([
+                'catalog_item_id' => $variant->catalog_item_id, 'inventory_id' => $replacementInventory->id,
+            ]);
+            StockReservationLine::query()->where('stock_reservation_id', $purchase->stock_reservation_id)
+                ->where('inventory_id', $variant->inventory_id)
+                ->update(['inventory_id' => $replacementInventory->id]);
+            $variant->inventory->update(['reserved_stock' => 0]);
+            $variant->update(['replaced_by_variant_id' => $replacement->id, 'sales_disabled_at' => now()]);
+            $reservedInventoryId = $replacementInventory->id;
+        } elseif ($change === 'suspended') {
+            $date = EventDate::query()->create([
+                'tenant_code' => $tenant->codigo, 'date' => '2027-10-09',
+                'time_start' => '09:00', 'time_end' => '18:00', 'suspended_at' => now(),
+            ]);
+            $variant->eventDates()->sync([$date->id]);
+        } else {
+            $variant->update(['sales_disabled_at' => now()]);
+        }
+
+        $this->actingAs($user, 'sanctum');
+        for ($attempt = 0; $attempt < 2; $attempt++) {
+            $this->postJson("/api/tenants/sonder/compras/{$purchase->id}/cancel")
+                ->assertOk()->assertJsonPath('data.status', Purchase::STATUS_CANCELLED);
+        }
+
+        $this->assertDatabaseHas('carritos', [
+            'id' => $cart->id, 'status' => Cart::STATUS_EXPIRED,
+            'current_purchase_id' => null, 'current_stock_reservation_id' => null,
+        ]);
+        $this->assertDatabaseHas('stock_reservations', [
+            'id' => $purchase->stock_reservation_id, 'status' => StockReservation::STATUS_RELEASED,
+            'release_reason' => 'purchase_cancelled',
+        ]);
+        foreach ([$reservedInventoryId, $otherVariant->inventory_id] as $inventoryId) {
+            $this->assertDatabaseHas('inventories', [
+                'id' => $inventoryId, 'real_stock' => 10, 'reserved_stock' => 0,
+            ]);
+        }
+        $this->getJson('/api/tenants/sonder/cart')->assertOk()->assertJsonCount(0, 'data.items');
+        $this->assertSame(Cart::STATUS_ABANDONED, $cart->fresh()->status);
+    }
+
     public function test_it_reuses_the_cart_reservation_for_a_new_checkout_and_rejects_a_late_confirmation(): void
     {
         $this->createTenant('sonder', 'Sonder', 'sonder.com.ar');

tests/Feature/Ticket/AdminAppTicketControllerTest.php

@@ -23,6 +23,7 @@ use Database\Seeders\AttributeSeeder;
 use Database\Seeders\AuthorizationSeeder;
 use Database\Seeders\FiestaFutbolInfantilProductSeeder;
 use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Log;
 use Illuminate\Support\Str;
 use Laravel\Sanctum\Sanctum;
 use Tests\TestCase;
@@ -186,6 +187,7 @@ class AdminAppTicketControllerTest extends TestCase
         $this->grantTicketsMenu($tenant);
         Sanctum::actingAs($admin);
         [$ticket, $purchaseItem] = $this->createRefundableTicket($tenant, $admin, '100.00');
+        $inventory = $ticket->sourceCatalogItem->inventory;
 
         $this->postJson("/api/v1/adminapp/tenant/tickets/{$ticket->id}/refund", [
             'refund_type' => 'total',
@@ -201,6 +203,9 @@ class AdminAppTicketControllerTest extends TestCase
             ->assertJsonPath('data.refund.created_by', $admin->nombre_apellido);
 
         $this->assertNotNull($ticket->fresh()->refunded_at);
+        $this->assertSame(1, $inventory->fresh()->real_stock);
+        $this->assertSame(1, $inventory->fresh()->sold_units);
+        $this->assertSame(1, $inventory->fresh()->refunded_units);
         $this->assertDatabaseHas('ticket_refunds', [
             'ticket_id' => $ticket->id,
             'purchase_item_id' => $purchaseItem->id,
@@ -208,6 +213,13 @@ class AdminAppTicketControllerTest extends TestCase
             'type' => TicketRefund::TYPE_TOTAL,
             'amount' => '100.00',
         ]);
+
+        $this->postJson("/api/v1/adminapp/tenant/tickets/{$ticket->id}/refund", [
+            'refund_type' => 'total',
+        ])->assertUnprocessable();
+        $this->assertSame(1, $inventory->fresh()->real_stock);
+        $this->assertSame(1, $inventory->fresh()->refunded_units);
+        $this->assertSame(1, $purchaseItem->ticketRefunds()->count());
     }
 
     public function test_it_partially_refunds_a_ticket_using_the_tenant_percentage(): void
@@ -222,6 +234,7 @@ class AdminAppTicketControllerTest extends TestCase
         $this->grantTicketsMenu($tenant);
         Sanctum::actingAs($admin);
         [$ticket, $purchaseItem] = $this->createRefundableTicket($tenant, $admin, '100.00');
+        $inventory = $ticket->sourceCatalogItem->inventory;
 
         $this->postJson("/api/v1/adminapp/tenant/tickets/{$ticket->id}/refund", [
             'refund_type' => 'partial',
@@ -238,6 +251,73 @@ class AdminAppTicketControllerTest extends TestCase
             'type' => TicketRefund::TYPE_PARTIAL,
             'amount' => '25.50',
         ]);
+        $this->assertSame(1, $inventory->fresh()->real_stock);
+        $this->assertSame(1, $inventory->fresh()->refunded_units);
+    }
+
+    public function test_backfill_restores_existing_refunds_before_new_refunds(): void
+    {
+        $tenant = $this->createTenant('ticket-historical-refund');
+        $tenant->update([
+            'allow_ticket_refund' => true,
+            'allow_ticket_total_refund' => true,
+        ]);
+        $admin = $this->createAdminAppUser($tenant);
+        $this->grantTicketsMenu($tenant);
+        Sanctum::actingAs($admin);
+        [$historicalTicket, $purchaseItem] = $this->createRefundableTicket($tenant, $admin, '100.00');
+        $inventory = $historicalTicket->sourceCatalogItem->inventory;
+        $inventory->update(['sold_units' => 2]);
+        $purchaseItem->update(['cantidad' => 2, 'total' => '200.00']);
+        $historicalTicket->markAsRefunded();
+        $historicalTicket->save();
+        TicketRefund::query()->create([
+            'ticket_id' => $historicalTicket->id,
+            'purchase_item_id' => $purchaseItem->id,
+            'type' => TicketRefund::TYPE_TOTAL,
+            'amount' => '100.00',
+        ]);
+
+        $this->assertSame(0, $inventory->fresh()->refunded_units);
+        $this->assertSame(0, $inventory->fresh()->real_stock);
+
+        Log::shouldReceive('info')->once()->with('inventory.refunded_units_backfill.completed', [
+            'refunds_seen' => 1,
+            'refunds_applied' => 1,
+            'bundles_skipped' => 0,
+            'inventories_updated' => 1,
+            'refunded_units_added' => 1,
+            'real_stock_added' => 1,
+        ]);
+        $this->artisan('tickets:backfill-refunded-units')->assertSuccessful();
+
+        $this->assertSame(1, $inventory->fresh()->refunded_units);
+        $this->assertSame(1, $inventory->fresh()->real_stock);
+
+        $newTicket = $this->createTicket($tenant, $admin, [
+            'source_purchase_item_id' => $purchaseItem->id,
+            'source_catalog_item_id' => $historicalTicket->source_catalog_item_id,
+        ]);
+        $this->postJson("/api/v1/adminapp/tenant/tickets/{$newTicket->id}/refund", [
+            'refund_type' => TicketRefund::TYPE_TOTAL,
+        ])->assertOk();
+
+        $this->assertSame(2, $inventory->fresh()->sold_units);
+        $this->assertSame(2, $inventory->fresh()->refunded_units);
+        $this->assertSame(2, $inventory->fresh()->real_stock);
+    }
+
+    public function test_backfill_command_fails_without_changing_existing_refunded_units(): void
+    {
+        $inventory = Inventory::query()->create([
+            'real_stock' => 3,
+            'refunded_units' => 1,
+        ]);
+
+        $this->artisan('tickets:backfill-refunded-units')->assertFailed();
+
+        $this->assertSame(1, $inventory->fresh()->refunded_units);
+        $this->assertSame(3, $inventory->fresh()->real_stock);
     }
 
     public function test_it_records_different_refund_types_for_tickets_from_the_same_purchase_item(): void
@@ -835,6 +915,50 @@ class AdminAppTicketControllerTest extends TestCase
             ->assertJsonPath('total_tickets', 1);
     }
 
+    public function test_it_shows_the_effective_date_after_multiple_reschedules_and_suspension(): void
+    {
+        $tenant = $this->createTenant('fiesta_futbol_infantil');
+        $admin = $this->createAdminAppUser($tenant);
+        $this->grantTicketsMenu($tenant);
+        $this->seed([AttributeSeeder::class, FiestaFutbolInfantilProductSeeder::class]);
+        Sanctum::actingAs($admin);
+
+        $entry = CatalogItem::query()->where('tenant_code', $tenant->codigo)->where('slug', 'abono')->firstOrFail();
+        $variant = $entry->variants()->whereHas('eventDates')->firstOrFail();
+        $original = $variant->selectedEventDates()->firstOrFail();
+        $middle = $tenant->eventDates()->create([
+            'date' => '2026-11-01', 'time_start' => '09:00', 'time_end' => '18:00',
+        ]);
+        $latest = $tenant->eventDates()->create([
+            'date' => '2026-11-02', 'time_start' => '09:00', 'time_end' => '18:00',
+        ]);
+        $original->update(['rescheduled_to_event_date_id' => $middle->id]);
+        $middle->update(['rescheduled_to_event_date_id' => $latest->id]);
+        $ticket = $this->createTicket($tenant, $admin, [
+            'source_catalog_item_id' => $entry->id,
+            'source_variant_id' => $variant->id,
+        ]);
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets')
+            ->assertOk()
+            ->assertJsonPath('data.0.id', $ticket->id)
+            ->assertJsonPath('data.0.values.date', '10/10, 11/10, 12/10, 02/11');
+
+        $latest->update(['suspended_at' => now()]);
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets')
+            ->assertOk()
+            ->assertJsonPath('data.0.values.date', '10/10, 11/10, 12/10');
+
+        foreach ($variant->selectedEventDates()->skip(1) as $date) {
+            $date->update(['suspended_at' => now()]);
+        }
+
+        $this->getJson('/api/v1/adminapp/tenant/tickets')
+            ->assertOk()
+            ->assertJsonPath('data.0.values.date', '-');
+    }
+
     public function test_it_exposes_and_filters_merchandise_color_and_size(): void
     {
         $tenant = $this->createTenant('fiesta_futbol_infantil');
@@ -1045,8 +1169,10 @@ class AdminAppTicketControllerTest extends TestCase
     /** @return array{Ticket, PurchaseItem} */
     private function createRefundableTicket(Tenant $tenant, User $admin, string $amount): array
     {
+        $inventory = Inventory::query()->create(['sold_units' => 1]);
         $catalogItem = CatalogItem::query()->create([
             'tenant_code' => $tenant->codigo,
+            'inventory_id' => $inventory->id,
             'slug' => 'ticket-reembolsable-'.Str::uuid(),
             'nombre' => 'Ticket reembolsable',
             'precio' => $amount,

tests/Unit/Cart/InvalidateEventDateCartsServiceTest.php

@@ -0,0 +1,175 @@
+<?php
+
+namespace Tests\Unit\Cart;
+
+use App\Domains\Cart\Models\Cart;
+use App\Domains\Cart\Services\InvalidateEventDateCartsService;
+use App\Domains\Catalog\Models\Inventory;
+use App\Domains\Catalog\Models\StockReservation;
+use App\Domains\Catalog\Services\StockReservationService;
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Tests\TestCase;
+
+class InvalidateEventDateCartsServiceTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        // Minimal service schema, still using the guarded SQLite :memory: connection.
+        Schema::create('carritos', function (Blueprint $table): void {
+            $table->id();
+            $table->string('tenant_codigo');
+            $table->string('status');
+            $table->unsignedBigInteger('current_purchase_id')->nullable();
+            $table->unsignedBigInteger('current_stock_reservation_id')->nullable();
+            $table->timestamps();
+            $table->softDeletes();
+        });
+        Schema::create('carrito_items', function (Blueprint $table): void {
+            $table->id();
+            $table->unsignedBigInteger('cart_id');
+            $table->unsignedBigInteger('variant_id');
+        });
+        Schema::create('variantes', function (Blueprint $table): void {
+            $table->id();
+            $table->unsignedBigInteger('event_date_id')->nullable();
+            $table->softDeletes();
+        });
+        Schema::create('event_dates', function (Blueprint $table): void {
+            $table->id();
+            $table->date('date')->nullable();
+            $table->time('time_start')->nullable();
+        });
+        Schema::create('variant_event_dates', function (Blueprint $table): void {
+            $table->unsignedBigInteger('variant_id');
+            $table->unsignedBigInteger('event_date_id');
+        });
+        Schema::create('compras', function (Blueprint $table): void {
+            $table->id();
+            $table->unsignedBigInteger('stock_reservation_id');
+        });
+        Schema::create('inventories', function (Blueprint $table): void {
+            $table->id();
+            $table->integer('real_stock')->default(10);
+            $table->integer('reserved_stock')->default(2);
+            $table->integer('sold_units')->default(0);
+            $table->integer('refunded_units')->default(0);
+        });
+        Schema::create('stock_reservations', function (Blueprint $table): void {
+            $table->id();
+            $table->string('status');
+            $table->timestamp('expires_at')->nullable();
+            $table->timestamp('released_at')->nullable();
+            $table->timestamp('expired_at')->nullable();
+            $table->string('release_reason')->nullable();
+            $table->timestamps();
+        });
+        Schema::create('stock_reservation_lines', function (Blueprint $table): void {
+            $table->id();
+            $table->unsignedBigInteger('stock_reservation_id');
+            $table->unsignedBigInteger('inventory_id');
+            $table->integer('quantity');
+        });
+        DB::table('event_dates')->insert([['id' => 1], ['id' => 2]]);
+        DB::table('variantes')->insert([
+            ['id' => 1, 'event_date_id' => 1],
+            ['id' => 2, 'event_date_id' => 2],
+            ['id' => 3, 'event_date_id' => null],
+        ]);
+        DB::table('variant_event_dates')->insert(['variant_id' => 3, 'event_date_id' => 1]);
+    }
+
+    public static function releaseReasons(): array
+    {
+        return [
+            [StockReservationService::REASON_EVENT_DATE_RESCHEDULED],
+            [StockReservationService::REASON_EVENT_DATE_SUSPENDED],
+        ];
+    }
+
+    #[DataProvider('releaseReasons')]
+    public function test_invalidates_whole_cart_and_releases_all_its_stock_only_once(string $reason): void
+    {
+        $cart = $this->cart(1);
+        $otherInventory = DB::table('inventories')->insertGetId([]);
+        DB::table('carrito_items')->insert(['cart_id' => $cart->id, 'variant_id' => 2]);
+        DB::table('stock_reservation_lines')->insert([
+            'stock_reservation_id' => $cart->current_stock_reservation_id,
+            'inventory_id' => $otherInventory,
+            'quantity' => 2,
+        ]);
+        $reservationId = $cart->current_stock_reservation_id;
+        $this->invalidate($reason);
+        $this->invalidate($reason);
+
+        $this->assertSame(Cart::STATUS_EXPIRED, $cart->fresh()->status);
+        $this->assertNull($cart->fresh()->current_stock_reservation_id);
+        $this->assertSame(0, (int) Inventory::query()->sum('reserved_stock'));
+        $this->assertSame(20, (int) Inventory::query()->sum('real_stock'));
+        $this->assertDatabaseHas('stock_reservations', [
+            'id' => $reservationId, 'status' => StockReservation::STATUS_RELEASED,
+            'release_reason' => $reason,
+        ]);
+    }
+
+    public function test_preserves_other_dates_tenants_and_purchase_reservations(): void
+    {
+        $otherDate = $this->cart(2);
+        $otherTenant = $this->cart(1, 'other');
+        $purchaseCart = $this->cart(1);
+        DB::table('compras')->insert(['stock_reservation_id' => $purchaseCart->current_stock_reservation_id]);
+        $currentPurchaseCart = $this->cart(1);
+        $currentPurchaseCart->update(['current_purchase_id' => 99]);
+        $affected = $this->cart(3);
+
+        $this->invalidate();
+
+        foreach ([$otherDate, $otherTenant, $purchaseCart, $currentPurchaseCart] as $cart) {
+            $this->assertSame(Cart::STATUS_ACTIVE, $cart->fresh()->status);
+            $this->assertSame(StockReservation::STATUS_ACTIVE, $cart->fresh()->currentStockReservation->status);
+        }
+        $this->assertSame(Cart::STATUS_EXPIRED, $affected->fresh()->status);
+        $this->assertSame(8, (int) Inventory::query()->sum('reserved_stock'));
+    }
+
+    public function test_rolls_back_invalidation_when_the_date_change_fails(): void
+    {
+        $cart = $this->cart(1);
+        DB::beginTransaction();
+        $this->invalidate();
+        DB::rollBack();
+
+        $this->assertSame(Cart::STATUS_ACTIVE, $cart->fresh()->status);
+        $this->assertSame(StockReservation::STATUS_ACTIVE, $cart->fresh()->currentStockReservation->status);
+        $this->assertSame(2, (int) Inventory::query()->sum('reserved_stock'));
+    }
+
+    private function invalidate(string $reason = StockReservationService::REASON_EVENT_DATE_RESCHEDULED): void
+    {
+        app(InvalidateEventDateCartsService::class)->invalidate(new Tenant(['codigo' => 'acme']), collect([1]), $reason);
+    }
+
+    private function cart(int $variantId, string $tenantCode = 'acme'): Cart
+    {
+        $reservation = StockReservation::query()->create([
+            'status' => StockReservation::STATUS_ACTIVE, 'expires_at' => now()->addHour(),
+        ]);
+        $cart = Cart::query()->create([
+            'tenant_codigo' => $tenantCode, 'status' => Cart::STATUS_ACTIVE,
+            'current_stock_reservation_id' => $reservation->id,
+        ]);
+        DB::table('carrito_items')->insert(['cart_id' => $cart->id, 'variant_id' => $variantId]);
+        DB::table('stock_reservation_lines')->insert([
+            'stock_reservation_id' => $reservation->id,
+            'inventory_id' => DB::table('inventories')->insertGetId([]),
+            'quantity' => 2,
+        ]);
+
+        return $cart;
+    }
+}

tests/Unit/Event/EventModelsTest.php

@@ -89,4 +89,21 @@ class EventModelsTest extends TestCase
 
         $this->assertInstanceOf(EventDate::class, $tenant->eventDates()->getRelated());
     }
+
+    public function test_effective_date_follows_all_replacements_and_returns_null_when_suspended(): void
+    {
+        $original = new EventDate;
+        $original->setRawAttributes(['id' => 1, 'rescheduled_to_event_date_id' => 2]);
+        $middle = new EventDate;
+        $middle->setRawAttributes(['id' => 2, 'rescheduled_to_event_date_id' => 3]);
+        $latest = new EventDate;
+        $latest->setRawAttributes(['id' => 3, 'date' => '2026-11-02']);
+        $original->setRelation('rescheduledTo', $middle);
+        $middle->setRelation('rescheduledTo', $latest);
+
+        $this->assertSame($latest, $original->effectiveDate());
+
+        $latest->suspended_at = '2026-11-01 12:00:00';
+        $this->assertNull($original->effectiveDate());
+    }
 }

tests/Unit/FiestaFutbolInfantil/EntryResourceTest.php

@@ -8,7 +8,7 @@ use App\Domains\Catalog\Models\Variant;
 use App\Domains\Event\Models\EventDate;
 use App\Domains\FiestaFutbolInfantil\Resources\EntryResource;
 use Illuminate\Http\Request;
-use Illuminate\Support\MultipleItemsFoundException;
+use Illuminate\Validation\ValidationException;
 use Tests\TestCase;
 
 class EntryResourceTest extends TestCase
@@ -38,7 +38,7 @@ class EntryResourceTest extends TestCase
         $entry = new CatalogItem;
         $entry->setRelation('variants', collect([new Variant, new Variant]));
 
-        $this->expectException(MultipleItemsFoundException::class);
+        $this->expectException(ValidationException::class);
 
         (new EntryResource($entry))->resolve(Request::create('/'));
     }