S11 - Integración con Cliente Frontend: Angular 22 sobre el Gateway, con Keycloak¶
Por: Angel Sullon Macalupu @asullom - 2026
1. Introducción¶
Tiempo: 20 min.
1.1 Presentación de la sesión¶
S7 construyó pagatu-auth-ms a propósito como una pieza temporal — la Tabla 6 de esa sesión ya dejó escrito, celda por celda, qué reemplaza Keycloak y qué no cambia en el Gateway ni en pagatu-orden-ms; la Figura 6 de esa misma sesión ya dibujó el flujo Authorization Code + PKCE (Proof Key for Code Exchange) "del cliente Angular con Keycloak (S11)"; y 3.27 ya hizo, a mano, el cálculo de code_challenge que "reproduce el cálculo que hará el cliente Angular en S11". Ninguna de esas tres cosas era retórica: S07b ya ejecutó ese reemplazo —pagatu-auth-ms retirado, Keycloak con el realm pagatu validado por el Gateway y pagatu-orden-ms mediante issuer-uri— como paso intermedio entre S7 y esta sesión. Hoy se construye lo que faltaba: el primer y único cliente frontend del curso — hasta ahora, pagatu solo se probó desde PowerShell, curl y Swagger.
Requisito: haber completado S07b completa, incluida la sección 7 (Keycloak corriendo, realm pagatu, pagatu-auth-ms retirado, Gateway/pagatu-orden-ms validando por issuer-uri, y idCliente ya migrado a sub — código de pagatu-orden-ms y columna de Postgres, 7.3-7.4) — esta sesión parte de ese estado. Sin la migración de 7.3-7.4, OrdenController.crear espera un claim idCliente que ya no existe (S07b retiró el protocol mapper que lo generaba) y falla con IllegalArgumentException en cualquier intento de crear una orden.
El reto real no es solo "hacer un login y mostrar una tabla": pagatu-orden-ms y pagatu-pago-ms se comunican de forma asíncrona desde S8 (mensajería con Kafka) y S9 (consistencia distribuida con el patrón Saga) — crear una orden no deja pagada la orden en la misma respuesta HTTP. El cliente Angular tiene que mostrarle a un usuario real una orden que queda PENDIENTE_PAGO al crearse, y que en algún momento posterior, sin que nadie recargue la página a mano, pasa a PAGADA o a CANCELADA — la consistencia eventual que S9 resolvió del lado del backend ahora tiene que resolverse también del lado de la interfaz.
1.2 Índice¶
- Punto de partida: qué dejó S07b, y qué le toca a esta sesión.
- CORS en el Gateway: el primer cliente que llama desde un origen distinto.
- Arquitectura mínima de la SPA y login con Authorization Code + PKCE.
- Consistencia eventual en la interfaz: de "pendiente" a "pagada" sin que el usuario recargue nada.
1.3 Propósito de aprendizaje¶
Al concluir la clase, estarás en condiciones de:
- Ejecutar el reemplazo de un servidor de autorización propio por Keycloak sin tocar el código de los resource servers, construir un cliente Angular con Authorization Code + PKCE a través de un API Gateway, y diseñar una interfaz que refleje con honestidad un estado que todavía no se resolvió, en vez de asumir que una respuesta HTTP exitosa significa que el proceso de negocio completo ya terminó.
1.4 Producto de sesión¶
pagatu-frontend (Angular 22), el primer cliente del curso: CORS habilitado en el Gateway, login real con Authorization Code + PKCE contra el Keycloak que S07b ya dejó corriendo, catálogo de productos, creación de una orden y una pantalla de "Mis pedidos" que muestra el estado real de cada orden — incluida la transición de PENDIENTE_PAGO a PAGADA/CANCELADA, verificada de punta a punta sin recargar la página a mano.
1.5 Metodología¶
Tabla 1. Metodología de la sesión
| Actividades a Realizar en el Periodo | Orientaciones generales (Orientaciones Metodológicas) | Material de estudio recomendado |
|---|---|---|
| Revisión previa individual | Completar S07b si tu equipo todavía no lo hizo — es prerrequisito, no parte de la clase de hoy. Repasar S7 (2.4 completa, Tabla 6, Figura 6, 3.27) y S9 (el patrón Saga y los estados de EstadoOrden). Confirmar que Keycloak, el Gateway, pagatu-orden-ms/pagatu-pago-ms y Kafka siguen corriendo (obs/ no hace falta para esta sesión). Trabajo individual, antes de clase. |
S07b completa, S7 (2.4, Tabla 6), S9 (2.2-2.4). |
| Clase presencial | Construcción guiada del cliente Angular, login con PKCE, catálogo, creación de orden y la pantalla de consistencia eventual. Trabajo individual en la propia laptop, siguiendo al docente paso a paso. | Contenedores y servicios corriendo, Pasos 3.1 a 3.8 de esta guía. |
| Evaluación formativa | Revisión en clase del login real, la creación de una orden y su transición observada de PENDIENTE_PAGO a su estado final. La evidencia se completa y sustenta de forma individual, fuera del aula, según los criterios mínimos de la sección 4.4. |
Indicaciones de entrega (4.3), rúbrica de evaluación (4.6). |
1.6 Motivación de la sesión¶
1.6.1 Caso: dos pestañas, la misma tarjeta, y una condición de carrera que Starbucks tardó más de un mes en admitir¶
En marzo de 2015, el investigador Egor Homakov encontró que el sistema de recarga y transferencia de saldo entre tarjetas de regalo de Starbucks no serializaba correctamente dos operaciones simultáneas sobre la misma cuenta. Abrió dos sesiones distintas (dos navegadores, dos cookies de sesión) y disparó, casi al mismo instante, dos transferencias idénticas desde la misma tarjeta de origen. El sistema procesó las dos como válidas — el saldo de la tarjeta de destino terminó duplicado, como si la validación de "hay saldo suficiente" hubiera revisado el mismo número dos veces antes de que la primera transferencia alcanzara a descontarlo. Homakov reportó el hallazgo el 23 de marzo; Starbucks no respondió hasta el 29 de abril (Schneier, 2015).
Fuente: Schneier, B. (2015, 27 de mayo). Race Condition Exploit in Starbucks Gift Cards. Schneier on Security. https://www.schneier.com/blog/archives/2015/05/race_condition_.html
El paralelo con pagatu no es decorativo: PagoServiceImpl.procesar (S8) ya se defiende exactamente de este problema — revisa si el ordenId ya tiene un pago registrado antes de procesar, y además atrapa DataIntegrityViolationException como una segunda línea de defensa para una condición de carrera real (dos eventos casi simultáneos intentando crear el mismo pago). Esa protección existe desde S8 precisamente porque un sistema distribuido con mensajería asíncrona puede entregar —o un cliente puede, sin querer, provocar— el mismo evento más de una vez. Hoy, el lado que todavía no se construyó es el opuesto: la interfaz que un usuario ve. Si el cliente Angular asumiera que la respuesta de POST /api/v1/ordenes ya significa "pagado", o si volviera a enviar la misma orden porque el usuario, ansioso, hizo doble clic sin ver confirmación, el problema de Starbucks —confiar en que una operación ya terminó cuando en realidad sigue en curso— se repetiría del lado del cliente, no del servidor.
Preguntas de análisis
Activación de conocimientos previos
- ¿Qué tendría que haber hecho el sistema de Starbucks para que las dos transferencias simultáneas no se procesaran ambas como válidas?
Comprensión de consistencia eventual en la interfaz
- Si
pagatu-frontendmostrara "Pedido confirmado" apenas recibe la respuesta201dePOST /api/v1/ordenes, ¿qué información real todavía no tiene en ese momento? - ¿Por qué
PagoServiceImpl.procesar(S8) revisa si el pago ya existe antes de crearlo, en vez de confiar en que Kafka nunca entrega un evento duplicado?
1.7 Ubicación en el curso¶
- Unidad: U2 - Sistema distribuido robusto.
- Producto del curso: sistema distribuido de microservicios end-to-end, configurable, escalable, seguro, resiliente, consistente, observable, integrado con frontend y defendido técnicamente.
- Producto de unidad: sistema distribuido seguro, resiliente, consistente, observable e integrado con cliente frontend.
- Avance del producto en esta sesión: el primer cliente Angular del curso, con login real contra Keycloak (ya migrado en S07b), catálogo, creación de orden y consistencia eventual en la interfaz.
Figura 1. Roadmap del producto de la unidad
flowchart TB
S7["`**S7:** Seguridad distribuida`"]
S8["`**S8:** Mensajería asíncrona`"]
S9["`**S9:** Consistencia distribuida`"]
S10["`**S10:** Observabilidad y diagnóstico`"]
S11["`**S11:** Integración con cliente frontend`"]
S12["`**S12:** Producto U2`"]
S7 --> S8 --> S9 --> S10 --> S11 --> S12
classDef today fill:#ffe08a,stroke:#9a6b00,stroke-width:2px,color:#111;
class S11 today;
2. Explica¶
Tiempo: 30 min.
2.1 Arquitectura de la sesión¶
Figura 2. Del login a una orden que todavía no sabe si está pagada
sequenceDiagram
actor U as Usuario (CLIENTE)
participant SPA as pagatu-frontend
participant KC as Keycloak (realm pagatu)
participant GW as pagatu-gateway
participant Ord as pagatu-orden-ms
participant Kafka as Kafka
participant Pago as pagatu-pago-ms
U->>SPA: abre la SPA
SPA->>KC: Authorization Code + PKCE (2.4 de S7)
KC-->>SPA: access_token (sub=idCliente, realm_access.roles)
SPA->>GW: POST /api/v1/ordenes (Bearer)
GW->>Ord: enruta (lb://)
Ord-->>GW: 201, estado=PENDIENTE_PAGO
GW-->>SPA: 201, estado=PENDIENTE_PAGO
Ord->>Kafka: orden.creada
Kafka->>Pago: consume
Pago->>Kafka: pago.validado o pago.fallido
Kafka->>Ord: consume, marca PAGADA o CANCELADA
SPA->>GW: GET /api/v1/ordenes/{id} (consulta repetida)
GW->>Ord: enruta
Ord-->>SPA: estado=PAGADA (o CANCELADA)
Lectura del diagrama: hay un instante —entre la respuesta 201 y el momento en que pagatu-orden-ms consume el evento de vuelta— en el que la orden existe, tiene un id, y nadie en el sistema sabe todavía si se va a pagar. Ese instante no es un error ni un caso raro: es el costo normal de la consistencia eventual que S9 ya construyó del lado del backend. 2.5 desarrolla cómo la interfaz debe comportarse durante ese instante, en vez de ignorarlo.
2.2 Punto de partida: qué dejó S07b, y qué le toca a esta sesión¶
S07b ya ejecutó, fila por fila, la Tabla 1 de esa guía: pagatu-auth-ms retirado, Keycloak con el realm pagatu, los roles CLIENTE/ADMIN, y idCliente migrado a sub — a diferencia de lo que S7 (3.13) diseñó originalmente (un user attribute + protocol mapper propios, porque ahí idCliente todavía era "un dato de negocio que no coincide por definición con quién inició sesión"), S07b (7.4) cambió de criterio: idCliente pasó a ser literalmente sub, el mismo patrón que vendedorId ya usaba en LP2 (BomERP), evitando que alguien tenga que asignar a mano un identificador único por cada cliente nuevo. El Gateway y pagatu-orden-ms ya validan por issuer-uri, sin que el conversor de roles ni ninguna regla hasRole hayan cambiado una línea.
Lo que no dejó resuelto S07b, a propósito —porque es una necesidad del cliente de hoy, no del cambio de proveedor de identidad—, es CORS (2.3) y, por supuesto, el cliente Angular en sí (2.4 en adelante).
2.3 CORS en el Gateway: el primer cliente que llama desde un origen distinto¶
Hasta hoy, cada petición a pagatu salió de PowerShell, curl o Swagger — ninguno de los tres es un navegador ejecutando JavaScript desde un origen (origin: protocolo + dominio + puerto) distinto al del servidor. pagatu-frontend sí lo es: corre en http://localhost:4200 (el puerto por defecto de Angular), y llama a pagatu-gateway en http://localhost:18080 — dos orígenes distintos, por definición (CORS, Cross-Origin Resource Sharing, compara los tres componentes, y el puerto ya es suficiente para que difieran). Sin configurar CORS en el Gateway, el navegador bloquea la respuesta antes de que el código de Angular la vea, con un error que nunca aparece en Postman/curl porque esa política la aplica el navegador, no el servidor ni ninguna herramienta de línea de comandos.
El Gateway es el lugar correcto para esta configuración — no cada microservicio por separado: es el único componente por el que pasa cualquier petición del cliente, y configurarlo ahí una sola vez cubre pagatu-catalogo-ms, pagatu-orden-ms y pagatu-pago-ms a la vez, sin tocar ninguno de los tres. 3.3 lo construye.
2.4 Arquitectura mínima de la SPA y login con PKCE¶
pagatu-frontend reutiliza exactamente el mismo mecanismo que S7 (2.4, Figura 6) ya diagramó y que 3.27 de esa sesión ya calculó a mano: generar un code_verifier, derivar su code_challenge con SHA-256, redirigir a Keycloak, recibir un code de un solo uso, y canjearlo por tokens presentando el code_verifier original. Esta sesión no repite esa explicación — la ejecuta en TypeScript en vez de en PowerShell/bash.
Tabla 2. Dónde vive cada pieza de la sesión, según S7 (2.4, línea de "Errores de diseño más comunes")
| Pieza | Decisión de esta sesión | Por qué (S7, 2.4) |
|---|---|---|
access_token/refresh_token |
En memoria (un campo privado de un servicio Angular, nunca en localStorage) |
S7 ya lo advirtió: "Guardar access tokens en localStorage, vulnerable a XSS" — es uno de los "errores de diseño más comunes" que esa misma sesión lista para cuando llegara el cliente Angular. |
code_verifier |
sessionStorage, solo durante la ida y vuelta a Keycloak, borrado tras usarse una vez |
La redirección completa recarga la página — el JavaScript en memoria se pierde; el code_verifier por sí solo, sin el code de esa sesión de login específica, no sirve para nada. |
state (parámetro anti-CSRF) |
Generado junto al code_verifier, verificado al volver |
S7 ya lo advirtió: "No validar el parámetro state en el redirect, que protege contra CSRF" — es el segundo "error de diseño común" de esa misma lista. |
La fila de refresh_token en una cookie httpOnly —la alternativa que S7 (2.4) menciona como "la habitual"— exige un Backend-for-Frontend que gestione esa cookie, una pieza que ningún servicio de pagatu construye hoy; esta sesión documenta esa limitación con la misma honestidad que S10 documentó el límite de licencia de AWR (Automatic Workload Repository) en Oracle Database Free — no es que no se conozca la opción mejor, es que queda fuera del alcance de esta sesión.
2.5 Consistencia eventual en la interfaz: de "pendiente" a "pagada" sin recargar¶
La Figura 2 (2.1) ya mostró el instante en el que una orden existe pero su pago todavía no se resolvió. Una interfaz honesta tiene tres opciones reales frente a ese instante — ninguna de las tres es "asumir que ya terminó":
Tabla 3. Tres formas de reflejar un estado que todavía no se resolvió
| Estrategia | Cómo funciona | Costo |
|---|---|---|
| Polling (sondeo periódico) | El cliente vuelve a pedir GET /api/v1/ordenes/{id} cada pocos segundos, mientras el estado siga PENDIENTE_PAGO. |
Tráfico adicional, mientras la respuesta no cambie; simple de construir, sin infraestructura nueva. |
| WebSocket/Server-Sent Events | El servidor empuja la actualización al cliente apenas cambia el estado, sin que el cliente pregunte. | Elimina el tráfico redundante del polling, pero exige una conexión persistente y código nuevo en cada microservicio involucrado. |
| Recarga manual | El usuario mismo refresca la pantalla para ver si ya cambió. | El mínimo esfuerzo de construcción, pero traslada el trabajo de "darse cuenta" al usuario — la peor experiencia de las tres. |
Esta sesión construye polling (3.7) — no porque sea la opción ideal en términos absolutos (WebSocket evita tráfico redundante, y una arquitectura orientada a eventos con Server-Sent Events es el camino natural para un sistema que ya es 100% asíncrono del lado del backend), sino porque es la que se puede construir y verificar de punta a punta en una sesión, sin agregar infraestructura nueva a pagatu-orden-ms. Queda documentado, igual que el Backend-for-Frontend de 2.4, como un límite honesto de alcance, no como una decisión de que polling sea la respuesta correcta para cualquier sistema.
3. Aplica: actividad práctica guiada¶
Tiempo: 100 min.
Actividad: construcción del primer cliente Angular del curso, en el mismo orden incremental que LP2 ya usó (S7 de esa guía): primero una pantalla real sin ninguna seguridad, directo contra un microservicio, para confirmar que el proyecto en sí funciona; recién después el Gateway, CORS y Keycloak; y solo al final, con el login ya resuelto, todo lo que depende de saber quién inició sesión (órdenes, pagos, consistencia eventual) (Producto de la sesión en 1.4).
Propósito de la actividad: que cada estudiante vea, de punta a punta, que todo lo diseñado en S7 sobre papel (Tabla 6, Figura 6) se ejecuta sin sorpresas cuando llega el momento, y que una interfaz real puede mostrar honestamente un estado que el propio sistema todavía no resolvió — sin tener que depurar Angular y PKCE al mismo tiempo, desde el primer minuto.
Orientaciones metodológicas: el docente construye la SPA paso a paso frente a la clase, probando cada pieza contra el sistema real (ya migrado a Keycloak en S07b) antes de avanzar; los estudiantes replican cada paso en su propia instancia y provocan ellos mismos el caso de un método de pago rechazado (3.8) para ver la transición a CANCELADA en su propia pantalla.
Actividades para realizar:
- 3.1 Verificar el punto de partida.
- 3.2 Crear el proyecto Angular 22 y una pantalla de categorías, sin seguridad.
- 3.3 Cambiar al Gateway y habilitar CORS ahí.
- 3.4 Login con Authorization Code + PKCE.
- 3.5 Crear una orden.
- 3.6 Agregar la consulta de pago por orden en
pagatu-pago-ms. - 3.7 "Mis pedidos": consistencia eventual con polling.
- 3.8 Probar de punta a punta, incluido un pago rechazado.
3.1 Verificar el punto de partida¶
Producto del paso: confirmación de que S07b ya quedó completa, y de que todo el sistema sigue corriendo sobre Keycloak.
git clone --branch s07b-keycloak https://github.com/262dist/pagatu.git
Si tu equipo no congeló esa rama, clona s07-seguridad-jwt y completa S07b tú mismo antes de seguir — no continúes con pagatu-auth-ms todavía corriendo, ni con Orden.idCliente todavía como Long (S07b, 7.3-7.4). Levanta pagatu-config, pagatu-eureka, pagatu-gateway, Keycloak (keycloak/), los tres microservicios que quedan activos (pagatu-catalogo-ms, pagatu-orden-ms, pagatu-pago-ms — pagatu-auth-ms ya está retirado, S07b, sección 8) y kafka/ — obs/ no hace falta para esta sesión (README raíz): nada de lo que construyes hoy depende de Prometheus/Grafana/Loki, y Docker ya va suficientemente cargado con lo anterior. Confirma en http://localhost:18761 (Eureka) que los tres microservicios y el Gateway aparecen registrados, que http://localhost:19000/health/ready (Keycloak) responde {"status": "UP"}, y que una petición con un token de Keycloak (el mismo procedimiento de S07b, 7.4) sigue devolviendo 200 contra http://localhost:18080/api/v1/ordenes.
Parte A — Angular sin seguridad, directo contra un microservicio¶
Las secciones 3.2 solas construyen pagatu-frontend desde cero y confirman que el proyecto en sí funciona, llamando directo a pagatu-catalogo-ms, sin Gateway, sin Keycloak. Nada de esto se vuelve a tocar en la Parte B — lo que cambia ahí es dónde apunta la aplicación, no cómo está construida.
3.2 Crear el proyecto Angular 22 y una pantalla de categorías, sin seguridad¶
Producto del paso: pagatu-frontend corriendo en el navegador, con un CRUD completo de categorías (listar, crear, editar, eliminar) — sin Gateway, sin CORS centralizado, sin Keycloak — para confirmar que el proyecto en sí funciona antes de sumarle seguridad: si algo falla más adelante, esta pantalla ya deja descartado que el problema sea Angular o el backend.
Instalar Node.js y la CLI de Angular. Si nunca instalaste Angular en esta laptop, hace falta esto primero:
Instala Node.js LTS (incluye npm, el instalador de paquetes de Node). Verifica la instalación:
node --version
npm --version
Solo en Windows. npm y ng se instalan como scripts de PowerShell (.ps1), y PowerShell bloquea por defecto la ejecución de cualquier script local — sin este permiso, el siguiente comando (o cualquier ng que corras después) falla con no se puede cargar el archivo ... porque la ejecución de scripts está deshabilitada en este sistema. Habilítalo una sola vez por usuario:
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
-Scope CurrentUser limita el cambio a tu propio usuario, no a toda la máquina — no hace falta ser administrador. En macOS/Linux este paso no aplica: la terminal no restringe ejecutar scripts por defecto.
Instala la CLI de Angular de forma global, fijando la versión 22:
npm install -g @angular/cli@22
Verifica:
ng version
Debe mostrar Angular CLI: 22.x.x. Si aparece una versión distinta (de otro curso, por ejemplo), no hace falta desinstalarla primero: vuelve a correr el mismo comando — npm sobrescribe en el mismo lugar la versión global que ya tengas.
Crear el proyecto, dentro de clients/ — ese directorio ya existe reservado en la raíz del repositorio (README) precisamente porque pagatu-frontend no tiene por qué ser el único cliente: mañana puede sumarse una app móvil u otro frontend web, cada uno en su propia carpeta junto a este:
mkdir clients
cd clients
ng new pagatu-frontend --routing --style=css --ssr=false
cd pagatu-frontend
La CLI hace un par de preguntas interactivas antes de generar el proyecto:
- "Which AI tools should Angular integrate with?" — elige None. Cada opción agrega archivos de configuración que no son parte de lo que esta sesión enseña.
- Motor de pruebas end-to-end — elige No (no es tema de esta sesión).
ng serve
Abre http://localhost:4200 — debe mostrarse la página de bienvenida por defecto de Angular.
Recorrer la estructura generada, antes de tocar nada: dentro de src/app/, ng new ya dejó app.ts (componente raíz), app.html, app.config.ts (los providers de la aplicación) y app.routes.ts — este último empieza vacío (export const routes: Routes = [];), sin ninguna ruta todavía. Zoneless (sin Zone.js) ya es el comportamiento por defecto de Angular 22, sin necesidad de ninguna bandera ni provider adicional — por eso el comando de arriba no lleva ninguna opción relacionada.
Reemplaza app.html (todavía trae la página de bienvenida de la CLI, que nunca es parte de pagatu-frontend) por algo vacío por ahora:
<router-outlet />
Guarda y mira http://localhost:4200: la página queda en blanco. Es lo esperado, no un error — app.routes.ts todavía no tiene ninguna ruta, así que <router-outlet /> no tiene nada que mostrar todavía.
Crear el layout: encabezado y menú. Esta pantalla ya no va a ser la única — en este mismo paso vas a tener categorias, categorias/nueva y categorias/:id/editar, y más adelante (3.5, 3.7) se suman las de órdenes — así que, a diferencia de un ejemplo de una sola pantalla, sí hace falta un lugar fijo para el menú que no se repita dentro de cada componente. En Angular, eso se resuelve con una ruta padre: un componente de layout con su propio <router-outlet />, y las pantallas de cada funcionalidad como rutas hijas que se renderizan ahí dentro (mismo patrón de LP2 S07, 2.4/3.5).
De aquí hasta el final de este paso, todo es Angular puro — ningún archivo todavía llama al backend. La idea es ir viendo en el navegador, paso a paso, lo que cada pieza nueva agrega (el router, el layout, la navegación) antes de sumarle la comunicación con pagatu-catalogo-ms.
El comando de la CLI es opcional — en esta guía (y en el resto de la sesión) cada paso ya muestra el contenido completo de cada archivo, así que crear layout.ts/layout.html/layout.css a mano, con ese mismo contenido, funciona exactamente igual. Si vienes de React, donde no es costumbre generar archivos por un comando, puedes saltarte esto y solo crear los tres archivos directamente en src/app/core/layout/. Si prefieres que la CLI cree el andamiaje (incluye un layout.spec.ts de pruebas que esta sesión no usa):
ng generate component core/layout
src/app/core/layout/layout.ts:
import { Component } from '@angular/core';
import { RouterOutlet, RouterLink, RouterLinkActive } from '@angular/router';
@Component({
selector: 'app-layout',
imports: [RouterOutlet, RouterLink, RouterLinkActive],
templateUrl: './layout.html',
styleUrl: './layout.css',
})
export class Layout {}
src/app/core/layout/layout.html:
<header class="header">
<a routerLink="/" class="home-link">pagatu</a>
</header>
<div class="body">
<nav class="sidebar" aria-label="Menú principal">
<a routerLink="/categorias" routerLinkActive="active">Categorías</a>
</nav>
<main class="content">
<router-outlet />
</main>
</div>
src/app/core/layout/layout.css:
:host {
display: flex;
flex-direction: column;
min-height: 100dvh;
}
.header {
display: flex;
align-items: center;
gap: 0.75rem;
padding: 0.75rem 1rem;
background-color: #1f2937;
color: white;
}
.home-link {
color: inherit;
text-decoration: none;
font-weight: 600;
}
.body {
display: flex;
flex: 1;
}
.sidebar {
display: flex;
flex-direction: column;
width: 180px;
padding: 1rem;
border-right: 1px solid #e5e7eb;
}
.sidebar a {
padding: 0.5rem;
color: inherit;
text-decoration: none;
border-radius: 0.25rem;
}
.sidebar a.active {
font-weight: bold;
background-color: #e5e7eb;
}
.content {
flex: 1;
padding: 1rem;
}
routerLinkActive="active" resalta el enlace de la pantalla activa — así quien usa la aplicación sabe en qué sección está sin leer la URL. app.html/app.ts no se tocan: siguen siendo el <router-outlet /> de arriba.
Montar Layout en el router, antes de seguir. Todavía sin ninguna pantalla hija — la idea es confirmar que el layout en sí ya se ve, antes de sumarle nada más encima. Reemplaza src/app/app.routes.ts (hoy vacío):
import { Routes } from '@angular/router';
export const routes: Routes = [
{
path: '',
loadComponent: () => import('./core/layout/layout').then((m) => m.Layout),
},
];
Guarda y mira http://localhost:4200: ya se ve el encabezado ("pagatu") y el menú con Categorías — aunque el área de contenido quede vacía. Es lo esperado, no un error: Layout todavía no tiene ninguna ruta hija que mostrar dentro de su propio <router-outlet /> (eso llega en el siguiente paso). loadComponent (en vez de un import normal arriba del archivo) carga el componente de forma perezosa — recién cuando el router necesita mostrarlo, no antes.
Crear una página de inicio, la primera ruta hija de Layout — sin lógica ni estilos propios: un redirect automático hacia categorias forzaría esa pantalla como si fuera la única posible, en vez de dejar que quien entra a la aplicación elija desde el menú (mismo criterio de LP2 S07, 3.6). De nuevo, la CLI es opcional — crear inicio.ts/inicio.html a mano en src/app/core/inicio/ funciona igual:
ng generate component core/inicio
core/inicio/inicio.ts no necesita ningún cambio: la CLI ya genera una clase vacía (export class Inicio {}), y esta pantalla no tiene ningún estado propio — solo texto. Reemplaza src/app/core/inicio/inicio.html:
<h2>Bienvenido a pagatu</h2>
<p>Usa el menú de la izquierda para navegar entre las pantallas disponibles.</p>
Agrega Inicio como hija de Layout, en src/app/app.routes.ts:
import { Routes } from '@angular/router';
export const routes: Routes = [
{
path: '',
loadComponent: () => import('./core/layout/layout').then((m) => m.Layout),
children: [
{
path: '',
loadComponent: () => import('./core/inicio/inicio').then((m) => m.Inicio),
},
],
},
];
Guarda y vuelve a http://localhost:4200: ahora el área de contenido ya no está vacía — muestra el mensaje de bienvenida de Inicio, dentro del layout. Con el router y la navegación ya confirmados en el navegador, recién ahora tiene sentido sumarle a Angular la comunicación con el backend.
src/environments/environment.ts — por ahora, apunta directo a pagatu-catalogo-ms, no al Gateway:
export const environment = {
apiBaseUrl: 'http://localhost:8080',
};
services/pagatu-catalogo-ms/src/main/java/pe/edu/upeu/catalogo/CorsConfig.java (archivo nuevo) — el mismo patrón que ya usaste en LP2 (un único WebMvcConfigurer, el origen permitido externalizado en application-dev.yml), con una diferencia a propósito: @ConditionalOnProperty hace que todo este bean solo exista si pagatu.cors.enabled=true — así, cuando en 3.3 ya no haga falta, apagarlo es cambiar una línea del YAML y reiniciar, sin tocar ni recompilar este .java (que puede quedarse en el repositorio, igual que pagatu-auth-ms quedó como referencia en S07b):
package pe.edu.upeu.catalogo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.Arrays;
@Configuration
@ConditionalOnProperty(name = "pagatu.cors.enabled", havingValue = "true")
public class CorsConfig implements WebMvcConfigurer {
@Value("${pagatu.cors.allowed-origins}")
private String allowedOrigins;
@Override
public void addCorsMappings(CorsRegistry registry) {
String[] origins = Arrays.stream(allowedOrigins.split(","))
.map(String::trim)
.toArray(String[]::new);
registry.addMapping("/api/**")
.allowedOrigins(origins)
.allowedMethods("GET", "POST", "PUT", "PATCH", "DELETE")
.allowedHeaders("*");
}
}
infra/pagatu-config/config-repo/pagatu-catalogo-ms-dev.yml — agrega las dos propiedades que el CorsConfig espera:
pagatu:
cors:
enabled: true
allowed-origins: http://localhost:4200
pagatu-catalogo-ms no tiene Spring Security (S11 ya lo confirmó: nada le impide responder) — pero el navegador sí bloquea la respuesta sin este header, aunque el servidor la haya enviado sin problema (S07, 2.3).
src/app/features/catalogo/categoria.model.ts (archivo nuevo) — id y descripcion quedan opcionales porque una categoría nueva, antes de crearse, todavía no tiene ninguno de los dos (el backend asigna id; descripcion no es obligatoria, CategoriaRequest solo exige nombre):
export interface Categoria {
id?: number;
nombre: string;
descripcion?: string;
}
src/app/features/catalogo/categoria-service.ts (archivo nuevo) — solo listar, no hace falta el CRUD completo: el objetivo de este paso es confirmar que Angular, CORS y el backend se hablan, no construir la pantalla final de categorías:
import { Injectable, inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
import { environment } from '../../../environments/environment';
import { Categoria } from './categoria.model';
@Injectable({ providedIn: 'root' })
export class CategoriaService {
private readonly http = inject(HttpClient);
listar(): Observable<Categoria[]> {
return this.http.get<Categoria[]>(`${environment.apiBaseUrl}/api/v1/categorias`);
}
}
Igual que con Layout: este comando es opcional, --flat evita el subdirectorio extra que la CLI crearía por defecto (categoria-list/categoria-list.ts) — si prefieres, crea categoria-list.ts/categoria-list.html a mano, directo en features/catalogo/:
ng generate component features/catalogo/categoria-list --flat
src/app/features/catalogo/categoria-list.ts:
import { Component, OnInit, inject, signal } from '@angular/core';
import { CategoriaService } from './categoria-service';
import { Categoria } from './categoria.model';
@Component({
selector: 'app-categoria-list',
templateUrl: './categoria-list.html',
})
export class CategoriaList implements OnInit {
private readonly categoriaService = inject(CategoriaService);
protected readonly categorias = signal<Categoria[]>([]);
protected readonly cargando = signal(true);
protected readonly error = signal<string | null>(null);
ngOnInit(): void {
this.categoriaService.listar().subscribe({
next: (data) => {
this.categorias.set(data);
this.cargando.set(false);
},
error: () => {
this.error.set('No se pudo cargar la lista de categorias.');
this.cargando.set(false);
},
});
}
}
src/app/features/catalogo/categoria-list.html:
@if (cargando()) {
<p>Cargando categorias...</p>
} @else if (error()) {
<p>{{ error() }}</p>
} @else {
<table>
<thead>
<tr><th>Nombre</th><th>Descripcion</th></tr>
</thead>
<tbody>
@for (categoria of categorias(); track categoria.id) {
<tr>
<td>{{ categoria.nombre }}</td>
<td>{{ categoria.descripcion }}</td>
</tr>
} @empty {
<tr><td colspan="2">No hay categorias registradas.</td></tr>
}
</tbody>
</table>
}
Agrega categorias como segunda hija de Layout, junto a Inicio, en src/app/app.routes.ts:
import { Routes } from '@angular/router';
export const routes: Routes = [
{
path: '',
loadComponent: () => import('./core/layout/layout').then((m) => m.Layout),
children: [
{
path: '',
loadComponent: () => import('./core/inicio/inicio').then((m) => m.Inicio),
},
{
path: 'categorias',
loadComponent: () => import('./features/catalogo/categoria-list').then((m) => m.CategoriaList),
},
],
},
];
Confirma en el navegador: haz clic en Categorías (menú) y confirma que la lista aparece — sin ningún token, sin ningún login. Si ves un error de CORS en la consola del navegador (no en la terminal de Angular), revisa que CorsConfig.java quedó creado y que pagatu-catalogo-ms se reinició para tomarlo.
Completa el CRUD: crear, editar y eliminar. Con la lista ya confirmada, agrega a categoria-service.ts los cuatro métodos que todavía faltan, junto a listar():
obtener(id: number): Observable<Categoria> {
return this.http.get<Categoria>(`${environment.apiBaseUrl}/api/v1/categorias/${id}`);
}
crear(categoria: Categoria): Observable<Categoria> {
return this.http.post<Categoria>(`${environment.apiBaseUrl}/api/v1/categorias`, categoria);
}
actualizar(id: number, categoria: Categoria): Observable<Categoria> {
return this.http.put<Categoria>(`${environment.apiBaseUrl}/api/v1/categorias/${id}`, categoria);
}
eliminar(id: number): Observable<void> {
return this.http.delete<void>(`${environment.apiBaseUrl}/api/v1/categorias/${id}`);
}
obtener hace falta porque crear y editar van a vivir en una pantalla separada de la lista (mismo patrón de LP2 S07: CategoriaList solo lista y elimina; CategoriaForm crea y edita, navegando entre una y otra por routing, no con un formulario escondido dentro de la tabla) — al entrar a "editar", esa pantalla nueva necesita poder pedir los datos de una categoría puntual.
En categoria-list.ts, saca la carga de la lista de ngOnInit a un método propio cargar() — vas a necesitar repetirla después de eliminar, no solo al entrar a la pantalla — y agrega eliminar, con una confirmación antes de borrar y un mensaje distinto si el backend rechaza el borrado porque la categoría tiene productos asociados:
import { Component, OnInit, inject, signal } from '@angular/core';
import { HttpErrorResponse } from '@angular/common/http';
import { RouterLink } from '@angular/router';
import { CategoriaService } from './categoria-service';
import { Categoria } from './categoria.model';
@Component({
selector: 'app-categoria-list',
imports: [RouterLink],
templateUrl: './categoria-list.html',
})
export class CategoriaList implements OnInit {
private readonly categoriaService = inject(CategoriaService);
protected readonly categorias = signal<Categoria[]>([]);
protected readonly cargando = signal(true);
protected readonly error = signal<string | null>(null);
protected readonly errorAccion = signal<string | null>(null);
ngOnInit(): void {
this.cargar();
}
private cargar(): void {
this.cargando.set(true);
this.categoriaService.listar().subscribe({
next: (data) => {
this.categorias.set(data);
this.cargando.set(false);
},
error: () => {
this.error.set('No se pudo cargar la lista de categorias.');
this.cargando.set(false);
},
});
}
eliminar(id: number): void {
if (!confirm(`¿Seguro que quieres eliminar la categoría ${id}?`)) {
return;
}
this.errorAccion.set(null);
this.categoriaService.eliminar(id).subscribe({
next: () => this.cargar(),
error: (err: HttpErrorResponse) => {
if (err.status === 500) {
this.errorAccion.set('No se puede eliminar: la categoría tiene productos asociados.');
} else {
this.errorAccion.set('No se pudo eliminar la categoría.');
}
},
});
}
}
errorAccion es una señal distinta de error: error significa "no se pudo traer la lista, no hay nada que mostrar" (3.2) — errorAccion significa "la lista sí está, pero esta acción puntual falló", y la lista debe seguir visible para que el usuario pueda intentar de nuevo o elegir otra fila. Reusar error para los dos casos es el bug que ibas a encontrar al probar: un eliminar fallido dejaría la pantalla entera reemplazada por el mensaje de error (ver más abajo, el @else que envuelve toda la tabla), sin ninguna forma de volver a verla sin salir de la ruta y volver a entrar.
confirm(...) es un diálogo nativo del navegador (sin librerías) — alcanza para esta confirmación puntual; err.status === 500 distingue el caso real que vas a poder reproducir en 3.8 (Producto depende de Categoria, S1/S3): el backend rechaza el DELETE con un error de integridad referencial, y ese catch evita mostrar un mensaje genérico para un problema que sí tiene una explicación concreta.
En categoria-list.html, reemplaza el contenido por el enlace a "nueva categoría" y las acciones de cada fila — errorAccion() se muestra dentro del @else (junto a la tabla), nunca en lugar de ella:
@if (cargando()) {
<p>Cargando categorias...</p>
} @else if (error()) {
<p>{{ error() }}</p>
} @else {
<a routerLink="/categorias/nueva">Nueva categoría</a>
@if (errorAccion()) {
<p class="error">{{ errorAccion() }}</p>
}
<table>
<thead>
<tr><th>Nombre</th><th>Descripcion</th><th></th></tr>
</thead>
<tbody>
@for (categoria of categorias(); track categoria.id) {
<tr>
<td>{{ categoria.nombre }}</td>
<td>{{ categoria.descripcion }}</td>
<td>
<a [routerLink]="['/categorias', categoria.id, 'editar']">Editar</a>
<button (click)="eliminar(categoria.id!)">Eliminar</button>
</td>
</tr>
} @empty {
<tr><td colspan="3">No hay categorias registradas.</td></tr>
}
</tbody>
</table>
}
Error frecuente: después de un eliminar fallido, el enlace Categorías del menú "no responde" — en realidad sí responde, pero el router ya está parado en /categorias, así que un clic sobre el mismo enlace no dispara ninguna navegación nueva (no hay ruta que cambiar) y el componente no se vuelve a crear. Si la pantalla quedó reemplazada por un mensaje de error en vez de la tabla, parece que el menú dejó de funcionar. Con errorAccion separado de error (arriba), esto ya no debería pasar: la tabla queda visible incluso con la acción fallida, así que no hace falta salir de la ruta para recuperar el control.
categoria.id! (con !) le confirma a TypeScript que, para una categoría que ya vino del backend y aparece en esta tabla, id nunca es undefined — solo es opcional (3.2, categoria.model.ts) para el caso de una categoría que todavía no se crea.
Crear CategoriaForm, el formulario separado de crear/editar (la CLI es opcional, igual que en los pasos anteriores — --flat evita el subdirectorio extra):
ng generate component features/catalogo/categoria-form --flat
src/app/features/catalogo/categoria-form.ts — usa Reactive Forms (FormBuilder, Validators), no [(ngModel)]: valida en el propio formulario antes de llamar al backend, con reglas que calzan con las de CategoriaRequest (@NotBlank, @Size(max = 100) en nombre; @Size(max = 255) en descripcion, S3) — la validación real y definitiva sigue siendo la del backend, esto solo evita mandar una petición que ya se sabe que va a fallar. Si la ruta trae un id (editar), el constructor pide esa categoría y precarga el formulario; si no (crear), el formulario arranca vacío:
import { Component, inject, signal } from '@angular/core';
import { ActivatedRoute, Router } from '@angular/router';
import { FormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
import { CategoriaService } from './categoria-service';
@Component({
selector: 'app-categoria-form',
imports: [ReactiveFormsModule],
templateUrl: './categoria-form.html',
})
export class CategoriaForm {
private readonly fb = inject(FormBuilder);
private readonly categoriaService = inject(CategoriaService);
private readonly route = inject(ActivatedRoute);
private readonly router = inject(Router);
protected readonly id = signal<number | null>(null);
protected readonly cargando = signal(false);
protected readonly error = signal<string | null>(null);
protected readonly form = this.fb.nonNullable.group({
nombre: ['', [Validators.required, Validators.maxLength(100)]],
descripcion: ['', [Validators.maxLength(255)]],
});
constructor() {
const idParam = this.route.snapshot.paramMap.get('id');
if (idParam) {
const id = Number(idParam);
this.id.set(id);
this.cargando.set(true);
this.categoriaService.obtener(id).subscribe({
next: (categoria) => {
this.form.patchValue(categoria);
this.cargando.set(false);
},
error: () => {
this.error.set('No se pudo cargar la categoría.');
this.cargando.set(false);
},
});
}
}
guardar(): void {
if (this.form.invalid) {
this.form.markAllAsTouched();
return;
}
const valor = this.form.getRawValue();
const id = this.id();
const peticion = id ? this.categoriaService.actualizar(id, valor) : this.categoriaService.crear(valor);
peticion.subscribe({
next: () => this.router.navigate(['/categorias']),
error: () => this.error.set('No se pudo guardar la categoría.'),
});
}
cancelar(): void {
this.router.navigate(['/categorias']);
}
protected mensajeValidacion(campo: 'nombre' | 'descripcion'): string {
const control = this.form.controls[campo];
if (!control.touched) return '';
if (control.hasError('required')) return 'Este campo es obligatorio.';
if (control.hasError('maxlength')) {
return `Máximo ${control.getError('maxlength').requiredLength} caracteres.`;
}
return '';
}
}
this.route.snapshot.paramMap.get('id') lee el segmento :id de la URL (la ruta que falta agregar más abajo, categorias/:id/editar) — snapshot alcanza porque este componente se vuelve a crear desde cero cada vez que cambias de categoría a editar (nunca navegas de un editar a otro sin pasar por la lista), así que no hace falta reaccionar a un cambio de parámetro sin recrear el componente.
mensajeValidacion solo devuelve texto una vez que el campo está touched — un campo queda touched cuando el usuario hace clic dentro y sale de él, no al apretar "Guardar" directamente; por eso guardar() llama a this.form.markAllAsTouched() antes de salir si el formulario es inválido: sin eso, alguien que nunca tocó ningún campo y aprieta "Guardar" vería que "no pasa nada", sin ningún mensaje que lo explique.
src/app/features/catalogo/categoria-form.html:
<form [formGroup]="form" (ngSubmit)="guardar()">
@if (cargando()) {
<p>Cargando...</p>
}
<label>
Nombre
<input type="text" formControlName="nombre" />
</label>
@if (mensajeValidacion('nombre'); as mensaje) {
<p class="error">{{ mensaje }}</p>
}
<label>
Descripcion
<textarea formControlName="descripcion"></textarea>
</label>
@if (mensajeValidacion('descripcion'); as mensaje) {
<p class="error">{{ mensaje }}</p>
}
@if (error()) {
<p class="error">{{ error() }}</p>
}
<button type="submit" [disabled]="cargando()">Guardar</button>
<button type="button" (click)="cancelar()">Cancelar</button>
</form>
type="button" en Cancelar no es opcional: sin él, heredaría el tipo por defecto de cualquier <button> dentro de un <form> (submit), y un clic en "Cancelar" dispararía igual el (ngSubmit)="guardar()" — justo lo que se quiere evitar.
Agrega las dos rutas que faltan, como hijas de Layout, junto a categorias:
import { Routes } from '@angular/router';
export const routes: Routes = [
{
path: '',
loadComponent: () => import('./core/layout/layout').then((m) => m.Layout),
children: [
{
path: '',
loadComponent: () => import('./core/inicio/inicio').then((m) => m.Inicio),
},
{
path: 'categorias',
loadComponent: () => import('./features/catalogo/categoria-list').then((m) => m.CategoriaList),
},
{
path: 'categorias/nueva',
loadComponent: () => import('./features/catalogo/categoria-form').then((m) => m.CategoriaForm),
},
{
path: 'categorias/:id/editar',
loadComponent: () => import('./features/catalogo/categoria-form').then((m) => m.CategoriaForm),
},
],
},
];
Las dos rutas nuevas apuntan al mismo componente, CategoriaForm — es el propio componente el que decide, leyendo :id, si está creando o editando (arriba, en su constructor).
Confirma de nuevo en el navegador: crea una categoría nueva, edítala, y elimínala — las tres acciones deben reflejarse en la lista sin recargar la página a mano.
Parte B — El mismo proyecto, a través del Gateway y con CORS centralizado¶
3.3 Cambiar al Gateway y habilitar CORS ahí¶
Producto del paso: la misma pantalla de categorías de 3.2, ahora a través de pagatu-gateway, con CORS centralizado — y pagatu-catalogo-ms ya sin necesidad de su propio CorsConfig.
Importante: pagatu-gateway corre sobre spring.cloud.gateway.server.webmvc (la variante servlet de Spring Cloud Gateway, no la reactiva/WebFlux) — la propiedad spring.cloud.gateway.globalcors, que sí existe para la variante reactiva, no aplica aquí. En esta variante, el Gateway es, por debajo, una aplicación Spring MVC normal — CORS se configura exactamente igual que en cualquier otro microservicio Spring MVC (2.3), con un bean, no con YAML.
infra/pagatu-gateway/src/main/java/pe/edu/upeu/gateway/config/CorsConfig.java (archivo nuevo):
package pe.edu.upeu.gateway.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import java.util.Arrays;
import java.util.List;
@Configuration
public class CorsConfig {
@Value("${pagatu.cors.allowed-origins}")
private String allowedOrigins;
@Bean
public CorsConfigurationSource corsConfigurationSource() {
CorsConfiguration configuracion = new CorsConfiguration();
configuracion.setAllowedOrigins(Arrays.stream(allowedOrigins.split(","))
.map(String::trim)
.toList());
configuracion.setAllowedMethods(List.of("GET", "POST", "PUT", "PATCH", "DELETE"));
configuracion.setAllowedHeaders(List.of("*"));
configuracion.setAllowCredentials(true);
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", configuracion);
return source;
}
}
infra/pagatu-config/config-repo/pagatu-gateway-dev.yml — agrega la propiedad que el bean espera (mismo nombre de propiedad que ya usaste en pagatu-catalogo-ms-dev.yml, 3.2, aunque viva en un archivo distinto):
pagatu:
cors:
allowed-origins: http://localhost:4200
Esto por sí solo no alcanza. Esta aplicación tiene Spring Security activo (SecurityConfig.java, S07b) con sus propias reglas de autorización — y esas reglas corren antes de que cualquier bean de CORS tenga oportunidad de responder. El navegador, antes de un PUT/DELETE (no antes de un GET simple), manda primero una petición de verificación (OPTIONS, el preflight del estándar CORS) — y esa petición nunca lleva el header Authorization, porque todavía no es la petición real. Si ninguna regla de SecurityConfig.java permite explícitamente ese OPTIONS, cae en anyRequest().authenticated() y Spring Security la rechaza con 401 antes de que el bean de CORS de arriba pueda agregarle el header Access-Control-Allow-Origin — exactamente el error que ves en la consola, aunque el problema real no es de CORS, es de autorización.
infra/pagatu-gateway/src/main/java/pe/edu/upeu/gateway/config/SecurityConfig.java — agrega .cors(...) a la cadena, antes de .csrf(...), para que Spring Security use el bean que acabas de crear y deje pasar el preflight sin exigirle sesión:
http
.cors(cors -> {})
.csrf(csrf -> csrf.disable())
.authorizeHttpRequests(auth -> auth
// ... las reglas que ya existen, sin cambios
)
.oauth2ResourceServer(oauth2 -> oauth2
.jwt(jwt -> jwt.jwtAuthenticationConverter(jwtAuthenticationConverter))
);
.cors(cors -> {}) le dice a Spring Security "toma el CorsConfigurationSource que ya está registrado como bean" (el de CorsConfig.java) — con eso habilitado, Spring Security reconoce un OPTIONS de preflight y lo deja pasar automáticamente, sin pedirle que calce con ninguna regla de authorizeHttpRequests, porque el preflight en sí nunca va a transportar un token.
Apaga el CorsConfig de pagatu-catalogo-ms (3.2) — ya no hace falta, y gracias al @ConditionalOnProperty no hay que tocar ni recompilar el .java. En infra/pagatu-config/config-repo/pagatu-catalogo-ms-dev.yml:
pagatu:
cors:
enabled: false
allowed-origins: http://localhost:4200
Reinicia pagatu-catalogo-ms después del cambio — no hace falta reiniciar pagatu-config, que solo sirve el archivo tal cual; quien necesita volver a pedirlo es el propio pagatu-catalogo-ms. Esta es exactamente la razón por la que el Gateway es el lugar correcto para configurar CORS y no cada microservicio por separado (2.3) — imagina mantener ese mismo CorsConfig encendido en pagatu-catalogo-ms, pagatu-orden-ms y pagatu-pago-ms por separado, uno por uno, cada vez que cambie el origen permitido.
Error frecuente: Access-Control-Allow-Origin header contains multiple values 'http://localhost:4200, http://localhost:4200'. Significa que pagatu.cors.enabled se quedó en true (arriba) mientras pagatu-catalogo-ms seguía corriendo — su respuesta ya trae el header, el Gateway reenvía esa respuesta y le agrega el suyo encima, y el navegador recibe el mismo valor dos veces (algo que el estándar CORS no permite, aunque ambos valores sean idénticos). Confirma que el YAML quedó en false y que reiniciaste pagatu-catalogo-ms después del cambio, no solo el Gateway.
src/environments/environment.ts — agrega la configuración de Keycloak, y cambia solo el valor de apiBaseUrl, no su nombre (la variable queda igual, para no tener que salir a cambiarla en cada servicio que ya la use):
export const environment = {
apiBaseUrl: 'http://localhost:18080',
keycloak: {
issuer: 'http://localhost:18180/realms/pagatu',
clientId: 'pagatu-frontend',
redirectUri: 'http://localhost:4200/auth/callback',
postLogoutRedirectUri: 'http://localhost:4200/',
},
};
categoria-service.ts no necesita ningún cambio de código — sigue leyendo environment.apiBaseUrl, que ahora vale 18080 en vez de 8080 (misma ruta, /api/v1/categorias — el Gateway la enruta igual, S4). Confirma que la pantalla de 3.2 sigue funcionando con ese único cambio de valor — todavía sin login, porque GET /api/v1/categorias es pública incluso a través del Gateway (S07, permitAll en las reglas hasRole/hasAnyRole del Gateway). Aprovecha y agrega también ProductoService (mismo patrón, /api/v1/productos, también pública para GET) — lo vas a necesitar en 3.5.
Crear, editar y eliminar todavía van a fallar — y está bien que fallen. POST/PUT/DELETE de /categorias/** exigen rol ADMIN en SecurityConfig.java del Gateway, y a esta altura (3.3) todavía no existe ningún login: sin un token que probar, esas tres operaciones responden 401 (Unauthorized), no un error de CORS. Es exactamente la confirmación de que la seguridad del Gateway sigue intacta a través de la pantalla nueva — recién en 3.4, con Keycloak, esas tres acciones empiezan a funcionar.
Todas las llamadas de negocio apuntan a apiBaseUrl de aquí en adelante — ningún componente ni servicio de pagatu-frontend conoce la dirección de pagatu-catalogo-ms, pagatu-orden-ms ni pagatu-pago-ms por separado (2.1): el Gateway es el único punto de entrada, exactamente como ya lo es para PowerShell/curl/Swagger desde S4.
3.4 Login con Authorization Code + PKCE¶
Producto del paso: AuthService, con el mismo mecanismo de PKCE que S7 (3.27) ya calculó a mano, ahora en TypeScript — token en memoria (Tabla 2, 2.4).
src/app/core/auth/pkce.ts:
function base64UrlEncode(bytes: Uint8Array): string {
let binario = '';
bytes.forEach((byte) => (binario += String.fromCharCode(byte)));
return btoa(binario).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
}
export function generarCodeVerifier(): string {
return base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)));
}
export async function generarCodeChallenge(verifier: string): Promise<string> {
const hash = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(verifier));
return base64UrlEncode(new Uint8Array(hash));
}
export function generarState(): string {
return base64UrlEncode(crypto.getRandomValues(new Uint8Array(16)));
}
Compara este resultado contra el de S7 (3.27): el Get-Pkce/pkce que calculaste ahí a mano con [System.Security.Cryptography.SHA256]/openssl dgst -sha256 es exactamente el mismo algoritmo que generarCodeChallenge ejecuta aquí con la Web Crypto API del navegador — mismo SHA-256, misma codificación Base64 apta para URL, ninguna sorpresa de cálculo.
src/app/core/auth/auth-service.ts (login + estado en memoria):
import { Injectable, computed, signal } from '@angular/core';
import { environment } from '../../../environments/environment';
import { generarCodeChallenge, generarCodeVerifier, generarState } from './pkce';
import { decodeJwtPayload } from './jwt';
interface SesionKeycloak {
accessToken: string;
refreshToken: string;
idToken: string;
expiraEn: number;
}
const CLAVE_VERIFIER = 'pagatu_pkce_verifier';
const CLAVE_STATE = 'pagatu_pkce_state';
const CLAVE_DESTINO = 'pagatu_pkce_destino';
@Injectable({ providedIn: 'root' })
export class AuthService {
private readonly sesion = signal<SesionKeycloak | null>(null);
readonly autenticado = computed(() => {
const actual = this.sesion();
return actual !== null && actual.expiraEn > Date.now();
});
readonly roles = computed<string[]>(
() => decodeJwtPayload(this.sesion()?.accessToken ?? '')?.realm_access?.roles ?? [],
);
readonly idCliente = computed<string | null>(
() => decodeJwtPayload(this.sesion()?.accessToken ?? '')?.sub ?? null,
);
readonly nombreUsuario = computed<string | null>(
() => decodeJwtPayload(this.sesion()?.accessToken ?? '')?.preferred_username ?? null,
);
tieneRol(...rolesPermitidos: string[]): boolean {
return rolesPermitidos.some((rol) => this.roles().includes(rol));
}
accessToken(): string | null {
return this.sesion()?.accessToken ?? null;
}
async iniciarLogin(destino = location.pathname): Promise<void> {
const verifier = generarCodeVerifier();
const state = generarState();
sessionStorage.setItem(CLAVE_VERIFIER, verifier);
sessionStorage.setItem(CLAVE_STATE, state);
sessionStorage.setItem(CLAVE_DESTINO, destino);
const parametros = new URLSearchParams({
client_id: environment.keycloak.clientId,
response_type: 'code',
redirect_uri: environment.keycloak.redirectUri,
scope: 'openid profile',
state,
code_challenge: await generarCodeChallenge(verifier),
code_challenge_method: 'S256',
});
location.href = `${environment.keycloak.issuer}/protocol/openid-connect/auth?${parametros}`;
}
async completarLogin(code: string, stateRecibido: string): Promise<void> {
const stateEsperado = sessionStorage.getItem(CLAVE_STATE);
const verifier = sessionStorage.getItem(CLAVE_VERIFIER);
sessionStorage.removeItem(CLAVE_STATE);
sessionStorage.removeItem(CLAVE_VERIFIER);
if (!verifier || stateRecibido !== stateEsperado) {
throw new Error('state o code_verifier invalido: posible CSRF, reinicia el login');
}
const cuerpo = new URLSearchParams({
grant_type: 'authorization_code',
client_id: environment.keycloak.clientId,
redirect_uri: environment.keycloak.redirectUri,
code,
code_verifier: verifier,
});
const respuesta = await fetch(`${environment.keycloak.issuer}/protocol/openid-connect/token`, {
method: 'POST',
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
body: cuerpo,
});
if (!respuesta.ok) throw new Error('No se pudo intercambiar el codigo por un token');
const datos = await respuesta.json();
this.sesion.set({
accessToken: datos.access_token,
refreshToken: datos.refresh_token,
idToken: datos.id_token,
expiraEn: Date.now() + datos.expires_in * 1000,
});
}
destinoPendiente(): string {
const destino = sessionStorage.getItem(CLAVE_DESTINO) ?? '/';
sessionStorage.removeItem(CLAVE_DESTINO);
return destino;
}
cerrarSesion(): void {
const idToken = this.sesion()?.idToken;
this.sesion.set(null);
const parametros = new URLSearchParams({
post_logout_redirect_uri: environment.keycloak.postLogoutRedirectUri,
...(idToken ? { id_token_hint: idToken } : {}),
});
location.href = `${environment.keycloak.issuer}/protocol/openid-connect/logout?${parametros}`;
}
}
A diferencia de un cliente que solo valida PKCE, este AuthService también genera y verifica state (Tabla 2) — el segundo "error de diseño común" que S7 (2.4) ya advirtió. completarLogin revisa state antes de confiar en el code_verifier: si no coinciden, lanza un error en vez de intentar el intercambio, sin importar si el code_verifier guardado era correcto.
Por qué fetch y no HttpClient, como en CategoriaService. No es un descuido — es a propósito, y solo en este método. Desde 3.4 (más abajo), authInterceptor se registra globalmente sobre HttpClient y le agrega el header Authorization a toda petición que salga por ahí, pensado para hablar con pagatu-gateway (nuestro propio backend). La petición de completarLogin va a un destino completamente distinto — el propio Keycloak, con el contrato de un servidor de tokens OAuth2/OIDC (application/x-www-form-urlencoded, grant_type), no el de nuestra API — y es, además, la petición que recién va a producir el primer token; no hay ningún accessToken todavía que adjuntarle. Mezclar esa llamada con el mismo pipeline pensado para el Gateway no rompe nada hoy (sin token, el interceptor simplemente no agrega el header), pero si authInterceptor cambia mañana — o si Keycloak alguna vez respondiera 401 en vez del 400 habitual de un code inválido — terminaría disparando auth.iniciarLogin(...) dentro de la misma llamada que ya está completando un login, un bucle de redirecciones sin sentido. fetch, sin pasar por HttpClient, mantiene esta única llamada completamente aislada de ese pipeline. La regla general: HttpClient para hablar con nuestro propio backend (vía el Gateway, con el token ya adjunto); fetch para hablar directo con Keycloak (antes de que exista un token, o para cualquier endpoint que no sea nuestro).
idCliente lee el claim sub, no uno propio (S07b, 7.4 — idCliente ya es sub, el mismo patrón que vendedorId en LP2): por eso, para idCliente en sí, no hace falta ningún campo extra en JwtPayload, ni ninguna configuración adicional de Keycloak para que viaje en el token (nombreUsuario, más abajo, sí agrega uno — pero para otro propósito: mostrar algo legible en el encabezado, no identificar al dueño de la orden).
src/app/core/auth/jwt.ts (decodificación, sin validar firma — la SPA nunca valida un token, eso lo hace el Gateway como resource server, S07; solo lee los claims que ya confió en Keycloak):
export interface JwtPayload {
sub: string;
exp: number;
preferred_username?: string;
realm_access?: { roles: string[] };
}
export function decodeJwtPayload(token: string): JwtPayload | null {
const partes = token.split('.');
if (partes.length !== 3) return null;
try {
const base64 = partes[1].replace(/-/g, '+').replace(/_/g, '/');
const json = decodeURIComponent(
atob(base64).split('').map((c) => '%' + c.charCodeAt(0).toString(16).padStart(2, '0')).join(''),
);
return JSON.parse(json) as JwtPayload;
} catch {
return null;
}
}
src/app/core/auth/auth-callback.ts (componente de retorno, verifica state antes de completar el login):
import { Component, inject } from '@angular/core';
import { ActivatedRoute, Router } from '@angular/router';
import { AuthService } from './auth-service';
@Component({
selector: 'app-auth-callback',
template: `<p>Completando inicio de sesion...</p>`,
})
export class AuthCallback {
constructor() {
const route = inject(ActivatedRoute);
const router = inject(Router);
const auth = inject(AuthService);
const codigo = route.snapshot.queryParamMap.get('code');
const state = route.snapshot.queryParamMap.get('state');
if (!codigo || !state) {
router.navigateByUrl('/');
return;
}
auth
.completarLogin(codigo, state)
.then(() => router.navigateByUrl(auth.destinoPendiente()))
.catch(() => router.navigateByUrl('/'));
}
}
src/app/core/guards/auth-guard.ts (archivo nuevo) — protege cualquier ruta que exija sesión activa; si no la hay, inicia el login en vez de solo bloquear:
import { inject } from '@angular/core';
import { CanActivateFn } from '@angular/router';
import { AuthService } from '../auth/auth-service';
export const authGuard: CanActivateFn = async (_route, state) => {
const auth = inject(AuthService);
if (auth.autenticado()) {
return true;
}
await auth.iniciarLogin(state.url);
return false;
};
authGuard es async porque iniciarLogin lo es (3.4, por el await a generarCodeChallenge) — el return false final casi nunca le importa a nadie: para cuando se ejecuta, location.href ya empezó a navegar el navegador entero fuera de la SPA, hacia Keycloak.
src/app/core/guards/rol-guard.ts (archivo nuevo) — compara contra CLIENTE/ADMIN, los únicos dos roles de este realm (S07b):
import { inject } from '@angular/core';
import { CanActivateFn, Router } from '@angular/router';
import { AuthService } from '../auth/auth-service';
export function rolGuard(...rolesPermitidos: string[]): CanActivateFn {
return () => {
const auth = inject(AuthService);
const router = inject(Router);
if (auth.tieneRol(...rolesPermitidos)) {
return true;
}
alert('No tienes permiso para acceder a esa pantalla.');
router.navigateByUrl('/');
return false;
};
}
alert(...) aquí es el mismo criterio que confirm(...) en eliminar (3.2): un diálogo nativo, sin agregar ninguna librería, alcanza para avisar algo puntual. Sin él, a alguien con rol CLIENTE que entra a categorias/nueva a mano (URL) el guard lo rebota a Inicio en silencio — funciona, pero parece que el enlace no hizo nada.
src/app/core/interceptors/auth-interceptor.ts (archivo nuevo) — adjunta el token a cada petición saliente; si el servidor responde 401 (token inválido o vencido), reinicia el login — a diferencia de LP2, AuthService (3.4) no construyó un método para renovar el refresh_token en silencio, así que no hay nada que reintentar: la única salida honesta de un 401 aquí es volver a loguearse:
import { inject } from '@angular/core';
import { HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
import { catchError, throwError } from 'rxjs';
import { AuthService } from '../auth/auth-service';
export const authInterceptor: HttpInterceptorFn = (req, next) => {
const auth = inject(AuthService);
const token = auth.accessToken();
const conToken = token ? req.clone({ setHeaders: { Authorization: `Bearer ${token}` } }) : req;
return next(conToken).pipe(
catchError((error: HttpErrorResponse) => {
if (error.status === 401) {
auth.iniciarLogin(location.pathname);
}
return throwError(() => error);
}),
);
};
403 no se maneja aquí a propósito: el token sí es válido, el rol no alcanza — reintentar o redirigir a login no cambia nada, es responsabilidad de cada pantalla mostrar el error (o, mejor, no ofrecer la acción si rolGuard/tieneRol ya la descartó de antemano).
src/app/app.routes.ts — ya existe desde 3.2 con Layout como ruta padre y las tres rutas de categorías como hijas; agrega auth/callback como hermana de Layout. A diferencia de lo que esta guía decía antes, authGuard no va en la propia ruta de Layout: Inicio ('') debe quedar público — cualquiera que abra http://localhost:4200 tiene que poder navegar la aplicación sin que se le exija sesión de entrada (mismo criterio que cualquier sitio con un botón "Iniciar sesión" visible, en vez de forzar el login en la puerta). El guard va, en cambio, en categorias y sus dos hijas de escritura — recién ahí, al intentar entrar, se dispara el login:
import { Routes } from '@angular/router';
import { authGuard } from './core/guards/auth-guard';
import { rolGuard } from './core/guards/rol-guard';
export const routes: Routes = [
{
path: 'auth/callback',
loadComponent: () => import('./core/auth/auth-callback').then((m) => m.AuthCallback),
},
{
path: '',
loadComponent: () => import('./core/layout/layout').then((m) => m.Layout),
children: [
{
path: '',
loadComponent: () => import('./core/inicio/inicio').then((m) => m.Inicio),
},
{
path: 'categorias',
canActivate: [authGuard],
loadComponent: () => import('./features/catalogo/categoria-list').then((m) => m.CategoriaList),
},
{
path: 'categorias/nueva',
canActivate: [authGuard, rolGuard('ADMIN')],
loadComponent: () => import('./features/catalogo/categoria-form').then((m) => m.CategoriaForm),
},
{
path: 'categorias/:id/editar',
canActivate: [authGuard, rolGuard('ADMIN')],
loadComponent: () => import('./features/catalogo/categoria-form').then((m) => m.CategoriaForm),
},
],
},
];
categorias/nueva/categorias/:id/editar llevan los dos guards, en ese orden: primero authGuard (¿hay sesión? si no, dispara el login) y recién después rolGuard('ADMIN') (¿el rol alcanza?) — poner solo rolGuard ahí no bastaría, porque sin sesión auth.tieneRol(...) simplemente da false y rebota a / en silencio, en vez de ofrecer el login. rolGuard('ADMIN') calza con SecurityConfig.java del Gateway (S07b): POST/PUT/DELETE de /categorias/** exigen ROLE_ADMIN ahí, así que la SPA no inventa una regla nueva, solo refleja en el router la que ya existe en el backend.
app.ts/app.html no cambian — siguen siendo el <router-outlet /> que ya quedó listo desde 3.2, sin tocar.
src/app/app.config.ts — este paso va junto con app.routes.ts, no después: sin él, authGuard/rolGuard ya protegen las rutas, pero ninguna petición sale con el token todavía. A diferencia de lo que decía antes esta guía, la CLI no genera ningún provider de HttpClient: ng new deja app.config.ts solo con provideBrowserGlobalErrorListeners() y provideRouter(routes). Reemplaza el archivo completo:
import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
import { provideRouter } from '@angular/router';
import { provideHttpClient, withInterceptors } from '@angular/common/http';
import { routes } from './app.routes';
import { authInterceptor } from './core/interceptors/auth-interceptor';
import { traceInterceptor } from './core/interceptors/trace-interceptor';
export const appConfig: ApplicationConfig = {
providers: [
provideBrowserGlobalErrorListeners(),
provideRouter(routes),
provideHttpClient(withInterceptors([authInterceptor, traceInterceptor])),
],
};
src/app/core/interceptors/trace-interceptor.ts (archivo nuevo) — pagatu-catalogo-ms/pagatu-orden-ms/pagatu-pago-ms ya tienen, cada uno, un CorrelationIdFilter (S1/S6) que lee el header X-Trace-ID de la petición entrante y lo reutiliza si llega — recién genera uno nuevo si no llega ninguno. Hasta hoy, ninguna petición de pagatu-frontend lo mandaba, así que cada backend terminaba inventando el suyo por separado, sin ninguna forma de seguir una sola acción del usuario a través de los logs de más de un servicio:
import { HttpInterceptorFn } from '@angular/common/http';
export const traceInterceptor: HttpInterceptorFn = (req, next) => {
const conTraceId = req.clone({ setHeaders: { 'X-Trace-ID': crypto.randomUUID() } });
return next(conTraceId);
};
El Gateway no toca este header en absoluto (es puro pass-through) — por eso alcanza con generarlo acá y dejar que cada CorrelationIdFilter aguas abajo lo recoja solo, sin tocar ni el Gateway ni ningún microservicio. crypto.randomUUID() genera uno nuevo por cada petición HTTP, no uno por sesión — el mismo criterio que ya usa cada CorrelationIdFilter (un traceId identifica una petición, no todo lo que hizo un usuario en su visita). Esto conecta con S10 (3.4): el mismo traceId que ves en la consola de Angular (Network → Response Headers → X-Trace-ID, el filter lo devuelve también en la respuesta) es el que vas a poder buscar en los logs de pagatu-orden-ms y, de ahí, de pagatu-catalogo-ms (vía Feign, S10 §3.4) — no en pagatu-pago-ms, porque el salto por Kafka (S8/S9) todavía no propaga traceId a través del evento; eso queda fuera del alcance de esta sesión.
Error frecuente: un PUT/DELETE/POST responde 401 aunque ya hayas iniciado sesión, y en la pestaña Network el header Authorization directamente no aparece en la petición (revisa Request Headers, no la respuesta). Significa que provideHttpClient(withInterceptors([authInterceptor, traceInterceptor])) nunca quedó en app.config.ts — sin ese provider, ningún interceptor se ejecuta, así que ninguna petición sale con el token (ni con X-Trace-ID), sin importar que la sesión sí esté activa.
Mostrar la sesión real en el propio Layout: "Iniciar sesión" o "Cerrar sesión", según corresponda. Hasta ahora el encabezado solo mostraba "pagatu" — con AuthService ya construido, y con Inicio público (arriba), el encabezado tiene que servir para los dos casos: alguien que todavía no inició sesión (ve un botón para hacerlo, voluntariamente, sin que nadie se lo exija) y alguien que ya la tiene (ve que la tiene, y puede cerrarla):
import { Component, inject } from '@angular/core';
import { RouterOutlet, RouterLink, RouterLinkActive } from '@angular/router';
import { AuthService } from '../auth/auth-service';
@Component({
selector: 'app-layout',
imports: [RouterOutlet, RouterLink, RouterLinkActive],
templateUrl: './layout.html',
styleUrl: './layout.css',
})
export class Layout {
protected readonly auth = inject(AuthService);
}
En layout.html, agrega los dos botones dentro de <header>, junto al enlace existente — solo uno de los dos se muestra a la vez:
<header class="header">
<a routerLink="/" class="home-link">pagatu</a>
<div class="sesion-area">
@if (auth.autenticado()) {
<span class="sesion">{{ auth.nombreUsuario() }}</span>
<button type="button" (click)="auth.cerrarSesion()">Cerrar sesión</button>
} @else {
<button type="button" (click)="auth.iniciarLogin()">Iniciar sesión</button>
}
</div>
</header>
nombreUsuario lee preferred_username — a diferencia de idCliente (el claim sub, un identificador técnico sin sentido para mostrarse en pantalla, S07b 7.4), preferred_username sí es el nombre de usuario legible (cliente1, admin, S07b sección 4) y ya viaja en el token sin configuración adicional: es un claim estándar de OIDC, incluido por Keycloak con el scope openid profile que iniciarLogin (arriba) ya pide. Si tu propio dominio (4.1) necesita mostrar, además, un dato de negocio real que no sea ni sub ni el nombre de usuario (ej. un nombre completo), ahí sí hace falta un user attribute + protocol mapper propios en Keycloak (el mismo patrón que S07 diseñó originalmente para idCliente, antes de que S07b decidiera que no hacía falta, 7.4).
En src/app/core/layout/layout.css, empuja la sesión/botón a la derecha del encabezado — sin esto, quedan pegados al logo, a la izquierda (.header ya es flex desde 3.2):
.sesion-area {
display: flex;
align-items: center;
gap: 0.75rem;
margin-left: auto;
}
El margin-left: auto va en el contenedor (.sesion-area), no en el <span>/<button> por separado. Si se lo pones a los dos (algo tentador, ya que nunca aparecen juntos... excepto cuando sí: <span> y <button> de Cerrar sesión conviven en el mismo momento), flexbox reparte el espacio libre entre todos los elementos con margin-left: auto, no se lo da entero al primero — el nombre de usuario termina centrado, no pegado al botón, que es exactamente el efecto roto que corrige este cambio. Con el margin-left: auto en un único contenedor que envuelve a ambos, el par completo se mueve junto al borde derecho, sin importar cuál de los dos esté visible adentro.
Con el botón Iniciar sesión siempre visible cuando no hay sesión, quien abre / directo nunca ve un redirect forzoso a Keycloak — puede quedarse en Inicio leyendo, o ir voluntariamente a loguearse. El único disparador automático sigue siendo authGuard (arriba), y solo al intentar entrar a categorias.
Ahora sí, distinguir el 403 en pantalla. Hasta 3.3, categoria-form.ts/categoria-list.ts solo podían recibir 401 (no existía ningún token todavía) — por eso sus manejadores de error no distinguían nada más. Con login y roles reales ya en juego, un 403 (sesión válida, rol insuficiente) sí es un caso distinto que vale la pena mostrar con su propio mensaje. Agrega el import y el chequeo en categoria-form.ts (guardar):
import { HttpErrorResponse } from '@angular/common/http';
peticion.subscribe({
next: () => this.router.navigate(['/categorias']),
error: (err: HttpErrorResponse) => {
this.error.set(
err.status === 403
? 'No tienes permiso para esta acción.'
: 'No se pudo guardar la categoría.',
);
},
});
Este 403 casi nunca debería verse en la práctica — rolGuard('ADMIN') (arriba) ya le bloquea el acceso a esta pantalla a cualquiera que no sea ADMIN. El chequeo queda igual, como segunda capa: por ejemplo, si el rol de alguien cambia en Keycloak mientras ya tenía la sesión abierta en el navegador (el guard solo se evalúa al navegar, no en cada petición).
En categoria-list.ts (eliminar), junto al chequeo de 500 que ya existe:
error: (err: HttpErrorResponse) => {
if (err.status === 500) {
this.errorAccion.set('No se puede eliminar: la categoría tiene productos asociados.');
} else if (err.status === 403) {
this.errorAccion.set('No tienes permiso para esta acción.');
} else {
this.errorAccion.set('No se pudo eliminar la categoría.');
}
},
Aquí el 403 sí es más probable que en CategoriaForm: el botón Eliminar vive en la lista (categorias), que cualquier usuario logueado puede abrir — no hay route guard de rol sobre esa ruta, solo sobre categorias/nueva/categorias/:id/editar. Un CLIENTE ve el botón igual que un ADMIN, y es recién el backend quien lo rechaza.
3.5 Crear una orden¶
Producto del paso: una pantalla de catálogo + carrito (lista de productos, cantidad, método de pago) que llama a POST /api/v1/ordenes con el token del usuario, y muestra el estado inicial real — PENDIENTE_PAGO lo normal, pero también el caso honesto en el que algún producto ya no tiene stock (CARRITO, sin total ni pago asociado) — nunca un mensaje genérico de "¡Compra exitosa!".
src/app/features/catalogo/producto.model.ts (archivo nuevo) — mismos campos que ProductoResponse (S1/S3); reusa Categoria (3.2) para el campo anidado:
import { Categoria } from './categoria.model';
export interface Producto {
id: number;
nombre: string;
descripcion: string;
precio: number;
activo: boolean;
stock: number;
categoria: Categoria;
}
src/app/features/catalogo/producto-service.ts (archivo nuevo) — solo listar(): esta sesión no construye un CRUD de productos, solo los necesita para armar el carrito:
import { Injectable, inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
import { environment } from '../../../environments/environment';
import { Producto } from './producto.model';
@Injectable({ providedIn: 'root' })
export class ProductoService {
private readonly http = inject(HttpClient);
listar(): Observable<Producto[]> {
return this.http.get<Producto[]>(`${environment.apiBaseUrl}/api/v1/productos`);
}
}
src/app/features/ordenes/orden.model.ts (archivo nuevo) — calca OrdenRequest/OrdenResponse/DetalleOrdenRequest/DetalleOrdenResponse (S2/S6): total queda null cuando el backend no pudo reservar el stock completo (abajo, OrdenServiceImpl.crear, S6) — por eso es number | null, no number:
export interface DetalleOrdenRequest {
idProducto: number;
cantidad: number;
}
export interface OrdenRequest {
metodoPago: string;
detalles: DetalleOrdenRequest[];
}
export interface DetalleOrdenResponse {
idProducto: number;
nombreProducto: string | null;
cantidad: number;
precioUnitario: number | null;
subtotal: number | null;
}
export interface OrdenResponse {
id: number;
idCliente: string;
fechaCreacion: string;
estado: string;
total: number | null;
detalles: DetalleOrdenResponse[];
}
src/app/features/ordenes/orden-service.ts (archivo nuevo):
import { Injectable, inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
import { environment } from '../../../environments/environment';
import { OrdenRequest, OrdenResponse } from './orden.model';
@Injectable({ providedIn: 'root' })
export class OrdenService {
private readonly http = inject(HttpClient);
crear(request: OrdenRequest): Observable<OrdenResponse> {
return this.http.post<OrdenResponse>(`${environment.apiBaseUrl}/api/v1/ordenes`, request);
}
obtener(id: number): Observable<OrdenResponse> {
return this.http.get<OrdenResponse>(`${environment.apiBaseUrl}/api/v1/ordenes/${id}`);
}
listar(): Observable<OrdenResponse[]> {
return this.http.get<OrdenResponse[]>(`${environment.apiBaseUrl}/api/v1/ordenes`);
}
}
OrdenCrear — carga el catálogo, arma un carrito en memoria (sin backend propio para "guardar el carrito": vive en un signal, se manda completo recién al confirmar) y llama a crear con el método de pago elegido:
ng generate component features/ordenes/orden-crear --flat
src/app/features/ordenes/orden-crear.ts:
import { Component, OnInit, inject, signal, computed } from '@angular/core';
import { RouterLink } from '@angular/router';
import { FormsModule } from '@angular/forms';
import { ProductoService } from '../catalogo/producto-service';
import { Producto } from '../catalogo/producto.model';
import { OrdenService } from './orden-service';
import { OrdenResponse } from './orden.model';
interface ItemCarrito {
producto: Producto;
cantidad: number;
}
@Component({
selector: 'app-orden-crear',
imports: [RouterLink, FormsModule],
templateUrl: './orden-crear.html',
})
export class OrdenCrear implements OnInit {
private readonly productoService = inject(ProductoService);
private readonly ordenService = inject(OrdenService);
protected readonly productos = signal<Producto[]>([]);
protected readonly carrito = signal<ItemCarrito[]>([]);
protected readonly cargando = signal(true);
protected readonly enviando = signal(false);
protected readonly error = signal<string | null>(null);
protected readonly resultado = signal<OrdenResponse | null>(null);
protected metodoPago = 'YAPE_PLIN';
protected readonly total = computed(() =>
this.carrito().reduce((suma, item) => suma + item.producto.precio * item.cantidad, 0),
);
ngOnInit(): void {
this.productoService.listar().subscribe({
next: (data) => {
this.productos.set(data.filter((p) => p.activo));
this.cargando.set(false);
},
error: () => {
this.error.set('No se pudo cargar el catálogo de productos.');
this.cargando.set(false);
},
});
}
agregar(producto: Producto, cantidad: number): void {
if (cantidad < 1) return;
const existente = this.carrito().find((item) => item.producto.id === producto.id);
if (existente) {
this.carrito.update((lista) =>
lista.map((item) =>
item.producto.id === producto.id ? { ...item, cantidad: item.cantidad + cantidad } : item,
),
);
} else {
this.carrito.update((lista) => [...lista, { producto, cantidad }]);
}
}
quitar(idProducto: number): void {
this.carrito.update((lista) => lista.filter((item) => item.producto.id !== idProducto));
}
confirmar(): void {
if (this.carrito().length === 0) return;
this.enviando.set(true);
this.error.set(null);
this.ordenService
.crear({
metodoPago: this.metodoPago,
detalles: this.carrito().map((item) => ({ idProducto: item.producto.id, cantidad: item.cantidad })),
})
.subscribe({
next: (orden) => {
this.resultado.set(orden);
this.carrito.set([]);
this.enviando.set(false);
},
error: () => {
this.error.set('No se pudo crear la orden.');
this.enviando.set(false);
},
});
}
}
productos().filter((p) => p.activo) descarta productos inactivos del catálogo que ofrece el carrito — ProductoService.listar() (S3, backend) devuelve todos, activos e inactivos, sin filtrar; filtrar es responsabilidad de quien consume la lista, no del endpoint. El carrito vive solo en memoria (signal, sin persistir en ningún lado) — si recargas la página antes de confirmar, se pierde, igual que el carrito de cualquier sitio sin sesión de compra abierta.
src/app/features/ordenes/orden-crear.html:
@if (cargando()) {
<p>Cargando catálogo...</p>
} @else if (resultado(); as orden) {
<h3>Orden #{{ orden.id }} — estado: {{ orden.estado }}</h3>
@if (orden.estado === 'PENDIENTE_PAGO') {
<p>Tu orden quedó registrada con total {{ orden.total }}. El pago se procesa de forma asíncrona — revisa "Mis pedidos" en unos segundos.</p>
} @else {
<p>No se pudo reservar el stock de uno o más productos — la orden quedó en estado <strong>{{ orden.estado }}</strong>, sin total ni pago asociado.</p>
}
<a routerLink="/mis-pedidos">Ir a Mis pedidos</a>
} @else {
<h3>Catálogo</h3>
@if (error()) {
<p class="error">{{ error() }}</p>
}
<table>
<thead>
<tr><th>Producto</th><th>Precio</th><th>Stock</th><th>Cantidad</th><th></th></tr>
</thead>
<tbody>
@for (producto of productos(); track producto.id) {
<tr>
<td>{{ producto.nombre }}</td>
<td>{{ producto.precio }}</td>
<td>{{ producto.stock }}</td>
<td><input type="number" min="1" value="1" #cantidadInput /></td>
<td>
<button type="button" (click)="agregar(producto, cantidadInput.valueAsNumber || 1)">
Agregar
</button>
</td>
</tr>
}
</tbody>
</table>
<h3>Carrito</h3>
@if (carrito().length === 0) {
<p>Todavía no agregaste ningún producto.</p>
} @else {
<table>
<thead>
<tr><th>Producto</th><th>Cantidad</th><th>Subtotal</th><th></th></tr>
</thead>
<tbody>
@for (item of carrito(); track item.producto.id) {
<tr>
<td>{{ item.producto.nombre }}</td>
<td>{{ item.cantidad }}</td>
<td>{{ item.producto.precio * item.cantidad }}</td>
<td><button type="button" (click)="quitar(item.producto.id)">Quitar</button></td>
</tr>
}
</tbody>
</table>
<p>Total: {{ total() }}</p>
<label>
Método de pago
<select name="metodoPago" [(ngModel)]="metodoPago">
<option value="YAPE_PLIN">Yape / Plin</option>
<option value="TARJETA">Tarjeta</option>
<option value="TRANSFERENCIA">Transferencia</option>
<option value="TARJETA_RECHAZADA">Tarjeta (forzar rechazo — solo para pruebas, 3.8)</option>
</select>
</label>
<button type="button" [disabled]="enviando()" (click)="confirmar()">Confirmar pedido</button>
}
}
#cantidadInput + .valueAsNumber (en vez de [(ngModel)]) alcanza para un campo que no necesita validación ni enlace bidireccional — se lee una sola vez, al hacer clic en Agregar (mismo criterio que templates anteriores: la herramienta más simple que resuelve el caso, no la más sofisticada disponible). El método de pago sí usa [(ngModel)] porque su valor se necesita más adelante, en confirmar(), no en el momento del clic.
En la plantilla, al recibir la respuesta de crear, se muestra el estado tal cual llega — no un mensaje genérico de "¡Compra exitosa!". Es la misma disciplina que el caso de 1.6 motivó: la respuesta 201 confirma que la orden se registró, no que el pago se resolvió (ni, como acaba de confirmarse arriba, que el stock alcanzó).
Agrega la ruta y el enlace del menú — en src/app/app.routes.ts, como nueva hija de Layout, junto a categorias:
{
path: 'ordenes/nueva',
canActivate: [authGuard],
loadComponent: () => import('./features/ordenes/orden-crear').then((m) => m.OrdenCrear),
},
Solo authGuard — sin rolGuard: SecurityConfig.java del Gateway ya exige hasAnyRole("CLIENTE", "ADMIN") para /api/v1/ordenes/** (S07b), cualquiera de los dos roles alcanza, a diferencia de categorias/nueva (solo ADMIN).
En src/app/core/layout/layout.html, agrega el enlace al <nav class="sidebar">, junto al de Categorías:
<a routerLink="/ordenes/nueva" routerLinkActive="active">Nueva orden</a>
Error frecuente: usar OrdenRequest.metodoPago = "TARJETA_RECHAZADA" sin querer durante las pruebas normales. Es el valor exacto que PagoServiceImpl (S8) usa para simular un rechazo — útil a propósito en 3.8 (Probar de punta a punta), pero confuso si lo eliges sin querer aquí, en 3.5.
3.6 Agregar la consulta de pago por orden en pagatu-pago-ms¶
Producto del paso: GET /api/v1/pagos/por-orden/{ordenId}, el endpoint que falta para que la SPA pueda mostrar el pago de una orden específica — hoy PagoController solo tiene listar() (todos los pagos) y obtener(id) (por el id del propio pago, no por el de la orden); y, ya que listar() queda expuesto por primera vez a un cliente real, una pantalla (solo ADMIN) que lo consuma.
services/pagatu-pago-ms/src/main/java/pe/edu/upeu/pago/repository/PagoRepository.java — ya tiene findByOrdenId (lo usa procesar, S8); solo falta exponerlo.
PagoService.java y PagoServiceImpl.java — agrega el método:
Optional<PagoResponse> buscarPorOrden(Long ordenId);
@Override
public Optional<PagoResponse> buscarPorOrden(Long ordenId) {
return pagoRepository.findByOrdenId(ordenId).map(pagoMapper::toResponse);
}
PagoController.java — agrega el endpoint:
@GetMapping("/por-orden/{ordenId}")
public ResponseEntity<PagoResponse> buscarPorOrden(@PathVariable Long ordenId) {
return pagoService.buscarPorOrden(ordenId)
.map(ResponseEntity::ok)
.orElseGet(() -> ResponseEntity.notFound().build());
}
Optional (no una excepción) es la elección correcta aquí: que una orden todavía no tenga pago registrado no es un error — es, precisamente, el estado normal mientras Kafka todavía no entregó el evento (2.1, Figura 2). 404 es la respuesta honesta: "este pago no existe todavía", no "algo falló".
Agrega la ruta en el Gateway, junto a las que ya existen (infra/pagatu-config/config-repo/pagatu-gateway-dev.yml):
- id: pagatu-pago-consulta
uri: lb://pagatu-pago-ms
predicates:
- Path=/api/v1/pagos/**
Es la primera ruta de pagatu-pago-ms en el Gateway — hasta hoy, nadie necesitaba llamarlo desde afuera (solo consumía eventos de Kafka).
src/app/features/ordenes/pago.model.ts (archivo nuevo) — mismos campos que PagoResponse:
export interface Pago {
id: number;
ordenId: number;
monto: number;
metodoPago: string;
estado: string;
fechaPago: string;
}
src/app/features/ordenes/pago-service.ts (archivo nuevo):
import { Injectable, inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
import { environment } from '../../../environments/environment';
import { Pago } from './pago.model';
@Injectable({ providedIn: 'root' })
export class PagoService {
private readonly http = inject(HttpClient);
obtenerPorOrden(ordenId: number): Observable<Pago> {
return this.http.get<Pago>(`${environment.apiBaseUrl}/api/v1/pagos/por-orden/${ordenId}`);
}
}
Un 404 de obtenerPorOrden no es un error que mostrar en pantalla (arriba, el propio PagoController lo devuelve a propósito para "todavía no existe") — 3.7 lo trata como ausencia de pago, no como falla.
Listar todos los pagos (ADMIN). PagoController.listar() existe desde S8 (todos los pagos, sin filtrar), pero hasta ahora ningún cliente lo llamaba desde afuera — solo se usaba internamente/por Swagger. A diferencia de por-orden (lo que un CLIENTE necesita para ver su propio pedido), ver todos los pagos de todos los clientes es una función administrativa — no una extensión de "Mis pedidos", sino una pantalla aparte, solo para ADMIN.
El backend no lo restringía todavía: GET /api/v1/pagos caía en el anyRequest().authenticated() genérico de SecurityConfig.java, abierto a cualquier rol. Restringir esto en el router de Angular sin tocar el backend repetiría el error que ya se evitó con categorias/nueva (3.2): la SPA no es el límite real, solo lo refleja. Agrega la regla, antes de anyRequest().authenticated() — con GET y sin /**, para no afectar por-orden/{id} ni /{id} (que sí deben seguir abiertos a cualquier rol autenticado):
.requestMatchers(HttpMethod.GET, "/api/v1/pagos").hasRole("ADMIN")
src/app/features/ordenes/pago-service.ts — agrega listar(), junto a obtenerPorOrden:
listar(): Observable<Pago[]> {
return this.http.get<Pago[]>(`${environment.apiBaseUrl}/api/v1/pagos`);
}
ng generate component features/ordenes/pago-list --flat
src/app/features/ordenes/pago-list.ts:
import { Component, OnInit, inject, signal } from '@angular/core';
import { PagoService } from './pago-service';
import { Pago } from './pago.model';
@Component({
selector: 'app-pago-list',
templateUrl: './pago-list.html',
})
export class PagoList implements OnInit {
private readonly pagoService = inject(PagoService);
protected readonly pagos = signal<Pago[]>([]);
protected readonly cargando = signal(true);
protected readonly error = signal<string | null>(null);
ngOnInit(): void {
this.pagoService.listar().subscribe({
next: (data) => {
this.pagos.set(data);
this.cargando.set(false);
},
error: () => {
this.error.set('No se pudo cargar la lista de pagos.');
this.cargando.set(false);
},
});
}
}
src/app/features/ordenes/pago-list.html:
@if (cargando()) {
<p>Cargando pagos...</p>
} @else if (error()) {
<p class="error">{{ error() }}</p>
} @else {
<table>
<thead>
<tr><th>Pago</th><th>Orden</th><th>Monto</th><th>Método</th><th>Estado</th><th>Fecha</th></tr>
</thead>
<tbody>
@for (pago of pagos(); track pago.id) {
<tr>
<td>#{{ pago.id }}</td>
<td>#{{ pago.ordenId }}</td>
<td>{{ pago.monto }}</td>
<td>{{ pago.metodoPago }}</td>
<td>{{ pago.estado }}</td>
<td>{{ pago.fechaPago }}</td>
</tr>
} @empty {
<tr><td colspan="6">No hay pagos registrados.</td></tr>
}
</tbody>
</table>
}
Agrega la ruta, protegida con los dos guards — authGuard primero (¿hay sesión?), rolGuard('ADMIN') después (¿el rol alcanza?), mismo orden que categorias/nueva (3.4):
{
path: 'pagos',
canActivate: [authGuard, rolGuard('ADMIN')],
loadComponent: () => import('./features/ordenes/pago-list').then((m) => m.PagoList),
},
En src/app/core/layout/layout.html, el enlace va condicionado por rol — a diferencia de Categorías/Nueva orden/Mis pedidos (visibles para cualquier sesión), Pagos no tiene sentido ofrecerlo a quien el guard va a rebotar igual con una alerta:
@if (auth.tieneRol('ADMIN')) {
<a routerLink="/pagos" routerLinkActive="active">Pagos</a>
}
3.7 "Mis pedidos": consistencia eventual con polling¶
Producto del paso: una pantalla que lista las órdenes del usuario autenticado y refresca automáticamente cada orden que siga PENDIENTE_PAGO, hasta que cambie.
Filtrado por idCliente (UX, no seguridad): GET /api/v1/ordenes (S7, hasAnyRole("CLIENTE", "ADMIN")) no filtra por dueño del lado del servidor — cualquier CLIENTE autenticado ve todas las órdenes si llama a ese endpoint sin más. "Mis pedidos" filtra del lado del cliente, comparando orden.idCliente contra auth.idCliente() (3.4) — exactamente la misma distinción que LP2 (S11, 2.7) ya estableció: ocultar no es asegurar, el backend sigue siendo quien decide de verdad qué puede hacer cada rol; esto solo mejora lo que un usuario normal ve, sin pretender ser un límite de seguridad. Esta limitación de GET /api/v1/ordenes se diagnostica con dos usuarios y se corrige en S13 (3.4 y 3.5).
src/app/features/ordenes/pedido.model.ts (archivo nuevo):
import { OrdenResponse } from './orden.model';
import { Pago } from './pago.model';
export interface PedidoConPago {
orden: OrdenResponse;
pago: Pago | null;
}
ng generate component features/ordenes/mis-pedidos --flat
src/app/features/ordenes/mis-pedidos.ts:
import { Component, OnDestroy, OnInit, inject, signal } from '@angular/core';
import { RouterLink } from '@angular/router';
import { OrdenService } from './orden-service';
import { PagoService } from './pago-service';
import { AuthService } from '../../core/auth/auth-service';
import { PedidoConPago } from './pedido.model';
@Component({
selector: 'app-mis-pedidos',
imports: [RouterLink],
templateUrl: './mis-pedidos.html',
})
export class MisPedidos implements OnInit, OnDestroy {
private readonly ordenService = inject(OrdenService);
private readonly pagoService = inject(PagoService);
private readonly auth = inject(AuthService);
protected readonly pedidos = signal<PedidoConPago[]>([]);
protected readonly cargando = signal(true);
private intervalo?: ReturnType<typeof setInterval>;
ngOnInit(): void {
this.cargar();
this.intervalo = setInterval(() => this.refrescarPendientes(), 4000);
}
ngOnDestroy(): void {
clearInterval(this.intervalo);
}
private cargar(): void {
this.ordenService.listar().subscribe((ordenes) => {
const propias = ordenes.filter((o) => o.idCliente === this.auth.idCliente());
this.pedidos.set(propias.map((orden) => ({ orden, pago: null })));
this.cargando.set(false);
for (const pedido of this.pedidos()) {
if (pedido.orden.estado !== 'PENDIENTE_PAGO') {
this.cargarPago(pedido.orden.id);
}
}
});
}
private refrescarPendientes(): void {
const pendientes = this.pedidos().filter((p) => p.orden.estado === 'PENDIENTE_PAGO');
for (const pendiente of pendientes) {
this.ordenService.obtener(pendiente.orden.id).subscribe((actualizada) => {
this.pedidos.update((lista) =>
lista.map((p) => (p.orden.id === actualizada.id ? { ...p, orden: actualizada } : p)),
);
if (actualizada.estado !== 'PENDIENTE_PAGO') {
this.cargarPago(actualizada.id);
}
});
}
}
private cargarPago(ordenId: number): void {
this.pagoService.obtenerPorOrden(ordenId).subscribe({
next: (pago) => {
this.pedidos.update((lista) => lista.map((p) => (p.orden.id === ordenId ? { ...p, pago } : p)));
},
error: () => {
// 404 esperado (3.6): esta orden (p. ej. CARRITO, sin stock) nunca tuvo un pago que generar.
},
});
}
protected etiqueta(estado: string): string {
switch (estado) {
case 'PENDIENTE_PAGO':
return 'Procesando pago…';
case 'PAGADA':
return 'Pagado';
case 'CANCELADA':
return 'Pago rechazado';
case 'CARRITO':
return 'Sin stock disponible';
default:
return estado;
}
}
}
refrescarPendientes solo vuelve a consultar las órdenes que siguen PENDIENTE_PAGO — una vez que una orden llega a PAGADA o CANCELADA, deja de incluirse en el sondeo (2.5, Tabla 3: el costo real del polling es tráfico redundante; dejar de preguntar por lo que ya no cambia es la forma más simple de acotarlo). ngOnDestroy limpia el intervalo — sin esto, navegar fuera de "Mis pedidos" dejaría el sondeo corriendo en segundo plano indefinidamente. cargarPago se llama tanto al cargar la lista (para una orden que ya llegó resuelta) como justo después de que refrescarPendientes detecta un cambio de estado — en los dos casos, solo si el estado ya no es PENDIENTE_PAGO (3.6: mientras lo sea, no hay ningún pago que consultar todavía).
src/app/features/ordenes/mis-pedidos.html:
@if (cargando()) {
<p>Cargando tus pedidos...</p>
} @else if (pedidos().length === 0) {
<p>Todavía no tienes pedidos. <a routerLink="/ordenes/nueva">Crear uno</a>.</p>
} @else {
<table>
<thead>
<tr><th>Orden</th><th>Fecha</th><th>Total</th><th>Estado</th><th>Pago</th></tr>
</thead>
<tbody>
@for (pedido of pedidos(); track pedido.orden.id) {
<tr>
<td>#{{ pedido.orden.id }}</td>
<td>{{ pedido.orden.fechaCreacion }}</td>
<td>{{ pedido.orden.total ?? '—' }}</td>
<td>{{ etiqueta(pedido.orden.estado) }}</td>
<td>
@if (pedido.pago) {
{{ pedido.pago.metodoPago }} — {{ pedido.pago.fechaPago }}
} @else {
—
}
</td>
</tr>
}
</tbody>
</table>
}
Agrega la ruta y el enlace del menú — en src/app/app.routes.ts, como nueva hija de Layout, junto a ordenes/nueva:
{
path: 'mis-pedidos',
canActivate: [authGuard],
loadComponent: () => import('./features/ordenes/mis-pedidos').then((m) => m.MisPedidos),
},
En src/app/core/layout/layout.html, agrega el enlace al <nav class="sidebar">, junto a Nueva orden:
<a routerLink="/mis-pedidos" routerLinkActive="active">Mis pedidos</a>
3.8 Probar de punta a punta, incluido un pago rechazado¶
Producto del paso: evidencia real de los dos desenlaces posibles — una orden que termina PAGADA y una que termina CANCELADA — ambas vistas cambiar en pantalla sin recargar la página a mano.
- Inicia sesión como
cliente1@pagatu.com. - Crea una orden con cualquier
metodoPagonormal (ej.YAPE_PLIN). Confirma que aparece de inmediato en "Mis pedidos" comoPENDIENTE_PAGO, y que en pocos segundos (sin tocar nada) cambia aPAGADA. - Crea una segunda orden con
metodoPago: "TARJETA_RECHAZADA"(S8, el valor quePagoServiceImplrechaza a propósito). Confirma que esta sí cambia, también sola, aCANCELADA. - (Opcional, si tienes
obs/levantado) Verifica en el tablero de Grafana (S10) que ambas transiciones generaron actividad real enpagatu-pago-msypagatu-orden-ms— el mismo tablero de diagnóstico de la sesión anterior, ahora observando tráfico real generado por un cliente de verdad, no porcurl. No es indispensable para el producto de esta sesión (3.1 ya aclaró queobs/no hace falta hoy); es solo una confirmación adicional, si ya lo tienes corriendo de la sesión anterior.
Error frecuente: ver que una orden se queda en PENDIENTE_PAGO indefinidamente. Antes de sospechar del polling, confirma que pagatu-pago-ms sigue corriendo y que el consumer group de Kafka no quedó atascado (S8, 2.6) — el mismo diagnóstico que esa sesión ya enseñó, aplicado ahora a un síntoma visible en la interfaz en vez de en los logs.
Evidencia de aprendizaje:
- CORS habilitado en el Gateway, con la SPA llamando sin error de origen cruzado.
- Login real con Authorization Code + PKCE, con
stateverificado. - Catálogo, creación de orden y "Mis pedidos" funcionando a través del Gateway.
- Las dos transiciones de estado (
PAGADAyCANCELADA) observadas en vivo, sin recargar la página.
4. Crea: actividad autónoma¶
Tiempo: 3h fuera del aula.
4.1 Actividad¶
Extensión del cliente frontend del Proyecto Sello propio del equipo, documentada en evidencia individual.
Completa y evidencia estas tareas, sobre tu propio proyecto:
- Si tu proyecto todavía no reemplazó su propio servidor de autorización por Keycloak, hazlo siguiendo el mismo criterio de la Tabla 6 de S7 — o, si ya lo hiciste en una sesión anterior, confirma que el cliente de tu propia SPA usa Authorization Code + PKCE, sin Direct access grants.
- Decide, para al menos un dato de negocio de tu propio dominio, si de verdad es distinto de "quién inició sesión" o si —como terminó siendo
idClienteaquí (S07b, 7.4)— puede ser literalmentesub. Si es genuinamente distinto, configura un user attribute + protocol mapper propios en tu realm (el patrón que S07, 3.13, diseñó originalmente paraidCliente, antes de que S07b decidiera que no hacía falta) para que viaje en el token. - Construye al menos una pantalla de tu propio proyecto que dependa de un proceso asíncrono (una cola, un webhook, un batch) y decida explícitamente cómo reflejar el estado "todavía no se sabe" — polling, otra estrategia de la Tabla 3, o una justificación documentada de por qué tu caso no lo necesita.
- Prueba, con datos reales, el camino feliz y al menos un camino de rechazo/fallo, y documenta ambos con capturas.
4.2 Propósito¶
Que cada estudiante demuestre, de forma individual y fuera del aula, que puede migrar un cliente frontend a un proveedor de identidad externo y diseñar una interfaz que refleje con honestidad el estado real de un proceso asíncrono propio — no solo replicar lo visto en clase sobre pagatu.
4.3 Indicaciones¶
Entrega un PDF con el siguiente nombre:
S11_Equipo##_ApellidoNombre.pdf
Cada captura de pantalla del informe debe mostrar, sin recortar, el reloj del sistema (fecha y hora) y tu usuario o foto de perfil (Windows, VS Code o navegador) visibles en pantalla.
4.3.1 Estructura del informe¶
Datos del estudiante
- Nombre:
- Equipo:
- Sesión: S11 - Integración con Cliente Frontend: Angular 22 sobre el Gateway, con Keycloak
- Rol o aporte realizado:
- Link de GitHub:
Evidencia técnica
Incluye capturas con una breve explicación debajo de cada una, organizadas en los mismos 4 bloques de la rúbrica (4.6):
- Migración a Keycloak
- Realm, roles y protocol mapper de tu propio proyecto, con el login real funcionando.
- Cliente con Authorization Code + PKCE
- Login completo de punta a punta, con
stateycode_verifierverificados.
- Login completo de punta a punta, con
- Proceso asíncrono reflejado en la interfaz
- La pantalla que decide cómo mostrar un estado "todavía no resuelto", con la estrategia elegida justificada.
- Camino feliz y camino de fallo
- Ambos desenlaces probados y documentados con capturas reales.
Error o hallazgo
Describe un error real: un protocol mapper sin Add to access token, un state que no coincidía por reusar una pestaña vieja, un polling que seguía corriendo después de salir de la pantalla, o un CORS mal configurado que bloqueaba silenciosamente las peticiones.
Reflexión técnica breve
Responde en 5 a 8 líneas:
¿Por qué el caso de Starbucks (1.6) es un problema de consistencia y
no solo de seguridad? Relaciona tu respuesta con la decisión de
diseño que tomaste en tu propia pantalla de 4.1.3 para reflejar un
estado que tu sistema todavía no había resuelto.
4.4 Criterios mínimos de aceptación¶
- El archivo respeta el nombre solicitado.
- Si corresponde, el servidor de autorización propio fue reemplazado por Keycloak (o ya lo estaba, y se verifica PKCE sin Direct access grants).
- Se decidió explícitamente, con justificación, si el dato de negocio elegido podía ser
subo necesitaba un user attribute + protocol mapper propios — y si fue lo segundo, quedó verificado con un token real. - Existe al menos una pantalla que depende de un proceso asíncrono, con una estrategia explícita y justificada para reflejar su estado pendiente.
- Se probaron y documentaron tanto el camino feliz como un camino de rechazo/fallo real.
- Cada captura de la evidencia técnica muestra el reloj del sistema y el usuario/perfil visible, sin recortar.
- Las fechas y horas de las capturas son coherentes con el historial de commits de su repositorio en GitHub.
- Incluye un error o hallazgo técnico diagnosticado.
- Incluye la reflexión técnica breve solicitada.
4.5 Preguntas de defensa¶
- ¿Por qué S07b terminó decidiendo que
idClientepodía ser literalmentesub, en vez de usar el protocol mapper que S07 (3.13) había diseñado originalmente para ese mismo dato? - ¿Qué problema concreto previene verificar
stateal volver de Keycloak, y qué pasaría si tu cliente lo ignorara? - ¿Por qué una respuesta
201dePOST /api/v1/ordenesno es evidencia de que el pago se resolvió? - De las tres estrategias de la Tabla 3 (2.5), ¿cuál elegiste para tu propio proyecto, y qué te hizo descartar las otras dos?
- ¿Por qué el Gateway es el lugar correcto para configurar CORS, y no cada microservicio por separado?
- Si
GET /api/v1/ordenesno filtra poridClientedel lado del servidor, ¿qué protege realmente el filtrado que hiciste en el frontend, y qué no protege?
4.6 Rúbrica de evaluación¶
Tabla 4. Rúbrica de evaluación
| Criterio | Peso (%) | A (20 pts) | B (15 pts) | C (10 pts) | D (5 pts) | Nivel obtenido |
|---|---|---|---|---|---|---|
| 1. Migración a Keycloak* | 25 | Realm, roles y protocol mapper configurados y verificados, con login real funcionando. | Migración funcional, con alguna configuración incompleta (ej. mapper sin "Add to access token"). | Migración parcial, o PKCE no obligatorio. | No presenta migración a Keycloak. | |
| 2. Cliente con Authorization Code + PKCE* | 25 | Login completo verificado de punta a punta, con state y code_verifier validados correctamente. | Login funcional, con alguna verificación (state o PKCE) incompleta. | Login funcional solo con un flujo inseguro. | No presenta login funcional. | |
| 3. Proceso asíncrono en la interfaz* | 25 | Estrategia explícita y bien justificada, verificada con datos reales cambiando de estado sin recargar. | Estrategia presente, con la verificación incompleta. | Estrategia presente solo en el diseño, sin implementación real. | No presenta ninguna estrategia. | |
| 4. Camino feliz y de fallo* | 25 | Ambos caminos probados y documentados con evidencia real y clara. | Ambos presentes, con alguno documentado superficialmente. | Solo el camino feliz probado. | No presenta ninguno de los dos caminos. |
* Agregado manual.
Nota final = suma de (Peso / 100 × Puntos del nivel obtenido) = ____ / 20.
Para usar la rúbrica con IA (inteligencia artificial), solicita:
Evalúa el PDF usando la rúbrica de la sesión.
Para cada criterio selecciona el nivel obtenido usando la escala A=20, B=15, C=10, D=5 puntos.
Justifica brevemente cada nivel asignado.
Verifica que cada captura muestre reloj del sistema y usuario/perfil visible, y que las fechas sean coherentes con el historial de commits de GitHub. Si falta esta evidencia o hay inconsistencias, indícalo explícitamente antes de calificar.
Calcula la nota final con la fórmula: suma de (Peso/100 × Puntos del nivel obtenido), directamente sobre 20.
Indica 2 fortalezas y 2 recomendaciones.
5. Cierre¶
Tiempo: 5 min.
Resumen breve: hoy pagatu dejó de ser un sistema que solo se probaba desde PowerShell y curl. Con pagatu-auth-ms ya retirado desde S07b —exactamente como la Tabla 6 de S7 lo anticipó, sin tocar el código del Gateway ni de pagatu-orden-ms— el primer cliente Angular del curso ya inicia sesión con Authorization Code + PKCE contra Keycloak, crea órdenes a través del Gateway, y —la pieza que no tenía precedente en ninguna sesión anterior— refleja con honestidad un estado que el propio sistema todavía no resolvió, hasta que la consistencia eventual que S9 construyó del lado del backend termina su trabajo y la orden pasa, sola, a PAGADA o CANCELADA.
Dinámica participativa: en una ronda rápida, cada estudiante comparte en una frase cuánto tardó, en su propia prueba, en ver una orden pasar de PENDIENTE_PAGO a su estado final.
Metacognición: ¿qué te costó más entender hoy: por qué idCliente terminó siendo sub en vez del protocol mapper que S07 había diseñado originalmente, o por qué una respuesta 201 no es lo mismo que "el proceso ya terminó"?
Proyección: S12 integra todo lo construido en esta unidad —seguridad, mensajería, consistencia, observabilidad y ahora el cliente frontend— en el Producto de Unidad 2: el sistema distribuido robusto completo, sustentado de punta a punta.
Bibliografía¶
- Schneier, B. (2015, 27 de mayo). Race Condition Exploit in Starbucks Gift Cards. Schneier on Security. https://www.schneier.com/blog/archives/2015/05/race_condition_.html
- Sakimura, N., Bradley, J., & Agarwal, N. (2015). Proof Key for Code Exchange by OAuth Public Clients (RFC 7636). IETF. https://www.rfc-editor.org/rfc/rfc7636
- Lodderstedt, T., Bradley, J., Labunets, A., & Fett, D. (2025). Best Current Practice for OAuth 2.0 Security (RFC 9700). IETF. https://datatracker.ietf.org/doc/html/rfc9700
- Spring Cloud Gateway. (2026). Global CORS Configuration. https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway/global-cors-configuration.html