How isaactakamura/front-veterinaria works
Para dibujar un diagrama de arquitectura claro y preciso de este proyecto “Sistema de Gestión Veterinaria – Frontend”, sigue estos pasos:
Identificar el tipo y propósito del proyecto
• Es una aplicación web full-stack (frontend en Angular) destinada a la gestión de clínicas veterinarias.
• Se comunica vía API REST con un backend (no incluido en este repositorio) que expone endpoints bajo “/api”.
Analizar la estructura de carpetas
• Top-level: angular.json, package.json, proxy.conf.json, carpetas src/ y public/.
• src/app/ se divide en:
• components/ (UI reutilizable y por dominio: admin, enfermería, listaPacientes, vete, shared, ui)
• core/ (guardias de ruta, modelos, servicios HTTP con lógica de negocio)
• layouts/ (layouts por rol: admin-layout, asistente-layout, veterinario-layout)
• pages/ (páginas de enrutamiento: admin-dashboard, enfermera, listapacientes, veterinario…)
• Se usan Guards y un interceptor (token.interceptor.ts) para autenticación JWT.
• Configuración de proxy apunta al backend en localhost:8080.
Insights del README
• Tecnología central: Angular 19, TypeScript, Tailwind CSS, Angular Material y PrimeNG.
• Arquitectura descrita: Frontend (Componentes UI, Guards, Interceptors, Servicios, Modelos) → Backend (API REST, Base de Datos).
• Roles: ADMIN, VET, ASISTENTE, cada uno con un layout y páginas específicas.
Principales componentes para el diagrama
a. Cliente Web (Browser)
b. Angular App
• Módulo raíz (AppModule)
• Módulos de funcionalidad / rutas (AdminModule, AsistenteModule, VeterinarioModule, SharedModule)
• Layouts: AdminLayoutComponent, AsistenteLayoutComponent, VeterinarioLayoutComponent
• Pages: AdminDashboardPage, EnfermeraPage, ListaPacientesPage, VeterinarioPage, LoginPage, RegisterPage, HeroPage, IndexPage, etc.
• Components:
· UI compartida (Navbar, Sidebar, Footer, ChatBot, Avatares…)
· Dominios específicos (AppointmentSupervision, CatalogManagement, InventoryManagement, TriageModal, DetallesCitaModal…)
• Core:
· Guards (auth.guard)
· Interceptor (token.interceptor)
· Servicios HTTP (AuthService, CitaService, ClienteService, MascotaService, VeterinarioService, etc.)
· Modelos/Interfaces (Cita.model.ts, Cliente.model.ts, Paciente-info.model.ts…)
c. HTTP Client / Interceptor
• Flujo: Servicio → HttpClient → Interceptor añade JWT → Llama a API REST
d. Backend API REST (externo)
• Endpoints bajo /api
• Autenticación JWT, lógica de negocio y acceso a BD
e. Base de Datos (externa, p. ej. PostgreSQL o MySQL, esquema webvet.sql)
Relaciones e interacciones
• El navegador envía peticiones al AppModule/Router.
• El Router carga el layout y el módulo de la ruta según rol.
• Los Components invocan Core Services; éstos usan HttpClient + Interceptor para llamar a la API REST.
• La API interactúa con la Base de Datos y devuelve JSON.
• Guards protegen rutas según JWT y rol de usuario.
• Modelos e interfaces garantizan tipado de datos en toda la app.
Patrones y principios arquitectónicos
• Modularidad: separación clara por dominio (components/), recursos compartidos (shared/), lógica (core/).
• Lazy Loading: cargar módulos de Admin, Enfermería, Vete sólo al entrar a sus rutas.
• Single Responsibility: cada servicio Angular gestiona una entidad (CitaService, ClienteService…).
• Dependency Injection: servicios inyectados en componentes y guards.
• Reactive Programming: uso de RxJS para flujos de datos asincrónicos.
Cómo adaptar el diagrama a esta aplicación full-stack
• Distingue tres capas horizontales:
1. UI Layer: Browsers y Angular Components/Pages
2. Business Layer: Angular Core (Services, Guards, Interceptors)
3. Data Layer: API REST externa + Base de datos
• Muestra el flujo de datos bidireccional entre Cliente Web ↔ Frontend Angular ↔ Backend ↔ BD.
• Resalta módulos cargados lazy vs. módulos compartidos en el bootstrap.
Elementos que debe incluir tu diagrama
• Etiquetas claras para cada componente (p.ej., AdminSidebarComponent, CitaService).
• Flechas direccionales:
• Navegador → Angular Router
• Componentes → Services → HTTP Client → API
• API → Base de Datos
• Rectángulos azules para componentes/páginas
• Rectángulos verdes para servicios/core
• Líneas rojas para guards/interceptores
• Nube o cilindro naranja para API y BD
• Leyenda explicativa de colores y símbolos.
Detalle y modularidad
• No agrupes todo en “Frontend”. Separa: Layouts, Pages, Components, Services, Guards, Models.
• Incluye las rutas principales (login, register, admin-dashboard, enfermera, listapacientes, veterinario).
• Muestra conexión del proxy (/api/* → localhost:8080).
• Si hay lazy loading, anótalo con un icono de rayo o similar.
Resumen: tu diagrama debe reflejar la estructura modular de Angular, el flujo de datos desde componentes a servicios hasta la API REST, las rutas protegidas con JWT, y los módulos cargados bajo demanda. Usa colores y flechas claras para distinguir capas y dependencias.