# emartinz/reditos_prueba architecture

> Architecture diagram of the GitHub repository emartinz/reditos_prueba, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2025-03-31). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/emartinz/reditos_prueba
- Repository: https://github.com/emartinz/reditos_prueba

## Overview

A continuación se detalla una guía para que puedas crear un diagrama de arquitectura detallado y preciso, adaptado a este proyecto de gestión de tareas basado en microservicios y JWT.

##### Identificación del tipo de proyecto y propósito
- Se trata de una aplicación full-stack compuesta de microservicios (dos backends: Auth y Tasks) y un frontend en Angular.
- La aplicación implementa la arquitectura hexagonal, aprovechando Spring Boot, Spring Security (JWT) y Swagger para la documentación de APIs, mientras que el frontend utiliza Angular y Bootstrap.

##### Principales componentes a incluir en el diagrama
a. FrontEnd (Interfaz de Usuario):
- Representa la aplicación Angular que consume los microservicios.
- Incluye componentes como Login, Gestión de Tareas, y servicios relacionados (auth.service, task.service, etc.).

b. Microservicio Auth:
- Gestión de la autenticación y autorización.
- Contiene controladores (AuthController, UserController), servicios (AuthService, JwtService) y repositorios (IUserRepository, IUserRoleRepository).
- Implementa JWT para la seguridad y usa Spring Security.
- Se conecta a la base de datos para el manejo de usuarios y roles.

c. Microservicio Task:
- Encargado de la gestión de tareas.
- Incluye controladores (TaskController, UserDetailsController), servicios (TaskService, UserDetailsService) y repositorios (ITaskRepository, IUserDetailsRepository).
- También implementa seguridad basada en JWT y se conecta a la base de datos para gestionar tareas y detalles de usuarios.

d. Base de Datos:
- MySQL es el sistema de persistencia usado.
- Cada microservicio tiene su propio esquema o conjunto de tablas, como se indica en los diagramas de BD (BD_Auth y BD_Task).

e. Infraestructura y otras consideraciones:
- Docker: Se utilizan Dockerfiles y un docker-compose para orquestar el despliegue de los contenedores (los microservicios y posiblemente el frontend y la base de datos).
- Swagger: Debe ser un componente o punto de acceso dentro de cada microservicio para la documentación de API.
- Autenticación con JWT: Usado a nivel de API y seguridad entre frontend y microservicios.
- Arquitectura Hexagonal: Ilustra claramente la separación entre núcleos de negocio (dominio y servicios de aplicación) y adaptadores (controladores de entrada, repositorios de salida, etc.).

##### Relación o interacción entre componentes
- El FrontEnd consume servicios REST expuestos por los microservicios.
- Microservicio Auth administra el proceso de registro, login y validación de tokens, almacenando la información de usuarios y roles en la base de datos.
- Microservicio Task gestiona la creación, actualización, eliminación y consulta de tareas, utilizando información tanto de tareas como de detalles de usuarios.
- Ambos microservicios se comunican con la base de datos (MySQL).
- El flujo se inicia desde el cliente (frontend) que envía solicitudes de autenticación o gestión de tareas, pasando por el Gateway o directamente a los microservicios (según configuración Docker y red) y regresando respuestas en formato JSON.

##### Elementos gráficos y etiquetado
- Usa rectángulos o cajas para representar cada uno de los principales componentes: FrontEnd, Auth Microservice, Task Microservice y Base de Datos.
- Dibuja flechas direccionales que indiquen el flujo de datos:
- El FrontEnd enviando solicitudes HTTP (con JWT) hacia cada microservicio.
- Los microservicios comunicándose con la Base de Datos.
- La interacción interna en cada microservicio entre controladores, servicios y repositorios; si se desea mayor detalle, puedes detallar además cómo se implementa la arquitectura hexagonal (núcleo y adaptadores).
- Incluye etiquetas claras en cada caja (por ejemplo: “Angular FrontEnd”, “Microservicio Auth (Spring Boot, JWT, Hexagonal)”, “Microservicio Task (Spring Boot, Swagger)”, “MySQL Database”).

##### Personalización del diagrama según el tipo de proyecto
- Debido a que es una aplicación full-stack con microservicios, enfatiza la separación lógica entre el frontend y el backend. Muestra conexiones independientes entre:
- FrontEnd y Microservicio Auth (para login/registro).
- FrontEnd y Microservicio Task (para la gestión de tareas).
- Dentro de cada microservicio, detalla la estructura hexagonal resaltando:
- Adaptadores de entrada (controladores).
- Adaptadores de salida (repositorios).
- Núcleo de negocio (servicios y lógica central).
- Incluir nodos que representen herramientas auxiliares (Swagger, Docker y JaCoCo para cobertura de código).

##### Guía paso a paso para crear el diagrama
- Esquematiza un diagrama de alto nivel que separe claramente:
- FrontEnd (cliente Angular): Ubicado en la parte superior o a un lado.
- BackEnd: Divide en dos secciones (Auth y Task) ubicadas en paralelo o en bloques distintos.
- Base de Datos (MySQL): A continuación, con líneas de conexión desde ambos microservicios.
- Dibuja dentro de cada microservicio una subdivisión que muestre:
- Controladores/Adaptadores de entrada (ej: AuthController, TaskController).
- Servicios (AuthService, TaskService, JwtService, etc.).
- Repositorios (IUserRepository, ITaskRepository, etc.).
- Agrega flechas indicando llamadas entre:
- FrontEnd → Controladores de microservicios (incluir headers JWT).
- Controladores → Servicios (lógica central).
- Servicios → Repositorios (acceso a Base de Datos).
- También, notas que dentro de cada microservicio se usa Spring Security para la validación de JWT y Swagger para la documentación.
- Agrega etiquetas de tecnologías donde corresponda (por ejemplo, “Spring Boot”, “Angular”, “MySQL”, “Docker”).

