Actividad Práctica: Estandarizar Categorías
Fecha de referencia: 2026-05-17
Objetivo
Refactorizar el módulo simple de categorías para que siga el mismo estándar usado en productos:
- No usar
HttpClientdirectamente dentro del componente. - Crear un servicio de datos.
- Usar interfaces tipadas.
- Consumir el gateway mediante
ApiService. - Mantener una plantilla consistente con formulario, tabla y acciones.
Punto de Partida
El componente Categorias inicialmente hacía llamadas HTTP directas:
constructor(private http: HttpClient) {}
cargarCategorias() {
this.http.get<any[]>('http://localhost:8090/api/v1/categorias')
.subscribe(data => this.categorias.set(data));
}
Eso funciona para aprender, pero a medida que crece la aplicación conviene separar responsabilidades.
Paso 1: Crear el Servicio de Categorías
Archivo:
src/app/categorias/categorias.service.ts
Responsabilidades:
- Definir el contrato
Categoria. - Definir el contrato
CategoriaRequest. - Centralizar las operaciones HTTP.
- Usar
ApiServicepara construir URLs.
Estructura esperada:
export interface Categoria {
id: number;
nombre: string;
descripcion: string;
}
export interface CategoriaRequest {
nombre: string;
descripcion: string;
}
Métodos del servicio:
listar(): Observable<Categoria[]>
crear(categoria: CategoriaRequest): Observable<Categoria>
actualizar(id: number, categoria: CategoriaRequest): Observable<Categoria>
eliminar(id: number): Observable<void>
Paso 2: Usar el Gateway Desde ApiService
En vez de escribir la URL completa:
http://localhost:8090/api/v1/categorias
se usa:
this.api.buildUrl('/api/v1/categorias')
Ventaja:
- Si cambia la URL del gateway, se modifica solo
environment.ts. - El componente queda libre de detalles de infraestructura.
Paso 3: Limpiar el Componente
Archivo:
src/app/categorias/categorias.ts
Antes:
- El componente tenía
HttpClient. - El componente conocía la URL exacta.
- Se usaba
any[].
Después:
- El componente usa
CategoriasService. - Usa
signal<Categoria[]>([]). - Maneja estado simple:
loading,error. - Maneja formulario:
formNombre,formDescripcion,editandoId.
Estados principales:
categorias = signal<Categoria[]>([]);
loading = signal(false);
error = signal('');
Paso 4: Unificar el Guardado
En vez de tener un flujo separado en el HTML:
(ngSubmit)="editandoId ? guardarEdicion() : crearCategoria()"
se usa un solo método:
(ngSubmit)="guardarCategoria()"
Dentro del componente se decide:
- Si
editandoIdtiene valor, se actualiza. - Si
editandoIdesnull, se crea.
Paso 5: Crear el Formulario Estándar
Archivo:
src/app/categorias/categorias.html
Formulario esperado:
<form class="categoria-form" (ngSubmit)="guardarCategoria()">
<input
type="text"
name="nombre"
placeholder="Nombre"
[(ngModel)]="formNombre"
required
>
<input
type="text"
name="descripcion"
placeholder="Descripción"
[(ngModel)]="formDescripcion"
required
>
<button type="submit">{{ editandoId ? 'Guardar' : 'Agregar' }}</button>
<button *ngIf="editandoId" type="button" class="secondary" (click)="cancelarEdicion()">Cancelar</button>
</form>
Paso 6: Crear la Tabla Estándar
La tabla debe mostrar:
- ID.
- Nombre.
- Descripción.
- Acciones.
Acciones:
- Editar.
- Eliminar.
Ejemplo:
<tr *ngFor="let categoria of categorias()">
<td>{{ categoria.id }}</td>
<td>{{ categoria.nombre }}</td>
<td>{{ categoria.descripcion }}</td>
<td class="actions">
<button type="button" class="secondary" (click)="iniciarEdicion(categoria)">Editar</button>
<button type="button" class="danger" (click)="eliminarCategoria(categoria.id)">Eliminar</button>
</td>
</tr>
Paso 7: Alinear Estilos con Productos
Archivo:
src/app/categorias/categorias.scss
Se agregan estilos equivalentes a productos:
.categorias-page.page-title.categoria-form.actions- botones primarios, secundarios y de peligro
- tabla con bordes
- responsive para pantallas pequeñas
Resultado Esperado
Al terminar, categorías y productos deben tener el mismo patrón:
Componente -> maneja estado y eventos de UI
Servicio -> maneja HTTP
ApiService -> construye URLs hacia gateway
HTML -> muestra formulario y tabla
SCSS -> mantiene estilo consistente
Checklist
- Existe
categorias.service.ts. - El componente ya no importa
HttpClient. - El componente usa
CategoriasService. - No se usa
any[]para categorías. - El formulario crea y edita desde
guardarCategoria(). - La tabla permite editar y eliminar.
- Las URLs pasan por
ApiService. - El diseño se parece al de productos.
Preguntas para el Alumno
- ¿Por qué conviene sacar
HttpClientdel componente? - ¿Qué diferencia hay entre
CategoriayCategoriaRequest? - ¿Para qué sirve
ApiService? - ¿Por qué
guardarCategoria()puede crear o actualizar? - ¿Qué parte del código cambiaría si el gateway pasa de
7091a otro puerto?
Siguiente Mejora
Reutilizar el listado de categorías en productos para elegir la categoría desde un <select>, evitando que el usuario escriba manualmente el idCategoria.
Estado actual: esta mejora ya fue aplicada en productos. El formulario de productos carga categorías desde /api/v1/categorias y usa un <select> para seleccionar la categoría.
Nota de Seguridad
En esta etapa, categorías queda como recurso público porque el gateway permite:
.pathMatchers("/api/v1/categorias/**", "/api/v1/ordenes/**", "/api/v1/pagos/**").permitAll()
Por eso no se agrega authGuard a /categorias.
Productos sí queda protegido:
{
path: 'productos',
canActivate: [authGuard],
loadComponent: () => import('./productos/productos').then(m => m.Productos),
}
Esta separación permite explicar claramente:
- Recurso público: categorías.
- Recurso protegido: productos.
- Autenticación actual: JWT propio emitido por
services/auth-ms. - Evolución futura: Keycloak/OAuth2/OIDC.