feat: add expires_at to PurchaseDetailResponse and update checkout logic for pending payments

- Refactor AuthService, CartService, CatalogService, CheckoutService, TenantService, and TicketService to extend BaseApiService for consistent loading context handling.
- Implement loading modes ('global', 'custom', 'none') using HttpContext for API requests.
- Update existing service methods to accept loading mode parameters and propagate them to HTTP requests.
- Enhance global loading interceptor to respect loading modes and prevent global loading for specific requests.
- Add unit tests to verify loading mode propagation in services and interceptors.
- Update component interactions to utilize the new loading mode functionality.

src/app/app.config.ts

@@ -10,6 +10,7 @@ import { provideClientHydration, withHttpTransferCacheOptions } from '@angular/p
 import { routes } from './app.routes';
 import { authBootstrap } from './core/services/auth/auth-bootstrap';
 import { authInterceptor } from './core/services/auth/auth.interceptor';
+import { globalLoadingInterceptor } from './core/services/global-loading/global-loading.interceptor';
 import { tenantBootstrap } from './core/services/tenant-bootstrap';
 
 function isStoreCatalogRequest(request: HttpRequest<unknown>): boolean {
@@ -29,7 +30,10 @@ export const appConfig: ApplicationConfig = {
         filter: isStoreCatalogRequest,
       }),
     ),
-    provideHttpClient(withFetch(), withInterceptors([authInterceptor])),
+    provideHttpClient(
+      withFetch(),
+      withInterceptors([authInterceptor, globalLoadingInterceptor])
+    ),
     provideAppInitializer(authBootstrap),
     provideAppInitializer(tenantBootstrap),
   ],

src/app/app.html

@@ -2,6 +2,7 @@
   <router-outlet />
   <app-toast-container />
   <app-modal-host />
+  <app-global-loading />
 } @else if (status() === 'not-found') {
   <section class="tenant-status">
     <div class="tenant-status__card">

src/app/app.routes.spec.ts

@@ -23,7 +23,8 @@ const tenant: Tenant = {
   header_bg_color: '#313131',
   footer_bg_color: '#313131',
   header_logo: 'https://example.com/header.png',
-  footer_logo: 'https://example.com/footer.png'
+  footer_logo: 'https://example.com/footer.png',
+  categories: []
 };
 
 function createTenantServiceStub(
@@ -165,6 +166,55 @@ describe('app routes', () => {
     ]);
   });
 