##### Recomendaciones adicionales
- Asegúrate de etiquetar claramente cada componente.
- Usa flechas de dirección para clarificar el flujo de datos y dependencias.
- Aplica codificación por colores o formas para que se distinga entre capa de presentación, capa de negocio y capa de persistencia.
- No olvides documentar en el diagrama puntos críticos, como el uso de JWT y la integración de Swagger.
- Es importante que la separación en “servicios” y “adaptadores” refleje la arquitectura hexagonal, lo cual ayuda a comprender las dependencias y la estructura modular del sistema.

Siguiendo estos pasos, conseguirás un diagrama completo que representa de forma precisa la arquitectura del Sistema de Gestión de Tareas, facilitando la comprensión tanto de la interacción entre los distintos microservicios como de la integración con las tecnologías empleadas. Esto ayudará a los equipos de desarrollo y operaciones a mantener y escalar la aplicación en el futuro.

## Diagram (Mermaid)

```mermaid
graph TD
    %% FrontEnd Layer
    FE["Angular FrontEnd"]:::frontend

    %% Microservicio Auth subgraph
    subgraph "Microservicio Auth (Spring Boot, JWT, Hexagonal)"
        AController["Auth Controllers (AuthController, UserController)"]:::auth
        AService["Auth Services (AuthService, JwtService, UserService)"]:::auth
        ARepo["Auth Repositories (IUserRepository, IUserRoleRepository)"]:::auth
        AController -->|"calls"| AService
        AService -->|"data_access"| ARepo
    end

    %% Microservicio Task subgraph
    subgraph "Microservicio Task (Spring Boot, Swagger, Hexagonal)"
        TController["Task Controllers (TaskController, UserDetailsController)"]:::task
        TService["Task Services (TaskService, UserDetailsService)"]:::task
        TRepo["Task Repositories (ITaskRepository, IUserDetailsRepository)"]:::task
        Swagger["Swagger Config"]:::task
        TController -->|"calls"| TService
        TService -->|"data_access"| TRepo
        Swagger ---|"docs"| TController
    end

    %% Database
    DB["MySQL Database"]:::db

    %% Docker subgraph
    subgraph "Docker"
        DockerAuth["Auth Dockerfile"]:::docker
        DockerTask["Task Dockerfile"]:::docker
        DockerFE["Frontend Dockerfile"]:::docker
        DockerCompose["docker-compose"]:::docker
    end

    %% Connections between layers
    FE -->|"HTTP_JWT"| AController
    FE -->|"HTTP_JWT"| TController
    ARepo -->|"CRUD"| DB
    TRepo -->|"CRUD"| DB

    %% Docker orchestration arrows
    DockerFE --> FE
    DockerAuth --> AController
    DockerTask --> TController
    DockerCompose -->|"orchestrates"| FE
    DockerCompose -->|"orchestrates"| AController
    DockerCompose -->|"orchestrates"| TController
    DockerCompose -->|"orchestrates"| DB

    %% Click Events
    click FE "https://github.com/emartinz/reditos_prueba/tree/main/FrontEnd/task-manager"
    click AController "https://github.com/emartinz/reditos_prueba/tree/main/BackEnd/auth/src/main/java/com/prtec/auth/adapter/in/controller"
    click AService "https://github.com/emartinz/reditos_prueba/tree/main/BackEnd/auth/src/main/java/com/prtec/auth/application/service"
    click ARepo "https://github.com/emartinz/reditos_prueba/tree/main/BackEnd/auth/src/main/java/com/prtec/auth/adapter/out/repository"
    click TController "https://github.com/emartinz/reditos_prueba/tree/main/BackEnd/tasks/src/main/java/com/prtec/tasks/adapter/in/controller"
    click TService "https://github.com/emartinz/reditos_prueba/tree/main/BackEnd/tasks/src/main/java/com/prtec/tasks/application/service"
    click TRepo "https://github.com/emartinz/reditos_prueba/tree/main/BackEnd/tasks/src/main/java/com/prtec/tasks/adapter/out/repository"
    click DB "https://github.com/emartinz/reditos_prueba/tree/main/recursos/mysql"
    click DockerAuth "https://github.com/emartinz/reditos_prueba/tree/main/BackEnd/auth/Dockerfile"
    click DockerTask "https://github.com/emartinz/reditos_prueba/tree/main/BackEnd/tasks/Dockerfile"
    click DockerFE "https://github.com/emartinz/reditos_prueba/tree/main/FrontEnd/task-manager/Dockerfile"
    click DockerCompose "https://github.com/emartinz/reditos_prueba/blob/main/docker.compose.yml"
    click Swagger "https://github.com/emartinz/reditos_prueba/blob/main/BackEnd/tasks/src/main/java/com/prtec/tasks/config/SwaggerConfig.java"

    %% Styles
    classDef frontend fill:#a2d7ff,stroke:#333,stroke-width:1px;
    classDef auth fill:#ffb3b3,stroke:#333,stroke-width:1px;
    classDef task fill:#ffe6a5,stroke:#333,stroke-width:1px;
    classDef db fill:#caffbf,stroke:#333,stroke-width:1px;
    classDef docker fill:#d3c0eb,stroke:#333,stroke-width:1px;
    classDef general fill:#e0e0e0,stroke:#333,stroke-width:1px;
```
