feat: enhance checkout process with purchase editing and status handling

- Implemented purchase editing functionality in CheckoutPageComponent, allowing users to modify items in their purchase.
- Added a new guard (checkoutPendingPurchaseGuard) to prevent navigation away from the checkout page while a purchase is in progress.
- Updated the login page to handle return URLs after authentication.
- Enhanced product detail page to support direct purchases with a new buyNow method.
- Introduced new UI elements and logic to handle purchase status, including expired and rejected states in PurchaseStatusPageComponent.
- Improved cart component to allow editing of item quantities with a toggle button.
- Added quantity selector enhancements to disable controls when necessary.
- Updated tests to cover new functionalities and ensure proper behavior of components.

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

@@ -1,7 +1,11 @@
-
-  <div class="checkout-page">
-    <div class="checkout-page__stepper-col ">
-      <app-stepper #stepper>
+<div class="checkout-page">
+  <div
+    class="checkout-page__stepper-col"
+    [class.checkout-page__stepper-col--editing]="isEditingItems()"
+    [attr.aria-hidden]="isEditingItems()"
+    [attr.inert]="isEditingItems() ? '' : null"
+  >
+    <app-stepper #stepper>
         <app-step label="Datos" [isValid]="isStep1Valid()">
           <app-checkout-data-step
             [form]="form"
@@ -30,16 +34,32 @@
             (retryQrPolling)="retryQrPolling()"
           />
         </app-step>
-      </app-stepper>
-    </div>
-
-    <div class="checkout-page__cart-col">
-      <app-cart
-        [items]="mappedCartItems()"
-        [subtotal]="cartSubtotal()"
-        [discount]="cartDiscount()"
-        [total]="cartTotal()"
-        backgroundColor="transparent"
-      />
-    </div>
+    </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,6 +12,27 @@
     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 {

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

@@ -1,18 +1,24 @@
 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>;
   };
@@ -23,6 +29,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,6 +44,16 @@ 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' },
       }),
@@ -63,14 +81,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 +118,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 +137,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);
   });
@@ -181,7 +213,7 @@ describe('CheckoutPageComponent payment validation', () => {
 
     await component.onComplete();
 
-    expect(cartServiceStub.clearCart).toHaveBeenCalledOnce();
+    expect(cartServiceStub.clearCart).not.toHaveBeenCalled();
     expect(routerStub.navigate).toHaveBeenCalledWith(['/checkout/status', 25]);
   });
 
@@ -197,4 +229,175 @@ 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,
+      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('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,11 +52,12 @@ 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;
 
@@ -74,19 +76,23 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
     telefono: ['', [Validators.required]],
   });
 
+  protected readonly createdPurchase = signal<PurchaseDetailResponse | null>(null);
+
   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 +106,19 @@ 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');
 
   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 +137,126 @@ 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 +266,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;
     }
 
@@ -266,6 +350,7 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
         }
 
         this.qrData.set(response.qr_data.qr_code);
+        this.markPurchasePendingPayment();
         this.startQrPolling();
       }
     } catch (error) {
@@ -276,6 +361,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();
 
@@ -291,10 +380,11 @@ export class CheckoutPageComponent implements OnInit, OnDestroy {
         tenant.codigo,
         purchaseId,
         'transfer',
-        dni
+        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;
@@ -448,11 +539,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 +562,23 @@ 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.getPurchase(tenant.codigo, purchaseId);
+      this.createdPurchaseId.set(purchase.id);
+      this.createdPurchase.set(purchase);
+    } 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/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',
@@ -84,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));
@@ -131,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

@@ -73,9 +73,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 {
@@ -72,6 +77,9 @@ describe('ProductDetailPageComponent', () => {
       danger: vi.fn(),
       info: vi.fn(),
     };
+    checkoutServiceStub = {
+      startCheckout: vi.fn().mockResolvedValue({ id: 44 }),
+    };
   });
 
   async function configureTestingModule() {
@@ -100,6 +108,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();
   }
@@ -364,7 +392,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 +408,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);
@@ -253,6 +260,55 @@ export class ProductDetailPageComponent implements OnInit, OnDestroy {
     });
   }
 
+  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 {
     return product.inventory_policy === 'unlimited' || (variant.stock_tecnico ?? 0) > 0;
   }

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

@@ -57,6 +57,20 @@
         Actualizar estado
       </app-button>
     </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>
+
+    <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">
       <div class="status-content__icon status-content__icon--error">

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

@@ -5,7 +5,7 @@ import { CheckoutService, PurchaseStatusResponse } from '../../../../core/servic
 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',
@@ -93,6 +93,10 @@ export class PurchaseStatusPageComponent implements OnInit, OnDestroy {
       return 'rejected';
     }
 
+    if (purchase.status === 'expired') {
+      return 'expired';
+    }
+
     return 'pending';
   }
 

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

@@ -12,6 +12,7 @@ import { ResetPasswordPageComponent } from './pages/reset-password-page/reset-pa
 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 = [
   {
@@ -86,6 +87,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,