+  it('loads the recover password page inside the simple layout', async () => {
+    const { fixture, router } = await renderAppAt('/recuperar-contrasena');
+    const compiled = fixture.nativeElement as HTMLElement;
+    const recoverPasswordPage = compiled.querySelector('app-recover-password-page');
+
+    expect(router.url).toBe('/recuperar-contrasena');
+    expect(compiled.querySelector('.simple-layout')).not.toBeNull();
+    expect(recoverPasswordPage).not.toBeNull();
+    expect(recoverPasswordPage?.textContent).toContain('Recuperar contraseña');
+    expect(recoverPasswordPage?.querySelector('input')?.getAttribute('placeholder')).toBe('Email');
+    expect(recoverPasswordPage?.textContent).toContain('Recuperar acceso');
+    expect(recoverPasswordPage?.textContent).toContain('Volver');
+  });
+
+  it('loads the recovery code page and shows the entered email', async () => {
+    const { fixture, router } = await renderAppAt(
+      '/recuperar-contrasena/codigo?email=ada%40example.com'
+    );
+    const compiled = fixture.nativeElement as HTMLElement;
+    const codePage = compiled.querySelector('app-recover-password-code-page');
+
+    expect(router.url).toBe('/recuperar-contrasena/codigo?email=ada%40example.com');
+    expect(compiled.querySelector('.simple-layout')).not.toBeNull();
+    expect(codePage).not.toBeNull();
+    expect(codePage?.textContent).toContain('ada@example.com');
+    expect(codePage?.querySelectorAll('app-input')).toHaveLength(4);
+    expect(codePage?.textContent).toContain('Validar');
+  });
+
+  it('loads the reset password page with the shared password inputs', async () => {
+    const { fixture, router } = await renderAppAt(
+      '/recuperar-contrasena/restablecer?email=ada%40example.com&code=1234'
+    );
+    const compiled = fixture.nativeElement as HTMLElement;
+    const resetPage = compiled.querySelector('app-reset-password-page');
+    const placeholders = Array.from(resetPage?.querySelectorAll('input') ?? []).map((input) =>
+      input.getAttribute('placeholder')
+    );
+
+    expect(router.url).toBe(
+      '/recuperar-contrasena/restablecer?email=ada%40example.com&code=1234'
+    );
+    expect(compiled.querySelector('.simple-layout')).not.toBeNull();
+    expect(resetPage).not.toBeNull();
+    expect(resetPage?.textContent).toContain('Restablecer contraseña');
+    expect(placeholders).toEqual(['Nueva Contraseña', 'Repetir Nueva Contraseña']);
+    expect(resetPage?.textContent).toContain('Guardar');
+  });
+
   it('redirects authenticated users away from /login', async () => {
     const { router } = await renderAppAt('/login', createTenantServiceStub(), createAuthServiceStub(true));
 
@@ -186,7 +236,7 @@ describe('app routes', () => {
   it('redirects unauthenticated users from /checkout to /login', async () => {
     const { router } = await renderAppAt('/checkout', createTenantServiceStub(), createAuthServiceStub(false));
 
-    expect(router.url).toBe('/login');
+    expect(router.url).toBe('/login?returnUrl=%2Fcheckout');
   });
 
   it('allows authenticated users to access /checkout', async () => {

src/app/app.spec.ts

@@ -24,7 +24,8 @@ const tenant: Tenant = {
   header_bg_color: '#313131',
   footer_bg_color: '#313131',
   header_logo: 'https://example.com/header.png',
-  footer_logo: 'https://example.com/footer.png'
+  footer_logo: 'https://example.com/footer.png',
+  categories: []
 };
 
 function createTenantServiceStub(status: 'ready' | 'not-found', currentTenant: Tenant | null) {

src/app/app.ts

@@ -3,6 +3,7 @@ import { RouterOutlet } from '@angular/router';
 
 import { TenantService } from './core/services/tenant.service';
 import { DEFAULT_TENANT_BRANDING } from './core/services/tenant-ssr-cache.store';
+import { GlobalLoadingComponent } from './shared/components/global-loading/global-loading.component';
 import { ModalHostComponent } from './shared/components/modal-host/modal-host.component';
 import { ToastContainerComponent } from './shared/components/toast-container/toast-container.component';
 
@@ -23,7 +24,12 @@ function hexToRgb(hex: string): string {
 
 @Component({
   selector: 'app-root',
-  imports: [RouterOutlet, ToastContainerComponent, ModalHostComponent],
+  imports: [
+    RouterOutlet,
+    ToastContainerComponent,
+    ModalHostComponent,
+    GlobalLoadingComponent
+  ],
   templateUrl: './app.html',
   styleUrl: './app.scss',
   host: {
@@ -88,4 +94,4 @@ export class App {
       this.tenantService.tenant()?.footer_bg_color ??
       DEFAULT_TENANT_BRANDING.footerBgColor
   );
-}
+}

src/app/core/layout/store-layout/store-header/category-dropdown/category-dropdown.component.html

@@ -0,0 +1,39 @@
+@if (open() && categories().length) {
+  <section class="dropdown-menu show p-2 category-dropdown" role="menu" aria-label="Categorías">
+    @for (category of categories(); track category.id) {
+      <div class="dropdown-submenu">
+        <button
+          type="button"
+          class="dropdown-item d-flex align-items-center justify-content-between gap-3"
+          [class.active]="activeCategory()?.id === category.id"
+          role="menuitem"
+          [attr.aria-expanded]="category.subcategories.length ? activeCategory()?.id === category.id : null"
+          (click)="selectCategory(category)"
+        >
+          <span>{{ category.nombre }}</span>
+          @if (category.subcategories.length) {
+            <i class="fa-solid fa-chevron-right" aria-hidden="true"></i>
+          }
+        </button>
+
+        @if (activeCategory()?.id === category.id && subcategories().length) {
+          <div class="dropdown-menu show p-2 category-dropdown__submenu">
+            @for (subcategory of subcategories(); track subcategory.id) {
+              <button
+                type="button"
+                class="dropdown-item d-flex align-items-center justify-content-between gap-3"
+                role="menuitem"
+                (click)="categorySelect.emit(subcategory)"
+              >
+                <span>{{ subcategory.nombre }}</span>
+                @if (subcategory.subcategories.length) {
+                  <i class="fa-solid fa-chevron-right" aria-hidden="true"></i>
+                }
+              </button>
+            }
+          </div>
+        }
+      </div>
+    }
+  </section>
+}

src/app/core/layout/store-layout/store-header/category-dropdown/category-dropdown.component.scss

@@ -0,0 +1,47 @@
+.category-dropdown {
+  min-width: 240px;
+  background-color: #ffffff;
+  border: 0;
+  box-shadow: 0 0 25px rgba(0, 0, 0, 0.05);
+}
+
+.category-dropdown .dropdown-item,
+.category-dropdown .dropdown-item:active {
+  display: flex;
+  align-items: center;
+  min-height: 2rem;
+  font-size: 14px;
+  font-weight: 700;
+  line-height: 1.25;
+  color: #8a8a8a;
+  background-color: #ffffff;
+}
+
+.category-dropdown .dropdown-item:hover,
+.category-dropdown .dropdown-item:focus,
+.category-dropdown .dropdown-item.active {
+  color: var(--tenant-primary, var(--bs-primary));
+  background-color: #ffffff;
+}
+
+.dropdown-submenu {
+  position: relative;
+}
+
+.category-dropdown__submenu {
+  top: -0.5rem;
+  left: calc(100% - 0.1rem);
+  min-width: 240px;
+  border: 0;
+  box-shadow: 0 0 25px rgba(0, 0, 0, 0.05);
+}
+
+@media (max-width: 575.98px) {
+  .category-dropdown__submenu {
+    position: static;
+    margin: 0;
+    border: 0;
+    border-radius: 0;
+    box-shadow: none;
+  }
+}

src/app/core/layout/store-layout/store-header/category-dropdown/category-dropdown.component.ts

@@ -0,0 +1,46 @@
+import { ChangeDetectionStrategy, Component, computed, effect, input, output, signal } from '@angular/core';
+
+import { Category } from '../../../../services/tenant.interface';
+
+@Component({
+  selector: 'app-category-dropdown',
+  standalone: true,
+  templateUrl: './category-dropdown.component.html',
+  styleUrl: './category-dropdown.component.scss',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class CategoryDropdownComponent {
+  readonly categories = input<readonly Category[]>([]);
+  readonly open = input(false);
+  readonly categorySelect = output<Category>();
+
+  protected readonly activeCategory = signal<Category | null>(null);
+  protected readonly subcategories = computed(() => this.activeCategory()?.subcategories ?? []);
+
+  constructor() {
+    effect(() => {
+      const categories = this.categories();
+      const activeCategory = this.activeCategory();
+
+      if (!this.open()) {
+        this.activeCategory.set(null);
+        return;
+      }
+
+      if (activeCategory && !categories.some((category) => category.id === activeCategory.id)) {
+        this.activeCategory.set(null);
+      }
+    });
+  }
+
+  protected selectCategory(category: Category): void {
+    if (category.subcategories.length) {
+      this.activeCategory.update((activeCategory) =>
+        activeCategory?.id === category.id ? null : category,
+      );
+      return;
+    }
+
+    this.categorySelect.emit(category);
+  }
+}

src/app/core/layout/store-layout/store-header/store-header.component.html

@@ -99,16 +99,28 @@
     </div>
   </div>
 
-  <div>
+  <div class="store-layout__categories">
     <div class="container-xl px-3 px-md-4">
-      <button
-        type="button"
-        class="btn btn-link d-inline-flex align-items-center gap-2 px-0 py-2 text-uppercase fw-bold text-decoration-none store-layout__category-trigger"
-        aria-label="Categorias"
-      >
-        <span>Categorias</span>
-        <i class="fa-solid fa-chevron-down" aria-hidden="true"></i>
-      </button>
+      <div class="store-layout__category-menu">
+        <button
+          type="button"
+          class="btn btn-link d-inline-flex align-items-center gap-2 px-0 py-2 text-uppercase fw-bold text-decoration-none store-layout__category-trigger"
+          aria-label="Categorias"
+          aria-controls="store-category-dropdown"
+          [attr.aria-expanded]="isCategoryDropdownOpen()"
+          (click)="toggleCategoryDropdown()"
+        >
+          <span>Categorias</span>
+          <i class="fa-solid fa-chevron-down" aria-hidden="true"></i>
+        </button>
+
+        <app-category-dropdown
+          id="store-category-dropdown"
+          [categories]="categories()"
+          [open]="isCategoryDropdownOpen()"
+          (categorySelect)="onCategorySelect($event)"
+        />
+      </div>
     </div>
   </div>
 </header>

src/app/core/layout/store-layout/store-header/store-header.component.scss

@@ -111,6 +111,19 @@
   color: #8a8a8a;
 }
 
+.store-layout__category-menu {
+  position: relative;
+  display: inline-flex;
+  flex-direction: column;
+}
+
+.store-layout__category-menu app-category-dropdown {
+  position: absolute;
+  z-index: 1050;
+  top: 100%;
+  left: 0;
+}
+
 @keyframes store-header-logo-skeleton {
   from {
     background-position: 200% 0;

src/app/core/layout/store-layout/store-header/store-header.component.ts

@@ -7,6 +7,8 @@ import { UserDropdownComponent } from './user-dropdown/user-dropdown.component';
 import { Menu } from '../../../services/tenant.interface';
 import { ButtonComponent } from '../../../../shared/components/button/button.component';
 import { ReactiveFormsModule, FormControl } from '@angular/forms';
+import { Category } from '../../../services/tenant.interface';
+import { CategoryDropdownComponent } from './category-dropdown/category-dropdown.component';
 
 @Component({
   selector: 'app-store-header',
@@ -17,6 +19,7 @@ import { ReactiveFormsModule, FormControl } from '@angular/forms';
     RouterLink,
     ReactiveFormsModule,
     UserDropdownComponent,
+    CategoryDropdownComponent,
   ],
   templateUrl: './store-header.component.html',
   styleUrl: './store-header.component.scss',
@@ -30,32 +33,37 @@ export class StoreHeaderComponent {
   readonly isAuthenticated = input<boolean>(false);
   readonly accountNavigationMenus = input<readonly Menu[]>([]);
   readonly ticketsMenu = input<Menu | null>(null);
+  readonly categories = input<readonly Category[]>([]);
   readonly cartClick = output<void>();
   readonly ticketsClick = output<void>();
   readonly loginClick = output<void>();
   readonly logoutClick = output<void>();
   readonly searchSubmit = output<string>();
+  readonly categorySelect = output<Category>();
 
   protected readonly isUserDropdownOpen = signal(false);
+  protected readonly isCategoryDropdownOpen = signal(false);
   protected readonly minSearchLength = 3;
   protected readonly showSearchError = signal(false);
   protected readonly searchControl = new FormControl('', { nonNullable: true });
 
   @HostListener('document:click', ['$event'])
   protected onDocumentClick(event: MouseEvent): void {
-    if (!this.isUserDropdownOpen()) {
+    if (!this.isUserDropdownOpen() && !this.isCategoryDropdownOpen()) {
       return;
     }
 
     const target = event.target;
     if (target instanceof Node && !this.elementRef.nativeElement.contains(target)) {
       this.isUserDropdownOpen.set(false);
+      this.isCategoryDropdownOpen.set(false);
     }
   }
 
   @HostListener('document:keydown.escape')
   protected onEscapeKey(): void {
     this.isUserDropdownOpen.set(false);
+    this.isCategoryDropdownOpen.set(false);
   }
 
   protected toggleUserDropdown(): void {
@@ -94,4 +102,13 @@ export class StoreHeaderComponent {
   protected clearSearchError(): void {
     this.showSearchError.set(false);
   }
+
+  protected toggleCategoryDropdown(): void {
+    this.isCategoryDropdownOpen.update((isOpen) => !isOpen);
+  }
+
+  protected onCategorySelect(category: Category): void {
+    this.isCategoryDropdownOpen.set(false);
+    this.categorySelect.emit(category);
+  }
 }

src/app/core/layout/store-layout/store-layout.component.html

@@ -6,15 +6,20 @@
     [isAuthenticated]="isAuthenticated()"
     [accountNavigationMenus]="accountNavigationMenus()"
     [ticketsMenu]="ticketsMenu() ?? null"
+    [categories]="tenant()?.categories ?? []"
     (cartClick)="isCartOpen.set(!isCartOpen())"
     (ticketsClick)="onTicketsClick()"
     (loginClick)="onLoginClick()"
     (logoutClick)="onLogoutClick()"
     (searchSubmit)="onSearch($event)"
+    (categorySelect)="onCategorySelect($event)"
   />
 
   @if (isCartOpen()) {
-    <div class="store-layout__cart-overlay" (click)="isCartOpen.set(false)"></div>
+    <div
+      class="store-layout__cart-overlay"
+      (click)="isCartOpen.set(false)"
+    ></div>
     <div class="store-layout__cart-dropdown card border-0 shadow-lg">
       <app-cart
         [showClose]="true"
@@ -25,12 +30,20 @@
         [backgroundColor]="'#ffffff'"
         (closed)="isCartOpen.set(false)"
       >
-        <app-button variant="secondary" class="flex-grow-1" (click)="isCartOpen.set(false)"
+        <app-button
+          variant="secondary"
+          class="flex-grow-1"
+          (click)="isCartOpen.set(false)"
           >Seguir comprando</app-button
         >
-        <app-button variant="primary" class="flex-grow-1" (click)="onCheckoutClick()"
-          >Comprar</app-button
+        <app-button
+          variant="primary"
+          class="flex-grow-1"
+          [disabled]="isCreatingPurchase()"
+          (click)="onCheckoutClick()"
         >
+          Comprar
+        </app-button>
       </app-cart>
     </div>
   }

src/app/core/layout/store-layout/store-layout.component.spec.ts

@@ -15,6 +15,7 @@ import { AuthService } from '../../services/auth/auth.service';
 import { AuthUser } from '../../services/auth/auth.interfaces';
 import { StoreLayoutComponent } from './store-layout.component';
 import { StoreHeaderComponent } from './store-header/store-header.component';
+import { CheckoutService } from '../../services/checkout.service';
 
 const tenant: Tenant = {
   id: 1,
@@ -29,6 +30,7 @@ const tenant: Tenant = {
   footer_bg_color: '#313131',
   header_logo: 'https://example.com/header.png',
   footer_logo: 'https://example.com/footer.png',
+  categories: [],
   menues: [
     {
       id: 4,
@@ -127,12 +129,17 @@ const tenant: Tenant = {
 describe('StoreLayoutComponent', () => {
   let tenantState = signal<Tenant | null>(tenant);
   let cartState = signal<Cart | null>(null);
+  let authUserState = signal<AuthUser | null>(null);
+  let checkoutServiceStub: { startCheckout: ReturnType<typeof vi.fn> };
 
   beforeEach(async () => {
     tenantState = signal<Tenant | null>(tenant);
     cartState = signal<Cart | null>(null);
-    const authUserState = signal<AuthUser | null>(null);
+    authUserState = signal<AuthUser | null>(null);
     const isAuthenticatedState = signal(false);
+    checkoutServiceStub = {
+      startCheckout: vi.fn().mockResolvedValue({ id: 55 }),
+    };
 
     await TestBed.configureTestingModule({
       imports: [StoreLayoutComponent],
@@ -156,6 +163,7 @@ describe('StoreLayoutComponent', () => {
               .fn()
               .mockReturnValue(of({ data: { id: 1, items: [], subtotal: '0' } })),
             removeItem: vi.fn().mockReturnValue(of({ data: { id: 1, items: [], subtotal: '0' } })),
+            clearCart: vi.fn(() => cartState.set(null)),
           },
         },
         {
@@ -176,6 +184,10 @@ describe('StoreLayoutComponent', () => {
             logout: vi.fn().mockReturnValue(of(void 0)),
           },
         },
+        {
+          provide: CheckoutService,
+          useValue: checkoutServiceStub,
+        },
       ],
     }).compileComponents();
   });
@@ -394,8 +406,9 @@ describe('StoreLayoutComponent', () => {
     expect(router.navigate).not.toHaveBeenCalled();
   });
 
-  it('logs out from the authenticated user dropdown', () => {
+  it('logs out from the authenticated user dropdown, clears the cart and returns home', () => {
     const authService = TestBed.inject(AuthService);
+    const cartService = TestBed.inject(CartService);
     const router = TestBed.inject(Router);
     vi.spyOn(router, 'navigate');
 
@@ -424,11 +437,13 @@ describe('StoreLayoutComponent', () => {
     fixture.detectChanges();
 
     expect(authService.logout).toHaveBeenCalled();
-    expect(router.navigate).toHaveBeenCalledWith(['/login']);
+    expect(cartService.clearCart).toHaveBeenCalled();
+    expect(router.navigate).toHaveBeenCalledWith(['/']);
   });
 
   it('provides account actions from the footer', () => {
     const authService = TestBed.inject(AuthService);
+    const cartService = TestBed.inject(CartService);
     const router = TestBed.inject(Router);
     vi.spyOn(router, 'navigate');
 
@@ -455,7 +470,28 @@ describe('StoreLayoutComponent', () => {
     fixture.detectChanges();
 
     expect(authService.logout).toHaveBeenCalled();
-    expect(router.navigate).toHaveBeenCalledWith(['/login']);
+    expect(cartService.clearCart).toHaveBeenCalled();
+    expect(router.navigate).toHaveBeenCalledWith(['/']);
+  });
+
+  it('leaves checkout before logging out so the pending purchase can be cancelled', async () => {
+    const authService = TestBed.inject(AuthService);
+    const cartService = TestBed.inject(CartService);
+    const router = TestBed.inject(Router);
+    vi.spyOn(router, 'url', 'get').mockReturnValue('/checkout?purchase=25');
+    const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+
+    const fixture = TestBed.createComponent(StoreLayoutComponent);
+    fixture.detectChanges();
+
+    await (fixture.componentInstance as any).onLogoutClick();
+
+    expect(navigateSpy).toHaveBeenCalledWith(['/']);
+    expect(authService.logout).toHaveBeenCalled();
+    expect(navigateSpy.mock.invocationCallOrder[0]).toBeLessThan(
+      (authService.logout as any).mock.invocationCallOrder[0],
+    );
+    expect(cartService.clearCart).toHaveBeenCalled();
   });
 
   it('renders only the help submenus assigned to the tenant in the footer', () => {
@@ -481,7 +517,7 @@ describe('StoreLayoutComponent', () => {
     expect(compiled.textContent).not.toContain('Medios de pago');
   });
 
-  it('redirects to /checkout when cart buy button is clicked', () => {
+  it('creates a purchase and redirects to checkout when cart buy is clicked', async () => {
     const router = TestBed.inject(Router);
     vi.spyOn(router, 'navigate');
     cartState.set({
@@ -503,23 +539,73 @@ describe('StoreLayoutComponent', () => {
         },
       ],
     });
+    authUserState.set({
+      id: 7,
+      nombre_apellido: 'Juan Perez',
+      email: 'juan@example.com',
+      dni: '12345678',
+      telefono: '3415555555',
+    });
+
+    const fixture = TestBed.createComponent(StoreLayoutComponent);
+    fixture.detectChanges();
+
+    (fixture.componentInstance as any).isCartOpen.set(true);
+    fixture.detectChanges();
+
+    const compiled = fixture.nativeElement as HTMLElement;
+    const buyButton = Array.from(compiled.querySelectorAll('app-button button')).find(
+      (button) => button.textContent?.trim() === 'Comprar',
+    ) as HTMLButtonElement | undefined;
+
+    expect(buyButton).toBeDefined();
+    buyButton!.click();
+    await Promise.resolve();
+    fixture.detectChanges();
+
+    expect(checkoutServiceStub.startCheckout).toHaveBeenCalledWith('test', {
+      cart_id: 1,
+    });
+    expect(router.navigate).toHaveBeenCalledWith(['/checkout'], {
+      queryParams: { purchase: 55 },
+    });
+    expect((fixture.componentInstance as any).isCartOpen()).toBe(false);
+  });
+
+  it('allows modifying quantities directly in the regular cart without a toggle', () => {
+    cartState.set({
+      id: 1,
+      tenant_codigo: tenant.codigo,
+      status: 'active',
+      subtotal: '100.00',
+      items: [
+        {
+          id: 1,
+          cantidad: 1,
+          precio_unitario: '100.00',
+          catalog_item_id: 1,
+          variant_id: null,
+          product: {
+            nombre: 'Producto',
+            imagen: null,
+          },
+        },
+      ],
+    });
 
     const fixture = TestBed.createComponent(StoreLayoutComponent);
     fixture.detectChanges();
-
     (fixture.componentInstance as any).isCartOpen.set(true);
     fixture.detectChanges();
 
-    const compiled = fixture.nativeElement as HTMLElement;
-    const buyButton = Array.from(compiled.querySelectorAll('app-button button')).find(
-      (button) => button.textContent?.trim() === 'Comprar',
-    ) as HTMLButtonElement | undefined;
+    const element = fixture.nativeElement as HTMLElement;
+    const cartItem = fixture.debugElement.query(By.css('app-cart-item'));
+    const buyButton = Array.from(
+      element.querySelectorAll<HTMLButtonElement>('app-button button'),
+    ).find((button) => button.textContent?.trim() === 'Comprar');
 
+    expect(element.querySelector('.cart-edit-btn')).toBeNull();
+    expect(cartItem.componentInstance.quantityDisabled()).toBe(false);
     expect(buyButton).toBeDefined();
-    buyButton!.click();
-    fixture.detectChanges();
-
-    expect(router.navigate).toHaveBeenCalledWith(['/checkout']);
-    expect((fixture.componentInstance as any).isCartOpen()).toBe(false);
   });
 });

src/app/core/layout/store-layout/store-layout.component.ts

@@ -9,6 +9,9 @@ import { ButtonComponent } from '../../../shared/components/button/button.compon
 import { CartItem } from '../../services/cart/cart.interface';
 import { AuthService } from '../../services/auth/auth.service';
 import { findMenu } from '../../services/menu.utils';
+import { CheckoutService } from '../../services/checkout.service';
+import { ToastService } from '../../services/toast.service';
+import { Category } from '../../services/tenant.interface';
 
 @Component({
   selector: 'app-store-layout',
@@ -26,9 +29,12 @@ export class StoreLayoutComponent implements OnInit {
   private readonly tenantService = inject(TenantService);
   private readonly cartService = inject(CartService);
   private readonly authService = inject(AuthService);
+  private readonly checkoutService = inject(CheckoutService);
+  private readonly toastService = inject(ToastService);
   private readonly router = inject(Router);
 
   protected readonly isCartOpen = signal(false);
+  protected readonly isCreatingPurchase = signal(false);
 
   protected readonly cartSubtotal = computed(() => {
     const cart = this.cartService.cart();
@@ -120,6 +126,12 @@ export class StoreLayoutComponent implements OnInit {
     });
   }
 
+  protected onCategorySelect(category: Category): void {
+    void this.router.navigate(['/categoria', category.id], {
+      queryParams: { page: 1 },
+    });
+  }
+
   protected onTicketsClick(): void {
     const route = this.ticketsMenu()?.route;
 
@@ -128,16 +140,69 @@ export class StoreLayoutComponent implements OnInit {
     }
   }
 
-  protected onLogoutClick(): void {
+  protected async onLogoutClick(): Promise<void> {
+    const isLeavingCheckout = this.router.url.startsWith('/checkout');
+
+    // Checkout must be left while the authenticated session is still valid so
+    // its CanDeactivate guard can cancel the pending purchase.
+    if (isLeavingCheckout) {
+      const navigationSucceeded = await this.router.navigate(['/']);
+
+      if (!navigationSucceeded) {
+        return;
+      }
+    }
+
     this.authService.logout().subscribe({
-      next: () => void this.router.navigate(['/login']),
+      next: () => {
+        this.cartService.clearCart();
+        this.isCartOpen.set(false);
+
+        if (!isLeavingCheckout) {
+          void this.router.navigate(['/']);
+        }
+      },
       error: (err) => console.error('Error logging out', err),
     });
   }
 
-  protected onCheckoutClick(): void {
-    this.isCartOpen.set(false);
-    void this.router.navigate(['/checkout']);
+  protected async onCheckoutClick(): Promise<void> {
+    if (this.isCreatingPurchase()) {
+      return;
+    }
+
+    const cart = this.cartService.cart();
+    const tenant = this.tenantService.tenant();
+    const user = this.authService.user();
+
+    if (!user) {
+      this.isCartOpen.set(false);
+      void this.router.navigate(['/login'], { queryParams: { returnUrl: '/' } });
+      return;
+    }
+
+    if (!cart?.id || !tenant) {
+      this.toastService.danger('No hay un carrito activo para iniciar la compra.');
+      return;
+    }
+
+    this.isCreatingPurchase.set(true);
+    try {
+      const purchase = await this.checkoutService.startCheckout(tenant.codigo, {
+        cart_id: cart.id,
+      });
+
+      this.cartService.clearCart();
+      this.isCartOpen.set(false);
+      await this.router.navigate(['/checkout'], {
+        queryParams: { purchase: purchase.id },
+      });
+    } catch (error) {
+      console.error('Failed to create cart purchase:', error);
+      this.toastService.danger('No se pudo iniciar la compra.');
+    } finally {
+      this.isCreatingPurchase.set(false);
+    }
   }
 
   protected readonly footerSections = computed<StoreFooterSection[]>(() => {

src/app/core/services/auth/auth.guards.spec.ts

@@ -23,10 +23,14 @@ describe('auth guards', () => {
       providers: [provideRouter([]), { provide: AuthService, useValue: createAuthServiceStub() }]
     });
 
-    const result = TestBed.runInInjectionContext(() => authGuard(null as never, null as never));
+    const result = TestBed.runInInjectionContext(() =>
+      authGuard(null as never, { url: '/checkout?mode=direct' } as never),
+    );
 
     expect(result instanceof UrlTree).toBe(true);
-    expect(TestBed.inject(Router).serializeUrl(result as UrlTree)).toBe('/login');
+    expect(TestBed.inject(Router).serializeUrl(result as UrlTree)).toBe(
+      '/login?returnUrl=%2Fcheckout%3Fmode%3Ddirect',
+    );
   });
 
   it('allows authenticated users through authGuard', () => {
@@ -34,7 +38,9 @@ describe('auth guards', () => {
       providers: [provideRouter([]), { provide: AuthService, useValue: createAuthServiceStub(true) }]
     });
 
-    const result = TestBed.runInInjectionContext(() => authGuard(null as never, null as never));
+    const result = TestBed.runInInjectionContext(() =>
+      authGuard(null as never, { url: '/checkout' } as never),
+    );
 
     expect(result).toBe(true);
   });

src/app/core/services/auth/auth.guards.ts

@@ -3,11 +3,15 @@ import { CanActivateFn, Router } from '@angular/router';
 
 import { AuthService } from './auth.service';
 
-export const authGuard: CanActivateFn = () => {
+export const authGuard: CanActivateFn = (_route, state) => {
   const authService = inject(AuthService);
   const router = inject(Router);
 
-  return authService.isAuthenticated() ? true : router.createUrlTree(['/login']);
+  return authService.isAuthenticated()
+    ? true
+    : router.createUrlTree(['/login'], {
+        queryParams: { returnUrl: state.url },
+      });
 };
 
 export const guestOnlyGuard: CanActivateFn = () => {

src/app/core/services/auth/auth.interfaces.ts

@@ -37,3 +37,25 @@ export interface RegisterResponse {
   message: string;
   data: AuthUser;
 }
+
+export interface ResetPasswordAttemptResponse {
+  message: string;
+  status: 'pending';
+}
+
+export interface ValidateResetPasswordAttemptResponse {
+  message: string;
+  status: 'validated';
+}
+
+export interface ResetPasswordPayload {
+  email: string;
+  codigo: string;
+  password: string;
+  password_confirmation: string;
+}
+
+export interface ResetPasswordResponse {
+  message: string;
+  status: 'used';
+}

src/app/core/services/auth/auth.service.spec.ts

@@ -19,8 +19,12 @@ describe('AuthService', () => {
   function createCookieServiceStub() {
     return {
       get: (name: string) => cookieStore[name] || null,
-      set: (name: string, value: string) => { cookieStore[name] = value; },
-      delete: (name: string) => { delete cookieStore[name]; }
+      set: (name: string, value: string) => {
+        cookieStore[name] = value;
+      },
+      delete: (name: string) => {
+        delete cookieStore[name];
+      }
     };
   }
 
@@ -31,6 +35,10 @@ describe('AuthService', () => {
         provideHttpClientTesting(),
         AuthService,
         { provide: CookieService, useValue: createCookieServiceStub() },
+        {
+          provide: TenantService,
+          useValue: { getTenant: () => ({ codigo: 'tenant-test' }) }
+        },
         TransferState
       ]
     });
@@ -44,6 +52,12 @@ describe('AuthService', () => {
 
     const request = httpController.expectOne(`${environment.url}login`);
     expect(request.request.method).toBe('POST');
+    expect(request.request.body).toEqual({
+      email: 'ada@example.com',
+      password: 'secret123',
+      tenant_codigo: 'tenant-test'
+    });
+    expect(request.request.withCredentials).toBe(true);
     request.flush({
       message: 'Sesion iniciada correctamente.',
       token: 'plain-text-token',
@@ -96,6 +110,47 @@ describe('AuthService', () => {
     httpController.verify();
   });
 
+  it('sends tenant and credentials when completing Google login', () => {
+    TestBed.configureTestingModule({
+      providers: [
+        provideHttpClient(),
+        provideHttpClientTesting(),
+        AuthService,
+        { provide: CookieService, useValue: createCookieServiceStub() },
+        {
+          provide: TenantService,
+          useValue: { getTenant: () => ({ codigo: 'tenant-test' }) }
+        },
+        TransferState
+      ]
+    });
+
+    const service = TestBed.inject(AuthService);
+    const httpController = TestBed.inject(HttpTestingController);
+
+    service.completeGoogleLogin('oauth-code').subscribe();
+
+    const request = httpController.expectOne(`${environment.url}auth/google/exchange`);
+    expect(request.request.method).toBe('POST');
+    expect(request.request.body).toEqual({
+      oauth_code: 'oauth-code',
+      tenant_codigo: 'tenant-test'
+    });
+    expect(request.request.withCredentials).toBe(true);
+    request.flush({
+      message: 'Sesion iniciada correctamente.',
+      token: 'google-token',
+      token_type: 'Bearer',
+      user: {
+        id: 1,
+        nombre_apellido: 'Ada Lovelace',
+        email: 'ada@example.com'
+      }
+    });
+
+    httpController.verify();
+  });
+
   it('clears an expired session when /me returns 401', async () => {
     cookieStore['shopit.auth.token'] = 'expired-token';
 
@@ -174,6 +229,121 @@ describe('AuthService', () => {
     httpController.verify();
   });
 
+  it('requests a password reset and exposes the final HTTP status', () => {
+    TestBed.configureTestingModule({
+      providers: [
+        provideHttpClient(),
+        provideHttpClientTesting(),
+        AuthService,
+        { provide: CookieService, useValue: createCookieServiceStub() },
+        {
+          provide: TenantService,
+          useValue: { getTenant: () => ({ codigo: 'tenant-test' }) }
+        },
+        TransferState
+      ]
+    });
+
+    const service = TestBed.inject(AuthService);
+    const httpController = TestBed.inject(HttpTestingController);
+
+    service.requestPasswordReset('ada@example.com').subscribe((response) => {
+      expect(response.status).toBe(202);
+      expect(response.body?.status).toBe('pending');
+    });
+
+    const request = httpController.expectOne(`${environment.url}password/reset-attempts`);
+    expect(request.request.method).toBe('POST');
+    expect(request.request.body).toEqual({
+      email: 'ada@example.com',
+      tenant_codigo: 'tenant-test'
+    });
+    request.flush(
+      {
+        message: 'Si el email está registrado, recibirás un código.',
+        status: 'pending'
+      },
+      { status: 202, statusText: 'Accepted' }
+    );
+
+    httpController.verify();
+  });
+
+  it('validates a password reset code and exposes its final status', () => {
+    TestBed.configureTestingModule({
+      providers: [
+        provideHttpClient(),
+        provideHttpClientTesting(),
+        AuthService,
+        { provide: CookieService, useValue: createCookieServiceStub() },
+        TransferState
+      ]
+    });
+
+    const service = TestBed.inject(AuthService);
+    const httpController = TestBed.inject(HttpTestingController);
+
+    service.validatePasswordResetCode('ada@example.com', '0123').subscribe((response) => {
+      expect(response.status).toBe(200);
+      expect(response.body?.status).toBe('validated');
+    });
+
+    const request = httpController.expectOne(`${environment.url}password/reset-attempts/validate`);
+    expect(request.request.method).toBe('POST');
+    expect(request.request.body).toEqual({
+      email: 'ada@example.com',
+      codigo: '0123'
+    });
+    request.flush(
+      {
+        message: 'Código validado correctamente.',
+        status: 'validated'
+      },
+      { status: 200, statusText: 'OK' }
+    );
+
+    httpController.verify();
+  });
+
+  it('resets the password and exposes the consumed attempt status', () => {
+    TestBed.configureTestingModule({
+      providers: [
+        provideHttpClient(),
+        provideHttpClientTesting(),
+        AuthService,
+        { provide: CookieService, useValue: createCookieServiceStub() },
+        TransferState
+      ]
+    });
+
+    const service = TestBed.inject(AuthService);
+    const httpController = TestBed.inject(HttpTestingController);
+    const payload = {
+      email: 'ada@example.com',
+      codigo: '0123',
+      password: 'NewSecret!456',
+      password_confirmation: 'NewSecret!456'
+    };
+
+    service.resetPassword(payload).subscribe((response) => {
+      expect(response.status).toBe(200);
+      expect(response.body?.status).toBe('used');
+    });
+
+    const request = httpController.expectOne(`${environment.url}password/reset`);
+    expect(request.request.method).toBe('POST');
+    expect(request.request.body).toEqual(payload);
+    request.flush(
+      {
+        message: 'Contraseña modificada correctamente.',
+        status: 'used'
+      },
+      { status: 200, statusText: 'OK' }
+    );
+
+    httpController.verify();
+  });
+
   it('propagates logout errors without clearing the local session', () => {
     TestBed.configureTestingModule({
       providers: [
@@ -181,6 +351,10 @@ describe('AuthService', () => {
         provideHttpClientTesting(),
         AuthService,
         { provide: CookieService, useValue: createCookieServiceStub() },
+        {
+          provide: TenantService,
+          useValue: { getTenant: () => ({ codigo: 'tenant-test' }) }
+        },
         TransferState
       ]
     });

src/app/core/services/auth/auth.service.ts

@@ -1,17 +1,22 @@
 import { DOCUMENT } from '@angular/common';
-import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
 import { computed, inject, Injectable, PLATFORM_ID, signal, TransferState, makeStateKey } from '@angular/core';
 import { firstValueFrom, map, Observable, of, tap } from 'rxjs';
 
 import { environment } from '../../../../environments/environment';
+import { BaseApiService } from '../base-api.service';
 import {
   AuthUser,
   LoginPayload,
   LoginResponse,
   RegisterPayload,
   RegisterResponse,
-  UpdateProfilePayload
+  ResetPasswordPayload,
+  ResetPasswordAttemptResponse,
+  ResetPasswordResponse,
+  UpdateProfilePayload,
+  ValidateResetPasswordAttemptResponse
 } from './auth.interfaces';
 import { CookieService } from '../cookie/cookie.service';
 import { TenantService } from '../tenant.service';
@@ -22,8 +27,7 @@ const AUTH_USER_SSR_STATE_KEY = makeStateKey<AuthUser>('shopit.auth.user');
 @Injectable({
   providedIn: 'root'
 })
-export class AuthService {
-  private readonly http = inject(HttpClient);
+export class AuthService extends BaseApiService {
   private readonly document = inject(DOCUMENT);
   private readonly platformId = inject(PLATFORM_ID);
   private readonly cookieService = inject(CookieService);
@@ -38,18 +42,70 @@ export class AuthService {
   readonly isAuthenticated = computed(() => this.tokenState() !== null);
 
   login(payload: LoginPayload): Observable<AuthUser> {
-    return this.http.post<LoginResponse>(`${environment.url}login`, payload).pipe(
-      tap((response) => this.applyAuthenticatedState(response.token, response.user)),
-      map((response) => response.user)
-    );
+    const tenant = this.tenantService.getTenant();
+    if (!tenant) {
+      throw new Error('No se pudo resolver el tenant activo.');
+    }
+
+    return this.http
+      .post<LoginResponse>(
+        `${environment.url}login`,
+        { ...payload, tenant_codigo: tenant.codigo },
+        {
+          withCredentials: true
+        }
+      )
+      .pipe(
+        tap((response) => this.applyAuthenticatedState(response.token, response.user)),
+        map((response) => response.user)
+      );
   }
 
   register(payload: RegisterPayload): Observable<RegisterResponse> {
     const tenantCode = this.tenantService.getTenant()?.codigo;
 
-    return this.http.post<RegisterResponse>(`${environment.url}register`, {
-      ...payload,
-      ...(tenantCode ? { tenant_codigo: tenantCode } : {})
+    return this.http.post<RegisterResponse>(
+      `${environment.url}register`,
+      {
+        ...payload,
+        ...(tenantCode ? { tenant_codigo: tenantCode } : {})
+      },
+    );
+  }
+
+  requestPasswordReset(
+    email: string
+  ): Observable<HttpResponse<ResetPasswordAttemptResponse>> {
+    const tenantCode = this.tenantService.getTenant()?.codigo;
+
+    return this.http.post<ResetPasswordAttemptResponse>(
+      `${environment.url}password/reset-attempts`,
+      {
+        email,
+        ...(tenantCode ? { tenant_codigo: tenantCode } : {})
+      },
+      {
+        observe: 'response'
+      }
+    );
+  }
+
+  validatePasswordResetCode(
+    email: string,
+    codigo: string
+  ): Observable<HttpResponse<ValidateResetPasswordAttemptResponse>> {
+    return this.http.post<ValidateResetPasswordAttemptResponse>(
+      `${environment.url}password/reset-attempts/validate`,
+      { email, codigo },
+      {
+        observe: 'response'
+      }
+    );
+  }
+
+  resetPassword(payload: ResetPasswordPayload): Observable<HttpResponse<ResetPasswordResponse>> {
+    return this.http.post<ResetPasswordResponse>(`${environment.url}password/reset`, payload, {
+      observe: 'response'
     });
   }
 
@@ -68,16 +124,29 @@ export class AuthService {
   }
 
   completeGoogleLogin(oauthCode: string): Observable<AuthUser> {
-    return this.http.post<LoginResponse>(`${environment.url}auth/google/exchange`, { oauth_code: oauthCode }).pipe(
-      tap((response) => this.applyAuthenticatedState(response.token, response.user)),
-      map((response) => response.user)
-    );
+    const tenant = this.tenantService.getTenant();
+    if (!tenant) {
+      throw new Error('No se pudo resolver el tenant activo.');
+    }
+
+    return this.http
+      .post<LoginResponse>(
+        `${environment.url}auth/google/exchange`,
+        { oauth_code: oauthCode, tenant_codigo: tenant.codigo },
+        {
+          withCredentials: true
+        }
+      )
+      .pipe(
+        tap((response) => this.applyAuthenticatedState(response.token, response.user)),
+        map((response) => response.user)
+      );
   }
 
   updateProfile(payload: UpdateProfilePayload): Observable<AuthUser> {
-    return this.http.put<AuthUser>(`${environment.url}me`, payload).pipe(
-      tap((user) => this.userState.set(user))
-    );
+    return this.http
+      .put<AuthUser>(`${environment.url}me`, payload)
+      .pipe(tap((user) => this.userState.set(user)));
   }
 
   logout(): Observable<void> {
@@ -86,9 +155,9 @@ export class AuthService {
       return of(void 0);
     }
 
-    return this.http.post<void>(`${environment.url}logout`, {}).pipe(
-      tap(() => this.clearSession())
-    );
+    return this.http
+      .post<void>(`${environment.url}logout`, {})
+      .pipe(tap(() => this.clearSession()));
   }
 
   async bootstrap(): Promise<void> {
@@ -127,9 +196,9 @@ export class AuthService {
   }
 
   loadCurrentUser(): Observable<AuthUser> {
-    return this.http.get<AuthUser>(`${environment.url}me`).pipe(
-      tap((user) => this.userState.set(user))
-    );
+    return this.http
+      .get<AuthUser>(`${environment.url}me`)
+      .pipe(tap((user) => this.userState.set(user)));
   }
 
   hydrateSession(): void {

src/app/core/services/base-api.service.spec.ts

@@ -0,0 +1,42 @@
+import '@angular/compiler';
+import { provideHttpClient } from '@angular/common/http';
+import { TestBed } from '@angular/core/testing';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { BaseApiService } from './base-api.service';
+import { LOADING_MODE } from './global-loading/loading-mode';
+
+class TestApiService extends BaseApiService {
+  contextFor() {
+    return this.loadingContext();
+  }
+}
+
+describe('BaseApiService', () => {
+  afterEach(() => {
+    TestBed.resetTestingModule();
+  });
+
+  it('uses global loading by default', () => {
+    TestBed.configureTestingModule({ providers: [provideHttpClient()] });
+    const service = TestBed.runInInjectionContext(() => new TestApiService());
+
+    expect(service.contextFor().get(LOADING_MODE)).toBe('global');
+  });
+
+  it('creates an isolated custom-loading scope', () => {
+    TestBed.configureTestingModule({ providers: [provideHttpClient()] });
+    const service = TestBed.runInInjectionContext(() => new TestApiService());
+
+    expect(service.withCustomLoading().contextFor().get(LOADING_MODE)).toBe('custom');
+    expect(service.contextFor().get(LOADING_MODE)).toBe('global');
+  });
+
+  it('creates an isolated scope without a loading indicator', () => {
+    TestBed.configureTestingModule({ providers: [provideHttpClient()] });
+    const service = TestBed.runInInjectionContext(() => new TestApiService());
+
+    expect(service.withoutLoading().contextFor().get(LOADING_MODE)).toBe('none');
+    expect(service.contextFor().get(LOADING_MODE)).toBe('global');
+  });
+});

src/app/core/services/base-api.service.ts

@@ -0,0 +1,79 @@
+import { HttpClient, HttpContext } from '@angular/common/http';
+import { inject } from '@angular/core';
+
+import {
+  LOADING_MODE,
+  LoadingMode
+} from './global-loading/loading-mode';
+
+const REQUEST_LOADING_MODE = Symbol('request-loading-mode');
+
+class LoadingHttpClient {
+  readonly get: HttpClient['get'];
+  readonly post: HttpClient['post'];
+  readonly put: HttpClient['put'];
+  readonly patch: HttpClient['patch'];
+  readonly delete: HttpClient['delete'];
+
+  constructor(
+    http: HttpClient,
+    private readonly buildContext: (context?: HttpContext) => HttpContext
+  ) {
+    this.get = ((url: string, options?: object) =>
+      http.get(url, this.withLoadingContext(options))) as HttpClient['get'];
+    this.post = ((url: string, body: unknown, options?: object) =>
+      http.post(url, body, this.withLoadingContext(options))) as HttpClient['post'];
+    this.put = ((url: string, body: unknown, options?: object) =>
+      http.put(url, body, this.withLoadingContext(options))) as HttpClient['put'];
+    this.patch = ((url: string, body: unknown, options?: object) =>
+      http.patch(url, body, this.withLoadingContext(options))) as HttpClient['patch'];
+    this.delete = ((url: string, options?: object) =>
+      http.delete(url, this.withLoadingContext(options))) as HttpClient['delete'];
+  }
+
+  private withLoadingContext(options?: object): object {
+    const requestOptions = options as { context?: HttpContext } | undefined;
+
+    return {
+      ...requestOptions,
+      context: this.buildContext(requestOptions?.context)
+    };
+  }
+}
+
+export abstract class BaseApiService {
+  private readonly rawHttp = inject(HttpClient);
+  private readonly [REQUEST_LOADING_MODE]: LoadingMode = 'global';
+
+  protected get http(): LoadingHttpClient {
+    return new LoadingHttpClient(
+      this.rawHttp,
+      (context) => this.loadingContext(context)
+    );
+  }
+
+  withLoading(loadingMode: LoadingMode): this {
+    const scopedService = Object.create(this) as this;
+
+    Object.defineProperty(scopedService, REQUEST_LOADING_MODE, {
+      configurable: false,
+      enumerable: false,
+      value: loadingMode,
+      writable: false
+    });
+
+    return scopedService;
+  }
+
+  withCustomLoading(): this {
+    return this.withLoading('custom');
+  }
+
+  withoutLoading(): this {
+    return this.withLoading('none');
+  }
+
+  protected loadingContext(context: HttpContext = new HttpContext()): HttpContext {
+    return context.set(LOADING_MODE, this[REQUEST_LOADING_MODE]);
+  }
+}

src/app/core/services/cart/cart.service.spec.ts

@@ -6,6 +6,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { CartService } from './cart.service';
 import { TenantService } from '../tenant.service';
 import { Cart } from './cart.interface';
+import { LOADING_MODE } from '../global-loading/loading-mode';
 
 describe('CartService', () => {
   let service: CartService;
@@ -75,6 +76,14 @@ describe('CartService', () => {
     req.flush({ data: mockCart });
   });
 
+  it('propagates a custom loading mode to the request context', () => {
+    service.withCustomLoading().loadCart().subscribe();
+
+    const req = httpMock.expectOne('http://api.test/tenants/acme/cart');
+    expect(req.request.context.get(LOADING_MODE)).toBe('custom');
+    req.flush({ data: mockCart });
+  });
+
   it('should clear cart state locally', () => {
     service.clearCart();
 

src/app/core/services/cart/cart.service.ts

@@ -1,16 +1,15 @@
 import { inject, Injectable, signal } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
 import { catchError, map, Observable, tap } from 'rxjs';
 
 import { ApiResponse } from '../api-response.interface';
+import { BaseApiService } from '../base-api.service';
 import { TenantService } from '../tenant.service';
 import { Cart } from './cart.interface';
 
 @Injectable({
   providedIn: 'root',
 })
-export class CartService {
-  private readonly http = inject(HttpClient);
+export class CartService extends BaseApiService {
   private readonly tenantService = inject(TenantService);
 
   private readonly cartState = signal<Cart | null>(null);
@@ -53,7 +52,13 @@ export class CartService {
     return this.http
       .post<
         ApiResponse<Cart>
-      >(`${this.tenantApiUrl}/cart/items`, { catalog_item_id: catalogItemId, variant_id: variantId, cantidad }, { withCredentials: true })
+      >(
+        `${this.tenantApiUrl}/cart/items`,
+        { catalog_item_id: catalogItemId, variant_id: variantId, cantidad },
+        {
+          withCredentials: true,
+        },
+      )
       .pipe(
         tap((response) => {
           this.cartState.set(response.data);
@@ -66,12 +71,21 @@ export class CartService {
       );
   }
 
-  updateItemQuantity(cartItemId: number, cantidad: number): Observable<ApiResponse<Cart>> {
+  updateItemQuantity(
+    cartItemId: number,
+    cantidad: number,
+  ): Observable<ApiResponse<Cart>> {
     this.isUpdatingState.set(true);
     return this.http
       .patch<
         ApiResponse<Cart>
-      >(`${this.tenantApiUrl}/cart/items/${cartItemId}`, { cantidad }, { withCredentials: true })
+      >(
+        `${this.tenantApiUrl}/cart/items/${cartItemId}`,
+        { cantidad },
+        {
+          withCredentials: true,
+        },
+      )
       .pipe(
         tap((response) => {
           this.cartState.set(response.data);
@@ -89,7 +103,9 @@ export class CartService {
     return this.http
       .delete<
         ApiResponse<Cart>
-      >(`${this.tenantApiUrl}/cart/items/${cartItemId}`, { withCredentials: true })
+      >(`${this.tenantApiUrl}/cart/items/${cartItemId}`, {
+        withCredentials: true,
+      })
       .pipe(
         tap((response) => {
           this.cartState.set(response.data);

src/app/core/services/catalog/catalog.interface.ts

@@ -35,16 +35,32 @@ export type InventoryPolicy = 'tracked' | 'unlimited';
 
 export interface CatalogItemVariant {
   id: number;
+  event_date_id?: number | null;
   stock_tecnico: number | null;
+  minimum_use_date?: string | null;
+  maximum_use_date?: string | null;
+  effective_minimum_use_date?: string | null;
+  effective_maximum_use_date?: string | null;
   values: Record<string, string>;
 }
 
+export interface CatalogItemEventDate {
+  id: number;
+  variant_id: number;
+  date: string;
+  starts_at: string;
+  ends_at: string;
+  label: string;
+  stock_tecnico: number | null;
+}
+
 export interface SelectedCatalogItemVariant extends CatalogItemVariant {
   images: string[];
 }
 
 export interface CatalogItemDetail {
   id: number;
+  purpose?: 'product' | 'entry';
   category_id: number | null;
   brand_id: number | null;
   slug: string;
@@ -59,6 +75,7 @@ export interface CatalogItemDetail {
   maximum_use_date: string | null;
   attributes: ProductAttribute[];
   variants: CatalogItemVariant[];
+  event_dates?: CatalogItemEventDate[];
   selected_variant?: SelectedCatalogItemVariant;
   stock_tecnico?: number | null;
   images?: string[];
@@ -84,7 +101,8 @@ export interface CatalogFeaturedItem {
 }
 
 export type CatalogFeaturedItems =
-  ApiPaginatedResponse<CatalogFeaturedItem[]> | CatalogFeaturedItem[];
+  | ApiPaginatedResponse<CatalogFeaturedItem[]>
+  | CatalogFeaturedItem[];
 
 export interface CatalogFeaturedGroup {
   id: number;
@@ -94,3 +112,15 @@ export interface CatalogFeaturedGroup {
   group_order: number;
   items: CatalogFeaturedItems;
 }
+
+export interface CatalogCategory {
+  id: number;
+  nombre: string;
+  categoria_id: number | null;
+}
+
+export interface CategoryItemsResponse extends ApiPaginatedResponse<CatalogFeaturedItem[]> {
+  category: CatalogCategory;
+  layout: CatalogProductLayout;
+  group_layout: CatalogGroupLayout;
+}

src/app/core/services/catalog/catalog.service.ts

@@ -1,16 +1,18 @@
+import { HttpParams } from '@angular/common/http';
 import { inject, Injectable } from '@angular/core';
-import { HttpClient, HttpParams } from '@angular/common/http';
 import { map, Observable } from 'rxjs';
 
 import { ApiPaginationQueryParams } from '../api-pagination-query-params.interface';
 import { ApiPaginatedResponse } from '../api-paginated-response.interface';
 import { ApiResponse } from '../api-response.interface';
+import { BaseApiService } from '../base-api.service';
 import { TenantService } from '../tenant.service';
 import {
   CatalogFeaturedGroup,
   CatalogFeaturedItem,
   CatalogFeaturedItems,
   CatalogItemDetail,
+  CategoryItemsResponse,
   Product,
 } from './catalog.interface';
 
@@ -23,8 +25,7 @@ export interface CatalogSearchQueryParams extends ApiPaginationQueryParams {
 @Injectable({
   providedIn: 'root',
 })
-export class CatalogService {
-  private readonly http = inject(HttpClient);
+export class CatalogService extends BaseApiService {
   private readonly tenantService = inject(TenantService);
 
   private get tenantApiUrl(): string {
@@ -46,28 +47,46 @@ export class CatalogService {
   ): Observable<ApiPaginatedResponse<CatalogFeaturedItem[]>> {
     return this.http.get<ApiPaginatedResponse<CatalogFeaturedItem[]>>(
       `${this.tenantApiUrl}/catalog-items`,
-      { params: this.buildHttpParams(params) },
+      {
+        params: this.buildHttpParams(params),
+      },
     );
   }
 
+  getCategoryItems(
+    categoryId: number,
+    params?: ApiPaginationQueryParams,
+  ): Observable<CategoryItemsResponse> {
+    return this.http.get<CategoryItemsResponse>(`${this.tenantApiUrl}/categories/${categoryId}`, {
+      params: this.buildHttpParams(params),
+    });
+  }
+
   getFeaturedGroupItems(
     featuredGroupId: number,
     params?: ApiPaginationQueryParams,
   ): Observable<CatalogFeaturedItems> {
     return this.http.get<CatalogFeaturedItems>(
       `${this.tenantApiUrl}/catalog/featured-groups/${featuredGroupId}/items`,
-      { params: this.buildHttpParams(params) },
+      {
+        params: this.buildHttpParams(params),
+      },
     );
   }
 
-  getCatalogItem(id: number, variantId?: number): Observable<CatalogItemDetail> {
+  getCatalogItem(
+    id: number,
+    variantId?: number,
+  ): Observable<CatalogItemDetail> {
     let params = new HttpParams();
     if (variantId) {
       params = params.set('variant_id', variantId);
     }
 
     return this.http
-      .get<ApiResponse<CatalogItemDetail>>(`${this.tenantApiUrl}/catalog-items/${id}`, { params })
+      .get<ApiResponse<CatalogItemDetail>>(`${this.tenantApiUrl}/catalog-items/${id}`, {
+        params,
+      })
       .pipe(map((response) => response.data));
   }
 

src/app/core/services/checkout.service.ts

@@ -1,17 +1,28 @@
-import { inject, Injectable } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
 import { firstValueFrom } from 'rxjs';
 
 import { environment } from '../../../environments/environment';
+import { BaseApiService } from './base-api.service';
 
-export interface CreatePurchasePayload {
-  cart_id: number;
+export interface UpdatePurchaseCustomerPayload {
   dni: string;
   telefono: string;
   nombre_apellido: string;
   email: string;
 }
 
+export type StartCheckoutPayload =
+  | {
+      cart_id: number;
+    }
+  | {
+      direct_item: {
+        catalog_item_id: number;
+        variant_id: number | null;
+        cantidad: number;
+      };
+    };
+
 export interface PurchaseStatusResponse {
   status: string | null;
 }
@@ -50,6 +61,7 @@ export interface PurchaseDetailResponse extends PurchaseStatusResponse {
   user_id: number;
   created_at: string | null;
   payment_method: string | null;
+  expires_at: string | null;
   dni: string | null;
   transfer_payer_dni: string | null;
   telefono: string | null;
@@ -57,22 +69,28 @@ export interface PurchaseDetailResponse extends PurchaseStatusResponse {
   email: string | null;
   items_source: 'purchase';
   items: PurchaseDetailItemResponse[];
+  tickets_count?: number;
+  has_generated_tickets?: boolean;
   subtotal: string;
   total: string;
 }
 
 @Injectable({
-  providedIn: 'root'
+  providedIn: 'root',
 })
-export class CheckoutService {
-  private readonly http = inject(HttpClient);
-
-  async createPurchase(tenantCode: string, payload: CreatePurchasePayload): Promise<{ id: number }> {
+export class CheckoutService extends BaseApiService {
+  async startCheckout(
+    tenantCode: string,
+    payload: StartCheckoutPayload,
+  ): Promise<PurchaseDetailResponse> {
     const response = await firstValueFrom(
-      this.http.post<{ data?: { id: number }; id?: number }>(`${environment.url}tenants/${tenantCode}/compras`, payload)
+      this.http.post<{ data?: PurchaseDetailResponse } | PurchaseDetailResponse>(
+        `${environment.url}tenants/${tenantCode}/compras/start-checkout`,
+        payload,
+      ),
     );
 
-    const purchase = this.extractResponseData<{ id: number }>(response);
+    const purchase = this.extractResponseData<PurchaseDetailResponse>(response);
 
     if (!purchase?.id) {
       throw new Error('Error al crear la compra.');
@@ -81,13 +99,21 @@ export class CheckoutService {
     return purchase;
   }
 
-  async generatePaymentIntent(tenantCode: string, purchaseId: number, method: 'qr' | 'transfer' | 'telepagos', payerDni?: string): Promise<any> {
+  async generatePaymentIntent(
+    tenantCode: string,
+    purchaseId: number,
+    method: 'qr' | 'transfer' | 'telepagos',
+    payerDni?: string,
+  ): Promise<any> {
     const payload: any = { method };
     if (payerDni) {
       payload.transfer_payer_dni = payerDni;
     }
     const response = await firstValueFrom(
-      this.http.post<any>(`${environment.url}tenants/${tenantCode}/compras/${purchaseId}/payment-intent`, payload)
+      this.http.post<any>(
+        `${environment.url}tenants/${tenantCode}/compras/${purchaseId}/payment-intent`,
+        payload,
+      ),
     );
     if (!response) {
       throw new Error('Error al generar la intención de pago.');
@@ -95,9 +121,75 @@ export class CheckoutService {
     return response;
   }
 
-  async completePurchase(tenantCode: string, purchaseId: number): Promise<PurchaseStatusResponse> {
+  async updateCustomerData(
+    tenantCode: string,
+    purchaseId: number,
+    payload: UpdatePurchaseCustomerPayload,
+  ): Promise<PurchaseDetailResponse> {
     const response = await firstValueFrom(
-      this.http.post<{ data?: PurchaseStatusResponse } | PurchaseStatusResponse>(`${environment.url}tenants/${tenantCode}/compras/${purchaseId}/complete`, {})
+      this.http.patch<{ data?: PurchaseDetailResponse } | PurchaseDetailResponse>(
+        `${environment.url}tenants/${tenantCode}/compras/${purchaseId}/customer-data`,
+        payload,
+      ),
+    );
+
+    const purchase = this.extractResponseData<PurchaseDetailResponse>(response);
+    if (!purchase) {
+      throw new Error('Error al actualizar los datos de la compra.');
+    }
+
+    return purchase;
+  }
+
+  async updateItemQuantity(
+    tenantCode: string,
+    purchaseId: number,
+    itemId: number,
+    quantity: number,
+  ): Promise<PurchaseDetailResponse> {
+    const response = await firstValueFrom(
+      this.http.patch<{ data?: PurchaseDetailResponse } | PurchaseDetailResponse>(
+        `${environment.url}tenants/${tenantCode}/compras/${purchaseId}/items/${itemId}`,
+        { quantity },
+      ),
+    );
+
+    const purchase = this.extractResponseData<PurchaseDetailResponse>(response);
+    if (!purchase) {
+      throw new Error('Error al actualizar la cantidad del producto.');
+    }
+
+    return purchase;
+  }
+
+  async prepareItemEditing(
+    tenantCode: string,
+    purchaseId: number,
+  ): Promise<PurchaseDetailResponse> {
+    const response = await firstValueFrom(
+      this.http.post<{ data?: PurchaseDetailResponse } | PurchaseDetailResponse>(
+        `${environment.url}tenants/${tenantCode}/compras/${purchaseId}/edit-items`,
+        {},
+      ),
+    );
+
+    const purchase = this.extractResponseData<PurchaseDetailResponse>(response);
+    if (!purchase) {
+      throw new Error('Error al preparar la compra para editarla.');
+    }
+
+    return purchase;
+  }
+
+  async completePurchase(
+    tenantCode: string,
+    purchaseId: number,
+  ): Promise<PurchaseStatusResponse> {
+    const response = await firstValueFrom(
+      this.http.post<{ data?: PurchaseStatusResponse } | PurchaseStatusResponse>(
+        `${environment.url}tenants/${tenantCode}/compras/${purchaseId}/complete`,
+        {},
+      ),
     );
 
     const purchase = this.extractResponseData<PurchaseStatusResponse>(response);
@@ -107,17 +199,58 @@ export class CheckoutService {
     }
 
     return {
-      status: purchase.status ?? null
+      status: purchase.status ?? null,
     };
   }
 
-  async getPurchases(tenantCode: string, status?: string): Promise<{ data: PurchaseSummaryResponse[] }> {
+  async submitPurchaseForReview(
+    tenantCode: string,
+    purchaseId: number,
+  ): Promise<PurchaseStatusResponse> {
+    const response = await firstValueFrom(
+      this.http.post<{ data?: PurchaseStatusResponse } | PurchaseStatusResponse>(
+        `${environment.url}tenants/${tenantCode}/compras/${purchaseId}/review`,
+        {},
+      ),
+    );
+
+    const purchase = this.extractResponseData<PurchaseStatusResponse>(response);
+    if (!purchase) {
+      throw new Error('Error al enviar la compra a revisi\u00f3n.');
+    }
+
+    return { status: purchase.status ?? null };
+  }
+
+  async cancelPurchase(
+    tenantCode: string,
+    purchaseId: number,
+  ): Promise<PurchaseStatusResponse> {
+    const response = await firstValueFrom(
+      this.http.post<{ data?: PurchaseStatusResponse } | PurchaseStatusResponse>(
+        `${environment.url}tenants/${tenantCode}/compras/${purchaseId}/cancel`,
+        {},
+      ),
+    );
+
+    const purchase = this.extractResponseData<PurchaseStatusResponse>(response);
+    if (!purchase) {
+      throw new Error('Error al cancelar la compra.');
+    }
+
+    return { status: purchase.status ?? null };
+  }
+
+  async getPurchases(
+    tenantCode: string,
+    status?: string,
+  ): Promise<{ data: PurchaseSummaryResponse[] }> {
     let url = `${environment.url}tenants/${tenantCode}/compras`;
     if (status) {
       url += `?status=${status}`;
     }
     const response = await firstValueFrom(
-      this.http.get<{ data: PurchaseSummaryResponse[] }>(url)
+      this.http.get<{ data: PurchaseSummaryResponse[] }>(url),
     );
     if (!response) {
       throw new Error('Error al obtener las compras.');
@@ -125,9 +258,14 @@ export class CheckoutService {
     return response;
   }
 
-  async getPurchase(tenantCode: string, purchaseId: string | number): Promise<PurchaseDetailResponse> {
+  async getPurchase(
+    tenantCode: string,
+    purchaseId: string | number,
+  ): Promise<PurchaseDetailResponse> {
     const response = await firstValueFrom(
-      this.http.get<{ data?: PurchaseDetailResponse } | PurchaseDetailResponse>(`${environment.url}tenants/${tenantCode}/compras/${purchaseId}`)
+      this.http.get<{ data?: PurchaseDetailResponse } | PurchaseDetailResponse>(
+        `${environment.url}tenants/${tenantCode}/compras/${purchaseId}`,
+      ),
     );
 
     const purchase = this.extractResponseData<PurchaseDetailResponse>(response);

src/app/core/services/global-loading/global-loading.interceptor.spec.ts

@@ -0,0 +1,80 @@
+import '@angular/compiler';
+import { HttpClient, HttpContext, provideHttpClient, withInterceptors } from '@angular/common/http';
+import {
+  HttpTestingController,
+  provideHttpClientTesting
+} from '@angular/common/http/testing';
+import { TestBed } from '@angular/core/testing';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { globalLoadingInterceptor } from './global-loading.interceptor';
+import { GlobalLoadingService } from './global-loading.service';
+import { LOADING_MODE, LoadingMode } from './loading-mode';
+
+describe('globalLoadingInterceptor', () => {
+  let client: HttpClient;
+  let httpTesting: HttpTestingController;
+  let loadingService: GlobalLoadingService;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    TestBed.configureTestingModule({
+      providers: [
+        provideHttpClient(withInterceptors([globalLoadingInterceptor])),
+        provideHttpClientTesting()
+      ]
+    });
+
+    client = TestBed.inject(HttpClient);
+    httpTesting = TestBed.inject(HttpTestingController);
+    loadingService = TestBed.inject(GlobalLoadingService);
+  });
+
+  afterEach(() => {
+    httpTesting.verify();
+    TestBed.resetTestingModule();
+    vi.useRealTimers();
+  });
+
+  it('tracks concurrent requests until the last one completes', () => {
+    client.get('/api/first').subscribe();
+    client.get('/api/second').subscribe();
+    vi.advanceTimersByTime(150);
+
+    expect(loadingService.isLoading()).toBe(true);
+
+    httpTesting.expectOne('/api/first').flush({});
+    expect(loadingService.isLoading()).toBe(true);
+
+    httpTesting.expectOne('/api/second').flush({});
+    expect(loadingService.isLoading()).toBe(false);
+  });
+
+  it('stops loading when a request fails', () => {
+    client.get('/api/failing').subscribe({ error: () => undefined });
+    vi.advanceTimersByTime(150);
+
+    expect(loadingService.isLoading()).toBe(true);
+
+    httpTesting.expectOne('/api/failing').flush(
+      { message: 'Error' },
+      { status: 500, statusText: 'Server Error' }
+    );
+
+    expect(loadingService.isLoading()).toBe(false);
+  });
+
+  it.each<LoadingMode>(['custom', 'none'])(
+    'does not show the global loader for %s requests',
+    (loadingMode) => {
+      const context = new HttpContext().set(LOADING_MODE, loadingMode);
+
+      client.get(`/api/${loadingMode}`, { context }).subscribe();
+      vi.advanceTimersByTime(150);
+
+      expect(loadingService.isLoading()).toBe(false);
+
+      httpTesting.expectOne(`/api/${loadingMode}`).flush({});
+    }
+  );
+});

src/app/core/services/global-loading/global-loading.interceptor.ts

@@ -0,0 +1,20 @@
+import { HttpEvent, HttpHandlerFn, HttpInterceptorFn, HttpRequest } from '@angular/common/http';
+import { inject } from '@angular/core';
+import { Observable, finalize } from 'rxjs';
+
+import { GlobalLoadingService } from './global-loading.service';
+import { LOADING_MODE } from './loading-mode';
+
+export const globalLoadingInterceptor: HttpInterceptorFn = (
+  request: HttpRequest<unknown>,
+  next: HttpHandlerFn
+): Observable<HttpEvent<unknown>> => {
+  if (request.context.get(LOADING_MODE) !== 'global') {
+    return next(request);
+  }
+
+  const loadingService = inject(GlobalLoadingService);
+  loadingService.start();
+
+  return next(request).pipe(finalize(() => loadingService.stop()));
+};

src/app/core/services/global-loading/global-loading.service.spec.ts

@@ -0,0 +1,65 @@
+import '@angular/compiler';
+import { TestBed } from '@angular/core/testing';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { GlobalLoadingService } from './global-loading.service';
+
+describe('GlobalLoadingService', () => {
+  let service: GlobalLoadingService;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(GlobalLoadingService);
+  });
+
+  afterEach(() => {
+    TestBed.resetTestingModule();
+    vi.useRealTimers();
+  });
+
+  it('delays the loading state to avoid flashes on fast operations', () => {
+    service.start();
+
+    expect(service.isLoading()).toBe(false);
+
+    service.stop();
+    vi.advanceTimersByTime(150);
+
+    expect(service.isLoading()).toBe(false);
+  });
+
+  it('shows the loading state for an operation that exceeds the delay', () => {
+    service.start();
+    vi.advanceTimersByTime(150);
+
+    expect(service.isLoading()).toBe(true);
+
+    service.stop();
+
+    expect(service.isLoading()).toBe(false);
+  });
+
+  it('stays visible until all concurrent operations finish', () => {
+    service.start();
+    service.start();
+    vi.advanceTimersByTime(150);
+
+    service.stop();
+    expect(service.isLoading()).toBe(true);
+
+    service.stop();
+    expect(service.isLoading()).toBe(false);
+  });
+
+  it('ignores extra stop calls without corrupting the counter', () => {
+    service.stop();
+    service.start();
+    vi.advanceTimersByTime(150);
+
+    expect(service.isLoading()).toBe(true);
+
+    service.stop();
+    expect(service.isLoading()).toBe(false);
+  });
+});

src/app/core/services/global-loading/global-loading.service.ts

@@ -0,0 +1,58 @@
+import { isPlatformBrowser } from '@angular/common';
+import { Injectable, PLATFORM_ID, inject, signal } from '@angular/core';
+
+const SHOW_DELAY_MS = 150;
+
+@Injectable({ providedIn: 'root' })
+export class GlobalLoadingService {
+  private readonly isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+  private readonly loadingState = signal(false);
+  private pendingOperations = 0;
+  private showTimer: ReturnType<typeof setTimeout> | undefined;
+
+  readonly isLoading = this.loadingState.asReadonly();
+
+  start(): void {
+    if (!this.isBrowser) {
+      return;
+    }
+
+    this.pendingOperations += 1;
+
+    if (this.pendingOperations > 1 || this.loadingState()) {
+      return;
+    }
+
+    this.showTimer = setTimeout(() => {
+      this.showTimer = undefined;
+
+      if (this.pendingOperations > 0) {
+        this.loadingState.set(true);
+      }
+    }, SHOW_DELAY_MS);
+  }
+
+  stop(): void {
+    if (!this.isBrowser || this.pendingOperations === 0) {
+      return;
+    }
+
+    this.pendingOperations -= 1;
+
+    if (this.pendingOperations > 0) {
+      return;
+    }
+
+    this.cancelShowTimer();
+    this.loadingState.set(false);
+  }
+
+  private cancelShowTimer(): void {
+    if (this.showTimer === undefined) {
+      return;
+    }
+
+    clearTimeout(this.showTimer);
+    this.showTimer = undefined;
+  }
+}

src/app/core/services/global-loading/loading-mode.ts

@@ -0,0 +1,5 @@
+import { HttpContextToken } from '@angular/common/http';
+
+export type LoadingMode = 'global' | 'custom' | 'none';
+
+export const LOADING_MODE = new HttpContextToken<LoadingMode>(() => 'global');

src/app/core/services/tenant.interface.ts

@@ -9,18 +9,63 @@ export interface BankAccount {
   cvu: string;
 }
 
+export interface WebsiteType {
+  codigo: string;
+  nombre: string;
+  primary_color: string | null;
+  secondary_color: string | null;
+  danger_color: string | null;
+  success_color: string | null;
+  site_logo: string | null;
+}
+
 export interface HeroConfig {
-  background_image?: string | null;
+  background_image_id?: string | null;
   title_html?: string | null;
   description_html?: string | null;
   button_text?: string | null;
   button_href?: string | null;
 }
 
+export interface AdditionalInfoConfig {
+  description?: string | null;
+}
+
+export interface EventDate {
+  id?: number;
+  date: string;
+  start_time: string;
+  end_time: string;
+}
+
 export interface EventConfig {
+  id?: number;
   title?: string | null;
   location?: string | null;
-  dates?: string[] | null;
+  dates_text?: string | null;
+  dates?: EventDate[] | null;
+  contact?: SocialMedia[];
+}
+
+export interface ActiveEventDate {
+  id: number;
+  date: string;
+  time_start: string;
+  time_end: string;
+}
+
+export interface ActiveEvent {
+  id: number;
+  name: string;
+  address: string;
+  dates: ActiveEventDate[];
+}
+
+export interface WebsiteExtras {
+  carousel?: string[];
+  heroConfig?: HeroConfig | null;
+  additionalInfoConfig?: AdditionalInfoConfig | null;
+  [extraName: string]: unknown;
 }
 
 export interface Menu {
@@ -41,6 +86,12 @@ export interface SocialMedia {
   url: string;
 }
 
+export interface Category {
+  id: number;
+  nombre: string;
+  subcategories: Category[];
+}
+
 export interface Tenant {
   id: number;
   codigo: string;
@@ -54,16 +105,19 @@ export interface Tenant {
   footer_bg_color: string;
   header_logo: string;
   footer_logo: string;
+  website_type_code?: string | null;
+  website_type?: WebsiteType | null;
+  extras?: WebsiteExtras;
+  active_event_id?: number | null;
+  active_event?: ActiveEvent | null;
   selected_bank_account_id?: number | null;
   selected_bank_account?: BankAccount | null;
-  hero_config?: HeroConfig | null;
-  event_config?: EventConfig | null;
   search_product_layout?: 'row' | 'column_with_image' | 'column_with_cart';
   search_group_layout?: 'paginated' | 'simple' | 'simple_vertical' | 'carousel';
   search_items_per_page?: number;
-  main_carousel_images?: string[];
   social_media?: SocialMedia[];
   menues?: Menu[];
+  categories: Category[];
 }
 
 export type TenantBootstrapResponse = ApiResponse<Tenant>;

src/app/core/services/tenant.service.spec.ts

@@ -20,7 +20,20 @@ const tenant: Tenant = {
   header_bg_color: '#313131',
   footer_bg_color: '#313131',
   header_logo: 'https://example.com/header.png',
-  footer_logo: 'https://example.com/footer.png'
+  footer_logo: 'https://example.com/footer.png',
+  categories: [
+    {
+      id: 1,
+      nombre: 'Remeras',
+      subcategories: [
+        {
+          id: 2,
+          nombre: 'Manga corta',
+          subcategories: []
+        }
+      ]
+    }
+  ]
 };
 
 const tenantResponse: TenantBootstrapResponse = {

src/app/core/services/tenant.service.ts

@@ -1,5 +1,5 @@
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
-import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { HttpErrorResponse } from '@angular/common/http';
 import {
   inject,
   Injectable,
@@ -13,6 +13,7 @@ import { IS_DISCOVERING_ROUTES } from '@angular/ssr';
 import { firstValueFrom } from 'rxjs';
 
 import { environment } from '../../../environments/environment';
+import { BaseApiService } from './base-api.service';
 import { Tenant, TenantBootstrapResponse } from './tenant.interface';
 import {
   TENANT_SSR_STATE_KEY,
@@ -23,8 +24,7 @@ import {
 @Injectable({
   providedIn: 'root'
 })
-export class TenantService {
-  private readonly http = inject(HttpClient);
+export class TenantService extends BaseApiService {
   private readonly platformId = inject(PLATFORM_ID);
   private readonly request = inject(REQUEST, { optional: true });
   private readonly responseInit = inject(RESPONSE_INIT, { optional: true });
@@ -73,7 +73,9 @@ export class TenantService {
 
     try {
       const response = await firstValueFrom(
-        this.http.get<TenantBootstrapResponse>(`${environment.url}tenants/bootstrap/${domain}`)
+        this.http.get<TenantBootstrapResponse>(
+          `${environment.url}tenants/bootstrap/${domain}`
+        )
       );
 
       if (!response?.data) {

src/app/features/componentes-test/pages/reutilizables-test-page/reutilizables-test-page.component.spec.ts

@@ -23,6 +23,7 @@ const tenant: Tenant = {
   footer_bg_color: '#313131',
   header_logo: 'https://example.com/header.png',
   footer_logo: 'https://example.com/footer.png',
+  categories: [],
 };
 
 function createTenantServiceStub(currentTenant: Tenant | null) {

src/app/features/store/pages/account-page/components/account-sidebar/account-sidebar.spec.ts

@@ -22,6 +22,7 @@ describe('AccountSidebar', () => {
       footer_bg_color: '#ffffff',
       header_logo: '',
       footer_logo: '',
+      categories: [],
       menues: [
         {
           id: 1,

src/app/features/store/pages/account-page/components/purchase-list/purchase-list.ts

@@ -29,7 +29,9 @@ export class PurchaseList implements OnInit {
     try {
       const tenantCode = this.tenantService.tenant()?.codigo || '';
       
-      const response = await this.checkoutService.getPurchases(tenantCode, 'paid');
+      const response = await this.checkoutService
+        .withCustomLoading()
+        .getPurchases(tenantCode, 'paid');
       const mappedPurchases = response.data.map((purchase: PurchaseSummaryResponse) => ({
         id: purchase.id,
         date: this.formatDate(purchase.created_at),

src/app/features/store/pages/account-page/pages/purchase-detail-page/purchase-detail-page.ts

@@ -44,7 +44,9 @@ export class PurchaseDetailPage implements OnInit {
     }
 
     try {
-      const response = await this.checkoutService.getPurchase(tenant.codigo, purchaseId);
+      const response = await this.checkoutService
+        .withCustomLoading()
+        .getPurchase(tenant.codigo, purchaseId);
 
       this.purchase.set({
         id: response.id,

src/app/features/store/pages/account-page/pages/tickets-page/components/ticket/ticket.component.html

@@ -41,9 +41,15 @@
       <app-icon-button
         variant="download"
         ariaLabel="Descargar ticket"
+        [disabled]="isGeneratingPdf()"
         (clicked)="download.emit()"
       />
-      <app-icon-button variant="share" ariaLabel="Compartir ticket" (clicked)="share.emit()" />
+      <app-icon-button
+        variant="share"
+        ariaLabel="Compartir ticket"
+        [disabled]="isGeneratingPdf()"
+        (clicked)="share.emit()"
+      />
     }
   </div>
 </article>

src/app/features/store/pages/account-page/pages/tickets-page/components/ticket/ticket.component.ts

@@ -16,6 +16,7 @@ export class TicketComponent {
   readonly date = input<string | null>(null);
   readonly disabled = input(false);
   readonly expired = input(false);
+  readonly isGeneratingPdf = input(false);
   readonly selected = model(false);
 
   readonly viewQr = output<void>();

src/app/features/store/pages/account-page/pages/tickets-page/ticket.service.ts

@@ -1,7 +1,7 @@
-import { HttpClient } from '@angular/common/http';
 import { inject, Injectable } from '@angular/core';
 import { firstValueFrom } from 'rxjs';
 
+import { BaseApiService } from '../../../../../../core/services/base-api.service';
 import { TenantService } from '../../../../../../core/services/tenant.service';
 
 export interface TicketResponse {
@@ -21,13 +21,26 @@ export interface TicketResponse {
 }
 
 @Injectable()
-export class TicketService {
-  private readonly http = inject(HttpClient);
+export class TicketService extends BaseApiService {
   private readonly tenantService = inject(TenantService);
 
   getTickets(): Promise<TicketResponse[]> {
     return firstValueFrom(
-      this.http.get<{ data: TicketResponse[] }>(`${this.tenantService.getTenantApiUrl()}/tickets`),
+      this.http.get<{ data: TicketResponse[] }>(
+        `${this.tenantService.getTenantApiUrl()}/tickets`,
+      ),
     ).then((response) => response.data ?? []);
   }
+
+  downloadPdf(ticketIds: number[]): Promise<Blob> {
+    return firstValueFrom(
+      this.http.post(
+        `${this.tenantService.getTenantApiUrl()}/tickets/pdf`,
+        { ticket_ids: ticketIds },
+        {
+          responseType: 'blob',
+        },
+      ),
+    );
+  }
 }

src/app/features/store/pages/account-page/pages/tickets-page/tickets-page.html

@@ -1,7 +1,14 @@
 <section class="tickets-page">
   <h1 class="tickets-page__title">MIS TICKETS</h1>
 
-  <div class="tickets-list" aria-busy="{{ isLoading() }}">
+  <div class="tickets-list" [attr.aria-busy]="isLoading() || isGeneratingPdf()">
+    @if (isGeneratingPdf()) {
+      <div class="tickets-list__generating" role="status" aria-live="polite">
+        <span class="tickets-list__generating-spinner" aria-hidden="true"></span>
+        <span>Generando PDF...</span>
+      </div>
+    }
+
     @if (activeTickets().length) {
       <header class="tickets-list__header">
         <label class="tickets-list__select-all">
@@ -15,11 +22,21 @@
 
         <div class="tickets-list__bulk-actions">
           <span class="tickets-list__bulk-action">
-            <app-icon-button variant="download" ariaLabel="Descargar tickets seleccionados" />
+            <app-icon-button
+              variant="download"
+              ariaLabel="Descargar tickets seleccionados"
+              [disabled]="isGeneratingPdf()"
+              (clicked)="downloadSelected()"
+            />
             <small>Descargar</small>
           </span>
           <span class="tickets-list__bulk-action">
-            <app-icon-button variant="share" ariaLabel="Compartir tickets seleccionados" />
+            <app-icon-button
+              variant="share"
+              ariaLabel="Compartir tickets seleccionados"
+              [disabled]="isGeneratingPdf()"
+              (clicked)="shareSelected()"
+            />
             <small>Compartir</small>
           </span>
         </div>
@@ -27,8 +44,31 @@
     }
 
     @if (isLoading()) {
+      <header class="tickets-list__skeleton-header" aria-hidden="true">
+        <div class="tickets-list__skeleton-selection">
+          <span class="tickets-list__skeleton-check"></span>
+          <span class="tickets-list__skeleton-line tickets-list__skeleton-line--section"></span>
+        </div>
+        <div class="tickets-list__skeleton-bulk-actions">
+          <span class="tickets-list__skeleton-icon"></span>
+          <span class="tickets-list__skeleton-icon"></span>
+        </div>
+      </header>
+
       @for (item of [1, 2, 3, 4]; track item) {
-        <div class="tickets-list__skeleton" aria-hidden="true"></div>
+        <div class="tickets-list__skeleton" aria-hidden="true">
+          <span class="tickets-list__skeleton-check"></span>
+          <div class="tickets-list__skeleton-details">
+            <span class="tickets-list__skeleton-line tickets-list__skeleton-line--title"></span>
+            <span class="tickets-list__skeleton-line tickets-list__skeleton-line--id"></span>
+          </div>
+          <span class="tickets-list__skeleton-line tickets-list__skeleton-line--date"></span>
+          <div class="tickets-list__skeleton-actions">
+            <span class="tickets-list__skeleton-button"></span>
+            <span class="tickets-list__skeleton-icon"></span>
+            <span class="tickets-list__skeleton-icon"></span>
+          </div>
+        </div>
       }
     } @else if (tickets().length) {
       @for (ticket of activeTickets(); track ticket.id) {
@@ -37,8 +77,11 @@
           [ticketId]="ticket.id"
           [date]="formatDate(ticket)"
           [selected]="isSelected(ticket.id)"
+          [isGeneratingPdf]="isGeneratingPdf()"
           (selectedChange)="toggleTicket(ticket.id, $event)"
           (viewQr)="viewQr(ticket)"
+          (download)="downloadTicket(ticket)"
+          (share)="shareTicket(ticket)"
         />
       }
 

src/app/features/store/pages/account-page/pages/tickets-page/tickets-page.scss

@@ -10,6 +10,35 @@
   font-weight: 700;
 }
 
+.tickets-list {
+  position: relative;
+}
+
+.tickets-list__generating {
+  position: absolute;
+  z-index: 10;
+  inset: 0;
+  display: flex;
+  min-height: 180px;
+  align-items: center;
+  justify-content: center;
+  gap: 12px;
+  border-radius: 8px;
+  color: #26322a;
+  font-size: 14px;
+  font-weight: 700;
+  backdrop-filter: blur(2px);
+}
+
+.tickets-list__generating-spinner {
+  width: 24px;
+  height: 24px;
+  border: 3px solid #dce8e0;
+  border-top-color: var(--tenant-primary, #009933);
+  border-radius: 50%;
+  animation: tickets-spinner 0.75s linear infinite;
+}
+
 .tickets-list__header {
   display: flex;
   min-height: 58px;
@@ -75,22 +104,128 @@
   text-align: center;
 }
 
-.tickets-list__skeleton {
-  height: 77px;
+.tickets-list__skeleton-header {
+  display: flex;
+  min-height: 58px;
+  align-items: center;
+  justify-content: space-between;
+  padding-bottom: 12px;
   border-bottom: 1px solid #dddddd;
-  background: linear-gradient(90deg, transparent, #f3f3f3, transparent);
-  background-size: 200% 100%;
-  animation: loading 1.4s infinite;
 }
 
-@keyframes loading {
+.tickets-list__skeleton-selection,
+.tickets-list__skeleton-bulk-actions,
+.tickets-list__skeleton-actions {
+  display: flex;
+  align-items: center;
+}
+
+.tickets-list__skeleton-selection {
+  gap: 16px;
+}
+
+.tickets-list__skeleton-bulk-actions,
+.tickets-list__skeleton-actions {
+  gap: 8px;
+}
+
+.tickets-list__skeleton {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) 78px auto;
+  min-height: 76px;
+  align-items: center;
+  gap: 16px;
+  padding: 16px 0;
+  border-bottom: 1px solid #dddddd;
+}
+
+.tickets-list__skeleton-check,
+.tickets-list__skeleton-line,
+.tickets-list__skeleton-icon,
+.tickets-list__skeleton-button {
+  display: block;
+  border-radius: 4px;
+  background: linear-gradient(90deg, #eeeeee 20%, #f7f7f7 50%, #eeeeee 80%);
+  background-size: 200% 100%;
+  animation: tickets-loading 1.4s ease-in-out infinite;
+}
+
+.tickets-list__skeleton-check {
+  width: 21px;
+  height: 21px;
+  border-radius: 2px;
+}
+
+.tickets-list__skeleton-details {
+  display: grid;
+  gap: 8px;
+}
+
+.tickets-list__skeleton-line--section {
+  width: 120px;
+  height: 14px;
+}
+
+.tickets-list__skeleton-line--title {
+  width: min(240px, 75%);
+  height: 13px;
+}
+
+.tickets-list__skeleton-line--id {
+  width: 86px;
+  height: 11px;
+}
+
+.tickets-list__skeleton-line--date {
+  width: 64px;
+  height: 11px;
+  justify-self: center;
+}
+
+.tickets-list__skeleton-button {
+  width: 115px;
+  height: 36px;
+}
+
+.tickets-list__skeleton-icon {
+  width: 28px;
+  height: 28px;
+  border-radius: 50%;
+}
+
+@keyframes tickets-loading {
   to {
     background-position: -200% 0;
   }
 }
 
+@keyframes tickets-spinner {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
 @media (max-width: 767.98px) {
   .tickets-page__title {
     margin-top: 24px;
   }
+
+  .tickets-list__skeleton {
+    grid-template-columns: auto minmax(0, 1fr) auto;
+    gap: 10px;
+  }
+
+  .tickets-list__skeleton-line--date {
+    grid-column: 2;
+    justify-self: start;
+  }
+
+  .tickets-list__skeleton-actions {
+    grid-column: 3;
+    grid-row: 1 / span 2;
+  }
+
+  .tickets-list__skeleton-actions .tickets-list__skeleton-icon {
+    display: none;
+  }
 }

src/app/features/store/pages/account-page/pages/tickets-page/tickets-page.spec.ts

@@ -8,6 +8,14 @@ import { TicketComponent } from './components/ticket/ticket.component';
 import { TicketResponse, TicketService } from './ticket.service';
 import { TicketsPage } from './tickets-page';
 
+function withCustomLoading<T extends object>(
+  service: T,
+): T & { withCustomLoading: () => T } {
+  return Object.assign(service, {
+    withCustomLoading: () => service,
+  });
+}
+
 const ticket = (overrides: Partial<TicketResponse>): TicketResponse => ({
   id: 1,
   tenant_code: 'tenant',
@@ -26,6 +34,122 @@ const ticket = (overrides: Partial<TicketResponse>): TicketResponse => ({
 });
 
 describe('TicketsPage', () => {
+  it('shares the generated PDF as a file without text that Windows could prioritize', async () => {
+    const share = vi.fn().mockResolvedValue(undefined);
+    const canShare = vi.fn().mockReturnValue(true);
+    vi.stubGlobal('navigator', { canShare, share });
+
+    await TestBed.configureTestingModule({
+      imports: [TicketsPage],
+      providers: [{ provide: ToastService, useValue: { danger: vi.fn() } }],
+    })
+      .overrideComponent(TicketsPage, {
+        set: {
+          providers: [
+            {
+              provide: TicketService,
+              useValue: withCustomLoading({
+                getTickets: () => Promise.resolve([ticket({})]),
+                downloadPdf: () => Promise.resolve(new Blob(['pdf-content'])),
+              }),
+            },
+          ],
+        },
+      })
+      .compileComponents();
+
+    const fixture = TestBed.createComponent(TicketsPage);
+    fixture.detectChanges();
+    await fixture.whenStable();
+    fixture.detectChanges();
+
+    const page = fixture.nativeElement as HTMLElement;
+    page.querySelector<HTMLButtonElement>('[aria-label="Compartir ticket"]')?.click();
+
+    await vi.waitFor(() => expect(share).toHaveBeenCalledOnce());
+
+    const shareData = share.mock.calls[0][0] as ShareData;
+    const [sharedFile] = shareData.files ?? [];
+
+    expect(Object.keys(shareData)).toEqual(['files']);
+    expect(canShare).toHaveBeenCalledWith({ files: [sharedFile] });
+    expect(sharedFile).toBeInstanceOf(File);
+    expect(sharedFile.name).toBe('tickets_1.pdf');
+    expect(sharedFile.type).toBe('application/pdf');
+    expect(sharedFile.size).toBeGreaterThan(0);
+
+    vi.unstubAllGlobals();
+  });
+
+  it('shows a loading overlay and disables PDF actions while the file is generated', async () => {
+    let resolvePdf!: (pdf: Blob) => void;
+    const downloadPdf = vi.fn(
+      () =>
+        new Promise<Blob>((resolve) => {
+          resolvePdf = resolve;
+        }),
+    );
+    const createObjectUrl = vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:ticket');
+    const revokeObjectUrl = vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => undefined);
+    let downloadedFilename = '';
+    const linkClick = vi
+      .spyOn(HTMLAnchorElement.prototype, 'click')
+      .mockImplementation(function (this: HTMLAnchorElement) {
+        downloadedFilename = this.download;
+      });
+
+    await TestBed.configureTestingModule({
+      imports: [TicketsPage],
+      providers: [{ provide: ToastService, useValue: { danger: vi.fn() } }],
+    })
+      .overrideComponent(TicketsPage, {
+        set: {
+          providers: [
+            {
+              provide: TicketService,
+              useValue: withCustomLoading({
+                getTickets: () => Promise.resolve([ticket({})]),
+                downloadPdf,
+              }),
+            },
+          ],
+        },
+      })
+      .compileComponents();
+
+    const fixture = TestBed.createComponent(TicketsPage);
+    fixture.detectChanges();
+    await fixture.whenStable();
+    fixture.detectChanges();
+
+    const page = fixture.nativeElement as HTMLElement;
+    page.querySelector<HTMLButtonElement>('[aria-label="Descargar ticket"]')?.click();
+    fixture.detectChanges();
+
+    expect(page.querySelector('.tickets-list__generating')?.textContent).toContain(
+      'Generando PDF...',
+    );
+    expect(page.querySelector('.tickets-list')?.getAttribute('aria-busy')).toBe('true');
+    expect(page.querySelector<HTMLButtonElement>('[aria-label="Descargar ticket"]')?.disabled).toBe(
+      true,
+    );
+    expect(page.querySelector<HTMLButtonElement>('[aria-label="Compartir ticket"]')?.disabled).toBe(
+      true,
+    );
+
+    resolvePdf(new Blob(['pdf'], { type: 'application/pdf' }));
+    await fixture.whenStable();
+    await vi.waitFor(() => expect(downloadedFilename).toBe('tickets_1.pdf'));
+    fixture.detectChanges();
+
+    expect(page.querySelector('.tickets-list__generating')).toBeNull();
+    expect(page.querySelector('.tickets-list')?.getAttribute('aria-busy')).toBe('false');
+
+    createObjectUrl.mockRestore();
+    revokeObjectUrl.mockRestore();
+    linkClick.mockRestore();
+  });
+
   it('hides the active tickets header when there are no available tickets', async () => {
     await TestBed.configureTestingModule({
       imports: [TicketsPage],
@@ -34,7 +158,10 @@ describe('TicketsPage', () => {
       .overrideComponent(TicketsPage, {
         set: {
           providers: [
-            { provide: TicketService, useValue: { getTickets: () => Promise.resolve([]) } },
+            {
+              provide: TicketService,
+              useValue: withCustomLoading({ getTickets: () => Promise.resolve([]) }),
+            },
           ],
         },
       })
@@ -67,7 +194,10 @@ describe('TicketsPage', () => {
       .overrideComponent(TicketsPage, {
         set: {
           providers: [
-            { provide: TicketService, useValue: { getTickets: () => Promise.resolve(tickets) } },
+            {
+              provide: TicketService,
+              useValue: withCustomLoading({ getTickets: () => Promise.resolve(tickets) }),
+            },
           ],
         },
       })
@@ -120,7 +250,9 @@ describe('TicketsPage', () => {
           providers: [
             {
               provide: TicketService,
-              useValue: { getTickets: () => Promise.resolve([ticket({})]) },
+              useValue: withCustomLoading({
+                getTickets: () => Promise.resolve([ticket({})]),
+              }),
             },
           ],
         },

src/app/features/store/pages/account-page/pages/tickets-page/tickets-page.ts

@@ -27,6 +27,7 @@ export class TicketsPage implements OnInit {
   );
   protected readonly selectedIds = signal<Set<number>>(new Set());
   protected readonly isLoading = signal(true);
+  protected readonly isGeneratingPdf = signal(false);
   protected readonly allSelected = computed(
     () =>
       this.activeTickets().length > 0 && this.selectedIds().size === this.activeTickets().length,
@@ -34,7 +35,7 @@ export class TicketsPage implements OnInit {
 
   async ngOnInit(): Promise<void> {
     try {
-      this.tickets.set(await this.ticketService.getTickets());
+      this.tickets.set(await this.ticketService.withCustomLoading().getTickets());
     } catch {
       this.toastService.danger('Hubo un error al cargar los tickets');
     } finally {
@@ -86,4 +87,93 @@ export class TicketsPage implements OnInit {
       ticket: ticket.ticket,
     });
   }
+
+  protected async downloadTicket(ticket: TicketResponse): Promise<void> {
+    await this.downloadTickets([ticket]);
+  }
+
+  protected async downloadSelected(): Promise<void> {
+    const tickets = this.activeTickets().filter((ticket) => this.selectedIds().has(ticket.id));
+
+    if (!tickets.length) {
+      this.toastService.danger('Seleccioná al menos un ticket para descargar.');
+      return;
+    }
+
+    await this.downloadTickets(tickets);
+  }
+
+  protected async shareTicket(ticket: TicketResponse): Promise<void> {
+    await this.shareTickets([ticket]);
+  }
+
+  protected async shareSelected(): Promise<void> {
+    const tickets = this.activeTickets().filter((ticket) => this.selectedIds().has(ticket.id));
+
+    if (!tickets.length) {
+      this.toastService.danger('Seleccioná al menos un ticket para compartir.');
+      return;
+    }
+
+    await this.shareTickets(tickets);
+  }
+
+  private async downloadTickets(tickets: TicketResponse[]): Promise<void> {
+    const pdf = await this.generateTicketsPdf(tickets);
+    if (pdf) this.downloadPdf(pdf, this.pdfFilename(tickets));
+  }
+
+  private async shareTickets(tickets: TicketResponse[]): Promise<void> {
+    const pdf = await this.generateTicketsPdf(tickets);
+    if (!pdf) return;
+
+    try {
+      const filename = this.pdfFilename(tickets);
+      const file = new File([pdf], filename, { type: 'application/pdf' });
+
+      if (navigator.canShare?.({ files: [file] })) {
+        await navigator.share({ files: [file] });
+        return;
+      }
+
+      this.downloadPdf(pdf, filename);
+      this.toastService.success('Tu navegador no permite compartir archivos; descargamos el PDF.');
+    } catch (error) {
+      if (error instanceof DOMException && error.name === 'AbortError') return;
+
+      this.toastService.danger('No se pudo compartir el PDF de los tickets.');
+    }
+  }
+
+  private async generateTicketsPdf(tickets: TicketResponse[]): Promise<Blob | null> {
+    if (this.isGeneratingPdf()) return null;
+
+    this.isGeneratingPdf.set(true);
+
+    try {
+      return await this.ticketService
+        .withCustomLoading()
+        .downloadPdf(tickets.map((ticket) => ticket.id));
+    } catch {
+      this.toastService.danger('No se pudo generar el PDF de los tickets.');
+      return null;
+    } finally {
+      this.isGeneratingPdf.set(false);
+    }
+  }
+
+  private pdfFilename(tickets: TicketResponse[]): string {
+    return `tickets_${tickets.map((ticket) => ticket.id).join('_')}.pdf`;
+  }
+
+  private downloadPdf(pdf: Blob, filename: string): void {
+    const url = URL.createObjectURL(pdf);
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    link.remove();
+    window.setTimeout(() => URL.revokeObjectURL(url), 0);
+  }
 }

src/app/features/store/pages/category-items-page/category-items-page.component.html

@@ -0,0 +1,26 @@
+<section class="category-items" aria-labelledby="category-items-title">
+  @if (error()) {
+    <p class="alert text-center mb-0 category-items__alert-error">{{ error() }}</p>
+  } @else if (results(); as categoryResults) {
+    <header class="category-items__header mb-5">
+      <h1 id="category-items-title" class="category-items__title mb-0">
+        {{ categoryResults.category.nombre }}
+      </h1>
+    </header>
+
+    @if (!categoryResults.data.length) {
+      <p class="alert alert-light border text-center mb-0">
+        No hay productos disponibles en esta categoría.
+      </p>
+    } @else {
+      <app-product-list
+        [layout]="categoryResults.layout"
+        [groupLayout]="paginatedLayout"
+        [items]="categoryResults"
+        (buy)="onBuyProduct($event)"
+        (addToCart)="onAddToCart($event)"
+        (pageChange)="onPageChange($event)"
+      />
+    }
+  }
+</section>

src/app/features/store/pages/category-items-page/category-items-page.component.scss

@@ -0,0 +1,18 @@
+.category-items__header {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 16px 28px;
+}
+
+.category-items__title {
+  font-size: 24px;
+  font-weight: bold;
+  line-height: 1.2;
+  text-align: center;
+  color:var(--bs-primary)
+}
+
+.category-items__alert-error {
+  color: var(--tenant-danger-color, var(--bs-danger));
+}

src/app/features/store/pages/category-items-page/category-items-page.component.spec.ts

@@ -0,0 +1,126 @@
+import { signal } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { ActivatedRoute, convertToParamMap, provideRouter } from '@angular/router';
+import { of } from 'rxjs';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { CartService } from '../../../../core/services/cart/cart.service';
+import { CatalogService } from '../../../../core/services/catalog/catalog.service';
+import { Tenant } from '../../../../core/services/tenant.interface';
+import { TenantService } from '../../../../core/services/tenant.service';
+import { ToastService } from '../../../../core/services/toast.service';
+import { ProductListComponent } from '../../../../shared/components/product-list/product-list.component';
+import { CategoryItemsPageComponent } from './category-items-page.component';
+
+describe('CategoryItemsPageComponent', () => {
+  const getCategoryItems = vi.fn();
+  const tenant = signal({ codigo: 'shop' } as Tenant);
+
+  beforeEach(async () => {
+    getCategoryItems.mockReset();
+    getCategoryItems.mockReturnValue(
+      of({
+        category: {
+          id: 7,
+          nombre: 'Remeras',
+          categoria_id: null,
+        },
+        layout: 'row',
+        group_layout: 'simple_vertical',
+        data: [
+          {
+            id: 1,
+            nombre: 'Remera clásica',
+            descripcion: 'Algodón',
+            precio: '100.00',
+            variants: [],
+          },
+        ],
+        links: {
+          first: '/categories/7?page=1',
+          last: '/categories/7?page=2',
+          prev: null,
+          next: '/categories/7?page=2',
+        },
+        meta: {
+          current_page: 1,
+          from: 1,
+          last_page: 2,
+          links: [],
+          path: '/categories/7',
+          per_page: 12,
+          to: 1,
+          total: 13,
+        },
+      }),
+    );
+
+    await TestBed.configureTestingModule({
+      imports: [CategoryItemsPageComponent],
+      providers: [
+        provideRouter([]),
+        {
+          provide: ActivatedRoute,
+          useValue: {
+            paramMap: of(convertToParamMap({ id: '7' })),
+            queryParamMap: of(convertToParamMap({ page: '1' })),
+          },
+        },
+        {
+          provide: CatalogService,
+          useValue: {
+            getCategoryItems,
+          },
+        },
+        {
+          provide: TenantService,
+          useValue: { tenant: tenant.asReadonly() },
+        },
+        {
+          provide: CartService,
+          useValue: { addItem: vi.fn() },
+        },
+        {
+          provide: ToastService,
+          useValue: {
+            success: vi.fn(),
+            danger: vi.fn(),
+          },
+        },
+      ],
+    }).compileComponents();
+  });
+
+  it('loads the category and renders its products with the configured product layout', () => {
+    const fixture = TestBed.createComponent(CategoryItemsPageComponent);
+    fixture.detectChanges();
+
+    expect(getCategoryItems).toHaveBeenCalledWith(7, { page: 1 });
+    expect((fixture.nativeElement as HTMLElement).textContent).toContain('Remeras');
+
+    const productList = fixture.debugElement.query(By.directive(ProductListComponent))
+      .componentInstance as ProductListComponent;
+
+    expect(productList.layout()).toBe('row');
+    expect(productList.groupLayout()).toBe('paginated');
+    expect(Array.isArray(productList.items())).toBe(false);
+  });
+
+  it('does not request the API when the category id is invalid', () => {
+    TestBed.overrideProvider(ActivatedRoute, {
+      useValue: {
+        paramMap: of(convertToParamMap({ id: 'invalid' })),
+        queryParamMap: of(convertToParamMap({ page: '1' })),
+      },
+    });
+
+    const fixture = TestBed.createComponent(CategoryItemsPageComponent);
+    fixture.detectChanges();
+
+    expect(getCategoryItems).not.toHaveBeenCalled();
+    expect((fixture.nativeElement as HTMLElement).textContent).toContain(
+      'La categoría solicitada no es válida.',
+    );
+  });
+});

src/app/features/store/pages/category-items-page/category-items-page.component.ts

@@ -0,0 +1,162 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import {
+  ChangeDetectionStrategy,
+  Component,
+  DestroyRef,
+  Injector,
+  inject,
+  signal,
+} from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { ActivatedRoute, Router } from '@angular/router';
+import { catchError, combineLatest, distinctUntilChanged, map, of, switchMap, tap } from 'rxjs';
+
+import { AuthService } from '../../../../core/services/auth/auth.service';
+import { CartService } from '../../../../core/services/cart/cart.service';
+import { CheckoutService } from '../../../../core/services/checkout.service';
+import {
+  CatalogGroupLayout,
+  CategoryItemsResponse,
+} from '../../../../core/services/catalog/catalog.interface';
+import { CatalogService } from '../../../../core/services/catalog/catalog.service';
+import { TenantService } from '../../../../core/services/tenant.service';
+import { ToastService } from '../../../../core/services/toast.service';
+import {
+  ProductListBuyEvent,
+  ProductListCartEvent,
+  ProductListComponent,
+} from '../../../../shared/components/product-list/product-list.component';
+
+interface CategoryRouteState {
+  categoryId: number;
+  page: number;
+}
+
+@Component({
+  selector: 'app-category-items-page',
+  imports: [ProductListComponent],
+  templateUrl: './category-items-page.component.html',
+  styleUrl: './category-items-page.component.scss',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class CategoryItemsPageComponent {
+  private readonly cartService = inject(CartService);
+  private readonly catalogService = inject(CatalogService);
+  private readonly injector = inject(Injector);
+  private readonly destroyRef = inject(DestroyRef);
+  private readonly route = inject(ActivatedRoute);
+  private readonly router = inject(Router);
+  private readonly tenantService = inject(TenantService);
+  private readonly toastService = inject(ToastService);
+
+  protected readonly results = signal<CategoryItemsResponse | null>(null);
+  protected readonly error = signal<string | null>(null);
+  protected readonly creatingDirectPurchase = signal(false);
+  protected readonly paginatedLayout: CatalogGroupLayout = 'paginated';
+
+  constructor() {
+    combineLatest([this.route.paramMap, this.route.queryParamMap])
+      .pipe(
+        map(
+          ([params, queryParams]): CategoryRouteState => ({
+            categoryId: this.parsePositiveInteger(params.get('id')),
+            page: this.parsePositiveInteger(queryParams.get('page'), 1),
+          }),
+        ),
+        distinctUntilChanged(
+          (previous, current) =>
+            previous.categoryId === current.categoryId && previous.page === current.page,
+        ),
+        tap(() => {
+          this.results.set(null);
+          this.error.set(null);
+        }),
+        switchMap(({ categoryId, page }) => {
+          if (categoryId === 0) {
+            this.error.set('La categoría solicitada no es válida.');
+
+            return of(null);
+          }
+
+          return this.catalogService.getCategoryItems(categoryId, { page }).pipe(
+            catchError(() => {
+              this.error.set('No pudimos cargar los productos de esta categoría.');
+
+              return of(null);
+            }),
+          );
+        }),
+        takeUntilDestroyed(this.destroyRef),
+      )
+      .subscribe((results) => {
+        this.results.set(results);
+      });
+  }
+
+  protected onPageChange(page: number): void {
+    void this.router.navigate([], {
+      relativeTo: this.route,
+      queryParams: { page },
+      queryParamsHandling: 'merge',
+    });
+  }
+
+  protected async onBuyProduct(event: ProductListBuyEvent): Promise<void> {
+    if (!event.directPurchase) {
+      await this.router.navigate(['/producto', event.product.id]);
+      return;
+    }
+
+    if (this.creatingDirectPurchase()) {
+      return;
+    }
+
+    if (!this.injector.get(AuthService).user()) {
+      await this.router.navigate(['/login'], {
+        queryParams: { returnUrl: `/producto/${event.product.id}` },
+      });
+      return;
+    }
+
+    const tenant = this.tenantService.tenant();
+    if (!tenant) {
+      this.toastService.danger('No se pudo identificar la tienda.');
+      return;
+    }
+
+    this.creatingDirectPurchase.set(true);
+    try {
+      const purchase = await this.injector.get(CheckoutService).startCheckout(tenant.codigo, {
+        direct_item: {
+          catalog_item_id: event.product.id,
+          variant_id: event.variant ?? null,
+          cantidad: event.quantity,
+        },
+      });
+      await this.router.navigate(['/checkout'], { queryParams: { purchase: purchase.id } });
+    } catch (error) {
+      console.error('Failed to create direct purchase:', error);
+      this.toastService.danger('No se pudo iniciar la compra directa.');
+    } finally {
+      this.creatingDirectPurchase.set(false);
+    }
+  }
+
+  protected onAddToCart(event: ProductListCartEvent): void {
+    this.cartService.addItem(event.product.id, event.variant ?? null, event.quantity).subscribe({
+      next: (response) => {
+        this.toastService.success(response.message || 'Producto agregado al carrito');
+      },
+      error: (error: HttpErrorResponse) => {
+        const message = error.error?.message || 'No se pudo agregar el producto al carrito.';
+        this.toastService.danger(message);
+      },
+    });
+  }
+
+  private parsePositiveInteger(value: string | null, fallback = 0): number {
+    const parsed = Number(value ?? fallback);
+
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+  }
+}

src/app/features/store/pages/checkout-page/checkout-page.component.html

@@ -1,7 +1,17 @@
-
+@if (isLoadingPurchase()) {
+  <div class="checkout-page__loading" role="status" aria-live="polite">
+    <span class="checkout-page__spinner" aria-hidden="true"></span>
+    <span>Cargando compra...</span>
+  </div>
+} @else {
   <div class="checkout-page">
-    <div class="checkout-page__stepper-col ">
-      <app-stepper #stepper>
+    <div
+      class="checkout-page__stepper-col"
+      [class.checkout-page__stepper-col--editing]="isEditingItems()"
+      [attr.aria-hidden]="isEditingItems()"
+      [attr.inert]="isEditingItems() ? '' : null"
+    >
+      <app-stepper #stepper [initialStepIndex]="checkoutStepIndex()">
         <app-step label="Datos" [isValid]="isStep1Valid()">
           <app-checkout-data-step
             [form]="form"
@@ -21,6 +31,8 @@
             [qrData]="qrData()"
             [qrPaymentStatus]="qrPaymentStatus()"
             [isCheckingQrPayment]="isCheckingQrPayment()"
+            [qrPaymentAmount]="cartTotal()"
+            [whatsappUrl]="whatsappUrl()"
             [transferValidationStatus]="transferValidationStatus()"
             (paymentMethodChange)="selectPaymentMethod($event)"
             (copyTransferValue)="copyTransferValue($event.field, $event.value)"
@@ -33,13 +45,30 @@
       </app-stepper>
     </div>
 
+    @if (isEditingItems()) {
+      <div class="checkout-page__editing-notice" role="status">
+        <p>Terminá de modificar las cantidades para continuar con el pago.</p>
+      </div>
+    }
+
     <div class="checkout-page__cart-col">
       <app-cart
+        title="COMPRA"
         [items]="mappedCartItems()"
         [subtotal]="cartSubtotal()"
         [discount]="cartDiscount()"
         [total]="cartTotal()"
+        [allowEditing]="
+          createdPurchase()?.status === 'created' || createdPurchase()?.status === 'pending_payment'
+        "
+        [allowRemove]="false"
+        [persistQuantityChanges]="false"
+        [editing]="isEditingItems()"
+        [editingDisabled]="isUpdatingItem() || isPreparingItemEdit()"
         backgroundColor="transparent"
+        (editingChange)="onEditingItemsChange($event)"
+        (itemQuantityChange)="onPurchaseItemQuantityChange($event)"
       />
     </div>
   </div>
+}

src/app/features/store/pages/checkout-page/checkout-page.component.scss

@@ -12,13 +12,57 @@
     min-width: 0;
     border-radius: 4px;
     min-height: 420px;
+
+    &--editing {
+      display: none;
+    }
+  }
+
+  &__editing-notice {
+    display: grid;
+    min-height: 420px;
+    place-items: center;
+    padding: 2rem;
+    border-radius: 4px;
+    background: #f5f5f5;
+    color: #666666;
+    text-align: center;
+
+    p {
+      max-width: 360px;
+      margin: 0;
+      font-size: 14px;
+    }
   }
 
   &__cart-col {
-
     max-height: 80vh;
     overflow: hidden;
     display: flex;
     flex-direction: column;
   }
 }
+
+.checkout-page__loading {
+  display: grid;
+  min-height: 420px;
+  place-items: center;
+  align-content: center;
+  gap: 1rem;
+  color: #666666;
+}
+
+.checkout-page__spinner {
+  width: 3rem;
+  height: 3rem;
+  border: 0.25rem solid rgba(32, 32, 32, 0.08);
+  border-top-color: var(--tenant-primary);
+  border-radius: 50%;
+  animation: checkout-page-spin 0.8s linear infinite;
+}
+
+@keyframes checkout-page-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}

src/app/features/store/pages/checkout-page/checkout-page.component.spec.ts

@@ -1,20 +1,28 @@
 import { signal } from '@angular/core';
 import { getTestBed, TestBed } from '@angular/core/testing';
 import { BrowserTestingModule, platformBrowserTesting } from '@angular/platform-browser/testing';
-import { Router } from '@angular/router';
+import { ActivatedRoute, convertToParamMap, Router } from '@angular/router';
 import { of } from 'rxjs';
 import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { AuthService } from '../../../../core/services/auth/auth.service';
 import { CartService } from '../../../../core/services/cart/cart.service';
 import { CheckoutService } from '../../../../core/services/checkout.service';
+import { CatalogService } from '../../../../core/services/catalog/catalog.service';
 import { TenantService } from '../../../../core/services/tenant.service';
 import { CheckoutPageComponent } from './checkout-page.component';
 
 describe('CheckoutPageComponent payment validation', () => {
   let checkoutServiceStub: {
+    startCheckout: ReturnType<typeof vi.fn>;
+    updateCustomerData: ReturnType<typeof vi.fn>;
+    updateItemQuantity: ReturnType<typeof vi.fn>;
+    prepareItemEditing: ReturnType<typeof vi.fn>;
+    cancelPurchase: ReturnType<typeof vi.fn>;
     generatePaymentIntent: ReturnType<typeof vi.fn>;
     getPurchase: ReturnType<typeof vi.fn>;
+    submitPurchaseForReview: ReturnType<typeof vi.fn>;
+    withCustomLoading: ReturnType<typeof vi.fn>;
   };
   let cartServiceStub: {
     cart: ReturnType<typeof signal>;
@@ -23,6 +31,8 @@ describe('CheckoutPageComponent payment validation', () => {
     clearCart: ReturnType<typeof vi.fn>;
   };
   let routerStub: { navigate: ReturnType<typeof vi.fn> };
+  let routeQueryParamMap: ReturnType<typeof convertToParamMap>;
+  let authUserState: ReturnType<typeof signal>;
 
   beforeAll(() => {
     try {
@@ -36,11 +46,24 @@ describe('CheckoutPageComponent payment validation', () => {
     vi.useFakeTimers();
 
     checkoutServiceStub = {
+      startCheckout: vi.fn().mockResolvedValue({
+        id: 25,
+        items: [],
+        subtotal: '0.00',
+        total: '0.00',
+      }),
+      updateCustomerData: vi.fn(),
+      updateItemQuantity: vi.fn(),
+      prepareItemEditing: vi.fn(),
+      cancelPurchase: vi.fn().mockResolvedValue({ status: 'cancelled' }),
       generatePaymentIntent: vi.fn().mockResolvedValue({
         qr_data: { qr_code: 'qr-value' },
       }),
       getPurchase: vi.fn().mockResolvedValue({ status: 'pending_payment' }),
+      submitPurchaseForReview: vi.fn().mockResolvedValue({ status: 'pending_payment' }),
+      withCustomLoading: vi.fn(),
     };
+    checkoutServiceStub.withCustomLoading.mockReturnValue(checkoutServiceStub);
     cartServiceStub = {
       cart: signal({
         id: 10,
@@ -63,14 +86,27 @@ describe('CheckoutPageComponent payment validation', () => {
       });
     });
     routerStub = { navigate: vi.fn() };
+    routeQueryParamMap = convertToParamMap({});
+    authUserState = signal(null);
 
     await TestBed.configureTestingModule({
       imports: [CheckoutPageComponent],
       providers: [
         { provide: CheckoutService, useValue: checkoutServiceStub },
+        { provide: CatalogService, useValue: { getCatalogItem: vi.fn() } },
         { provide: CartService, useValue: cartServiceStub },
         { provide: TenantService, useValue: { tenant: signal({ codigo: 'tenant-test' }) } },
-        { provide: AuthService, useValue: { user: signal(null) } },
+        { provide: AuthService, useValue: { user: authUserState } },
+        {
+          provide: ActivatedRoute,
+          useValue: {
+            snapshot: {
+              get queryParamMap() {
+                return routeQueryParamMap;
+              },
+            },
+          },
+        },
         { provide: Router, useValue: routerStub },
       ],
     })
@@ -87,6 +123,7 @@ describe('CheckoutPageComponent payment validation', () => {
     const fixture = TestBed.createComponent(CheckoutPageComponent);
     fixture.detectChanges();
     fixture.componentInstance['createdPurchaseId'].set(25);
+    routerStub.navigate.mockClear();
     return { fixture, component: fixture.componentInstance as any };
   }
 
@@ -105,7 +142,7 @@ describe('CheckoutPageComponent payment validation', () => {
 
     await vi.advanceTimersByTimeAsync(5_000);
     expect(checkoutServiceStub.getPurchase).toHaveBeenCalledTimes(2);
-    expect(cartServiceStub.clearCart).toHaveBeenCalledOnce();
+    expect(cartServiceStub.clearCart).not.toHaveBeenCalled();
     expect(routerStub.navigate).toHaveBeenCalledWith(['/checkout/status', 25]);
     expect(checkoutServiceStub.generatePaymentIntent).toHaveBeenCalledTimes(1);
   });
@@ -128,19 +165,19 @@ describe('CheckoutPageComponent payment validation', () => {
     fixture.destroy();
   });
 
-  it('stops QR polling after five minutes and can restart it', async () => {
+  it('stops QR polling after 45 seconds and can restart it', async () => {
     const { component } = createComponent();
 
     await component.selectPaymentMethod('qr');
-    await vi.advanceTimersByTimeAsync(300_000);
+    await vi.advanceTimersByTimeAsync(45_000);
 
-    expect(checkoutServiceStub.getPurchase).toHaveBeenCalledTimes(60);
+    expect(checkoutServiceStub.getPurchase).toHaveBeenCalledTimes(9);
     expect(component.qrPaymentStatus()).toBe('timed_out');
 
     component.retryQrPolling();
     expect(component.qrPaymentStatus()).toBe('waiting');
     await vi.advanceTimersByTimeAsync(5_000);
-    expect(checkoutServiceStub.getPurchase).toHaveBeenCalledTimes(61);
+    expect(checkoutServiceStub.getPurchase).toHaveBeenCalledTimes(10);
   });
 
   it('cancels QR polling when payment method changes or component is destroyed', async () => {
@@ -162,32 +199,33 @@ describe('CheckoutPageComponent payment validation', () => {
     component.selectedPaymentMethod.set('transfer');
 
     await component.onComplete();
-    expect(checkoutServiceStub.getPurchase).toHaveBeenCalledTimes(1);
+    expect(checkoutServiceStub.submitPurchaseForReview).toHaveBeenCalledTimes(1);
     expect(component.transferValidationStatus()).toBe('pending');
     expect(cartServiceStub.clearCart).not.toHaveBeenCalled();
     expect(routerStub.navigate).toHaveBeenCalledWith(['/checkout/status', 25]);
 
     await vi.advanceTimersByTimeAsync(30_000);
-    expect(checkoutServiceStub.getPurchase).toHaveBeenCalledTimes(1);
+    expect(checkoutServiceStub.submitPurchaseForReview).toHaveBeenCalledTimes(1);
 
     await component.onComplete();
-    expect(checkoutServiceStub.getPurchase).toHaveBeenCalledTimes(1);
+    expect(checkoutServiceStub.submitPurchaseForReview).toHaveBeenCalledTimes(1);
   });
 
   it('navigates after a transfer is confirmed as paid', async () => {
-    checkoutServiceStub.getPurchase.mockResolvedValue({ status: 'paid' });
+    checkoutServiceStub.submitPurchaseForReview.mockResolvedValue({ status: 'paid' });
     const { component } = createComponent();
     component.selectedPaymentMethod.set('transfer');
 
     await component.onComplete();
 
-    expect(cartServiceStub.clearCart).toHaveBeenCalledOnce();
+    expect(checkoutServiceStub.submitPurchaseForReview).toHaveBeenCalledWith('tenant-test', 25);
+    expect(cartServiceStub.clearCart).not.toHaveBeenCalled();
     expect(routerStub.navigate).toHaveBeenCalledWith(['/checkout/status', 25]);
   });
 
   it('shows a retryable state when transfer validation fails', async () => {
     vi.spyOn(console, 'error').mockImplementation(() => undefined);
-    checkoutServiceStub.getPurchase.mockRejectedValue(new Error('network error'));
+    checkoutServiceStub.submitPurchaseForReview.mockRejectedValue(new Error('network error'));
     const { component } = createComponent();
     component.selectedPaymentMethod.set('transfer');
 
@@ -197,4 +235,285 @@ describe('CheckoutPageComponent payment validation', () => {
     expect(cartServiceStub.clearCart).not.toHaveBeenCalled();
     expect(routerStub.navigate).not.toHaveBeenCalled();
   });
+
+  it('loads purchase items but prefills customer data from the user', async () => {
+    const purchase = {
+      id: 25,
+      cart_id: null,
+      status: 'created',
+      payment_method: null,
+      transfer_payer_dni: null,
+      nombre_apellido: 'Datos de la compra',
+      email: 'compra@example.com',
+      dni: '11111111',
+      telefono: '1111111111',
+      items: [
+        {
+          id: 91,
+          quantity: 2,
+          unit_price: '1250.50',
+          line_total: '2501.00',
+          source_catalog_item_id: 8,
+          source_variant_id: 21,
+          item_details: {
+            nombre: 'Remera',
+            descripcion: null,
+            slug: 'remera',
+            imagen: 'https://example.com/remera.jpg',
+            attributes: [{ name: 'Color', value: 'Negro' }],
+          },
+        },
+      ],
+      subtotal: '2501.00',
+      total: '2501.00',
+    };
+    routeQueryParamMap = convertToParamMap({ purchase: 25 });
+    checkoutServiceStub.getPurchase.mockResolvedValue(purchase);
+    authUserState.set({
+      id: 7,
+      nombre_apellido: 'Juan Perez',
+      email: 'juan@example.com',
+      dni: '12345678',
+      telefono: '3415555555',
+    });
+    const { component } = createComponent();
+    await Promise.resolve();
+
+    expect(checkoutServiceStub.getPurchase).toHaveBeenCalledWith('tenant-test', 25);
+    expect(component.mappedCartItems()).toEqual([
+      {
+        cartItemId: 91,
+        imageUrl: 'https://example.com/remera.jpg',
+        product: 'Remera',
+        originalPrice: null,
+        discountedPrice: 1250.5,
+        discountPercentage: null,
+        attributes: [{ label: 'Color', value: 'Negro' }],
+        quantity: 2,
+      },
+    ]);
+    expect(component.cartSubtotal()).toBe(2501);
+    expect(component.cartTotal()).toBe(2501);
+    expect(component.form.getRawValue()).toEqual({
+      nombre: 'Juan Perez',
+      email: 'juan@example.com',
+      dni: '12345678',
+      telefono: '3415555555',
+    });
+  });
+
+  it('keeps the checkout hidden while the purchase is loading', async () => {
+    let resolvePurchase!: (purchase: any) => void;
+    routeQueryParamMap = convertToParamMap({ purchase: 25 });
+    checkoutServiceStub.getPurchase.mockReturnValue(
+      new Promise((resolve) => {
+        resolvePurchase = resolve;
+      }),
+    );
+    const { component } = createComponent();
+
+    expect(component.isLoadingPurchase()).toBe(true);
+
+    resolvePurchase({
+      id: 25,
+      status: 'created',
+      payment_method: null,
+      transfer_payer_dni: null,
+      items: [],
+      subtotal: '0.00',
+      total: '0.00',
+    });
+    await Promise.resolve();
+
+    expect(component.isLoadingPurchase()).toBe(false);
+    expect(component.checkoutStepIndex()).toBe(0);
+  });
+
+  it('opens a pending purchase on the payment step and restores its payment method', async () => {
+    routeQueryParamMap = convertToParamMap({ purchase: 25 });
+    checkoutServiceStub.getPurchase.mockResolvedValue({
+      id: 25,
+      status: 'pending_payment',
+      payment_method: 'transfer',
+      transfer_payer_dni: '12345678',
+      items: [],
+      subtotal: '100.00',
+      total: '100.00',
+    });
+    const { component } = createComponent();
+    await Promise.resolve();
+
+    expect(component.checkoutStepIndex()).toBe(1);
+    expect(component.selectedPaymentMethod()).toBe('transfer');
+    expect(component.transferDni()).toBe('12345678');
+    expect(component.isLoadingPurchase()).toBe(false);
+  });
+
+  it('generates a new QR when reopening a pending QR purchase', async () => {
+    routeQueryParamMap = convertToParamMap({ purchase: 25 });
+    checkoutServiceStub.getPurchase.mockResolvedValue({
+      id: 25,
+      status: 'pending_payment',
+      payment_method: 'qr',
+      transfer_payer_dni: null,
+      items: [],
+      subtotal: '100.00',
+      total: '100.00',
+    });
+    const { component } = createComponent();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(component.checkoutStepIndex()).toBe(1);
+    expect(component.selectedPaymentMethod()).toBe('qr');
+    expect(checkoutServiceStub.generatePaymentIntent).toHaveBeenCalledWith(
+      'tenant-test',
+      25,
+      'qr',
+    );
+    expect(component.qrData()).toBe('qr-value');
+    expect(component.qrPaymentStatus()).toBe('waiting');
+  });
+
+  it.each(['paid', 'cancelled', 'rejected', 'expired'])(
+    'redirects a %s purchase to its status page',
+    async (status) => {
+      routeQueryParamMap = convertToParamMap({ purchase: 25 });
+      checkoutServiceStub.getPurchase.mockResolvedValue({
+        id: 25,
+        status,
+        payment_method: null,
+        transfer_payer_dni: null,
+        items: [],
+        subtotal: '100.00',
+        total: '100.00',
+      });
+      createComponent();
+      await Promise.resolve();
+
+      expect(routerStub.navigate).toHaveBeenCalledWith(['/checkout/status', 25]);
+    },
+  );
+
+  it('redirects a submitted pending payment purchase to its status page', async () => {
+    routeQueryParamMap = convertToParamMap({ purchase: 25 });
+    checkoutServiceStub.getPurchase.mockResolvedValue({
+      id: 25,
+      status: 'pending_payment',
+      payment_method: 'transfer',
+      expires_at: null,
+      transfer_payer_dni: null,
+      items: [],
+      subtotal: '100.00',
+      total: '100.00',
+    });
+
+    createComponent();
+    await Promise.resolve();
+
+    expect(routerStub.navigate).toHaveBeenCalledWith(['/checkout/status', 25]);
+  });
+
+  it('updates a purchase item while editing and refreshes checkout totals', async () => {
+    const updatedPurchase = {
+      id: 25,
+      items: [],
+      subtotal: '300.00',
+      total: '300.00',
+    };
+    checkoutServiceStub.updateItemQuantity.mockResolvedValue(updatedPurchase);
+    const { component } = createComponent();
+    component.isEditingItems.set(true);
+
+    await component.onPurchaseItemQuantityChange({
+      item: {
+        cartItemId: 91,
+        imageUrl: null,
+        product: 'Remera',
+        originalPrice: null,
+        discountedPrice: 100,
+        discountPercentage: null,
+        attributes: [],
+        quantity: 2,
+      },
+      quantity: 3,
+    });
+
+    expect(checkoutServiceStub.updateItemQuantity).toHaveBeenCalledWith('tenant-test', 25, 91, 3);
+    expect(component.createdPurchase()).toBe(updatedPurchase);
+    expect(component.isUpdatingItem()).toBe(false);
+  });
+
+  it('keeps the payment step selected while editing and regenerates payment afterward', async () => {
+    const editablePurchase = {
+      id: 25,
+      status: 'created',
+      items: [],
+      subtotal: '100.00',
+      total: '100.00',
+    };
+    checkoutServiceStub.prepareItemEditing.mockResolvedValue(editablePurchase);
+    const { component } = createComponent();
+    component.stepper = { currentStepIndex: signal(1) };
+    const selectPaymentMethod = vi
+      .spyOn(component, 'selectPaymentMethod')
+      .mockResolvedValue(undefined);
+
+    await component.onEditingItemsChange(true);
+
+    expect(checkoutServiceStub.prepareItemEditing).toHaveBeenCalledWith('tenant-test', 25);
+    expect(component.isEditingItems()).toBe(true);
+    expect(component.createdPurchase()).toBe(editablePurchase);
+
+    await component.onEditingItemsChange(false);
+
+    expect(component.stepper.currentStepIndex()).toBe(1);
+    expect(selectPaymentMethod).toHaveBeenCalledWith('qr');
+    expect(component.isEditingItems()).toBe(false);
+  });
+
+  it('updates customer data on the existing purchase before payment', async () => {
+    const updatedPurchase = {
+      id: 25,
+      cart_id: 10,
+      items: [],
+      subtotal: '100.00',
+      total: '100.00',
+    };
+    checkoutServiceStub.updateCustomerData.mockResolvedValue(updatedPurchase);
+    const { component } = createComponent();
+    component.form.setValue({
+      nombre: 'Juan Perez',
+      email: 'juan@example.com',
+      dni: '12345678',
+      telefono: '3415555555',
+    });
+    component.stepper = { next: vi.fn() };
+
+    await component.onStep1Continue();
+
+    expect(checkoutServiceStub.startCheckout).not.toHaveBeenCalled();
+    expect(checkoutServiceStub.updateCustomerData).toHaveBeenCalledWith('tenant-test', 25, {
+      dni: '12345678',
+      telefono: '3415555555',
+      email: 'juan@example.com',
+      nombre_apellido: 'Juan Perez',
+    });
+    expect(component.createdPurchase()).toEqual({
+      ...updatedPurchase,
+      status: 'pending_payment',
+    });
+    expect(component.stepper.next).toHaveBeenCalledOnce();
+  });
+
+  it('cancels the pending purchase before allowing navigation away', async () => {
+    const { component } = createComponent();
+
+    await expect(component.canDeactivate()).resolves.toBe(true);
+
+    expect(checkoutServiceStub.cancelPurchase).toHaveBeenCalledWith('tenant-test', 25);
+    expect(cartServiceStub.loadCart).toHaveBeenCalled();
+    expect(cartServiceStub.clearCart).not.toHaveBeenCalled();
+    expect(component.createdPurchaseId()).toBeNull();
+  });
 });

src/app/features/store/pages/checkout-page/checkout-page.component.ts

@@ -2,24 +2,25 @@ import {
   ChangeDetectionStrategy,
   Component,
   computed,
-  effect,
   inject,
   OnDestroy,
   OnInit,
   signal,
-  untracked,
   ViewChild,
 } from '@angular/core';
 import { FormBuilder, Validators } from '@angular/forms';
-import { Router } from '@angular/router';
-import { startWith } from 'rxjs';
+import { ActivatedRoute, Router } from '@angular/router';
+import { firstValueFrom, startWith } from 'rxjs';
 
-import { CartService } from '../../../../core/services/cart/cart.service';
 import { TenantService } from '../../../../core/services/tenant.service';
-import { CheckoutService, CreatePurchasePayload } from '../../../../core/services/checkout.service';
+import {
+  CheckoutService,
+  PurchaseDetailItemResponse,
+  PurchaseDetailResponse,
+} from '../../../../core/services/checkout.service';
 import { AuthService } from '../../../../core/services/auth/auth.service';
+import { CartService } from '../../../../core/services/cart/cart.service';
 import { BankAccount } from '../../../../core/services/tenant.interface';
-import { CartItem } from '../../../../core/services/cart/cart.interface';
 import { CartComponent, CartItemMock } from '../../../../shared/components/cart/cart.component';
 import { StepComponent } from '../../../../shared/components/stepper/step.component';
 import { StepperComponent } from '../../../../shared/components/stepper/stepper.component';
@@ -51,13 +52,14 @@ import {
 })
 export class CheckoutPageComponent implements OnInit, OnDestroy {
   private readonly formBuilder = inject(FormBuilder);
-  private readonly cartService = inject(CartService);
+  private readonly route = inject(ActivatedRoute);
   private readonly router = inject(Router);
   private readonly tenantService = inject(TenantService);
   private readonly checkoutService = inject(CheckoutService);
   private readonly authService = inject(AuthService);
+  private readonly cartService = inject(CartService);
   private readonly qrPollingIntervalMs = 5_000;
-  private readonly qrPollingMaxAttempts = 60;
+  private readonly qrPollingMaxAttempts = 9;
 
   private qrPollingTimeoutId: ReturnType<typeof setTimeout> | null = null;
   private qrPollingAttempts = 0;
@@ -74,19 +76,25 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
     telefono: ['', [Validators.required]],
   });
 
+  protected readonly createdPurchase = signal<PurchaseDetailResponse | null>(null);
+  protected readonly isLoadingPurchase = signal(true);
+  protected readonly checkoutStepIndex = signal(0);
+
   protected readonly cartSubtotal = computed(() => {
-    const cart = this.cartService.cart();
-    return cart ? parseFloat(cart.subtotal) : 0;
+    const purchase = this.createdPurchase();
+    return purchase ? parseFloat(purchase.subtotal) : 0;
   });
 
   protected readonly cartDiscount = computed(() => 0);
 
-  protected readonly cartTotal = computed(() => this.cartSubtotal() - this.cartDiscount());
+  protected readonly cartTotal = computed(() => {
+    const purchase = this.createdPurchase();
+    return purchase ? parseFloat(purchase.total) : this.cartSubtotal() - this.cartDiscount();
+  });
 
   protected readonly mappedCartItems = computed<CartItemMock[]>(() => {
-    const cart = this.cartService.cart();
-    if (!cart || !cart.items) return [];
-    return cart.items.map((item) => this.mapCartItemToMock(item));
+    const purchase = this.createdPurchase();
+    return purchase ? purchase.items.map((item) => this.mapPurchaseItemToMock(item)) : [];
   });
 
   protected readonly isStep1Valid = signal(this.form.valid);
@@ -100,32 +108,25 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
   protected readonly transferAccount = signal<TransferAccount | null>(null);
   protected readonly transferDni = signal<string>('');
 
-  protected readonly isCreatingPurchase = signal(false);
+  protected readonly isUpdatingPurchase = signal(false);
+  protected readonly isEditingItems = signal(false);
+  protected readonly isUpdatingItem = signal(false);
+  protected readonly isPreparingItemEdit = signal(false);
   protected readonly createdPurchaseId = signal<number | null>(null);
   protected readonly isGeneratingIntent = signal(false);
-  protected readonly isPaymentLoading = computed(
-    () => this.isGeneratingIntent() || this.cartService.isUpdating(),
-  );
+  protected readonly isPaymentLoading = computed(() => this.isGeneratingIntent());
   protected readonly qrData = signal<string | null>(null);
   protected readonly qrPaymentStatus = signal<QrPaymentStatus>('idle');
   protected readonly isCheckingQrPayment = signal(false);
   protected readonly transferValidationStatus = signal<TransferValidationStatus>('idle');
+  protected readonly whatsappUrl = computed(
+    () =>
+      this.tenantService
+        .tenant()
+        ?.social_media?.find((socialMedia) => socialMedia.code === 'whatsapp')?.url ?? null,
+  );
 
   constructor() {
-    effect(() => {
-      // We only want to trigger the intent generation when the cart changes.
-      // So we track the cart, but untrack the other signals to prevent duplicate calls.
-      const cart = this.cartService.cart();
-
-      untracked(() => {
-        const purchaseId = this.createdPurchaseId();
-        if (cart && purchaseId && !this.navigationStarted) {
-          // Trigger payment intent generation when cart changes and we are on the payment step
-          void this.selectPaymentMethod(this.selectedPaymentMethod());
-        }
-      });
-    });
-
     this.form.statusChanges
       .pipe(startWith(this.form.status))
       .subscribe(() => this.isStep1Valid.set(this.form.valid));
@@ -144,68 +145,123 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
   }
 
   ngOnInit(): void {
-    this.cartService.loadCart().subscribe();
+    const purchaseId = Number(this.route.snapshot.queryParamMap.get('purchase'));
+    if (!Number.isInteger(purchaseId) || purchaseId <= 0) {
+      void this.router.navigate(['/']);
+      return;
+    }
+
+    void this.loadPurchase(purchaseId);
   }
 
   ngOnDestroy(): void {
     this.stopQrPolling();
   }
 
-  private mapCartItemToMock(item: CartItem): CartItemMock {
-    const fullName = item.product?.nombre ?? '';
-    let product = fullName;
-    let attributes: { label: string; value: string }[] = [];
-
-    const match = fullName.match(/^(.*?)\s*\((.*?)\)$/);
-    if (match) {
-      product = match[1];
-      const attributesString = match[2];
-      attributes = attributesString.split(',').map((attr) => {
-        const parts = attr.split(':');
-        if (parts.length === 2) {
-          return { label: parts[0].trim(), value: parts[1].trim() };
-        }
-        return { label: '', value: attr.trim() };
-      });
-    }
-
+  private mapPurchaseItemToMock(item: PurchaseDetailItemResponse): CartItemMock {
     return {
       cartItemId: item.id,
-      imageUrl: item.product?.imagen ?? null,
-      product,
+      imageUrl: item.item_details.imagen,
+      product: item.item_details.nombre,
       originalPrice: null,
-      discountedPrice: parseFloat(item.precio_unitario),
+      discountedPrice: parseFloat(item.unit_price),
       discountPercentage: null,
-      attributes,
-      quantity: item.cantidad,
+      attributes: item.item_details.attributes.map((attribute) => ({
+        label: attribute.name,
+        value: attribute.value === null ? '' : String(attribute.value),
+      })),
+      quantity: item.quantity,
     };
   }
 
-  protected async onStep1Continue(): Promise<void> {
-    if (this.form.invalid) return;
+  protected async onEditingItemsChange(editing: boolean): Promise<void> {
+    if (this.isUpdatingItem() || this.isPreparingItemEdit()) {
+      return;
+    }
 
-    const tenant = this.tenantService.tenant();
-    if (!tenant) return;
+    if (!editing) {
+      this.isEditingItems.set(false);
 
-    this.isCreatingPurchase.set(true);
-
-    try {
-      const cart = this.cartService.cart();
-      if (!cart?.id) {
-        throw new Error('No hay un carrito activo para finalizar la compra.');
+      if (this.stepper?.currentStepIndex() === 1) {
+        void this.selectPaymentMethod(this.selectedPaymentMethod());
       }
 
+      return;
+    }
+
+    this.isEditingItems.set(true);
+    this.stopQrPolling();
+    this.qrData.set(null);
+    this.qrPaymentStatus.set('idle');
+    this.transferAccount.set(null);
+    this.transferValidationStatus.set('idle');
+
+    const tenant = this.tenantService.tenant();
+    const purchaseId = this.createdPurchaseId();
+
+    if (!tenant || !purchaseId) {
+      this.isEditingItems.set(false);
+      return;
+    }
+
+    this.isPreparingItemEdit.set(true);
+    try {
+      const purchase = await this.checkoutService.prepareItemEditing(tenant.codigo, purchaseId);
+      this.createdPurchase.set(purchase);
+    } catch (error) {
+      console.error('Failed to prepare purchase item editing:', error);
+      this.isEditingItems.set(false);
+    } finally {
+      this.isPreparingItemEdit.set(false);
+    }
+  }
+
+  protected async onPurchaseItemQuantityChange(event: {
+    item: CartItemMock;
+    quantity: number;
+  }): Promise<void> {
+    const tenant = this.tenantService.tenant();
+    const purchaseId = this.createdPurchaseId();
+    const itemId = event.item.cartItemId;
+
+    if (!tenant || !purchaseId || !itemId || this.isUpdatingItem() || !this.isEditingItems()) {
+      return;
+    }
+
+    this.isUpdatingItem.set(true);
+    try {
+      const purchase = await this.checkoutService.updateItemQuantity(
+        tenant.codigo,
+        purchaseId,
+        itemId,
+        event.quantity,
+      );
+      this.createdPurchase.set(purchase);
+    } catch (error) {
+      console.error('Failed to update purchase item quantity:', error);
+    } finally {
+      this.isUpdatingItem.set(false);
+    }
+  }
+
+  protected async onStep1Continue(): Promise<void> {
+    if (this.form.invalid || this.isUpdatingPurchase() || this.isEditingItems()) return;
+
+    const tenant = this.tenantService.tenant();
+    const purchaseId = this.createdPurchaseId();
+    if (!tenant || !purchaseId) return;
+
+    this.isUpdatingPurchase.set(true);
+
+    try {
       const formValue = this.form.getRawValue();
-      const payload: CreatePurchasePayload = {
-        cart_id: cart.id,
+      const purchase = await this.checkoutService.updateCustomerData(tenant.codigo, purchaseId, {
         dni: formValue.dni,
         telefono: formValue.telefono,
         email: formValue.email,
         nombre_apellido: formValue.nombre,
-      };
-
-      const response = await this.checkoutService.createPurchase(tenant.codigo, payload);
-      this.createdPurchaseId.set(response.id);
+      });
+      this.createdPurchase.set(purchase);
 
       this.stepper.next();
 
@@ -215,17 +271,50 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
       console.error('Failed to create purchase:', error);
       // Here we could show an alert or toast
     } finally {
-      this.isCreatingPurchase.set(false);
+      this.isUpdatingPurchase.set(false);
     }
   }
 
-  protected onCancel(): void {
+  protected async onCancel(): Promise<void> {
+    if (await this.canDeactivate()) {
+      void this.router.navigate(['/']);
+    }
+  }
+
+  public async canDeactivate(): Promise<boolean> {
     this.stopQrPolling();
-    void this.router.navigate(['/']);
+
+    if (this.navigationStarted) {
+      return true;
+    }
+
+    const purchaseId = this.createdPurchaseId();
+    const tenant = this.tenantService.tenant();
+
+    if (!purchaseId || !tenant) {
+      return true;
+    }
+
+    try {
+      await this.checkoutService.cancelPurchase(tenant.codigo, purchaseId);
+      this.createdPurchaseId.set(null);
+      this.createdPurchase.set(null);
+
+      try {
+        await firstValueFrom(this.cartService.loadCart());
+      } catch (error) {
+        console.error('Failed to restore cart after cancelling checkout:', error);
+      }
+
+      return true;
+    } catch (error) {
+      console.error('Failed to cancel purchase:', error);
+      return false;
+    }
   }
 
   protected async selectPaymentMethod(method: PaymentMethod): Promise<void> {
-    if (this.navigationStarted) {
+    if (this.navigationStarted || this.isEditingItems()) {
       return;
     }
 
@@ -254,11 +343,9 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
     this.isGeneratingIntent.set(true);
 
     try {
-      const response = await this.checkoutService.generatePaymentIntent(
-        tenant.codigo,
-        purchaseId,
-        method,
-      );
+      const response = await this.checkoutService
+        .withCustomLoading()
+        .generatePaymentIntent(tenant.codigo, purchaseId, method);
 
       if (method === 'qr' && response.qr_data?.qr_code) {
         if (requestId !== this.paymentMethodRequestId || this.selectedPaymentMethod() !== 'qr') {
@@ -266,6 +353,7 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
         }
 
         this.qrData.set(response.qr_data.qr_code);
+        this.markPurchasePendingPayment();
         this.startQrPolling();
       }
     } catch (error) {
@@ -276,6 +364,10 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
   }
 
   protected async generateTransferIntent(dni: string): Promise<void> {
+    if (this.isEditingItems()) {
+      return;
+    }
+
     const purchaseId = this.createdPurchaseId();
     const tenant = this.tenantService.tenant();
 
@@ -287,14 +379,12 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
     this.transferValidationStatus.set('idle');
     this.isGeneratingIntent.set(true);
     try {
-      const response = await this.checkoutService.generatePaymentIntent(
-        tenant.codigo,
-        purchaseId,
-        'transfer',
-        dni
-      );
+      const response = await this.checkoutService
+        .withCustomLoading()
+        .generatePaymentIntent(tenant.codigo, purchaseId, 'transfer', dni);
 
       if (response.transfer_data) {
+        this.markPurchasePendingPayment();
         this.transferAccount.set({
           titular: response.transfer_data.titular,
           entidad: response.transfer_data.entidad,
@@ -334,6 +424,7 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
       !purchaseId ||
       !tenant ||
       this.navigationStarted ||
+      this.isEditingItems() ||
       this.transferValidationStatus() === 'checking'
     ) {
       return;
@@ -342,22 +433,22 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
     this.transferValidationStatus.set('checking');
 
     try {
-      const purchase = await this.checkoutService.getPurchase(tenant.codigo, purchaseId);
+      const purchase = await this.checkoutService
+        .withCustomLoading()
+        .submitPurchaseForReview(tenant.codigo, purchaseId);
 
-      if (purchase.status === 'paid') {
-        this.handleConfirmedPayment(purchaseId);
-        return;
-      }
+      if (purchase.status === 'paid' || purchase.status === 'pending_payment') {
+        if (purchase.status === 'pending_payment') {
+          this.transferValidationStatus.set('pending');
+        }
 
-      if (purchase.status === 'pending_payment') {
-        this.transferValidationStatus.set('pending');
         this.navigateToPurchaseStatus(purchaseId);
         return;
       }
 
-      this.transferValidationStatus.set('pending');
+      this.transferValidationStatus.set('error');
     } catch (error) {
-      console.error('Failed to validate transfer payment:', error);
+      console.error('Failed to submit purchase for review:', error);
       this.transferValidationStatus.set('error');
     }
   }
@@ -401,7 +492,9 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
     this.isCheckingQrPayment.set(true);
 
     try {
-      const purchase = await this.checkoutService.getPurchase(tenant.codigo, purchaseId);
+      const purchase = await this.checkoutService
+        .withCustomLoading()
+        .getPurchase(tenant.codigo, purchaseId);
 
       if (runId !== this.qrPollingRunId) {
         return;
@@ -448,11 +541,22 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
     }
   }
 
-  private handleConfirmedPayment(purchaseId: number): void {
-    this.navigateToPurchaseStatus(purchaseId, true);
+  private markPurchasePendingPayment(): void {
+    this.createdPurchase.update((purchase) =>
+      purchase
+        ? {
+            ...purchase,
+            status: 'pending_payment',
+          }
+        : purchase,
+    );
   }
 
-  private navigateToPurchaseStatus(purchaseId: number, clearCart = false): void {
+  private handleConfirmedPayment(purchaseId: number): void {
+    this.navigateToPurchaseStatus(purchaseId);
+  }
+
+  private navigateToPurchaseStatus(purchaseId: number): void {
     if (this.navigationStarted) {
       return;
     }
@@ -460,10 +564,57 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
     this.navigationStarted = true;
     this.stopQrPolling();
 
-    if (clearCart) {
-      this.cartService.clearCart();
-    }
-
     void this.router.navigate(['/checkout/status', purchaseId]);
   }
+
+  private async loadPurchase(purchaseId: number): Promise<void> {
+    const tenant = this.tenantService.tenant();
+    if (!tenant) {
+      void this.router.navigate(['/']);
+      return;
+    }
+
+    try {
+      const purchase = await this.checkoutService
+        .withCustomLoading()
+        .getPurchase(tenant.codigo, purchaseId);
+
+      if (
+        (purchase.status === 'pending_payment' && purchase.expires_at === null) ||
+        purchase.status === 'paid' ||
+        purchase.status === 'cancelled' ||
+        purchase.status === 'rejected' ||
+        purchase.status === 'expired'
+      ) {
+        this.navigateToPurchaseStatus(purchaseId);
+        return;
+      }
+
+      if (purchase.status !== 'created' && purchase.status !== 'pending_payment') {
+        void this.router.navigate(['/']);
+        return;
+      }
+
+      this.createdPurchaseId.set(purchase.id);
+      this.createdPurchase.set(purchase);
+      this.checkoutStepIndex.set(purchase.status === 'pending_payment' ? 1 : 0);
+
+      if (
+        purchase.status === 'pending_payment' &&
+        this.paymentMethods.some((method) => method.id === purchase.payment_method)
+      ) {
+        this.selectedPaymentMethod.set(purchase.payment_method as PaymentMethod);
+        this.transferDni.set(purchase.transfer_payer_dni ?? '');
+      }
+
+      this.isLoadingPurchase.set(false);
+
+      if (purchase.status === 'pending_payment' && purchase.payment_method === 'qr') {
+        await this.selectPaymentMethod('qr');
+      }
+    } catch (error) {
+      console.error('Failed to load purchase:', error);
+      void this.router.navigate(['/']);
+    }
+  }
 }

src/app/features/store/pages/checkout-page/checkout-page.guard.ts

@@ -0,0 +1,8 @@
+import { CanDeactivateFn } from '@angular/router';
+
+interface PendingCheckoutComponent {
+  canDeactivate(): Promise<boolean>;
+}
+
+export const checkoutPendingPurchaseGuard: CanDeactivateFn<PendingCheckoutComponent> = (component) =>
+  component.canDeactivate();

src/app/features/store/pages/checkout-page/checkout-payment-step.component.html

@@ -1,14 +1,13 @@
 <div class="checkout-payment">
   <div class="checkout-payment__content">
     <section class="payment-methods" aria-labelledby="payment-methods-title">
-      <h2 id="payment-methods-title" class="payment-methods__title">Selecciona el metodo de pago</h2>
+      <h2 id="payment-methods-title" class="payment-methods__title">
+        Selecciona el metodo de pago
+      </h2>
 
       <div class="payment-methods__list" role="radiogroup" aria-label="Metodo de pago">
         @for (method of paymentMethods(); track method.id) {
-          <label
-            class="payment-method"
-            [class.is-selected]="selectedPaymentMethod() === method.id"
-          >
+          <label class="payment-method" [class.is-selected]="selectedPaymentMethod() === method.id">
             <input
               class="payment-method__radio"
               type="radio"
@@ -21,7 +20,8 @@
             <span class="payment-method__label">
               @if (method.id === 'telepagos') {
                 <span class="telepagos-logo" aria-label="TelePagos">
-                  <span class="telepagos-logo__tele">tele</span><span class="telepagos-logo__pagos">pagos</span>
+                  <span class="telepagos-logo__tele">tele</span
+                  ><span class="telepagos-logo__pagos">pagos</span>
                 </span>
               } @else {
                 {{ method.label }}
@@ -36,7 +36,7 @@
 
     <section class="payment-panel d-flex justify-content-end" aria-live="polite">
       @if (isGeneratingIntent()) {
-        <div class="payment-panel__card" style="text-align: center; padding: 2rem;">
+        <div class="payment-panel__card" style="text-align: center; padding: 2rem">
           <h3 class="payment-panel__title">Cargando información de pago...</h3>
         </div>
       } @else if (selectedPaymentMethod() === 'qr') {
@@ -44,7 +44,8 @@
           [qrData]="qrData()"
           [paymentStatus]="qrPaymentStatus()"
           [isCheckingPayment]="isCheckingQrPayment()"
-          (retryPolling)="retryQrPolling.emit()"
+          [paymentAmount]="qrPaymentAmount()"
+          [whatsappUrl]="whatsappUrl()"
         />
       } @else if (selectedPaymentMethod() === 'transfer') {
         <app-checkout-payment-transfer
@@ -52,6 +53,8 @@
           [transferDni]="transferDni()"
           [copiedTransferField]="copiedTransferField()"
           [validationStatus]="transferValidationStatus()"
+          [paymentAmount]="qrPaymentAmount()"
+          [whatsappUrl]="whatsappUrl()"
           (copyTransferValue)="requestCopy($event.field, $event.value)"
           (submitDni)="generateTransferIntent.emit($event)"
           (completePurchase)="complete.emit()"
@@ -62,4 +65,3 @@
     </section>
   </div>
 </div>
-

src/app/features/store/pages/checkout-page/checkout-payment-step.component.ts

@@ -30,6 +30,8 @@ export class CheckoutPaymentStepComponent {
   readonly qrData = input<string | null>(null);
   readonly qrPaymentStatus = input<QrPaymentStatus>('idle');
   readonly isCheckingQrPayment = input<boolean>(false);
+  readonly qrPaymentAmount = input<number>(0);
+  readonly whatsappUrl = input<string | null>(null);
   readonly transferValidationStatus = input<TransferValidationStatus>('idle');
 
   readonly paymentMethodChange = output<PaymentMethod>();
@@ -37,7 +39,6 @@ export class CheckoutPaymentStepComponent {
   readonly cancelStep = output<void>();
   readonly complete = output<void>();
   readonly generateTransferIntent = output<string>();
-  readonly retryQrPolling = output<void>();
 
   protected selectPaymentMethod(method: PaymentMethod): void {
     this.paymentMethodChange.emit(method);

src/app/features/store/pages/checkout-page/components/checkout-payment-qr/checkout-payment-qr.component.html

@@ -1,34 +1,34 @@
 <div class="payment-panel__card">
-  <h3 class="payment-panel__title">Ingresa a tu billetera y escanea el siguiente QR</h3>
-  <div class="payment-panel__divider"></div>
-
-  <div class="qr-code" aria-label="QR de pago">
-    @if (qrData()) {
-      <qrcode [qrdata]="qrData()!" [width]="200" [errorCorrectionLevel]="'M'"></qrcode>
-    } @else {
-      <span class="qr-code__finder qr-code__finder--tl"></span>
-      <span class="qr-code__finder qr-code__finder--tr"></span>
-      <span class="qr-code__finder qr-code__finder--bl"></span>
-    }
-
-    @if (isCheckingPayment()) {
-      <div class="payment-verification" role="status" aria-live="polite">
-        <span class="payment-verification__spinner" aria-hidden="true"></span>
-        <span class="payment-verification__message">Verificando pago</span>
-      </div>
-    }
-  </div>
-
   @if (paymentStatus() === 'timed_out') {
-    <p class="payment-status payment-status--warning" role="status">
-      Todavía no recibimos el pago.
-    </p>
-    <app-button type="button" variant="secondary" (click)="retryPolling.emit()">
-      Volver a verificar
-    </app-button>
-  } @else if (paymentStatus() === 'failed') {
-    <p class="payment-status payment-status--warning" role="alert">
-      El pago fue rechazado o cancelado.
-    </p>
+    <app-payment-verification-error
+      [paymentAmount]="paymentAmount()"
+      [whatsappUrl]="whatsappUrl()"
+    />
+  } @else {
+    <h3 class="payment-panel__title">Ingresa a tu billetera y escanea el siguiente QR</h3>
+    <div class="payment-panel__divider"></div>
+
+    <div class="qr-code" aria-label="QR de pago">
+      @if (qrData()) {
+        <qrcode [qrdata]="qrData()!" [width]="200" [errorCorrectionLevel]="'M'"></qrcode>
+      } @else {
+        <span class="qr-code__finder qr-code__finder--tl"></span>
+        <span class="qr-code__finder qr-code__finder--tr"></span>
+        <span class="qr-code__finder qr-code__finder--bl"></span>
+      }
+
+      @if (isCheckingPayment()) {
+        <div class="payment-verification" role="status" aria-live="polite">
+          <span class="payment-verification__spinner" aria-hidden="true"></span>
+          <span class="payment-verification__message">Verificando pago</span>
+        </div>
+      }
+    </div>
+
+    @if (paymentStatus() === 'failed') {
+      <p class="payment-status payment-status--warning" role="alert">
+        El pago fue rechazado o cancelado.
+      </p>
+    }
   }
 </div>

src/app/features/store/pages/checkout-page/components/checkout-payment-qr/checkout-payment-qr.component.scss

@@ -57,7 +57,9 @@
       rgba(17, 17, 17, 0.95) 84% 100%
     );
   background-size: 18px 18px;
-  background-position: 0 0, 9px 9px;
+  background-position:
+    0 0,
+    9px 9px;
   display: flex;
   justify-content: center;
   align-items: center;
@@ -86,7 +88,9 @@
   height: 38px;
   border: 5px solid #111111;
   background: #ffffff;
-  box-shadow: inset 0 0 0 8px #ffffff, inset 0 0 0 14px #111111;
+  box-shadow:
+    inset 0 0 0 8px #ffffff,
+    inset 0 0 0 14px #111111;
 
   &--tl {
     top: 10px;

src/app/features/store/pages/checkout-page/components/checkout-payment-qr/checkout-payment-qr.component.spec.ts

@@ -27,4 +27,25 @@ describe('CheckoutPaymentQrComponent', () => {
     expect(overlay.textContent).toContain('Verificando pago');
     expect(overlay.querySelector('.payment-verification__spinner')).not.toBeNull();
   });
+
+  it('shows the payment verification error and WhatsApp action after timeout', async () => {
+    await TestBed.configureTestingModule({
+      imports: [CheckoutPaymentQrComponent],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(CheckoutPaymentQrComponent);
+    fixture.componentRef.setInput('paymentStatus', 'timed_out');
+    fixture.componentRef.setInput('paymentAmount', 300000);
+    fixture.componentRef.setInput('whatsappUrl', 'https://wa.me/543412602222');
+    fixture.detectChanges();
+
+    const element = fixture.nativeElement as HTMLElement;
+    const whatsapp = Array.from(element.querySelectorAll('button')).find((button) =>
+      button.textContent?.includes('WhatsApp'),
+    );
+    expect(element.textContent).toMatch(/No pudimos verificar el pago de \$\s*300\.000\./);
+    expect(element.textContent).toContain('Por favor contactate con nosotros para resolverlo.');
+    expect(whatsapp).toBeDefined();
+    expect(element.textContent).not.toContain('Volver a verificar');
+  });
 });

src/app/features/store/pages/checkout-page/components/checkout-payment-qr/checkout-payment-qr.component.ts

@@ -1,19 +1,20 @@
-import { ChangeDetectionStrategy, Component, input, output } from '@angular/core';
+import { ChangeDetectionStrategy, Component, input } from '@angular/core';
 import { QRCodeComponent } from '../../../../../../shared/components/qrcode/qrcode.component';
-import { ButtonComponent } from '../../../../../../shared/components/button/button.component';
 import { QrPaymentStatus } from '../../checkout-page.models';
+import { PaymentVerificationErrorComponent } from '../payment-verification-error/payment-verification-error.component';
 
 @Component({
   selector: 'app-checkout-payment-qr',
   standalone: true,
-  imports: [QRCodeComponent, ButtonComponent],
+  imports: [PaymentVerificationErrorComponent, QRCodeComponent],
   templateUrl: './checkout-payment-qr.component.html',
   styleUrl: './checkout-payment-qr.component.scss',
-  changeDetection: ChangeDetectionStrategy.OnPush
+  changeDetection: ChangeDetectionStrategy.OnPush,
 })
 export class CheckoutPaymentQrComponent {
   readonly qrData = input<string | null>(null);
   readonly paymentStatus = input<QrPaymentStatus>('idle');
   readonly isCheckingPayment = input<boolean>(false);
-  readonly retryPolling = output<void>();
+  readonly paymentAmount = input<number>(0);
+  readonly whatsappUrl = input<string | null>(null);
 }

src/app/features/store/pages/checkout-page/components/checkout-payment-transfer/checkout-payment-transfer.component.html

@@ -1,105 +1,106 @@
 <div class="payment-panel__card">
-  <div class="dni-form-container">
-    <h3 class="dni-form-title">Ingresá DNI de quién va a transferir</h3>
-    <form class="dni-form row gx-2" (submit)="$event.preventDefault(); onSubmitDni()">
-      <div class="col-8">
-        <app-input
-          type="text"
-          [value]="dniControl.value"
-          (valueChange)="dniControl.setValue($event.toString()); dniControl.markAsDirty()"
-          [disabled]="isDniDisabled()"
-          [invalid]="dniControl.invalid && (dniControl.dirty || dniControl.touched)"
-        />
-      </div>
-      <div class="col-4">
-        @if (isDniDisabled()) {
-          <app-button
-            type="button"
-            variant="secondary"
-            hostClass="w-100 h-100"
-            buttonClass="w-100 h-100 px-0"
-            (click)="enableEditing()"
-          >
-            Modificar
-          </app-button>
-        } @else {
-          <app-button
-            type="submit"
-            variant="primary"
-            hostClass="w-100 h-100"
-            buttonClass="w-100 h-100 px-0"
-            [disabled]="dniControl.invalid"
-          >
-            Continuar
-          </app-button>
-        }
-      </div>
-    </form>
-  </div>
-
-  @if (transferAccount() && !isEditing()) {
-    <div class="payment-panel__divider"></div>
-    <div class="payment-panel__account">
-      <p class="payment-panel__eyebrow">DATOS DE CUENTA:</p>
-
-      <div class="payment-detail">
-        <span class="payment-detail__label">Titular:</span>
-        <span class="payment-detail__value">{{ transferAccount()?.titular }}</span>
-      </div>
-
-      <div class="payment-detail">
-        <span class="payment-detail__label">Entidad:</span>
-        <span class="payment-detail__value">{{ transferAccount()?.entidad }}</span>
-      </div>
-
-      <div class="payment-detail payment-detail--copy">
-        <span class="payment-detail__label">CVU:</span>
-        <span class="payment-detail__value">{{ transferAccount()?.cvu }}</span>
-        <app-icon-button
-          variant="copy"
-          ariaLabel="Copiar CVU"
-          (click)="requestCopy('cvu', transferAccount()!.cvu)"
-        />
-        @if (copiedTransferField() === 'cvu') {
-          <span class="payment-detail__feedback" style="grid-column: 1 / -1; text-align: center;">¡Copiado!</span>
-        }
-      </div>
-
-      <div class="payment-detail payment-detail--copy">
-        <span class="payment-detail__label">Alias:</span>
-        <span class="payment-detail__value">{{ transferAccount()?.alias }}</span>
-        <app-icon-button
-          variant="copy"
-          ariaLabel="Copiar Alias"
-          (click)="requestCopy('alias', transferAccount()!.alias)"
-        />
-        @if (copiedTransferField() === 'alias') {
-          <span class="payment-detail__feedback" style="grid-column: 1 / -1; text-align: center;">¡Copiado!</span>
-        }
-      </div>
+  @if (validationStatus() === 'pending' || validationStatus() === 'error') {
+    <app-payment-verification-error
+      [paymentAmount]="paymentAmount()"
+      [whatsappUrl]="whatsappUrl()"
+    />
+  } @else {
+    <div class="dni-form-container">
+      <h3 class="dni-form-title">Ingresá DNI de quién va a transferir</h3>
+      <form class="dni-form row gx-2" (submit)="$event.preventDefault(); onSubmitDni()">
+        <div class="col-8">
+          <app-input
+            type="text"
+            [value]="dniControl.value"
+            (valueChange)="dniControl.setValue($event.toString()); dniControl.markAsDirty()"
+            [disabled]="isDniDisabled()"
+            [invalid]="dniControl.invalid && (dniControl.dirty || dniControl.touched)"
+          />
+        </div>
+        <div class="col-4">
+          @if (isDniDisabled()) {
+            <app-button
+              type="button"
+              variant="secondary"
+              hostClass="w-100 h-100"
+              buttonClass="w-100 h-100 px-0"
+              (click)="enableEditing()"
+            >
+              Modificar
+            </app-button>
+          } @else {
+            <app-button
+              type="submit"
+              variant="primary"
+              hostClass="w-100 h-100"
+              buttonClass="w-100 h-100 px-0"
+              [disabled]="dniControl.invalid"
+            >
+              Continuar
+            </app-button>
+          }
+        </div>
+      </form>
     </div>
 
-    <div class="mt-4">
-      <app-button
-        type="button"
-        variant="primary"
-        hostClass="w-100"
-        buttonClass="w-100"
-        [disabled]="validationStatus() === 'checking'"
-        (click)="completePurchase.emit()"
-      >
-        {{ validationStatus() === 'checking' ? 'Validando pago...' : 'Ya transferí' }}
-      </app-button>
+    @if (transferAccount() && !isEditing()) {
+      <div class="payment-panel__divider"></div>
+      <div class="payment-panel__account">
+        <p class="payment-panel__eyebrow">DATOS DE CUENTA:</p>
 
-      @if (validationStatus() === 'pending') {
-        <p class="payment-validation payment-validation--pending" role="status">
-          Todavía no recibimos la transferencia. Podés volver a verificar.
-        </p>
-      } @else if (validationStatus() === 'error') {
-        <p class="payment-validation payment-validation--error" role="alert">
-          No pudimos validar la transferencia. Intentá nuevamente.
-        </p>
-      }
-    </div>
+        <div class="payment-detail">
+          <span class="payment-detail__label">Titular:</span>
+          <span class="payment-detail__value">{{ transferAccount()?.titular }}</span>
+        </div>
+
+        <div class="payment-detail">
+          <span class="payment-detail__label">Entidad:</span>
+          <span class="payment-detail__value">{{ transferAccount()?.entidad }}</span>
+        </div>
+
+        <div class="payment-detail payment-detail--copy">
+          <span class="payment-detail__label">CVU:</span>
+          <span class="payment-detail__value">{{ transferAccount()?.cvu }}</span>
+          <app-icon-button
+            variant="copy"
+            ariaLabel="Copiar CVU"
+            (click)="requestCopy('cvu', transferAccount()!.cvu)"
+          />
+          @if (copiedTransferField() === 'cvu') {
+            <span class="payment-detail__feedback" style="grid-column: 1 / -1; text-align: center"
+              >¡Copiado!</span
+            >
+          }
+        </div>
+
+        <div class="payment-detail payment-detail--copy">
+          <span class="payment-detail__label">Alias:</span>
+          <span class="payment-detail__value">{{ transferAccount()?.alias }}</span>
+          <app-icon-button
+            variant="copy"
+            ariaLabel="Copiar Alias"
+            (click)="requestCopy('alias', transferAccount()!.alias)"
+          />
+          @if (copiedTransferField() === 'alias') {
+            <span class="payment-detail__feedback" style="grid-column: 1 / -1; text-align: center"
+              >¡Copiado!</span
+            >
+          }
+        </div>
+      </div>
+
+      <div class="mt-4">
+        <app-button
+          type="button"
+          variant="primary"
+          hostClass="w-100"
+          buttonClass="w-100"
+          [disabled]="validationStatus() === 'checking'"
+          (click)="completePurchase.emit()"
+        >
+          {{ validationStatus() === 'checking' ? 'Validando pago...' : 'Ya transferí' }}
+        </app-button>
+      </div>
+    }
   }
 </div>

src/app/features/store/pages/checkout-page/components/checkout-payment-transfer/checkout-payment-transfer.component.scss

@@ -115,17 +115,3 @@
     height: 100%;
   }
 }
-
-.payment-validation {
-  margin: 0.75rem 0 0;
-  font-size: 0.8rem;
-  line-height: 1.35;
-
-  &--pending {
-    color: #8a681d;
-  }
-
-  &--error {
-    color: #b42318;
-  }
-}

src/app/features/store/pages/checkout-page/components/checkout-payment-transfer/checkout-payment-transfer.component.ts

@@ -1,23 +1,46 @@
-import { ChangeDetectionStrategy, Component, computed, input, output, signal, OnInit, effect, untracked } from '@angular/core';
+import {
+  ChangeDetectionStrategy,
+  Component,
+  computed,
+  input,
+  output,
+  signal,
+  OnInit,
+  effect,
+  untracked,
+} from '@angular/core';
 import { FormControl, ReactiveFormsModule, Validators } from '@angular/forms';
 import { IconButtonComponent } from '../../../../../../shared/components/icon-button/icon-button.component';
 import { ButtonComponent } from '../../../../../../shared/components/button/button.component';
 import { InputComponent } from '../../../../../../shared/components/input/input.component';
-import { TransferAccount, TransferField, TransferValidationStatus } from '../../checkout-page.models';
+import {
+  TransferAccount,
+  TransferField,
+  TransferValidationStatus,
+} from '../../checkout-page.models';
+import { PaymentVerificationErrorComponent } from '../payment-verification-error/payment-verification-error.component';
 
 @Component({
   selector: 'app-checkout-payment-transfer',
   standalone: true,
-  imports: [IconButtonComponent, ButtonComponent, InputComponent, ReactiveFormsModule],
+  imports: [
+    IconButtonComponent,
+    ButtonComponent,
+    InputComponent,
+    ReactiveFormsModule,
+    PaymentVerificationErrorComponent,
+  ],
   templateUrl: './checkout-payment-transfer.component.html',
   styleUrl: './checkout-payment-transfer.component.scss',
-  changeDetection: ChangeDetectionStrategy.OnPush
+  changeDetection: ChangeDetectionStrategy.OnPush,
 })
 export class CheckoutPaymentTransferComponent implements OnInit {
   readonly transferAccount = input<TransferAccount | null>(null);
   readonly transferDni = input<string>('');
   readonly copiedTransferField = input<TransferField | null>(null);
   readonly validationStatus = input<TransferValidationStatus>('idle');
+  readonly paymentAmount = input<number>(0);
+  readonly whatsappUrl = input<string | null>(null);
 
   readonly copyTransferValue = output<{ field: TransferField; value: string }>();
   readonly submitDni = output<string>();
@@ -25,7 +48,7 @@ export class CheckoutPaymentTransferComponent implements OnInit {
 
   protected readonly dniControl = new FormControl('', {
     nonNullable: true,
-    validators: [Validators.required, Validators.pattern(/^\d{7,8}$/)]
+    validators: [Validators.required, Validators.pattern(/^\d{7,8}$/)],
   });
 
   protected readonly isEditing = signal<boolean>(false);

src/app/features/store/pages/checkout-page/components/payment-verification-error/payment-verification-error.component.html

@@ -0,0 +1,17 @@
+<div class="payment-timeout" role="alert">
+  <div class="payment-timeout__icon" aria-hidden="true">
+    <i class="fa-solid fa-xmark"></i>
+  </div>
+  <h4 class="payment-timeout__title">No pudimos verificar el pago de {{ formattedAmount() }}.</h4>
+  <p class="payment-timeout__message">Por favor contactate con nosotros para resolverlo.</p>
+  @if (whatsappUrl()) {
+    <app-button
+      type="button"
+      variant="primary"
+      buttonClass="d-inline-flex align-items-center justify-content-center gap-2"
+      (click)="openWhatsApp()"
+    >
+      <span>WhatsApp</span>
+    </app-button>
+  }
+</div>

src/app/features/store/pages/checkout-page/components/payment-verification-error/payment-verification-error.component.scss

@@ -0,0 +1,35 @@
+.payment-timeout {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  width: 100%;
+  padding-top: 0.85rem;
+
+  &__icon {
+    display: grid;
+    width: 84px;
+    height: 84px;
+    place-items: center;
+    border: 1px solid var(--tenant-danger, #dc3545);
+    border-radius: 50%;
+    color: var(--tenant-danger, #dc3545);
+    font-size: 2.7rem;
+  }
+
+  &__title {
+    max-width: 250px;
+    margin: 1.35rem 0 0;
+    color: var(--tenant-danger, #dc3545);
+    font-size: 1.05rem;
+    font-weight: 700;
+    line-height: 1.3;
+  }
+
+  &__message {
+    max-width: 250px;
+    margin: 2rem 0 1.75rem;
+    color: #666666;
+    font-size: 1rem;
+    line-height: 1.25;
+  }
+}

src/app/features/store/pages/checkout-page/components/payment-verification-error/payment-verification-error.component.ts

@@ -0,0 +1,32 @@
+import { ChangeDetectionStrategy, Component, computed, input } from '@angular/core';
+
+import { ButtonComponent } from '../../../../../../shared/components/button/button.component';
+
+@Component({
+  selector: 'app-payment-verification-error',
+  standalone: true,
+  imports: [ButtonComponent],
+  templateUrl: './payment-verification-error.component.html',
+  styleUrl: './payment-verification-error.component.scss',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class PaymentVerificationErrorComponent {
+  readonly paymentAmount = input<number>(0);
+  readonly whatsappUrl = input<string | null>(null);
+
+  protected readonly formattedAmount = computed(() =>
+    new Intl.NumberFormat('es-AR', {
+      style: 'currency',
+      currency: 'ARS',
+      maximumFractionDigits: 0,
+    }).format(this.paymentAmount()),
+  );
+
+  protected openWhatsApp(): void {
+    const url = this.whatsappUrl();
+
+    if (url) {
+      window.open(url, '_blank', 'noopener,noreferrer');
+    }
+  }
+}

src/app/features/store/pages/help-page/components/help-sidebar/help-sidebar.spec.ts

@@ -22,6 +22,7 @@ describe('HelpSidebar', () => {
       footer_bg_color: '#ffffff',
       header_logo: '',
       footer_logo: '',
+      categories: [],
       menues: [
         {
           id: 1,

src/app/features/store/pages/help-page/pages/contact-page/contact-page.spec.ts

@@ -18,6 +18,7 @@ const tenant: Tenant = {
   footer_bg_color: '#202020',
   header_logo: '',
   footer_logo: '',
+  categories: [],
   menues: [
     {
       id: 1,

src/app/features/store/pages/help-page/pages/faq-page/faq-page.spec.ts

@@ -18,6 +18,7 @@ const tenant: Tenant = {
   footer_bg_color: '#202020',
   header_logo: '',
   footer_logo: '',
+  categories: [],
   menues: [
     {
       id: 1,

src/app/features/store/pages/login-page/login-page.component.html

@@ -30,7 +30,7 @@
       <label class="visually-hidden" for="login-password">Contraseña</label>
       <app-input
         id="login-password"
-        type="password"
+        type="password-toggle"
         placeholder="Contraseña"
         [value]="form.controls.password.value"
         [invalid]="showControlError('password')"
@@ -40,7 +40,11 @@
         <small class="text-danger">{{ errorMessage }}</small>
       }
       <div class="text-end">
-        <button type="button" class="login-page__forgot-password btn btn-link p-0 border-0 text-decoration-none">
+        <button
+          type="button"
+          class="login-page__forgot-password btn btn-link p-0 border-0 text-decoration-none"
+          (click)="goToRecoverPassword()"
+        >
           Olvide mi contraseña
         </button>
       </div>
@@ -56,7 +60,7 @@
     >
       {{ isSubmitting() ? 'Ingresando...' : 'Ingresar' }}
     </app-button>
-    
+
     <app-button
       type="button"
       variant="borderless"

src/app/features/store/pages/login-page/login-page.component.ts

@@ -9,6 +9,7 @@ import { InputComponent } from '../../../../shared/components/input/input.compon
 
 const PASSWORD_MIN_LENGTH = 8;
 const EMAIL_MAX_LENGTH = 255;
+const POST_LOGIN_RETURN_URL_KEY = 'shopit.auth.return-url';
 
 @Component({
   selector: 'app-login-page',
@@ -53,6 +54,10 @@ export class LoginPageComponent {
     void this.router.navigate(['/register']);
   }
 
+  goToRecoverPassword(): void {
+    void this.router.navigate(['/recuperar-contrasena']);
+  }
+
   onSubmit(): void {
     this.submittedState.set(true);
     this.serverErrorState.set(null);
@@ -80,6 +85,10 @@ export class LoginPageComponent {
     this.serverErrorState.set(null);
 
     try {
+      const returnUrl = this.route.snapshot.queryParamMap.get('returnUrl');
+      if (returnUrl?.startsWith('/') && !returnUrl.startsWith('//')) {
+        this.document.defaultView?.sessionStorage.setItem(POST_LOGIN_RETURN_URL_KEY, returnUrl);
+      }
       this.authService.loginWithGoogle();
     } catch (error: unknown) {
       this.serverErrorState.set(this.resolveErrorMessage(error));
@@ -127,8 +136,16 @@ export class LoginPageComponent {
   }
 
   protected redirectToHome(): void {
-    const homeUrl = this.router.serializeUrl(this.router.createUrlTree(['/']));
-    this.document.location.assign(homeUrl);
+    const requestedUrl =
+      this.route.snapshot.queryParamMap.get('returnUrl') ??
+      this.document.defaultView?.sessionStorage.getItem(POST_LOGIN_RETURN_URL_KEY);
+    const destination =
+      requestedUrl?.startsWith('/') && !requestedUrl.startsWith('//')
+        ? requestedUrl
+        : this.router.serializeUrl(this.router.createUrlTree(['/']));
+
+    this.document.defaultView?.sessionStorage.removeItem(POST_LOGIN_RETURN_URL_KEY);
+    this.document.location.assign(destination);
   }
 
   private completeGoogleLogin(oauthCode: string): void {

src/app/features/store/pages/product-detail-page/product-detail-page.component.html

@@ -35,6 +35,31 @@
             </div>
           </section>
 
+          @if (hasEventDates()) {
+            <div class="product-detail__divider"></div>
+
+            <section class="product-detail__section product-detail__section--event-date">
+              <label class="form-label" for="event-date-selector">Fecha</label>
+              <select
+                id="event-date-selector"
+                class="form-select"
+                [value]="selectedVariant()?.id ?? ''"
+                (change)="onEventDateChange($event)"
+              >
+                @for (eventDate of eventDates(); track eventDate.id) {
+                  <option
+                    [value]="eventDate.variant_id"
+                    [disabled]="
+                      prod.inventory_policy !== 'unlimited' && (eventDate.stock_tecnico ?? 0) <= 0
+                    "
+                  >
+                    {{ eventDate.label }}
+                  </option>
+                }
+              </select>
+            </section>
+          }
+
           @if (hasRenderableAttributes()) {
             <div class="product-detail__divider"></div>
 
@@ -73,9 +98,12 @@
                 <app-button
                   class="product-detail__cta"
                   type="button"
-                  [disabled]="!selectedVariantAvailable() || variantLoading()"
+                  [disabled]="
+                    !selectedVariantAvailable() || variantLoading() || creatingDirectPurchase()
+                  "
+                  (click)="buyNow()"
                 >
-                  @if (variantLoading()) {
+                  @if (variantLoading() || creatingDirectPurchase()) {
                     <div class="spinner-border spinner-border-sm" role="status"></div>
                   } @else {
                     Comprar

src/app/features/store/pages/product-detail-page/product-detail-page.component.spec.ts

@@ -1,4 +1,5 @@
 import { TestBed, getTestBed } from '@angular/core/testing';
+import { signal } from '@angular/core';
 import { BrowserTestingModule, platformBrowserTesting } from '@angular/platform-browser/testing';
 import { ActivatedRoute, Router } from '@angular/router';
 import { By } from '@angular/platform-browser';
@@ -10,6 +11,9 @@ import { CatalogService } from '../../../../core/services/catalog/catalog.servic
 import { CartService } from '../../../../core/services/cart/cart.service';
 import { ToastService } from '../../../../core/services/toast.service';
 import { ProductDetailPageComponent } from './product-detail-page.component';
+import { CheckoutService } from '../../../../core/services/checkout.service';
+import { TenantService } from '../../../../core/services/tenant.service';
+import { AuthService } from '../../../../core/services/auth/auth.service';
 import {
   PRODUCT_DETAIL_ERROR_MESSAGE,
   ProductDetailResolvedData,
@@ -41,6 +45,7 @@ describe('ProductDetailPageComponent', () => {
   let routerStub: any;
   let cartServiceStub: any;
   let toastServiceStub: any;
+  let checkoutServiceStub: any;
 
   beforeAll(() => {
     try {
@@ -60,18 +65,25 @@ describe('ProductDetailPageComponent', () => {
     });
     catalogServiceStub = {
       getCatalogItem: vi.fn(),
+      withCustomLoading: vi.fn(),
     };
+    catalogServiceStub.withCustomLoading.mockReturnValue(catalogServiceStub);
     routerStub = {
       navigate: vi.fn(),
     };
     cartServiceStub = {
       addItem: vi.fn().mockReturnValue(of({ message: 'Producto agregado al carrito' })),
+      withCustomLoading: vi.fn(),
     };
+    cartServiceStub.withCustomLoading.mockReturnValue(cartServiceStub);
     toastServiceStub = {
       success: vi.fn(),
       danger: vi.fn(),
       info: vi.fn(),
     };
+    checkoutServiceStub = {
+      startCheckout: vi.fn().mockResolvedValue({ id: 44 }),
+    };
   });
 
   async function configureTestingModule() {
@@ -100,6 +112,26 @@ describe('ProductDetailPageComponent', () => {
           provide: ToastService,
           useValue: toastServiceStub,
         },
+        {
+          provide: CheckoutService,
+          useValue: checkoutServiceStub,
+        },
+        {
+          provide: TenantService,
+          useValue: { tenant: signal({ codigo: 'tenant-test' }) },
+        },
+        {
+          provide: AuthService,
+          useValue: {
+            user: signal({
+              id: 7,
+              nombre_apellido: 'Juan Perez',
+              email: 'juan@example.com',
+              dni: '12345678',
+              telefono: '3415555555',
+            }),
+          },
+        },
       ],
     }).compileComponents();
   }
@@ -295,6 +327,63 @@ describe('ProductDetailPageComponent', () => {
     expect((swatches[0] as HTMLElement).style.backgroundColor).not.toBe('');
   });
 
+  it('renders event dates and resolves the selected date through its variant', async () => {
+    const detailProduct: CatalogItemDetail = {
+      ...mockProduct,
+      purpose: 'entry',
+      has_tickets: true,
+      variants: [
+        { id: 101, event_date_id: 20, stock_tecnico: 10, values: {} },
+        { id: 102, event_date_id: 21, stock_tecnico: 10, values: {} },
+      ],
+      event_dates: [
+        {
+          id: 20,
+          variant_id: 101,
+          date: '2026-10-09',
+          starts_at: '2026-10-09T10:00:00.000000Z',
+          ends_at: '2026-10-09T20:00:00.000000Z',
+          label: 'Viernes 9 de octubre - 10:00 a 20:00',
+          stock_tecnico: 10,
+        },
+        {
+          id: 21,
+          variant_id: 102,
+          date: '2026-10-10',
+          starts_at: '2026-10-10T10:00:00.000000Z',
+          ends_at: '2026-10-10T20:00:00.000000Z',
+          label: 'Sábado 10 de octubre - 10:00 a 20:00',
+          stock_tecnico: 10,
+        },
+      ],
+      selected_variant: {
+        id: 101,
+        event_date_id: 20,
+        stock_tecnico: 10,
+        images: [],
+        values: {},
+      },
+    };
+    resolveProduct(detailProduct);
+    catalogServiceStub.getCatalogItem.mockReturnValue(
+      of({ ...detailProduct, selected_variant: { ...detailProduct.selected_variant!, id: 102 } }),
+    );
+
+    await configureTestingModule();
+    const fixture = TestBed.createComponent(ProductDetailPageComponent);
+    fixture.detectChanges();
+
+    const select = fixture.nativeElement.querySelector('#event-date-selector') as HTMLSelectElement;
+    expect(select.options).toHaveLength(2);
+    expect(select.value).toBe('101');
+
+    select.value = '102';
+    select.dispatchEvent(new Event('change'));
+    fixture.detectChanges();
+
+    expect(catalogServiceStub.getCatalogItem).toHaveBeenCalledWith(1, 102);
+  });
+
   it('hides the attributes block and its extra divider when no attributes are present', async () => {
     await configureTestingModule();
     const fixture = TestBed.createComponent(ProductDetailPageComponent);
@@ -364,7 +453,7 @@ describe('ProductDetailPageComponent', () => {
     expect(toggleButton.textContent?.trim()).toBe('Mostrar menos');
   });
 
-  it('renders purchase actions without side effects', async () => {
+  it('renders purchase actions and starts a direct checkout', async () => {
     await configureTestingModule();
     const fixture = TestBed.createComponent(ProductDetailPageComponent);
     fixture.detectChanges();
@@ -380,8 +469,18 @@ describe('ProductDetailPageComponent', () => {
 
     buttons[0].click();
     buttons[1].click();
+    await Promise.resolve();
 
-    expect(routerStub.navigate).not.toHaveBeenCalled();
+    expect(checkoutServiceStub.startCheckout).toHaveBeenCalledWith('tenant-test', {
+      direct_item: {
+        catalog_item_id: 1,
+        variant_id: null,
+        cantidad: 1,
+      },
+    });
+    expect(routerStub.navigate).toHaveBeenCalledWith(['/checkout'], {
+      queryParams: { purchase: 44 },
+    });
   });
 
   it('calls CartService.addItem when variant is selected and Add to Cart is clicked', async () => {

src/app/features/store/pages/product-detail-page/product-detail-page.component.ts

@@ -28,6 +28,9 @@ import { ButtonComponent } from '../../../../shared/components/button/button.com
 import { ProductAttributeSelectorComponent } from '../../components/product-attribute-selector/product-attribute-selector.component';
 import { QuantitySelectorComponent } from '../../../../shared/components/quantity-selector/quantity-selector.component';
 import { ProductDetailResolvedData } from './product-detail-page.resolver';
+import { CheckoutService } from '../../../../core/services/checkout.service';
+import { TenantService } from '../../../../core/services/tenant.service';
+import { AuthService } from '../../../../core/services/auth/auth.service';
 
 @Component({
   selector: 'app-product-detail-page',
@@ -50,6 +53,9 @@ export class ProductDetailPageComponent implements OnInit, OnDestroy {
   private readonly catalogService = inject(CatalogService);
   private readonly toastService = inject(ToastService);
   private readonly cartService = inject(CartService);
+  private readonly checkoutService = inject(CheckoutService);
+  private readonly tenantService = inject(TenantService);
+  private readonly authService = inject(AuthService);
   private readonly attributeSelector = viewChild(ProductAttributeSelectorComponent);
   private readonly carouselHost = viewChild<ElementRef<HTMLElement>>('carouselHost');
   private readonly descriptionBody = viewChild<ElementRef<HTMLElement>>('descriptionBody');
@@ -77,6 +83,7 @@ export class ProductDetailPageComponent implements OnInit, OnDestroy {
   protected readonly loading = signal(false);
   protected readonly variantLoading = signal(false);
   protected readonly addingToCart = signal(false);
+  protected readonly creatingDirectPurchase = signal(false);
   protected readonly error = signal<string | null>(null);
   protected readonly selectedVariant = signal<CatalogItemVariant | null>(null);
   protected readonly quantity = signal(1);
@@ -93,6 +100,7 @@ export class ProductDetailPageComponent implements OnInit, OnDestroy {
 
     const variant = this.selectedVariant();
     if (variant) return this.isVariantAvailable(variant, prod);
+    if (prod.purpose === 'entry') return false;
     if (prod.variants.length > 0) return false;
 
     return prod.inventory_policy === 'unlimited' || (prod.stock_tecnico ?? 0) > 0;
@@ -101,8 +109,14 @@ export class ProductDetailPageComponent implements OnInit, OnDestroy {
   protected readonly descriptionMaxHeight = signal(0);
   protected readonly descriptionHasOverflow = signal(false);
   protected readonly renderableAttributes = computed(() =>
-    (this.product()?.attributes ?? []).filter((attribute) => attribute.options.length > 0),
+    (this.product()?.attributes ?? []).filter(
+      (attribute) =>
+        attribute.options.length > 0 &&
+        !(this.product()?.purpose === 'entry' && attribute.codigo === 'fecha'),
+    ),
   );
+  protected readonly eventDates = computed(() => this.product()?.event_dates ?? []);
+  protected readonly hasEventDates = computed(() => this.eventDates().length > 0);
   protected readonly hasRenderableAttributes = computed(
     () => this.renderableAttributes().length > 0,
   );
@@ -148,27 +162,30 @@ export class ProductDetailPageComponent implements OnInit, OnDestroy {
     this.variantLoading.set(true);
 
     this.productSub?.unsubscribe();
-    this.productSub = this.catalogService.getCatalogItem(productId, variantId).subscribe({
-      next: (prod) => {
-        this.applyProduct(prod, false);
-        this.variantLoading.set(false);
-      },
-      error: (err: HttpErrorResponse) => {
-        const errorMessage = err.error?.message || 'No pudimos cargar la variante seleccionada.';
-        this.toastService.danger(errorMessage);
-        this.variantLoading.set(false);
+    this.productSub = this.catalogService
+      .withCustomLoading()
+      .getCatalogItem(productId, variantId)
+      .subscribe({
+        next: (prod) => {
+          this.applyProduct(prod, false);
+          this.variantLoading.set(false);
+        },
+        error: (err: HttpErrorResponse) => {
+          const errorMessage = err.error?.message || 'No pudimos cargar la variante seleccionada.';
+          this.toastService.danger(errorMessage);
+          this.variantLoading.set(false);
 
-        this.product.update((currentProduct) => {
-          if (!currentProduct) return null;
-          return {
-            ...currentProduct,
-            variants: currentProduct.variants.filter((variant) => variant.id !== variantId),
-          };
-        });
+          this.product.update((currentProduct) => {
+            if (!currentProduct) return null;
+            return {
+              ...currentProduct,
+              variants: currentProduct.variants.filter((variant) => variant.id !== variantId),
+            };
+          });
 
-        this.attributeSelector()?.reset();
-      },
-    });
+          this.attributeSelector()?.reset();
+        },
+      });
   }
 
   private applyResolvedData(resolvedData: ProductDetailResolvedData): void {
@@ -230,6 +247,12 @@ export class ProductDetailPageComponent implements OnInit, OnDestroy {
     }
   }
 
+  protected onEventDateChange(event: Event): void {
+    const variantId = Number((event.target as HTMLSelectElement).value);
+    const variant = this.product()?.variants.find((item) => item.id === variantId) ?? null;
+    this.onVariantChange(variant);
+  }
+
   protected addToCart(): void {
     const currentProduct = this.product();
     const variant = this.selectedVariant();
@@ -239,18 +262,70 @@ export class ProductDetailPageComponent implements OnInit, OnDestroy {
     }
 
     this.addingToCart.set(true);
-    this.cartService.addItem(currentProduct.id, variant?.id ?? null, this.quantity()).subscribe({
-      next: (res) => {
-        const msg = res.message || 'Producto agregado al carrito';
-        this.toastService.success(msg);
-        this.addingToCart.set(false);
-      },
-      error: (err: HttpErrorResponse) => {
-        const errorMessage = err.error?.message || 'No se pudo agregar el producto al carrito.';
-        this.toastService.danger(errorMessage);
-        this.addingToCart.set(false);
-      },
-    });
+    this.cartService
+      .withCustomLoading()
+      .addItem(currentProduct.id, variant?.id ?? null, this.quantity())
+      .subscribe({
+        next: (res) => {
+          const msg = res.message || 'Producto agregado al carrito';
+          this.toastService.success(msg);
+          this.addingToCart.set(false);
+        },
+        error: (err: HttpErrorResponse) => {
+          const errorMessage = err.error?.message || 'No se pudo agregar el producto al carrito.';
+          this.toastService.danger(errorMessage);
+          this.addingToCart.set(false);
+        },
+      });
+  }
+
+  protected async buyNow(): Promise<void> {
+    const currentProduct = this.product();
+    const variant = this.selectedVariant();
+
+    if (this.creatingDirectPurchase()) {
+      return;
+    }
+
+    if (!currentProduct || !this.selectedVariantAvailable()) {
+      this.toastService.danger('Por favor, selecciona una variante.');
+      return;
+    }
+
+    const tenant = this.tenantService.tenant();
+    const user = this.authService.user();
+
+    if (!user) {
+      void this.router.navigate(['/login'], {
+        queryParams: { returnUrl: `/producto/${currentProduct.id}` },
+      });
+      return;
+    }
+
+    if (!tenant) {
+      this.toastService.danger('No se pudo identificar la tienda.');
+      return;
+    }
+
+    this.creatingDirectPurchase.set(true);
+    try {
+      const purchase = await this.checkoutService.startCheckout(tenant.codigo, {
+        direct_item: {
+          catalog_item_id: currentProduct.id,
+          variant_id: variant?.id ?? null,
+          cantidad: this.quantity(),
+        },
+      });
+
+      await this.router.navigate(['/checkout'], {
+        queryParams: { purchase: purchase.id },
+      });
+    } catch (error) {
+      console.error('Failed to create direct purchase:', error);
+      this.toastService.danger('No se pudo iniciar la compra directa.');
+    } finally {
+      this.creatingDirectPurchase.set(false);
+    }
   }
 
   private isVariantAvailable(variant: CatalogItemVariant, product: CatalogItemDetail): boolean {

src/app/features/store/pages/purchase-status-page/purchase-status-page.component.html

@@ -16,18 +16,34 @@
     <hr class="status-content__divider" />
 
     <div class="status-content__section status-content__section--secondary">
-      <p class="status-content__message">Comunicate con nosotros para coordinar el env&iacute;o.</p>
+      @if (ticketsRoute()) {
+        <p class="status-content__message">A continuación, vas a poder ver los tickets que debés presentar en el evento.</p>
 
-      <app-button
-        type="button"
-        variant="secondary"
-        hostClass="status-content__button d-block"
-        buttonClass="status-content__button-control d-inline-flex align-items-center justify-content-center gap-2 py-2"
-        (click)="openWhatsApp()"
-      >
-        <i class="fa-brands fa-whatsapp status-content__button-icon"></i>
-        <span>WhatsApp</span>
-      </app-button>
+        <app-button
+          type="button"
+          variant="primary"
+          hostClass="status-content__button d-block"
+          buttonClass="status-content__button-control d-inline-flex align-items-center justify-content-center gap-2 py-2"
+          (click)="goToTickets()"
+        >
+          <span>Mis tickets</span>
+        </app-button>
+      } @else if (whatsappUrl()) {
+        <p class="status-content__message">Comunicate con nosotros para coordinar el env&iacute;o.</p>
+
+        <app-button
+          type="button"
+          variant="secondary"
+          hostClass="status-content__button d-block"
+          buttonClass="status-content__button-control d-inline-flex align-items-center justify-content-center gap-2 py-2"
+          (click)="openWhatsApp()"
+        >
+          <i class="fa-brands fa-whatsapp status-content__button-icon"></i>
+          <span>WhatsApp</span>
+        </app-button>
+      } @else {
+        <p class="status-content__message">Tu compra qued&oacute; registrada correctamente.</p>
+      }
     </div>
   } @else if (status() === 'pending') {
     <div class="status-content__section status-content__section--primary">
@@ -41,21 +57,21 @@
     <hr class="status-content__divider" />
 
     <div class="status-content__section status-content__section--secondary">
-      <p class="status-content__message">Esta pantalla se actualiza autom&aacute;ticamente cuando el pago impacta.</p>
-      @if (isRefreshing()) {
-        <p class="status-content__hint">Actualizando estado...</p>
-      }
+      <p class="status-content__message">Te avisaremos cuando el pago sea confirmado.</p>
+    </div>
+  } @else if (status() === 'expired') {
+    <div class="status-content__section status-content__section--primary">
+      <div class="status-content__icon status-content__icon--warning">
+        <i class="fa-solid fa-clock"></i>
+      </div>
+      <h2 class="status-content__title">LA COMPRA VENCI&Oacute;</h2>
+      <p class="status-content__subtitle">El plazo de pago termin&oacute; y liberamos el stock reservado.</p>
+    </div>
 
-      <app-button
-        type="button"
-        variant="secondary"
-        hostClass="status-content__button d-block"
-        buttonClass="status-content__button-control d-inline-flex align-items-center justify-content-center py-2"
-        [disabled]="isRefreshing()"
-        (click)="retryStatusCheck()"
-      >
-        Actualizar estado
-      </app-button>
+    <hr class="status-content__divider" />
+
+    <div class="status-content__section status-content__section--secondary">
+      <p class="status-content__message">Pod&eacute;s volver a la tienda e iniciar una nueva compra.</p>
     </div>
   } @else if (status() === 'rejected') {
     <div class="status-content__section status-content__section--primary">
@@ -69,30 +85,22 @@
     <hr class="status-content__divider" />
 
     <div class="status-content__section status-content__section--secondary">
-      <p class="status-content__message">Si ya pagaste, pod&eacute;s reintentar la consulta o escribirnos para revisarlo.</p>
+      <p class="status-content__message">Si ya pagaste, escribinos para que podamos revisarlo.</p>
 
-      <div class="status-content__actions">
-        <app-button
-          type="button"
-          variant="secondary"
-          hostClass="status-content__button d-block"
-          buttonClass="status-content__button-control d-inline-flex align-items-center justify-content-center py-2"
-          (click)="retryStatusCheck()"
-        >
-          Reintentar
-        </app-button>
-
-        <app-button
-          type="button"
-          variant="secondary"
-          hostClass="status-content__button d-block"
-          buttonClass="status-content__button-control d-inline-flex align-items-center justify-content-center gap-2 py-2"
-          (click)="openWhatsApp()"
-        >
-          <i class="fa-brands fa-whatsapp status-content__button-icon"></i>
-          <span>WhatsApp</span>
-        </app-button>
-      </div>
+      @if (whatsappUrl()) {
+        <div class="status-content__actions">
+          <app-button
+            type="button"
+            variant="secondary"
+            hostClass="status-content__button d-block"
+            buttonClass="status-content__button-control d-inline-flex align-items-center justify-content-center gap-2 py-2"
+            (click)="openWhatsApp()"
+          >
+            <i class="fa-brands fa-whatsapp status-content__button-icon"></i>
+            <span>WhatsApp</span>
+          </app-button>
+        </div>
+      }
     </div>
   } @else {
     <div class="status-content__section status-content__section--primary">
@@ -106,30 +114,22 @@
     <hr class="status-content__divider" />
 
     <div class="status-content__section status-content__section--secondary">
-      <p class="status-content__message">Reintent&aacute; en unos segundos. Si el problema sigue, comunicate con nosotros.</p>
+      <p class="status-content__message">Volv&eacute; a ingresar m&aacute;s tarde. Si el problema sigue, comunicate con nosotros.</p>
 
-      <div class="status-content__actions">
-        <app-button
-          type="button"
-          variant="secondary"
-          hostClass="status-content__button d-block"
-          buttonClass="status-content__button-control d-inline-flex align-items-center justify-content-center py-2"
-          (click)="retryStatusCheck()"
-        >
-          Reintentar
-        </app-button>
-
-        <app-button
-          type="button"
-          variant="secondary"
-          hostClass="status-content__button d-block"
-          buttonClass="status-content__button-control d-inline-flex align-items-center justify-content-center gap-2 py-2"
-          (click)="openWhatsApp()"
-        >
-          <i class="fa-brands fa-whatsapp status-content__button-icon"></i>
-          <span>WhatsApp</span>
-        </app-button>
-      </div>
+      @if (whatsappUrl()) {
+        <div class="status-content__actions">
+          <app-button
+            type="button"
+            variant="secondary"
+            hostClass="status-content__button d-block"
+            buttonClass="status-content__button-control d-inline-flex align-items-center justify-content-center gap-2 py-2"
+            (click)="openWhatsApp()"
+          >
+            <i class="fa-brands fa-whatsapp status-content__button-icon"></i>
+            <span>WhatsApp</span>
+          </app-button>
+        </div>
+      }
     </div>
   }
 </div>

src/app/features/store/pages/purchase-status-page/purchase-status-page.component.scss

@@ -98,7 +98,7 @@
     font-size: 13px;
     font-weight: 325;
     line-height: 1.45;
-    color: var(--color-text);
+    color: #666666;
   }
 
   &__hint {

src/app/features/store/pages/purchase-status-page/purchase-status-page.component.spec.ts

@@ -0,0 +1,133 @@
+import { TestBed } from '@angular/core/testing';
+import { ActivatedRoute, convertToParamMap, Router } from '@angular/router';
+
+import { CheckoutService, PurchaseDetailResponse } from '../../../../core/services/checkout.service';
+import { Tenant } from '../../../../core/services/tenant.interface';
+import { TenantService } from '../../../../core/services/tenant.service';
+import { PurchaseStatusPageComponent } from './purchase-status-page.component';
+
+const tenant: Tenant = {
+  id: 1,
+  codigo: 'tickets-tenant',
+  nombre: 'Tickets tenant',
+  dominio: 'tickets.local',
+  primary_color: '#000000',
+  secondary_color: '#000000',
+  danger_color: '#000000',
+  success_color: '#000000',
+  header_bg_color: '#000000',
+  footer_bg_color: '#000000',
+  header_logo: '',
+  footer_logo: '',
+  categories: [],
+  social_media: [
+    {
+      code: 'whatsapp',
+      icon: 'whatsapp',
+      name: 'WhatsApp',
+      url: 'https://wa.me/543411234567',
+    },
+  ],
+  menues: [
+    {
+      id: 1,
+      code: 'account',
+      label: 'Mi cuenta',
+      parent_menu_code: null,
+      content_type: 'dynamic',
+      route: '/mi-cuenta',
+      submenues: [
+        {
+          id: 2,
+          code: 'account.tickets',
+          label: 'Mis tickets',
+          parent_menu_code: 'account',
+          content_type: 'dynamic',
+          route: '/mi-cuenta/tickets',
+          submenues: [],
+        },
+      ],
+    },
+  ],
+};
+
+const purchase = (hasGeneratedTickets: boolean): PurchaseDetailResponse =>
+  ({
+    status: 'paid',
+    has_generated_tickets: hasGeneratedTickets,
+    tickets_count: hasGeneratedTickets ? 1 : 0,
+  }) as PurchaseDetailResponse;
+
+describe('PurchaseStatusPageComponent', () => {
+  beforeEach(() => {
+    TestBed.resetTestingModule();
+  });
+
+  async function render(hasGeneratedTickets: boolean) {
+    const checkoutService = {
+      getPurchase: vi.fn().mockResolvedValue(purchase(hasGeneratedTickets)),
+      withCustomLoading() {
+        return this;
+      },
+    };
+    const router = {
+      navigate: vi.fn().mockResolvedValue(true),
+      navigateByUrl: vi.fn().mockResolvedValue(true),
+    };
+
+    await TestBed.configureTestingModule({
+      imports: [PurchaseStatusPageComponent],
+      providers: [
+        { provide: CheckoutService, useValue: checkoutService },
+        { provide: TenantService, useValue: { tenant: () => tenant } },
+        {
+          provide: ActivatedRoute,
+          useValue: { snapshot: { paramMap: convertToParamMap({ id: '42' }) } },
+        },
+        { provide: Router, useValue: router },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(PurchaseStatusPageComponent);
+    fixture.detectChanges();
+    await fixture.whenStable();
+    fixture.detectChanges();
+
+    return {
+      fixture,
+      element: fixture.nativeElement as HTMLElement,
+      checkoutService,
+      router,
+    };
+  }
+
+  it('shows the tickets action when this purchase generated tickets', async () => {
+    const { element, checkoutService, router } = await render(true);
+
+    expect(checkoutService.getPurchase).toHaveBeenCalledOnce();
+    expect(element.textContent).toContain('Ver mis tickets');
+    expect(element.textContent).not.toContain('WhatsApp');
+
+    element.querySelector<HTMLButtonElement>('app-button button')?.click();
+
+    expect(router.navigateByUrl).toHaveBeenCalledWith('/mi-cuenta/tickets');
+  });
+
+  it('shows the tenant WhatsApp action when this purchase did not generate tickets', async () => {
+    const openSpy = vi.spyOn(window, 'open').mockImplementation(() => null);
+    const { element } = await render(false);
+
+    expect(element.textContent).toContain('WhatsApp');
+    expect(element.textContent).not.toContain('Ver mis tickets');
+
+    element.querySelector<HTMLButtonElement>('app-button button')?.click();
+
+    expect(openSpy).toHaveBeenCalledWith(
+      'https://wa.me/543411234567',
+      '_blank',
+      'noopener,noreferrer',
+    );
+
+    openSpy.mockRestore();
+  });
+});

src/app/features/store/pages/purchase-status-page/purchase-status-page.component.ts

@@ -1,11 +1,12 @@
-import { ChangeDetectionStrategy, Component, OnDestroy, OnInit, inject, signal } from '@angular/core';
+import { ChangeDetectionStrategy, Component, OnInit, computed, inject, signal } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
 
 import { CheckoutService, PurchaseStatusResponse } from '../../../../core/services/checkout.service';
+import { findMenu } from '../../../../core/services/menu.utils';
 import { TenantService } from '../../../../core/services/tenant.service';
 import { ButtonComponent } from '../../../../shared/components/button/button.component';
 
-type PurchaseStatusView = 'approved' | 'pending' | 'rejected' | 'error';
+type PurchaseStatusView = 'approved' | 'pending' | 'rejected' | 'expired' | 'error';
 
 @Component({
   selector: 'app-purchase-status-page',
@@ -15,20 +16,31 @@ type PurchaseStatusView = 'approved' | 'pending' | 'rejected' | 'error';
   styleUrl: './purchase-status-page.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush
 })
-export class PurchaseStatusPageComponent implements OnInit, OnDestroy {
+export class PurchaseStatusPageComponent implements OnInit {
   private readonly route = inject(ActivatedRoute);
   private readonly router = inject(Router);
   private readonly checkoutService = inject(CheckoutService);
   private readonly tenantService = inject(TenantService);
 
-  private readonly pollIntervalMs = 5000;
   private purchaseId: string | null = null;
   private tenantCode: string | null = null;
-  private pollTimeoutId: ReturnType<typeof setTimeout> | null = null;
 
   protected readonly isLoading = signal(true);
-  protected readonly isRefreshing = signal(false);
   protected readonly status = signal<PurchaseStatusView>('pending');
+  protected readonly hasGeneratedTickets = signal(false);
+  protected readonly ticketsRoute = computed(() => {
+    if (!this.hasGeneratedTickets()) {
+      return null;
+    }
+
+    return findMenu(this.tenantService.tenant()?.menues ?? [], 'account.tickets')?.route ?? null;
+  });
+  protected readonly whatsappUrl = computed(
+    () =>
+      this.tenantService
+        .tenant()
+        ?.social_media?.find((socialMedia) => socialMedia.code === 'whatsapp')?.url ?? null,
+  );
 
   ngOnInit(): void {
     const purchaseId = this.route.snapshot.paramMap.get('id');
@@ -42,45 +54,25 @@ export class PurchaseStatusPageComponent implements OnInit, OnDestroy {
     this.purchaseId = purchaseId;
     this.tenantCode = tenant.codigo;
 
-    void this.refreshStatus(true);
+    void this.loadStatus();
   }
 
-  ngOnDestroy(): void {
-    this.clearScheduledPoll();
-  }
-
-  protected retryStatusCheck(): void {
-    void this.refreshStatus(false);
-  }
-
-  private async refreshStatus(showLoader: boolean): Promise<void> {
+  private async loadStatus(): Promise<void> {
     if (!this.purchaseId || !this.tenantCode) {
       return;
     }
 
-    this.clearScheduledPoll();
-
-    if (showLoader) {
-      this.isLoading.set(true);
-    } else {
-      this.isRefreshing.set(true);
-    }
-
     try {
-      const purchase = await this.checkoutService.getPurchase(this.tenantCode, this.purchaseId);
-      const resolvedStatus = this.resolveStatus(purchase);
-
-      this.status.set(resolvedStatus);
-
-      if (resolvedStatus === 'pending') {
-        this.scheduleNextPoll();
-      }
+      const purchase = await this.checkoutService
+        .withCustomLoading()
+        .getPurchase(this.tenantCode, this.purchaseId);
+      this.status.set(this.resolveStatus(purchase));
+      this.hasGeneratedTickets.set(purchase.has_generated_tickets === true);
     } catch (error) {
       console.error('Failed to fetch purchase status:', error);
       this.status.set('error');
     } finally {
       this.isLoading.set(false);
-      this.isRefreshing.set(false);
     }
   }
 
@@ -93,36 +85,26 @@ export class PurchaseStatusPageComponent implements OnInit, OnDestroy {
       return 'rejected';
     }
 
+    if (purchase.status === 'expired') {
+      return 'expired';
+    }
+
     return 'pending';
   }
 
-  private scheduleNextPoll(): void {
-    if (this.pollTimeoutId !== null) {
-      return;
+  protected goToTickets(): void {
+    const route = this.ticketsRoute();
+
+    if (route) {
+      void this.router.navigateByUrl(route);
     }
-
-    this.pollTimeoutId = setTimeout(() => {
-      this.pollTimeoutId = null;
-      void this.refreshStatus(false);
-    }, this.pollIntervalMs);
-  }
-
-  private clearScheduledPoll(): void {
-    if (this.pollTimeoutId === null) {
-      return;
-    }
-
-    clearTimeout(this.pollTimeoutId);
-    this.pollTimeoutId = null;
-  }
-
-  protected getWhatsAppLink(): string {
-    const phone = '5493416658247';
-    const message = encodeURIComponent('Hola! Mi compra fue realizada con \u00E9xito.');
-    return `https://wa.me/${phone}?text=${message}`;
   }
 
   protected openWhatsApp(): void {
-    window.open(this.getWhatsAppLink(), '_blank', 'noopener,noreferrer');
+    const url = this.whatsappUrl();
+
+    if (url) {
+      window.open(url, '_blank', 'noopener,noreferrer');
+    }
   }
 }

src/app/features/store/pages/recover-password-code-page/recover-password-code-page.component.html

@@ -0,0 +1,106 @@
+<header class="recover-password-code-page__header text-center mb-4">
+  <h1 id="recover-password-code-title" class="auth-title mb-4">Ingresá el código</h1>
+  <p class="recover-password-code-page__description mb-0">
+    Te enviamos un código a <strong>{{ email }}</strong>
+  </p>
+  <p class="recover-password-code-page__description fst-italic mb-0">
+    Recordá revisar en Correo no deseado.
+  </p>
+</header>
+
+<form
+  class="recover-password-code-page__form d-grid gap-4"
+  novalidate
+  aria-labelledby="recover-password-code-title"
+  [formGroup]="form"
+  (ngSubmit)="onSubmit()"
+>
+  <div>
+    <fieldset class="border-0 p-0 m-0">
+      <legend class="visually-hidden">Código de recuperación de cuatro dígitos</legend>
+      <div class="recover-password-code-page__inputs d-flex justify-content-center gap-2">
+        <app-input
+          id="recover-password-code-digit-1"
+          type="text"
+          [maxlength]="1"
+          [value]="form.controls.digit1.value"
+          [invalid]="isCodeInvalid()"
+          (valueChange)="updateDigit('digit1', $event)"
+          (pasteEvent)="pasteCode($event)"
+        />
+        <app-input
+          id="recover-password-code-digit-2"
+          type="text"
+          [maxlength]="1"
+          [value]="form.controls.digit2.value"
+          [invalid]="isCodeInvalid()"
+          (valueChange)="updateDigit('digit2', $event)"
+          (pasteEvent)="pasteCode($event)"
+        />
+        <app-input
+          id="recover-password-code-digit-3"
+          type="text"
+          [maxlength]="1"
+          [value]="form.controls.digit3.value"
+          [invalid]="isCodeInvalid()"
+          (valueChange)="updateDigit('digit3', $event)"
+          (pasteEvent)="pasteCode($event)"
+        />
+        <app-input
+          id="recover-password-code-digit-4"
+          type="text"
+          [maxlength]="1"
+          [value]="form.controls.digit4.value"
+          [invalid]="isCodeInvalid()"
+          (valueChange)="updateDigit('digit4', $event)"
+          (pasteEvent)="pasteCode($event)"
+        />
+      </div>
+    </fieldset>
+
+    @if (isCodeInvalid()) {
+      <small class="text-danger d-block text-center mt-2">
+        Ingresá los cuatro dígitos del código.
+      </small>
+    }
+
+    @if (serverError(); as errorMessage) {
+      <small class="text-danger d-block text-center mt-2" role="alert">
+        {{ errorMessage }}
+      </small>
+    }
+
+    <div class="text-center">
+      <app-button
+        type="button"
+        variant="borderless"
+        buttonClass="recover-password-code-page__resend-action px-3 py-2"
+        [disabled]="isResending()"
+        (click)="resendCode()"
+      >
+        {{ isResending() ? 'Reenviando...' : 'Reenviar Código' }}
+      </app-button>
+    </div>
+  </div>
+
+  <div class="d-grid gap-2 text-center">
+    <app-button
+      type="submit"
+      hostClass="w-100 d-block"
+      buttonClass="w-100"
+      [disabled]="isSubmitting()"
+    >
+      {{ isSubmitting() ? 'Validando...' : 'Validar' }}
+    </app-button>
+
+    <app-button
+      type="button"
+      variant="borderless"
+      hostClass="w-100 d-block text-center"
+      buttonClass="recover-password-code-page__back-action px-3 py-2"
+      (click)="goBack()"
+    >
+      Volver
+    </app-button>
+  </div>
+</form>

src/app/features/store/pages/recover-password-code-page/recover-password-code-page.component.scss

@@ -0,0 +1,65 @@
+:host {
+  display: block;
+}
+
+.recover-password-code-page__description {
+  color: #a0a0a0;
+  font-size: 12px;
+  font-weight: 325;
+}
+
+.recover-password-code-page__form {
+  width: 100%;
+}
+
+.recover-password-code-page__inputs app-input {
+  width: 52px;
+}
+
+:host ::ng-deep .recover-password-code-page__inputs .form-control {
+  min-height: 52px;
+  padding: 0.5rem;
+  text-align: center;
+  font-size: 20px;
+}
+
+:host ::ng-deep .recover-password-code-page__resend-action {
+  min-height: 36px;
+  color: #a0a0a0 !important;
+  font-size: 12px !important;
+  font-weight: 400 !important;
+  transition:
+    color 0.15s ease,
+    transform 0.1s ease;
+}
+
+:host ::ng-deep .recover-password-code-page__resend-action:hover,
+:host ::ng-deep .recover-password-code-page__resend-action:focus-visible {
+  color: #8a8a8a !important;
+}
+
+:host ::ng-deep .recover-password-code-page__resend-action:hover {
+  transform: translateY(-1px);
+}
+
+:host ::ng-deep .recover-password-code-page__resend-action:active {
+  color: #666666 !important;
+  transform: translateY(1px);
+}
+
+:host ::ng-deep .recover-password-code-page__back-action {
+  min-height: 40px;
+  transition:
+    color 0.15s ease,
+    transform 0.1s ease;
+}
+
+:host ::ng-deep .recover-password-code-page__back-action:hover,
+:host ::ng-deep .recover-password-code-page__back-action:focus-visible {
+  transform: translateY(-1px);
+}
+
+:host ::ng-deep .recover-password-code-page__back-action:active {
+  opacity: 0.75;
+  transform: translateY(1px);
+}

src/app/features/store/pages/recover-password-code-page/recover-password-code-page.component.spec.ts

@@ -0,0 +1,313 @@
+import { HttpResponse } from '@angular/common/http';
+import { TestBed } from '@angular/core/testing';
+import { ActivatedRoute, convertToParamMap, provideRouter, Router } from '@angular/router';
+import { of, throwError } from 'rxjs';
+
+import { AuthService } from '../../../../core/services/auth/auth.service';
+import { ToastService } from '../../../../core/services/toast.service';
+import { RecoverPasswordCodePageComponent } from './recover-password-code-page.component';
+
+describe('RecoverPasswordCodePageComponent', () => {
+  let validatePasswordResetCode: ReturnType<typeof vi.fn>;
+  let requestPasswordReset: ReturnType<typeof vi.fn>;
+  let showDangerToast: ReturnType<typeof vi.fn>;
+  let showSuccessToast: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    TestBed.resetTestingModule();
+    vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    validatePasswordResetCode = vi.fn(() => of(new HttpResponse({
+      body: {
+        message: 'Código validado correctamente.',
+        status: 'validated' as const,
+      },
+      status: 200,
+    })));
+    requestPasswordReset = vi.fn(() => of(new HttpResponse({
+      body: {
+        message: 'Solicitud aceptada.',
+        status: 'pending' as const,
+      },
+      status: 202,
+    })));
+    showDangerToast = vi.fn();
+    showSuccessToast = vi.fn();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  function authProviders() {
+    return [
+      {
+        provide: AuthService,
+        useValue: { requestPasswordReset, validatePasswordResetCode },
+      },
+      {
+        provide: ToastService,
+        useValue: { danger: showDangerToast, success: showSuccessToast },
+      },
+    ];
+  }
+
+  it('shows the email received from the recovery flow', async () => {
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordCodePageComponent],
+      providers: [
+        provideRouter([]),
+        ...authProviders(),
+        {
+          provide: ActivatedRoute,
+          useValue: {
+            snapshot: {
+              queryParamMap: convertToParamMap({ email: 'ada@example.com' }),
+            },
+          },
+        },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordCodePageComponent);
+    fixture.detectChanges();
+
+    expect(fixture.nativeElement.textContent).toContain('ada@example.com');
+  });
+
+  it('moves focus to the next input after entering a digit', async () => {
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordCodePageComponent],
+      providers: [
+        provideRouter([]),
+        ...authProviders(),
+        {
+          provide: ActivatedRoute,
+          useValue: {
+            snapshot: {
+              queryParamMap: convertToParamMap({ email: 'ada@example.com' }),
+            },
+          },
+        },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordCodePageComponent);
+    const component = fixture.componentInstance as any;
+    fixture.detectChanges();
+    const inputs = fixture.nativeElement.querySelectorAll('input');
+
+    inputs[0].focus();
+    component.updateDigit('digit1', '1');
+
+    expect(document.activeElement).toBe(inputs[1]);
+  });
+
+  it('distributes a pasted four-digit code across all inputs', async () => {
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordCodePageComponent],
+      providers: [
+        provideRouter([]),
+        ...authProviders(),
+        {
+          provide: ActivatedRoute,
+          useValue: {
+            snapshot: {
+              queryParamMap: convertToParamMap({ email: 'ada@example.com' }),
+            },
+          },
+        },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordCodePageComponent);
+    const component = fixture.componentInstance as any;
+    fixture.detectChanges();
+    const inputs = fixture.nativeElement.querySelectorAll('input');
+    const pasteEvent = new Event('paste', {
+      bubbles: true,
+      cancelable: true,
+    });
+    Object.defineProperty(pasteEvent, 'clipboardData', {
+      value: {
+        getData: () => '01 23',
+      },
+    });
+
+    inputs[0].dispatchEvent(pasteEvent);
+    fixture.detectChanges();
+
+    expect(pasteEvent.defaultPrevented).toBe(true);
+    expect(component.form.getRawValue()).toEqual({
+      digit1: '0',
+      digit2: '1',
+      digit3: '2',
+      digit4: '3',
+    });
+    expect(component.form.valid).toBe(true);
+    expect(document.activeElement).toBe(inputs[3]);
+  });
+
+  it('accepts only a complete four-digit code and navigates back preserving the email', async () => {
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordCodePageComponent],
+      providers: [
+        provideRouter([]),
+        ...authProviders(),
+        {
+          provide: ActivatedRoute,
+          useValue: {
+            snapshot: {
+              queryParamMap: convertToParamMap({ email: 'ada@example.com' }),
+            },
+          },
+        },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordCodePageComponent);
+    const component = fixture.componentInstance as any;
+    const router = TestBed.inject(Router);
+    const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+
+    component.updateDigit('digit1', '1');
+    component.updateDigit('digit2', 'a2');
+    component.updateDigit('digit3', '3');
+    component.updateDigit('digit4', '4');
+
+    expect(component.form.getRawValue()).toEqual({
+      digit1: '1',
+      digit2: '2',
+      digit3: '3',
+      digit4: '4',
+    });
+    expect(component.form.valid).toBe(true);
+
+    component.goBack();
+
+    expect(navigateSpy).toHaveBeenCalledWith(['/recuperar-contrasena'], {
+      queryParams: { email: 'ada@example.com' },
+    });
+  });
+
+  it('continues to the reset password page with the email and code', async () => {
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordCodePageComponent],
+      providers: [
+        provideRouter([]),
+        ...authProviders(),
+        {
+          provide: ActivatedRoute,
+          useValue: {
+            snapshot: {
+              queryParamMap: convertToParamMap({ email: 'ada@example.com' }),
+            },
+          },
+        },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordCodePageComponent);
+    const component = fixture.componentInstance as any;
+    const router = TestBed.inject(Router);
+    const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+
+    component.form.setValue({
+      digit1: '1',
+      digit2: '2',
+      digit3: '3',
+      digit4: '4',
+    });
+    component.onSubmit();
+
+    expect(validatePasswordResetCode).toHaveBeenCalledWith('ada@example.com', '1234');
+    expect(navigateSpy).toHaveBeenCalledWith(['/recuperar-contrasena/restablecer'], {
+      queryParams: {
+        email: 'ada@example.com',
+        code: '1234',
+      },
+    });
+  });
+
+  it('shows the validation error and stays on the code page', async () => {
+    validatePasswordResetCode.mockReturnValue(throwError(() => ({
+      error: {
+        errors: {
+          codigo: ['El código ingresado es inválido.'],
+        },
+      },
+    })));
+
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordCodePageComponent],
+      providers: [
+        provideRouter([]),
+        ...authProviders(),
+        {
+          provide: ActivatedRoute,
+          useValue: {
+            snapshot: {
+              queryParamMap: convertToParamMap({ email: 'ada@example.com' }),
+            },
+          },
+        },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordCodePageComponent);
+    const component = fixture.componentInstance as any;
+    const router = TestBed.inject(Router);
+    const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+
+    component.form.setValue({
+      digit1: '9',
+      digit2: '9',
+      digit3: '9',
+      digit4: '9',
+    });
+    component.onSubmit();
+
+    expect(navigateSpy).not.toHaveBeenCalled();
+    expect(component.serverError()).toBe('El código ingresado es inválido.');
+    expect(showDangerToast).toHaveBeenCalledWith('El código ingresado es inválido.');
+  });
+
+  it('requests a new code and clears the previous digits', async () => {
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordCodePageComponent],
+      providers: [
+        provideRouter([]),
+        ...authProviders(),
+        {
+          provide: ActivatedRoute,
+          useValue: {
+            snapshot: {
+              queryParamMap: convertToParamMap({ email: 'ada@example.com' }),
+            },
+          },
+        },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordCodePageComponent);
+    const component = fixture.componentInstance as any;
+    fixture.detectChanges();
+    component.form.setValue({
+      digit1: '1',
+      digit2: '2',
+      digit3: '3',
+      digit4: '4',
+    });
+
+    component.resendCode();
+
+    expect(requestPasswordReset).toHaveBeenCalledWith('ada@example.com');
+    expect(component.form.getRawValue()).toEqual({
+      digit1: '',
+      digit2: '',
+      digit3: '',
+      digit4: '',
+    });
+    expect(showSuccessToast).toHaveBeenCalledWith('Código reenviado correctamente.');
+  });
+});

src/app/features/store/pages/recover-password-code-page/recover-password-code-page.component.ts

@@ -0,0 +1,191 @@
+import { ChangeDetectionStrategy, Component, inject, signal, viewChildren } from '@angular/core';
+import { FormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+
+import { AuthService } from '../../../../core/services/auth/auth.service';
+import { ToastService } from '../../../../core/services/toast.service';
+import { ButtonComponent } from '../../../../shared/components/button/button.component';
+import { InputComponent } from '../../../../shared/components/input/input.component';
+
+type CodeControlName = 'digit1' | 'digit2' | 'digit3' | 'digit4';
+const CODE_CONTROL_NAMES: CodeControlName[] = ['digit1', 'digit2', 'digit3', 'digit4'];
+
+@Component({
+  selector: 'app-recover-password-code-page',
+  imports: [ReactiveFormsModule, InputComponent, ButtonComponent],
+  templateUrl: './recover-password-code-page.component.html',
+  styleUrl: './recover-password-code-page.component.scss',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class RecoverPasswordCodePageComponent {
+  private readonly formBuilder = inject(FormBuilder);
+  private readonly router = inject(Router);
+  private readonly route = inject(ActivatedRoute);
+  private readonly authService = inject(AuthService);
+  private readonly toastService = inject(ToastService);
+  private readonly submittedState = signal(false);
+  private readonly isSubmittingState = signal(false);
+  private readonly isResendingState = signal(false);
+  private readonly serverErrorState = signal<string | null>(null);
+  private readonly digitInputs = viewChildren(InputComponent);
+
+  protected readonly email = this.route.snapshot.queryParamMap.get('email') ?? '';
+  protected readonly form = this.formBuilder.nonNullable.group({
+    digit1: ['', [Validators.required, Validators.pattern(/^\d$/)]],
+    digit2: ['', [Validators.required, Validators.pattern(/^\d$/)]],
+    digit3: ['', [Validators.required, Validators.pattern(/^\d$/)]],
+    digit4: ['', [Validators.required, Validators.pattern(/^\d$/)]],
+  });
+  protected readonly submitted = this.submittedState.asReadonly();
+  protected readonly isSubmitting = this.isSubmittingState.asReadonly();
+  protected readonly isResending = this.isResendingState.asReadonly();
+  protected readonly serverError = this.serverErrorState.asReadonly();
+
+  protected updateDigit(controlName: CodeControlName, value: string | number): void {
+    const digit = String(value).replace(/\D/g, '').slice(-1);
+    this.form.controls[controlName].setValue(digit);
+
+    const currentIndex = CODE_CONTROL_NAMES.indexOf(controlName);
+    if (digit && currentIndex < CODE_CONTROL_NAMES.length - 1) {
+      this.digitInputs()[currentIndex + 1]?.focus();
+    }
+  }
+
+  protected pasteCode(event: ClipboardEvent): void {
+    event.preventDefault();
+
+    const pastedText = event.clipboardData?.getData('text') ?? '';
+    const digits = pastedText.replace(/\D/g, '');
+
+    if (digits.length !== CODE_CONTROL_NAMES.length) {
+      console.warn('Password reset code paste was rejected because it did not contain four digits.', {
+        digitCount: digits.length,
+      });
+      this.showServerError('Pegá un código de cuatro dígitos.');
+      return;
+    }
+
+    CODE_CONTROL_NAMES.forEach((controlName, index) => {
+      this.form.controls[controlName].setValue(digits[index]);
+    });
+
+    this.submittedState.set(false);
+    this.serverErrorState.set(null);
+    this.digitInputs()[CODE_CONTROL_NAMES.length - 1]?.focus();
+  }
+
+  protected isCodeInvalid(): boolean {
+    return this.form.invalid && this.submitted();
+  }
+
+  protected onSubmit(): void {
+    this.submittedState.set(true);
+    this.serverErrorState.set(null);
+
+    if (this.form.invalid || this.isSubmitting()) {
+      this.form.markAllAsTouched();
+      return;
+    }
+
+    const code = Object.values(this.form.getRawValue()).join('');
+
+    if (!this.email) {
+      console.warn('Password reset code validation cannot start without an email.');
+      this.showServerError('No se pudo identificar la solicitud de recuperación.');
+      return;
+    }
+
+    this.isSubmittingState.set(true);
+
+    this.authService.validatePasswordResetCode(this.email, code).subscribe({
+      next: (response) => {
+        this.isSubmittingState.set(false);
+
+        if (response.status !== 200 || response.body?.status !== 'validated') {
+          console.warn('Password reset code validation returned an unexpected status.', {
+            httpStatus: response.status,
+            attemptStatus: response.body?.status ?? null,
+          });
+          this.showServerError('No se pudo validar el código. Intenta nuevamente.');
+          return;
+        }
+
+        void this.router.navigate(['/recuperar-contrasena/restablecer'], {
+          queryParams: {
+            email: this.email,
+            code,
+          },
+        });
+      },
+      error: (error: unknown) => {
+        this.isSubmittingState.set(false);
+        console.error('Password reset code validation request failed.', error);
+        this.showServerError(this.resolveErrorMessage(error));
+      },
+    });
+  }
+
+  protected resendCode(): void {
+    if (!this.email || this.isResending()) {
+      return;
+    }
+
+    this.serverErrorState.set(null);
+    this.isResendingState.set(true);
+
+    this.authService.requestPasswordReset(this.email).subscribe({
+      next: (response) => {
+        this.isResendingState.set(false);
+
+        if (response.status !== 202 || response.body?.status !== 'pending') {
+          console.warn('Password reset code resend returned an unexpected status.', {
+            httpStatus: response.status,
+            attemptStatus: response.body?.status ?? null,
+          });
+          this.showServerError('No se pudo reenviar el código. Intenta nuevamente.');
+          return;
+        }
+
+        this.submittedState.set(false);
+        this.form.reset();
+        this.digitInputs()[0]?.focus();
+        this.toastService.success('Código reenviado correctamente.');
+      },
+      error: (error: unknown) => {
+        this.isResendingState.set(false);
+        console.error('Password reset code resend request failed.', error);
+        this.showServerError(this.resolveErrorMessage(error));
+      },
+    });
+  }
+
+  protected goBack(): void {
+    void this.router.navigate(['/recuperar-contrasena'], {
+      queryParams: this.email ? { email: this.email } : undefined,
+    });
+  }
+
+  private showServerError(message: string): void {
+    this.serverErrorState.set(message);
+    this.toastService.danger(message);
+  }
+
+  private resolveErrorMessage(error: unknown): string {
+    const errorPayload =
+      typeof error === 'object' && error !== null && 'error' in error
+        ? (error as { error?: { errors?: Record<string, string[]>; message?: string } }).error
+        : undefined;
+    const codeMessages = errorPayload?.errors?.['codigo'];
+    const codeError = Array.isArray(codeMessages) ? codeMessages[0] : null;
+
+    if (typeof codeError === 'string' && codeError.trim()) {
+      return codeError;
+    }
+
+    if (typeof errorPayload?.message === 'string' && errorPayload.message.trim()) {
+      return errorPayload.message;
+    }
+
+    return 'No se pudo validar el código. Intenta nuevamente.';
+  }
+}

src/app/features/store/pages/recover-password-page/recover-password-page.component.html

@@ -0,0 +1,53 @@
+<header class="recover-password-page__header text-center mb-4">
+  <h1 id="recover-password-title" class="auth-title mb-3">Recuperar contraseña</h1>
+  <p class="recover-password-page__description mb-0">
+    Ingresá tu Email para restablecer tu Contraseña.
+  </p>
+</header>
+
+<form
+  class="recover-password-page__form d-grid gap-3"
+  novalidate
+  aria-labelledby="recover-password-title"
+  [formGroup]="form"
+  (ngSubmit)="onSubmit()"
+>
+  <div class="d-grid gap-1">
+    <label class="visually-hidden" for="recover-password-email">Email</label>
+    <app-input
+      id="recover-password-email"
+      type="email"
+      placeholder="Email"
+      [value]="form.controls.email.value"
+      [invalid]="showEmailError()"
+      (valueChange)="updateEmail($event)"
+    />
+    @if (getEmailError(); as errorMessage) {
+      <small class="text-danger">{{ errorMessage }}</small>
+    }
+    @if (serverError(); as errorMessage) {
+      <small class="text-danger" role="alert">{{ errorMessage }}</small>
+    }
+  </div>
+
+  <div class="d-grid gap-2 text-center">
+    <app-button
+      type="submit"
+      hostClass="w-100 d-block"
+      buttonClass="w-100"
+      [disabled]="isSubmitting()"
+    >
+      {{ isSubmitting() ? 'Enviando...' : 'Recuperar acceso' }}
+    </app-button>
+
+    <app-button
+      type="button"
+      variant="borderless"
+      hostClass="w-100 d-block text-center"
+      buttonClass="recover-password-page__back-action px-3 py-2"
+      (click)="goToLogin()"
+    >
+      Volver
+    </app-button>
+  </div>
+</form>

src/app/features/store/pages/recover-password-page/recover-password-page.component.scss

@@ -0,0 +1,17 @@
+:host {
+  display: block;
+}
+
+.recover-password-page__description {
+  color: #a0a0a0;
+  font-size: 12px;
+  font-weight: 325;
+}
+
+.recover-password-page__form {
+  width: 100%;
+}
+
+.recover-password-page__back-action {
+  min-height: 40px;
+}

src/app/features/store/pages/recover-password-page/recover-password-page.component.spec.ts

@@ -0,0 +1,139 @@
+import { HttpResponse } from '@angular/common/http';
+import { TestBed } from '@angular/core/testing';
+import { provideRouter, Router } from '@angular/router';
+import { of, throwError } from 'rxjs';
+
+import { AuthService } from '../../../../core/services/auth/auth.service';
+import { ToastService } from '../../../../core/services/toast.service';
+import { RecoverPasswordPageComponent } from './recover-password-page.component';
+
+describe('RecoverPasswordPageComponent', () => {
+  let requestPasswordReset: ReturnType<typeof vi.fn>;
+  let showDangerToast: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    TestBed.resetTestingModule();
+    vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    requestPasswordReset = vi.fn(() => of(new HttpResponse({
+      body: {
+        message: 'Solicitud aceptada.',
+        status: 'pending' as const
+      },
+      status: 202
+    })));
+    showDangerToast = vi.fn();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  function authProviders() {
+    return [
+      { provide: AuthService, useValue: { requestPasswordReset } },
+      { provide: ToastService, useValue: { danger: showDangerToast } }
+    ];
+  }
+
+  it('validates the email before submitting', async () => {
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordPageComponent],
+      providers: [provideRouter([]), ...authProviders()],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordPageComponent);
+    const component = fixture.componentInstance as any;
+
+    component.form.controls.email.setValue('invalid-email');
+    component.onSubmit();
+
+    expect(component.form.invalid).toBe(true);
+    expect(component.getEmailError()).toBe('Ingresa un email válido.');
+  });
+
+  it('navigates back to login', async () => {
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordPageComponent],
+      providers: [provideRouter([]), ...authProviders()],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordPageComponent);
+    const component = fixture.componentInstance as any;
+    const router = TestBed.inject(Router);
+    const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+
+    component.goToLogin();
+
+    expect(navigateSpy).toHaveBeenCalledWith(['/login']);
+  });
+
+  it('continues to the code page with the entered email', async () => {
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordPageComponent],
+      providers: [provideRouter([]), ...authProviders()],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordPageComponent);
+    const component = fixture.componentInstance as any;
+    const router = TestBed.inject(Router);
+    const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+
+    component.form.controls.email.setValue('ada@example.com');
+    component.onSubmit();
+
+    expect(requestPasswordReset).toHaveBeenCalledWith('ada@example.com');
+    expect(navigateSpy).toHaveBeenCalledWith(['/recuperar-contrasena/codigo'], {
+      queryParams: { email: 'ada@example.com' },
+    });
+  });
+
+  it('stays on the page when the endpoint does not finish as pending', async () => {
+    requestPasswordReset.mockReturnValue(of(new HttpResponse({
+      body: null,
+      status: 200
+    })));
+
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordPageComponent],
+      providers: [provideRouter([]), ...authProviders()],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordPageComponent);
+    const component = fixture.componentInstance as any;
+    const router = TestBed.inject(Router);
+    const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+
+    component.form.controls.email.setValue('ada@example.com');
+    component.onSubmit();
+
+    expect(navigateSpy).not.toHaveBeenCalled();
+    expect(component.serverError()).toBe(
+      'No se pudo iniciar la recuperación. Intenta nuevamente.',
+    );
+    expect(showDangerToast).toHaveBeenCalled();
+  });
+
+  it('shows the API error and does not navigate when the request fails', async () => {
+    requestPasswordReset.mockReturnValue(throwError(() => ({
+      error: { message: 'Servicio temporalmente no disponible.' }
+    })));
+
+    await TestBed.configureTestingModule({
+      imports: [RecoverPasswordPageComponent],
+      providers: [provideRouter([]), ...authProviders()],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(RecoverPasswordPageComponent);
+    const component = fixture.componentInstance as any;
+    const router = TestBed.inject(Router);
+    const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+
+    component.form.controls.email.setValue('ada@example.com');
+    component.onSubmit();
+
+    expect(navigateSpy).not.toHaveBeenCalled();
+    expect(component.serverError()).toBe('Servicio temporalmente no disponible.');
+    expect(showDangerToast).toHaveBeenCalledWith('Servicio temporalmente no disponible.');
+  });
+});

src/app/features/store/pages/recover-password-page/recover-password-page.component.ts

@@ -0,0 +1,135 @@
+import { ChangeDetectionStrategy, Component, inject, signal } from '@angular/core';
+import { FormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+
+import { AuthService } from '../../../../core/services/auth/auth.service';
+import { ToastService } from '../../../../core/services/toast.service';
+import { ButtonComponent } from '../../../../shared/components/button/button.component';
+import { InputComponent } from '../../../../shared/components/input/input.component';
+
+const EMAIL_MAX_LENGTH = 255;
+
+@Component({
+  selector: 'app-recover-password-page',
+  imports: [ReactiveFormsModule, InputComponent, ButtonComponent],
+  templateUrl: './recover-password-page.component.html',
+  styleUrl: './recover-password-page.component.scss',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class RecoverPasswordPageComponent {
+  private readonly formBuilder = inject(FormBuilder);
+  private readonly router = inject(Router);
+  private readonly route = inject(ActivatedRoute);
+  private readonly authService = inject(AuthService);
+  private readonly toastService = inject(ToastService);
+  private readonly submittedState = signal(false);
+  private readonly isSubmittingState = signal(false);
+  private readonly serverErrorState = signal<string | null>(null);
+
+  protected readonly form = this.formBuilder.nonNullable.group({
+    email: [
+      this.route.snapshot.queryParamMap.get('email') ?? '',
+      [Validators.required, Validators.email, Validators.maxLength(EMAIL_MAX_LENGTH)],
+    ],
+  });
+  protected readonly submitted = this.submittedState.asReadonly();
+  protected readonly isSubmitting = this.isSubmittingState.asReadonly();
+  protected readonly serverError = this.serverErrorState.asReadonly();
+
+  protected updateEmail(value: string | number): void {
+    this.form.controls.email.setValue(String(value));
+  }
+
+  protected showEmailError(): boolean {
+    const email = this.form.controls.email;
+
+    return email.invalid && (email.touched || this.submitted());
+  }
+
+  protected getEmailError(): string | null {
+    const email = this.form.controls.email;
+
+    if (!this.showEmailError()) {
+      return null;
+    }
+
+    if (email.hasError('required')) {
+      return 'Este campo es obligatorio.';
+    }
+
+    if (email.hasError('maxlength')) {
+      return `No puede superar los ${EMAIL_MAX_LENGTH} caracteres.`;
+    }
+
+    if (email.hasError('email')) {
+      return 'Ingresa un email válido.';
+    }
+
+    return 'El valor ingresado no es válido.';
+  }
+
+  protected onSubmit(): void {
+    this.submittedState.set(true);
+    this.serverErrorState.set(null);
+
+    if (this.form.invalid || this.isSubmitting()) {
+      this.form.markAllAsTouched();
+      return;
+    }
+
+    const email = this.form.controls.email.value;
+    this.isSubmittingState.set(true);
+
+    this.authService.requestPasswordReset(email).subscribe({
+      next: (response) => {
+        this.isSubmittingState.set(false);
+
+        if (response.status !== 202 || response.body?.status !== 'pending') {
+          console.warn('Password reset attempt returned an unexpected status.', {
+            httpStatus: response.status,
+            attemptStatus: response.body?.status ?? null,
+          });
+          this.showServerError('No se pudo iniciar la recuperación. Intenta nuevamente.');
+          return;
+        }
+
+        void this.router.navigate(['/recuperar-contrasena/codigo'], {
+          queryParams: { email },
+        });
+      },
+      error: (error: unknown) => {
+        this.isSubmittingState.set(false);
+        console.error('Password reset attempt request failed.', error);
+        this.showServerError(this.resolveErrorMessage(error));
+      },
+    });
+  }
+
+  protected goToLogin(): void {
+    void this.router.navigate(['/login']);
+  }
+
+  private showServerError(message: string): void {
+    this.serverErrorState.set(message);
+    this.toastService.danger(message);
+  }
+
+  private resolveErrorMessage(error: unknown): string {
+    const errorPayload =
+      typeof error === 'object' && error !== null && 'error' in error
+        ? (error as { error?: { errors?: Record<string, string[]>; message?: string } }).error
+        : undefined;
+    const emailMessages = errorPayload?.errors?.['email'];
+    const emailError = Array.isArray(emailMessages) ? emailMessages[0] : null;
+
+    if (typeof emailError === 'string' && emailError.trim()) {
+      return emailError;
+    }
+
+    if (typeof errorPayload?.message === 'string' && errorPayload.message.trim()) {
+      return errorPayload.message;
+    }
+
+    return 'No se pudo iniciar la recuperación. Intenta nuevamente.';
+  }
+}

src/app/features/store/pages/reset-password-page/reset-password-page.component.html

@@ -0,0 +1,56 @@
+<header class="reset-password-page__header text-center mb-4">
+  <h1 id="reset-password-title" class="auth-title">Restablecer contraseña</h1>
+</header>
+
+<form
+  class="reset-password-page__form d-grid gap-3"
+  novalidate
+  aria-labelledby="reset-password-title"
+  [formGroup]="form"
+  (ngSubmit)="onSubmit()"
+>
+  <div class="d-grid gap-1">
+    <label class="visually-hidden" for="reset-password-new">Nueva Contraseña</label>
+    <app-input
+      id="reset-password-new"
+      type="password"
+      placeholder="Nueva Contraseña"
+      [value]="form.controls.password.value"
+      [invalid]="showControlError('password')"
+      (valueChange)="updatePassword('password', $event)"
+    />
+    @if (getControlError('password'); as errorMessage) {
+      <small class="text-danger">{{ errorMessage }}</small>
+    }
+  </div>
+
+  <div class="d-grid gap-1">
+    <label class="visually-hidden" for="reset-password-confirmation">
+      Repetir Nueva Contraseña
+    </label>
+    <app-input
+      id="reset-password-confirmation"
+      type="password"
+      placeholder="Repetir Nueva Contraseña"
+      [value]="form.controls.password_confirmation.value"
+      [invalid]="showControlError('password_confirmation')"
+      (valueChange)="updatePassword('password_confirmation', $event)"
+    />
+    @if (getControlError('password_confirmation'); as errorMessage) {
+      <small class="text-danger">{{ errorMessage }}</small>
+    }
+  </div>
+
+  @if (serverError(); as errorMessage) {
+    <small class="text-danger" role="alert">{{ errorMessage }}</small>
+  }
+
+  <app-button
+    type="submit"
+    hostClass="w-100 d-block"
+    buttonClass="w-100"
+    [disabled]="isSubmitting()"
+  >
+    {{ isSubmitting() ? 'Guardando...' : 'Guardar' }}
+  </app-button>
+</form>

src/app/features/store/pages/reset-password-page/reset-password-page.component.scss

@@ -0,0 +1,7 @@
+:host {
+  display: block;
+}
+
+.reset-password-page__form {
+  width: 100%;
+}

src/app/features/store/pages/reset-password-page/reset-password-page.component.spec.ts

@@ -0,0 +1,148 @@
+import { HttpResponse } from '@angular/common/http';
+import { TestBed } from '@angular/core/testing';
+import { ActivatedRoute, convertToParamMap, provideRouter, Router } from '@angular/router';
+import { of, throwError } from 'rxjs';
+
+import { AuthService } from '../../../../core/services/auth/auth.service';
+import { ModalService } from '../../../../core/services/modal.service';
+import { ToastService } from '../../../../core/services/toast.service';
+import { ResetPasswordPageComponent } from './reset-password-page.component';
+
+describe('ResetPasswordPageComponent', () => {
+  let resetPassword: ReturnType<typeof vi.fn>;
+  let showDangerToast: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    TestBed.resetTestingModule();
+    vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    resetPassword = vi.fn(() => of(new HttpResponse({
+      body: {
+        message: 'Contraseña modificada correctamente.',
+        status: 'used' as const,
+      },
+      status: 200,
+    })));
+    showDangerToast = vi.fn();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  function resetProviders(modalService: { openSimple: ReturnType<typeof vi.fn> }) {
+    return [
+      provideRouter([]),
+      { provide: AuthService, useValue: { resetPassword } },
+      { provide: ModalService, useValue: modalService },
+      { provide: ToastService, useValue: { danger: showDangerToast } },
+      {
+        provide: ActivatedRoute,
+        useValue: {
+          snapshot: {
+            queryParamMap: convertToParamMap({
+              email: 'ada@example.com',
+              code: '1234',
+            }),
+          },
+        },
+      },
+    ];
+  }
+
+  it('rejects passwords that do not match', async () => {
+    const modalService = {
+      openSimple: vi.fn(),
+    };
+
+    await TestBed.configureTestingModule({
+      imports: [ResetPasswordPageComponent],
+      providers: resetProviders(modalService),
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(ResetPasswordPageComponent);
+    const component = fixture.componentInstance as any;
+
+    component.form.setValue({
+      password: 'Secret!123',
+      password_confirmation: 'Different!123',
+    });
+    component.onSubmit();
+
+    expect(component.form.hasError('passwordMismatch')).toBe(true);
+    expect(component.getControlError('password_confirmation')).toBe(
+      'Las contraseñas no coinciden.',
+    );
+    expect(modalService.openSimple).not.toHaveBeenCalled();
+    expect(resetPassword).not.toHaveBeenCalled();
+  });
+
+  it('shows the success modal and returns to login for matching passwords', async () => {
+    const modalService = {
+      openSimple: vi.fn().mockReturnValue(of(undefined)),
+    };
+
+    await TestBed.configureTestingModule({
+      imports: [ResetPasswordPageComponent],
+      providers: resetProviders(modalService),
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(ResetPasswordPageComponent);
+    const component = fixture.componentInstance as any;
+    const router = TestBed.inject(Router);
+    const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+
+    component.form.setValue({
+      password: 'Secret!123',
+      password_confirmation: 'Secret!123',
+    });
+    component.onSubmit();
+
+    expect(component.form.valid).toBe(true);
+    expect(component.getControlError('password_confirmation')).toBeNull();
+    expect(resetPassword).toHaveBeenCalledWith({
+      email: 'ada@example.com',
+      codigo: '1234',
+      password: 'Secret!123',
+      password_confirmation: 'Secret!123',
+    });
+    expect(modalService.openSimple).toHaveBeenCalledWith({
+      content: 'Contraseña modificada correctamente',
+      buttonLabel: 'Cerrar',
+    });
+    expect(navigateSpy).toHaveBeenCalledWith(['/login']);
+  });
+
+  it('shows the API error without opening the success modal', async () => {
+    resetPassword.mockReturnValue(throwError(() => ({
+      error: {
+        errors: {
+          codigo: ['La solicitud de recuperación es inválida o ya fue utilizada.'],
+        },
+      },
+    })));
+    const modalService = {
+      openSimple: vi.fn(),
+    };
+
+    await TestBed.configureTestingModule({
+      imports: [ResetPasswordPageComponent],
+      providers: resetProviders(modalService),
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(ResetPasswordPageComponent);
+    const component = fixture.componentInstance as any;
+
+    component.form.setValue({
+      password: 'Secret!123',
+      password_confirmation: 'Secret!123',
+    });
+    component.onSubmit();
+
+    expect(modalService.openSimple).not.toHaveBeenCalled();
+    expect(component.serverError()).toBe(
+      'La solicitud de recuperación es inválida o ya fue utilizada.',
+    );
+    expect(showDangerToast).toHaveBeenCalled();
+  });
+});

src/app/features/store/pages/reset-password-page/reset-password-page.component.ts

@@ -0,0 +1,193 @@
+import { ChangeDetectionStrategy, Component, inject, signal } from '@angular/core';
+import {
+  AbstractControl,
+  FormBuilder,
+  ReactiveFormsModule,
+  ValidationErrors,
+  ValidatorFn,
+  Validators,
+} from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+
+import { AuthService } from '../../../../core/services/auth/auth.service';
+import { ModalService } from '../../../../core/services/modal.service';
+import { ToastService } from '../../../../core/services/toast.service';
+import { ButtonComponent } from '../../../../shared/components/button/button.component';
+import { InputComponent } from '../../../../shared/components/input/input.component';
+
+const PASSWORD_MIN_LENGTH = 8;
+
+const passwordsMatchValidator: ValidatorFn = (
+  control: AbstractControl,
+): ValidationErrors | null => {
+  const password = control.get('password')?.value;
+  const passwordConfirmation = control.get('password_confirmation')?.value;
+
+  if (!password || !passwordConfirmation) {
+    return null;
+  }
+
+  return password === passwordConfirmation ? null : { passwordMismatch: true };
+};
+
+type PasswordControlName = 'password' | 'password_confirmation';
+
+@Component({
+  selector: 'app-reset-password-page',
+  imports: [ReactiveFormsModule, InputComponent, ButtonComponent],
+  templateUrl: './reset-password-page.component.html',
+  styleUrl: './reset-password-page.component.scss',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class ResetPasswordPageComponent {
+  private readonly formBuilder = inject(FormBuilder);
+  private readonly router = inject(Router);
+  private readonly route = inject(ActivatedRoute);
+  private readonly authService = inject(AuthService);
+  private readonly modalService = inject(ModalService);
+  private readonly toastService = inject(ToastService);
+  private readonly submittedState = signal(false);
+  private readonly isSubmittingState = signal(false);
+  private readonly serverErrorState = signal<string | null>(null);
+
+  private readonly email = this.route.snapshot.queryParamMap.get('email') ?? '';
+  private readonly code = this.route.snapshot.queryParamMap.get('code') ?? '';
+
+  protected readonly form = this.formBuilder.nonNullable.group(
+    {
+      password: [
+        '',
+        [
+          Validators.required,
+          Validators.minLength(PASSWORD_MIN_LENGTH),
+          Validators.pattern(/^(?=.*[a-z])(?=.*[A-Z])(?=.*[\W_]).+$/),
+        ],
+      ],
+      password_confirmation: ['', [Validators.required]],
+    },
+    {
+      validators: [passwordsMatchValidator],
+    },
+  );
+  protected readonly submitted = this.submittedState.asReadonly();
+  protected readonly isSubmitting = this.isSubmittingState.asReadonly();
+  protected readonly serverError = this.serverErrorState.asReadonly();
+
+  protected updatePassword(controlName: PasswordControlName, value: string | number): void {
+    this.form.controls[controlName].setValue(String(value));
+  }
+
+  protected showControlError(controlName: PasswordControlName): boolean {
+    const control = this.form.controls[controlName];
+    const hasPasswordMismatch =
+      controlName === 'password_confirmation' &&
+      this.form.hasError('passwordMismatch') &&
+      (control.touched || this.submitted());
+
+    return (control.invalid && (control.touched || this.submitted())) || hasPasswordMismatch;
+  }
+
+  protected getControlError(controlName: PasswordControlName): string | null {
+    const control = this.form.controls[controlName];
+
+    if (!this.showControlError(controlName)) {
+      return null;
+    }
+
+    if (control.hasError('required')) {
+      return 'Este campo es obligatorio.';
+    }
+
+    if (control.hasError('minlength')) {
+      return `Debe tener al menos ${PASSWORD_MIN_LENGTH} caracteres.`;
+    }
+
+    if (controlName === 'password' && control.hasError('pattern')) {
+      return 'Debe contener mayúscula, minúscula y un carácter especial.';
+    }
+
+    if (controlName === 'password_confirmation' && this.form.hasError('passwordMismatch')) {
+      return 'Las contraseñas no coinciden.';
+    }
+
+    return 'El valor ingresado no es válido.';
+  }
+
+  protected onSubmit(): void {
+    this.submittedState.set(true);
+    this.serverErrorState.set(null);
+
+    if (this.form.invalid || this.isSubmitting()) {
+      this.form.markAllAsTouched();
+      return;
+    }
+
+    if (!this.email || !/^\d{4}$/.test(this.code)) {
+      console.warn('Password reset cannot start without a validated recovery request.');
+      this.showServerError('La solicitud de recuperación es inválida.');
+      return;
+    }
+
+    this.isSubmittingState.set(true);
+
+    this.authService.resetPassword({
+      email: this.email,
+      codigo: this.code,
+      ...this.form.getRawValue(),
+    }).subscribe({
+      next: (response) => {
+        this.isSubmittingState.set(false);
+
+        if (response.status !== 200 || response.body?.status !== 'used') {
+          console.warn('Password reset returned an unexpected status.', {
+            httpStatus: response.status,
+            attemptStatus: response.body?.status ?? null,
+          });
+          this.showServerError('No se pudo modificar la contraseña. Intenta nuevamente.');
+          return;
+        }
+
+        this.modalService
+          .openSimple({
+            content: 'Contraseña modificada correctamente',
+            buttonLabel: 'Cerrar',
+          })
+          .subscribe(() => {
+            void this.router.navigate(['/login']);
+          });
+      },
+      error: (error: unknown) => {
+        this.isSubmittingState.set(false);
+        console.error('Password reset request failed.', error);
+        this.showServerError(this.resolveErrorMessage(error));
+      },
+    });
+  }
+
+  private showServerError(message: string): void {
+    this.serverErrorState.set(message);
+    this.toastService.danger(message);
+  }
+
+  private resolveErrorMessage(error: unknown): string {
+    const errorPayload =
+      typeof error === 'object' && error !== null && 'error' in error
+        ? (error as { error?: { errors?: Record<string, string[]>; message?: string } }).error
+        : undefined;
+    const errors = errorPayload?.errors;
+
+    for (const field of ['codigo', 'password'] as const) {
+      const messages = errors?.[field];
+
+      if (Array.isArray(messages) && typeof messages[0] === 'string' && messages[0].trim()) {
+        return messages[0];
+      }
+    }
+
+    if (typeof errorPayload?.message === 'string' && errorPayload.message.trim()) {
+      return errorPayload.message;
+    }
+
+    return 'No se pudo modificar la contraseña. Intenta nuevamente.';
+  }
+}

src/app/features/store/pages/search-page/search-page.component.html

@@ -1,8 +1,8 @@
 <section class="search-results" aria-labelledby="search-results-title">
-  <header class="search-results__header mb-4">
-    <h1 id="search-results-title" class="h3 mb-2">Resultados de búsqueda</h1>
+  <header class="search-results__header mb-5">
+    <h1 id="search-results-title" class="search-results__title mb-0">Resultados de búsqueda</h1>
     @if (query()) {
-      <p class="text-body-secondary mb-0">
+      <p class="search-results__subtitle text-body-secondary mb-0">
         Resultados para <strong>“{{ query() }}”</strong>
       </p>
     }
@@ -10,8 +10,6 @@
 
   @if (error()) {
     <p class="alert text-center mb-0 search-results__alert-error">{{ error() }}</p>
-  } @else if (loading()) {
-    <p class="alert alert-light border text-center mb-0">Buscando productos...</p>
   } @else if (results(); as searchResults) {
     @if (!searchResults.data.length) {
       <p class="alert alert-light border text-center mb-0">

src/app/features/store/pages/search-page/search-page.component.scss

@@ -1,3 +1,24 @@
+.search-results__header {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  padding: 16px 28px;
+  text-align: center;
+}
+
+.search-results__title {
+  color: var(--bs-primary);
+  font-size: 24px;
+  font-weight: bold;
+  line-height: 1.2;
+}
+
+.search-results__subtitle {
+  line-height: 1.2;
+}
+
 .search-results__alert-error {
   color: var(--tenant-danger-color, var(--bs-danger));
 }

src/app/features/store/pages/search-page/search-page.component.spec.ts

@@ -65,7 +65,9 @@ describe('SearchPageComponent', () => {
         },
         {
           provide: CatalogService,
-          useValue: { searchCatalog },
+          useValue: {
+            searchCatalog,
+          },
         },
         {
           provide: TenantService,
@@ -106,6 +108,22 @@ describe('SearchPageComponent', () => {
     );
   });
 
+  it('renders the search title and query subtitle with the category header layout', () => {
+    const fixture = TestBed.createComponent(SearchPageComponent);
+    fixture.detectChanges();
+
+    const element = fixture.nativeElement as HTMLElement;
+    const header = element.querySelector('.search-results__header');
+    const title = element.querySelector('#search-results-title');
+    const subtitle = element.querySelector('.search-results__subtitle');
+
+    expect(header?.classList).toContain('mb-5');
+    expect(title?.classList).toContain('search-results__title');
+    expect(title?.classList).toContain('mb-0');
+    expect(subtitle?.textContent).toContain('Resultados para');
+    expect(subtitle?.textContent).toContain('running');
+  });
+
   it('does not search when the query has fewer than three characters', () => {
     TestBed.overrideProvider(ActivatedRoute, {
       useValue: {

src/app/features/store/pages/search-page/search-page.component.ts

@@ -3,6 +3,7 @@ import {
   ChangeDetectionStrategy,
   Component,
   DestroyRef,
+  Injector,
   computed,
   inject,
   signal,
@@ -12,6 +13,8 @@ import { catchError, distinctUntilChanged, map, of, switchMap, tap } from 'rxjs'
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 
 import { CartService } from '../../../../core/services/cart/cart.service';
+import { AuthService } from '../../../../core/services/auth/auth.service';
+import { CheckoutService } from '../../../../core/services/checkout.service';
 import {
   CatalogFeaturedItem,
   CatalogFeaturedItems,
@@ -24,8 +27,8 @@ import { TenantService } from '../../../../core/services/tenant.service';
 import { ToastService } from '../../../../core/services/toast.service';
 import {
   ProductListCartEvent,
+  ProductListBuyEvent,
   ProductListComponent,
-  ProductListItem,
 } from '../../../../shared/components/product-list/product-list.component';
 
 interface SearchRouteState {
@@ -44,6 +47,7 @@ export class SearchPageComponent {
   private readonly minSearchLength = 3;
   private readonly cartService = inject(CartService);
   private readonly catalogService = inject(CatalogService);
+  private readonly injector = inject(Injector);
   private readonly destroyRef = inject(DestroyRef);
   private readonly route = inject(ActivatedRoute);
   private readonly router = inject(Router);
@@ -52,8 +56,8 @@ export class SearchPageComponent {
 
   protected readonly query = signal('');
   protected readonly results = signal<ApiPaginatedResponse<CatalogFeaturedItem[]> | null>(null);
-  protected readonly loading = signal(false);
   protected readonly error = signal<string | null>(null);
+  protected readonly creatingDirectPurchase = signal(false);
 
   protected readonly productLayout = computed<CatalogProductLayout>(
     () => this.tenantService.tenant()?.search_product_layout ?? 'column_with_image',
@@ -100,7 +104,6 @@ export class SearchPageComponent {
               ? null
               : `Ingresá al menos ${this.minSearchLength} caracteres para buscar.`,
           );
-          this.loading.set(query.length >= this.minSearchLength);
         }),
         switchMap(({ query, page }) => {
           if (query.length < this.minSearchLength) {
@@ -119,7 +122,6 @@ export class SearchPageComponent {
       )
       .subscribe((results) => {
         this.results.set(results);
-        this.loading.set(false);
       });
   }
 
@@ -131,8 +133,45 @@ export class SearchPageComponent {
     });
   }
 
-  protected onBuyProduct(product: ProductListItem): void {
-    void this.router.navigate(['/producto', product.id]);
+  protected async onBuyProduct(event: ProductListBuyEvent): Promise<void> {
+    if (!event.directPurchase) {
+      await this.router.navigate(['/producto', event.product.id]);
+      return;
+    }
+
+    if (this.creatingDirectPurchase()) {
+      return;
+    }
+
+    if (!this.injector.get(AuthService).user()) {
+      await this.router.navigate(['/login'], {
+        queryParams: { returnUrl: `/producto/${event.product.id}` },
+      });
+      return;
+    }
+
+    const tenant = this.tenantService.tenant();
+    if (!tenant) {
+      this.toastService.danger('No se pudo identificar la tienda.');
+      return;
+    }
+
+    this.creatingDirectPurchase.set(true);
+    try {
+      const purchase = await this.injector.get(CheckoutService).startCheckout(tenant.codigo, {
+        direct_item: {
+          catalog_item_id: event.product.id,
+          variant_id: event.variant ?? null,
+          cantidad: event.quantity,
+        },
+      });
+      await this.router.navigate(['/checkout'], { queryParams: { purchase: purchase.id } });
+    } catch (error) {
+      console.error('Failed to create direct purchase:', error);
+      this.toastService.danger('No se pudo iniciar la compra directa.');
+    } finally {
+      this.creatingDirectPurchase.set(false);
+    }
   }
 
   protected onAddToCart(event: ProductListCartEvent): void {

src/app/features/store/pages/store-home-page/store-home-page.component.html

@@ -1,19 +1,16 @@
-@if (tenant()?.main_carousel_images; as mainCarouselImages) {
-  @if (mainCarouselImages.length) {
+@if (mainCarouselImages(); as images) {
+  @if (images.length) {
     <app-main-carousel
       class="store-home__main-carousel"
-      [images]="mainCarouselImages"
+      [images]="images"
       ariaLabel="Imágenes destacadas de la tienda"
       (firstImageReady)="mainCarouselReady.set(true)"
     />
   }
 }
 
-@if (tenant()?.hero_config || tenant()?.event_config) {
-  <app-hero-banner
-    [heroConfig]="tenant()?.hero_config"
-    [eventConfig]="tenant()?.event_config"
-  ></app-hero-banner>
+@if (heroConfig() || eventConfig()) {
+  <app-hero-banner [heroConfig]="heroConfig()" [eventConfig]="eventConfig()" />
 }
 
 @if (error()) {
@@ -40,3 +37,9 @@
     </app-store-section>
   }
 }
+
+@if (additionalInfo(); as content) {
+  <app-store-section class="store-home__additional-info" title="Información adicional">
+    <div class="store-home__additional-info-content" [innerHTML]="content"></div>
+  </app-store-section>
+}

src/app/features/store/pages/store-home-page/store-home-page.component.scss

@@ -11,6 +11,25 @@ app-store-section + app-store-section {
   margin-top: clamp(3rem, 6vw, 5rem);
 }
 
+:host > .store-home__additional-info:not(:first-child) {
+  margin-top: clamp(3rem, 6vw, 5rem);
+}
+
+.store-home__additional-info-content {
+  width: 100%;
+  text-align: center;
+}
+
+::ng-deep .store-home__additional-info-content img {
+  display: block;
+  margin-right: auto;
+  margin-left: auto;
+}
+
+::ng-deep .store-home__additional-info-content > :last-child {
+  margin-bottom: 0;
+}
+
 .store-home__alert-error {
   margin: 0;
   border-color: rgba(var(--tenant-danger-rgb, 220, 53, 69), 0.18);

src/app/features/store/pages/store-home-page/store-home-page.component.spec.ts

@@ -16,6 +16,7 @@ import { Tenant } from '../../../../core/services/tenant.interface';
 import { TenantService } from '../../../../core/services/tenant.service';
 import { ToastService } from '../../../../core/services/toast.service';
 import { ProductListComponent } from '../../../../shared/components/product-list/product-list.component';
+import { HeroBannerComponent } from '../../../../shared/components/hero-banner/hero-banner.component';
 import { StoreHomePageComponent } from './store-home-page.component';
 import {
   STORE_HOME_PRODUCTS_ERROR_MESSAGE,
@@ -88,7 +89,7 @@ const pageOneItems: CatalogFeaturedItem[] = [
   },
 ];
 
-function createTenant(mainCarouselImages?: string[]): Tenant {
+function createTenant(extras: Tenant['extras'] = {}): Tenant {
   return {
     id: 1,
     codigo: 'acme',
@@ -102,7 +103,18 @@ function createTenant(mainCarouselImages?: string[]): Tenant {
     footer_bg_color: '#ffffff',
     header_logo: '/header.png',
     footer_logo: '/footer.png',
-    main_carousel_images: mainCarouselImages,
+    website_type_code: 'shopit',
+    website_type: {
+      codigo: 'shopit',
+      nombre: 'ShopIt',
+      primary_color: null,
+      secondary_color: null,
+      danger_color: null,
+      success_color: null,
+      site_logo: null,
+    },
+    extras,
+    categories: [],
   };
 }
 
@@ -145,11 +157,8 @@ describe('StoreHomePageComponent', () => {
     );
   });
 
-  it('renders the tenant main carousel images at the beginning of the home page', async () => {
-    const mainCarouselImages = [
-      'https://example.com/carousel-1.webp',
-      'https://example.com/carousel-2.webp',
-    ];
+  it('renders the carousel URLs received in tenant extras', async () => {
+    const carousel = ['https://example.com/carousel-1.webp', 'https://example.com/carousel-2.webp'];
 
     await TestBed.configureTestingModule({
       imports: [StoreHomePageComponent],
@@ -161,7 +170,7 @@ describe('StoreHomePageComponent', () => {
         },
         {
           provide: TenantService,
-          useValue: createTenantServiceStub(createTenant(mainCarouselImages)),
+          useValue: createTenantServiceStub(createTenant({ carousel })),
         },
       ],
     }).compileComponents();
@@ -170,25 +179,61 @@ describe('StoreHomePageComponent', () => {
     fixture.detectChanges();
 
     const element = fixture.nativeElement as HTMLElement;
-    const carousel = element.querySelector('app-main-carousel');
-    const images = carousel?.querySelectorAll('.main-carousel__image');
+    const carouselElement = element.querySelector('app-main-carousel');
+    const images = carouselElement?.querySelectorAll('.main-carousel__image');
 
-    expect(element.firstElementChild).toBe(carousel);
+    expect(element.firstElementChild).toBe(carouselElement);
     expect(images).toHaveLength(2);
-    expect(images?.[0].getAttribute('src')).toBe(mainCarouselImages[0]);
-    expect(images?.[1].getAttribute('src')).toBeNull();
-    expect(element.querySelectorAll('app-product-column-with-image img')).toHaveLength(0);
-
-    images?.[0].dispatchEvent(new Event('load'));
-    fixture.detectChanges();
-
-    expect(images?.[1].getAttribute('src')).toBe(mainCarouselImages[1]);
-    expect(element.querySelectorAll('app-product-column-with-image img')).toHaveLength(1);
-
-    fixture.destroy();
+    expect(images?.[0].getAttribute('src')).toBe(carousel[0]);
   });
 
-  it('does not render the main carousel when the tenant has no images', async () => {
+  it('renders the hero extra and the active tenant event', async () => {
+    const tenant = createTenant({
+      heroConfig: {
+        title_html: '<h1>Fiesta Fútbol Infantil</h1>',
+        description_html: '<p>Viví una jornada inolvidable de fútbol infantil.</p>',
+        background_image_id: 'https://example.com/hero.jpg',
+      },
+    });
+    tenant.active_event_id = 10;
+    tenant.active_event = {
+      id: 10,
+      name: 'Fiesta Fútbol Infantil',
+      address: 'Rosario, Santa Fe',
+      dates: [
+        {
+          id: 20,
+          date: '2026-12-05',
+          time_start: '09:00:00',
+          time_end: '18:00:00',
+        },
+        {
+          id: 21,
+          date: '2026-12-06',
+          time_start: '09:00:00',
+          time_end: '18:00:00',
+        },
+      ],
+    };
+    tenant.website_type_code = 'onticket';
+    tenant.social_media = [
+      {
+        code: 'whatsapp',
+        icon: 'fa-brands fa-whatsapp',
+        name: 'WhatsApp',
+        url: 'https://wa.me/5493410000000',
+      },
+    ];
+    tenant.website_type = {
+      codigo: 'onticket',
+      nombre: 'OnTicket',
+      primary_color: null,
+      secondary_color: null,
+      danger_color: null,
+      success_color: null,
+      site_logo: null,
+    };
+
     await TestBed.configureTestingModule({
       imports: [StoreHomePageComponent],
       providers: [
@@ -199,7 +244,7 @@ describe('StoreHomePageComponent', () => {
         },
         {
           provide: TenantService,
-          useValue: createTenantServiceStub(createTenant([])),
+          useValue: createTenantServiceStub(tenant),
         },
       ],
     }).compileComponents();
@@ -207,7 +252,129 @@ describe('StoreHomePageComponent', () => {
     const fixture = TestBed.createComponent(StoreHomePageComponent);
     fixture.detectChanges();
 
-    expect((fixture.nativeElement as HTMLElement).querySelector('app-main-carousel')).toBeNull();
+    const hero = (fixture.nativeElement as HTMLElement).querySelector(
+      'app-hero-banner .hero-banner',
+    ) as HTMLElement;
+
+    expect(hero).not.toBeNull();
+    expect(hero.style.backgroundImage).toContain('https://example.com/hero.jpg');
+    expect(hero.textContent).toContain('Fiesta Fútbol Infantil');
+    expect(hero.textContent).toContain('Viví una jornada inolvidable de fútbol infantil.');
+    expect(hero.textContent).toContain('Rosario, Santa Fe');
+    expect(hero.textContent).toContain('2026-12-05, 2026-12-06');
+    const heroComponent = fixture.debugElement.query(By.directive(HeroBannerComponent))
+      .componentInstance as HeroBannerComponent;
+    expect(heroComponent.eventConfig?.contact).toEqual(tenant.social_media);
+  });
+
+  it('renders additional information as an HTML section', async () => {
+    const description =
+      '<p>Consultá los <strong>términos del evento</strong>.</p><ul><li>Ingreso con DNI</li></ul>';
+
+    await TestBed.configureTestingModule({
+      imports: [StoreHomePageComponent],
+      providers: [
+        provideActivatedRoute({ response: createCatalog(), error: null }),
+        {
+          provide: CatalogService,
+          useValue: { getCatalog: vi.fn(), getFeaturedGroupItems: vi.fn() },
+        },
+        {
+          provide: TenantService,
+          useValue: createTenantServiceStub(
+            createTenant({ additionalInfoConfig: { description } }),
+          ),
+        },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(StoreHomePageComponent);
+    fixture.detectChanges();
+
+    const element = fixture.nativeElement as HTMLElement;
+    const section = element.querySelector('.store-home__additional-info');
+    const sections = element.querySelectorAll(':scope > app-store-section');
+
+    expect(sections[sections.length - 1]).toBe(section);
+    expect(section?.querySelector('.store-section__title')?.textContent?.trim()).toBe(
+      'Información adicional',
+    );
+    expect(section?.querySelector('strong')?.textContent).toBe('términos del evento');
+    expect(section?.querySelector('li')?.textContent).toBe('Ingreso con DNI');
+  });
+
+  it('does not render the additional information section without content', async () => {
+    await TestBed.configureTestingModule({
+      imports: [StoreHomePageComponent],
+      providers: [
+        provideActivatedRoute({ response: createCatalog(), error: null }),
+        {
+          provide: CatalogService,
+          useValue: { getCatalog: vi.fn(), getFeaturedGroupItems: vi.fn() },
+        },
+        {
+          provide: TenantService,
+          useValue: createTenantServiceStub(
+            createTenant({ additionalInfoConfig: { description: '   ' } }),
+          ),
+        },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(StoreHomePageComponent);
+    fixture.detectChanges();
+
+    expect(
+      (fixture.nativeElement as HTMLElement).querySelector('.store-home__additional-info'),
+    ).toBeNull();
+  });
+
+  it('renders only the active event data when the tenant does not have the hero extra', async () => {
+    const tenant = createTenant();
+    tenant.active_event_id = 12;
+    tenant.active_event = {
+      id: 12,
+      name: 'Fiesta Fútbol Infantil',
+      address: 'Sunchales, Santa Fe',
+      dates: [
+        {
+          id: 25,
+          date: '2026-10-09',
+          time_start: '09:00:00',
+          time_end: '18:00:00',
+        },
+      ],
+    };
+    await TestBed.configureTestingModule({
+      imports: [StoreHomePageComponent],
+      providers: [
+        provideActivatedRoute({ response: createCatalog(), error: null }),
+        {
+          provide: CatalogService,
+          useValue: { getCatalog: vi.fn(), getFeaturedGroupItems: vi.fn() },
+        },
+        {
+          provide: TenantService,
+          useValue: createTenantServiceStub(tenant),
+        },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(StoreHomePageComponent);
+    fixture.detectChanges();
+
+    const element = fixture.nativeElement as HTMLElement;
+    const heroComponent = fixture.debugElement.query(By.directive(HeroBannerComponent))
+      .componentInstance as HeroBannerComponent;
+
+    expect(heroComponent.heroConfig).toBeNull();
+    expect(element.querySelector('.hero-banner')).toBeNull();
+    expect(element.querySelector('.hero-banner-container')).toBeNull();
+    expect(element.querySelector('.hero-content')).toBeNull();
+    expect(element.querySelector('.event-card')).not.toBeNull();
+    expect(element.textContent).toContain('Fiesta Fútbol Infantil');
+    expect(element.textContent).toContain('Sunchales, Santa Fe');
+    expect(element.textContent).toContain('2026-10-09');
   });
 
   it('requests another page for the selected featured group', async () => {
@@ -215,7 +382,9 @@ describe('StoreHomePageComponent', () => {
     const catalogServiceStub = {
       getCatalog: vi.fn(),
       getFeaturedGroupItems: vi.fn().mockReturnValue(of(createItemsPage(pageTwoItems, 2, 2))),
+      withCustomLoading: vi.fn(),
     };
+    catalogServiceStub.withCustomLoading.mockReturnValue(catalogServiceStub);
 
     await TestBed.configureTestingModule({
       imports: [StoreHomePageComponent],
@@ -231,6 +400,7 @@ describe('StoreHomePageComponent', () => {
     (element.querySelector('[data-testid="paginator-next"]') as HTMLButtonElement).click();
     fixture.detectChanges();
 
+    expect(catalogServiceStub.withCustomLoading).toHaveBeenCalledOnce();
     expect(catalogServiceStub.getFeaturedGroupItems).toHaveBeenCalledWith(7, { page: 2 });
     expect(element.textContent).toContain('Mouse Gamer');
     expect(element.querySelector('[data-testid="paginator-status"]')?.textContent?.trim()).toBe(
@@ -243,7 +413,9 @@ describe('StoreHomePageComponent', () => {
     const catalogServiceStub = {
       getCatalog: vi.fn(),
       getFeaturedGroupItems: vi.fn().mockReturnValue(nextPage.asObservable()),
+      withCustomLoading: vi.fn(),
     };
+    catalogServiceStub.withCustomLoading.mockReturnValue(catalogServiceStub);
 
     await TestBed.configureTestingModule({
       imports: [StoreHomePageComponent],
@@ -317,9 +489,9 @@ describe('StoreHomePageComponent', () => {
   it('adds a product-list cart event to the cart', async () => {
     const catalogServiceStub = { getCatalog: vi.fn(), getFeaturedGroupItems: vi.fn() };
     const cartServiceStub = {
-      addItem: vi.fn().mockReturnValue(
-        of({ data: {}, message: 'Producto agregado correctamente' }),
-      ),
+      addItem: vi
+        .fn()
+        .mockReturnValue(of({ data: {}, message: 'Producto agregado correctamente' })),
     };
     const toastServiceStub = { success: vi.fn(), danger: vi.fn() };
 

src/app/features/store/pages/store-home-page/store-home-page.component.ts

@@ -1,6 +1,7 @@
 import {
   ChangeDetectionStrategy,
   Component,
+  Injector,
   OnDestroy,
   OnInit,
   computed,
@@ -12,14 +13,16 @@ import { ActivatedRoute, Router } from '@angular/router';
 import { Subscription } from 'rxjs';
 
 import { CartService } from '../../../../core/services/cart/cart.service';
+import { AuthService } from '../../../../core/services/auth/auth.service';
 import { CatalogFeaturedGroup } from '../../../../core/services/catalog/catalog.interface';
 import { CatalogService } from '../../../../core/services/catalog/catalog.service';
 import { TenantService } from '../../../../core/services/tenant.service';
 import { ToastService } from '../../../../core/services/toast.service';
+import { CheckoutService } from '../../../../core/services/checkout.service';
 import {
   ProductListComponent,
   ProductListCartEvent,
-  ProductListItem,
+  ProductListBuyEvent,
 } from '../../../../shared/components/product-list/product-list.component';
 import { HeroBannerComponent } from '../../../../shared/components/hero-banner/hero-banner.component';
 import { MainCarouselComponent } from '../../../../shared/components/main-carousel/main-carousel.component';
@@ -44,6 +47,7 @@ import {
 export class StoreHomePageComponent implements OnInit, OnDestroy {
   private readonly cartService = inject(CartService);
   private readonly catalogService = inject(CatalogService);
+  private readonly injector = inject(Injector);
   private readonly route = inject(ActivatedRoute);
   private readonly router = inject(Router);
   private readonly tenantService = inject(TenantService);
@@ -55,16 +59,43 @@ export class StoreHomePageComponent implements OnInit, OnDestroy {
   protected readonly loadingGroupIds = signal<ReadonlySet<number>>(new Set());
   protected readonly error = signal<string | null>(null);
   protected readonly mainCarouselReady = signal(false);
-  protected readonly hasMainCarouselImages = computed(
-    () => (this.tenant()?.main_carousel_images?.length ?? 0) > 0,
+  protected readonly creatingDirectPurchase = signal(false);
+  protected readonly mainCarouselImages = computed(() => this.tenant()?.extras?.carousel ?? []);
+  protected readonly heroConfig = computed(() => this.tenant()?.extras?.heroConfig ?? null);
+  protected readonly additionalInfo = computed(
+    () => this.tenant()?.extras?.additionalInfoConfig?.description?.trim() || null,
   );
+  protected readonly eventConfig = computed(() => {
+    const tenant = this.tenant();
+    const contact = tenant?.social_media ?? [];
+    const activeEvent = tenant?.active_event;
+
+    if (activeEvent) {
+      return {
+        id: activeEvent.id,
+        title: activeEvent.name,
+        location: activeEvent.address,
+        dates: activeEvent.dates.map((eventDate) => ({
+          id: eventDate.id,
+          date: eventDate.date,
+          start_time: eventDate.time_start,
+          end_time: eventDate.time_end,
+        })),
+        contact,
+      };
+    }
+
+    return null;
+  });
+  protected readonly hasMainCarouselImages = computed(() => this.mainCarouselImages().length > 0);
 
   private catalogRequestSubscription: Subscription | null = null;
   private readonly groupRequestSubscriptions = new Map<number, Subscription>();
 
   ngOnInit(): void {
     const resolvedData = this.route.snapshot.data['catalogData'] as
-      StoreHomeCatalogResolvedData | undefined;
+      | StoreHomeCatalogResolvedData
+      | undefined;
 
     if (resolvedData) {
       this.applyResolvedData(resolvedData);
@@ -99,27 +130,67 @@ export class StoreHomePageComponent implements OnInit, OnDestroy {
     this.setGroupLoading(groupId, true);
     this.groupRequestSubscriptions.get(groupId)?.unsubscribe();
 
-    const subscription = this.catalogService.getFeaturedGroupItems(groupId, { page }).subscribe({
-      next: (items) => {
-        this.catalog.update((groups) =>
-          groups.map((candidate) =>
-            candidate.id === groupId ? { ...candidate, items } : candidate,
-          ),
-        );
-        this.error.set(null);
-      },
-      error: () => {
-        this.error.set(STORE_HOME_PRODUCTS_ERROR_MESSAGE);
-        this.setGroupLoading(groupId, false);
-      },
-      complete: () => this.setGroupLoading(groupId, false),
-    });
+    const subscription = this.catalogService
+      .withCustomLoading()
+      .getFeaturedGroupItems(groupId, { page })
+      .subscribe({
+        next: (items) => {
+          this.catalog.update((groups) =>
+            groups.map((candidate) =>
+              candidate.id === groupId ? { ...candidate, items } : candidate,
+            ),
+          );
+          this.error.set(null);
+        },
+        error: () => {
+          this.error.set(STORE_HOME_PRODUCTS_ERROR_MESSAGE);
+          this.setGroupLoading(groupId, false);
+        },
+        complete: () => this.setGroupLoading(groupId, false),
+      });
 
     this.groupRequestSubscriptions.set(groupId, subscription);
   }
 
-  protected onBuyProduct(product: ProductListItem): void {
-    this.router.navigate(['/producto', product.id]);
+  protected async onBuyProduct(event: ProductListBuyEvent): Promise<void> {
+    if (!event.directPurchase) {
+      await this.router.navigate(['/producto', event.product.id]);
+      return;
+    }
+
+    if (this.creatingDirectPurchase()) {
+      return;
+    }
+
+    if (!this.injector.get(AuthService).user()) {
+      await this.router.navigate(['/login'], {
+        queryParams: { returnUrl: `/producto/${event.product.id}` },
+      });
+      return;
+    }
+
+    const tenant = this.tenantService.tenant();
+    if (!tenant) {
+      this.toastService.danger('No se pudo identificar la tienda.');
+      return;
+    }
+
+    this.creatingDirectPurchase.set(true);
+    try {
+      const purchase = await this.injector.get(CheckoutService).startCheckout(tenant.codigo, {
+        direct_item: {
+          catalog_item_id: event.product.id,
+          variant_id: event.variant ?? null,
+          cantidad: event.quantity,
+        },
+      });
+      await this.router.navigate(['/checkout'], { queryParams: { purchase: purchase.id } });
+    } catch (error) {
+      console.error('Failed to create direct purchase:', error);
+      this.toastService.danger('No se pudo iniciar la compra directa.');
+    } finally {
+      this.creatingDirectPurchase.set(false);
+    }
   }
 
   protected onAddToCart(event: ProductListCartEvent): void {
@@ -139,15 +210,18 @@ export class StoreHomePageComponent implements OnInit, OnDestroy {
     this.error.set(null);
     this.catalogRequestSubscription?.unsubscribe();
 
-    this.catalogRequestSubscription = this.catalogService.getCatalog().subscribe({
-      next: (catalog) => this.catalog.set(catalog),
-      error: () => {
-        this.catalog.set([]);
-        this.loading.set(false);
-        this.error.set(STORE_HOME_PRODUCTS_ERROR_MESSAGE);
-      },
-      complete: () => this.loading.set(false),
-    });
+    this.catalogRequestSubscription = this.catalogService
+      .withCustomLoading()
+      .getCatalog()
+      .subscribe({
+        next: (catalog) => this.catalog.set(catalog),
+        error: () => {
+          this.catalog.set([]);
+          this.loading.set(false);
+          this.error.set(STORE_HOME_PRODUCTS_ERROR_MESSAGE);
+        },
+        complete: () => this.loading.set(false),
+      });
   }
 
   private applyResolvedData(resolvedData: StoreHomeCatalogResolvedData): void {

src/app/features/store/store.routes.ts

@@ -6,9 +6,13 @@ import { authGuard, guestOnlyGuard } from '../../core/services/auth/auth.guards'
 import { LoginPageComponent } from './pages/login-page/login-page.component';
 import { hasMenuGuard } from '../../core/guards/menu.guard';
 import { productDetailResolver } from './pages/product-detail-page/product-detail-page.resolver';
+import { RecoverPasswordCodePageComponent } from './pages/recover-password-code-page/recover-password-code-page.component';
+import { RecoverPasswordPageComponent } from './pages/recover-password-page/recover-password-page.component';
+import { ResetPasswordPageComponent } from './pages/reset-password-page/reset-password-page.component';
 import { RegisterPageComponent } from './pages/register-page/register-page.component';
 import { StoreHomePageComponent } from './pages/store-home-page/store-home-page.component';
 import { storeHomeCatalogResolver } from './pages/store-home-page/store-home-page.resolver';
+import { checkoutPendingPurchaseGuard } from './pages/checkout-page/checkout-page.guard';
 
 export const routes: Routes = [
   {
@@ -45,11 +49,37 @@ export const routes: Routes = [
           },
         ],
       },
+      {
+        path: 'recuperar-contrasena',
+        canActivate: [guestOnlyGuard],
+        component: SimpleLayoutComponent,
+        children: [
+          {
+            path: '',
+            component: RecoverPasswordPageComponent,
+          },
+          {
+            path: 'codigo',
+            component: RecoverPasswordCodePageComponent,
+          },
+          {
+            path: 'restablecer',
+            component: ResetPasswordPageComponent,
+          },
+        ],
+      },
       {
         path: 'buscar',
         loadComponent: () =>
           import('./pages/search-page/search-page.component').then((m) => m.SearchPageComponent),
       },
+      {
+        path: 'categoria/:id',
+        loadComponent: () =>
+          import('./pages/category-items-page/category-items-page.component').then(
+            (m) => m.CategoryItemsPageComponent,
+          ),
+      },
       {
         path: 'producto/:id',
         canActivate: [hasMenuGuard('product.detail')],
@@ -64,6 +94,7 @@ export const routes: Routes = [
       {
         path: 'checkout',
         canActivate: [authGuard, hasMenuGuard('checkout')],
+        canDeactivate: [checkoutPendingPurchaseGuard],
         loadComponent: () =>
           import('./pages/checkout-page/checkout-page.component').then(
             (m) => m.CheckoutPageComponent,

src/app/shared/components/cart-item/cart-item.component.html

@@ -34,20 +34,25 @@
       }
     </div>
 
-    <div class="d-flex justify-content-end align-items-center mt-auto cart-item-actions">
-      <app-quantity-selector
-        size="small"
-        [quantity]="quantity()"
-        (quantityChange)="onQuantityChange($event)"
-        (increase)="onIncrease()"
-        (decrease)="onDecrease()"
-      />
-      <app-icon-button
-        variant="trash"
-        class="cart-item-remove-btn"
-        (click)="onRemove()"
-      />
-    </div>
+    @if (!readonly()) {
+      <div class="d-flex justify-content-end align-items-center mt-auto cart-item-actions">
+        <app-quantity-selector
+          size="small"
+          [quantity]="quantity()"
+          [disabled]="quantityDisabled()"
+          (quantityChange)="onQuantityChange($event)"
+          (increase)="onIncrease()"
+          (decrease)="onDecrease()"
+        />
+        @if (!quantityDisabled() && showRemove()) {
+          <app-icon-button
+            variant="trash"
+            class="cart-item-remove-btn"
+            (click)="onRemove()"
+          />
+        }
+      </div>
+    }
   </div>
 </article>