PharmaCare - Sistema de Farmacia con Microservicios

📋 Descripción del Proyecto

PharmaCare es un sistema completo de gestión para farmacias desarrollado con arquitectura de microservicios, implementando Clean Architecture, Domain-Driven Design (DDD) y SOLID principles con las características modernas de Java 21 y Spring Boot 3.x.

¿Qué hace este sistema?

Este proyecto es una plataforma completa de e-commerce farmacéutico que permite:

• 🛒 Carrito de Compras: Los clientes pueden agregar medicamentos y productos al carrito
• 💊 Catálogo de Productos: Gestión completa de medicamentos y productos farmacéuticos
• 📦 Gestión de Inventario: Control de stock y disponibilidad en tiempo real
• 🛍️ Ventas y Pedidos: Procesamiento de órdenes con seguimiento de estado
• 👥 Gestión de Usuarios: Registro, autenticación y perfiles de clientes
• 🔒 Seguridad JWT: Autenticación stateless con tokens JWT
• 📋 Recetas Médicas: Gestión de prescripciones médicas digitales
• 🔔 Notificaciones: Sistema de mensajería con RabbitMQ para alertas y actualizaciones
• 📊 Analytics: Análisis de ventas y comportamiento de usuarios con Kafka
• 🤖 Machine Learning: Recomendaciones inteligentes de productos (Python)

Tecnologías Utilizadas

Backend:

• Java 21 (Records, Sealed Classes, Pattern Matching, Virtual Threads)
• Spring Boot 3.x (Clean Architecture + DDD)
• PostgreSQL (11 bases de datos independientes)
• RabbitMQ (mensajería asíncrona)
• Apache Kafka (streaming de eventos)
• Spring Cloud Netflix Eureka (Service Discovery)
• Spring Cloud Gateway (API Gateway)

Frontend:

• React 18 con TypeScript
• Vite (build tool)
• React Router (navegación)
• Axios (cliente HTTP)
• Tailwind CSS (estilos)

DevOps:

• Docker & Docker Compose
• Prometheus (métricas)
• Grafana (visualización)
• Kafka UI (monitoreo de Kafka)

🏗️ Arquitectura

Principios Aplicados

• Clean Architecture: Separación en capas Domain, Application e Infrastructure
• SOLID Principles:
  • Single Responsibility Principle (SRP)
  • Open/Closed Principle (OCP)
  • Liskov Substitution Principle (LSP)
  • Interface Segregation Principle (ISP)
  • Dependency Inversion Principle (DIP)
• Domain-Driven Design (DDD): Entidades ricas con lógica de negocio
• Hexagonal Architecture: Adaptadores para infraestructura

Características Java 21

• ✅ Records: DTOs inmutables y concisos
• ✅ Sealed Classes: Jerarquías de excepciones controladas
• ✅ Pattern Matching: Switch expressions e instanceof mejorado
• ✅ Virtual Threads: Mejor concurrencia y rendimiento
• ✅ Text Blocks: Queries SQL y JSON más legibles
• ✅ Optional Chaining: Manejo seguro de nulls

🚀 Guía de Inicio para Principiantes

Requisitos Previos

Antes de comenzar, asegúrate de tener instalado:

1. Docker Desktop (versión 20.10 o superior)

   • Descargar desde: https://www.docker.com/products/docker-desktop
   • Docker Compose viene incluido en Docker Desktop

2. Git (para clonar el repositorio)

   • Descargar desde: https://git-scm.com/downloads

3. Node.js (versión 18 o superior) - Solo si vas a ejecutar el frontend

   • Descargar desde: https://nodejs.org/

4. Un navegador web moderno (Chrome, Firefox, Edge)

---

📥 Paso 1: Clonar el Repositorio

Abre una terminal (PowerShell en Windows, Terminal en Mac/Linux) y ejecuta:

# Clonar el repositorio
git clone https://github.com/tu-usuario/microservicios.git

# Entrar al directorio del proyecto
cd microservicios

---

🐳 Paso 2: Levantar el Backend con Docker

2.1. Iniciar todos los microservicios

# Levantar todos los servicios (primera vez tomará varios minutos)
docker-compose up -d

Este comando hará lo siguiente:

• Descargará todas las imágenes de Docker necesarias (PostgreSQL, RabbitMQ, Kafka, etc.)
• Construirá las imágenes de los microservicios Java y Python
• Creará 11 bases de datos PostgreSQL independientes
• Levantará 11 microservicios + infraestructura (total: ~25 contenedores)
• Tiempo estimado: 5-10 minutos en la primera ejecución

2.2. Verificar que todo esté funcionando

Espera aproximadamente 2-3 minutos después de que termine el comando anterior, luego verifica:

# Ver el estado de todos los contenedores
docker ps

# Ver los logs de todos los servicios
docker-compose logs -f

# Ver logs de un servicio específico (ejemplo: service-products)
docker-compose logs -f service-products

# Para salir de los logs, presiona Ctrl+C

2.3. Verificar los servicios en el navegador

Abre tu navegador y verifica estos endpoints:

• Eureka (Service Discovery): http://localhost:8761

  • Deberías ver todos los microservicios registrados

• API Gateway (Health Check): http://localhost:8080/actuator/health

  • Debe mostrar {"status":"UP"}

• RabbitMQ Management: http://localhost:15672

  • Usuario: guest / Contraseña: guest

• Kafka UI: http://localhost:8090

  • Interfaz para monitorear Kafka

• Grafana: http://localhost:3000

  • Usuario: admin / Contraseña: admin

---

🎨 Paso 3: Levantar el Frontend

3.1. Navegar al directorio del frontend

# Desde la raíz del proyecto
cd pharma-care-frontend

3.2. Instalar dependencias de Node.js

# Instalar todas las dependencias (primera vez)
npm install

3.3. Iniciar el servidor de desarrollo

# Iniciar el frontend en modo desarrollo
npm run dev

Verás un mensaje similar a:

  VITE v5.x.x  ready in xxx ms

  ➜  Local:   http://localhost:5173/
  ➜  Network: use --host to expose

3.4. Abrir la aplicación

Abre tu navegador y visita: http://localhost:5173

---

🎯 Paso 4: Probar la Aplicación

4.1. Usuario por defecto (ya pre-cargado)

El sistema viene con usuarios pre-cargados para que puedas empezar a probar inmediatamente:

Usuario de prueba:

• Username: customer1
• Password: admin1234

Administrador:

• Username: admin
• Password: admin1234

4.2. O registrar un nuevo usuario

Si prefieres crear tu propia cuenta:

1. Ve a http://localhost:5173
2. Haz clic en "Registrarse" o "Sign Up"
3. Completa el formulario:
   • Nombre de usuario: tu_usuario
   • Email: tu_email@ejemplo.com
   • Contraseña: TuPassword123!
   • Nombre: Tu Nombre
   • Apellido: Tu Apellido

4.3. Iniciar sesión

1. Usa las credenciales del usuario pre-cargado o las que acabas de crear
2. Serás redirigido al dashboard principal

4.4. Explorar las funcionalidades

• 🏠 Dashboard: Ver resumen de actividad y accesos rápidos
• 🛒 Tienda: Explorar el catálogo completo de productos farmacéuticos
• ➕ Carrito: Agregar medicamentos y productos al carrito de compras
• 💳 Checkout: Completar la compra ingresando dirección de envío
• 📦 Mis Pedidos: Ver historial completo de pedidos con estado de entrega
• 👤 Perfil: Actualizar información personal y datos de contacto

---

🛑 Paso 5: Detener los Servicios

Detener solo el frontend

En la terminal donde ejecutaste npm run dev, presiona Ctrl+C

Detener el backend (manteniendo datos)

# Desde el directorio raíz del proyecto
docker-compose down

Detener y limpiar todo (eliminar bases de datos)

# ADVERTENCIA: Esto eliminará todos los datos almacenados
docker-compose down -v

---

🔧 Solución de Problemas Comunes

Problema 1: Puerto ya en uso

Si ves un error como "port 8080 is already in use":

# En Windows PowerShell, encuentra el proceso usando el puerto
netstat -ano | findstr :8080

# Mata el proceso (reemplaza PID con el número que viste)
taskkill /PID <PID> /F

Problema 2: Contenedor "unhealthy"

# Ver logs del contenedor problemático
docker-compose logs service-users

# Reiniciar un servicio específico
docker-compose restart service-users

Problema 3: Error de RabbitMQ con queues

# Detener todos los servicios
docker-compose down

# Eliminar el volumen de RabbitMQ
docker volume rm microservicios_rabbitmq-data

# Volver a levantar
docker-compose up -d

Problema 4: "Cannot connect to Docker daemon"

Asegúrate de que Docker Desktop esté ejecutándose. Ábrelo desde el menú de inicio.

---

📊 Arquitectura del Sistema

┌─────────────────────────────────────────────────────────────┐
│                    Frontend (React + Vite)                   │
│                     http://localhost:5173                     │
└───────────────────────────┬─────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                   API Gateway (Port 8080)                     │
│              Enrutamiento + Seguridad JWT                     │
└───┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┘
    │       │       │       │       │       │       │
    ▼       ▼       ▼       ▼       ▼       ▼       ▼
┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐
│Auth │ │Users│ │Prod │ │Cart │ │Sales│ │Inv. │ │ ... │
│8081 │ │8082 │ │8083 │ │8091 │ │8084 │ │8085 │ │     │
└──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘ └─────┘
   │       │       │       │       │       │
   ▼       ▼       ▼       ▼       ▼       ▼
┌─────────────────────────────────────────────────────────────┐
│           PostgreSQL Databases (11 instancias)               │
└─────────────────────────────────────────────────────────────┘
                            │
                    ┌───────┴───────┐
                    ▼               ▼
            ┌──────────────┐ ┌──────────────┐
            │   RabbitMQ   │ │    Kafka     │
            │  Mensajería  │ │  Streaming   │
            └──────────────┘ └──────────────┘

---

🛠️ Comandos Útiles

Docker

# Ver todos los contenedores corriendo
docker ps

# Ver logs de todos los servicios
docker-compose logs -f

# Ver logs de un servicio específico
docker-compose logs -f service-products

# Reiniciar un servicio específico
docker-compose restart service-products

# Ver uso de recursos
docker stats

# Limpiar contenedores detenidos
docker container prune

# Limpiar imágenes no utilizadas
docker image prune

Frontend - Desarrollo

# Instalar dependencias
cd pharma-care-frontend
npm install

# Iniciar en modo desarrollo
npm run dev

# Construir para producción
npm run build

# Preview de producción
npm run preview

# Linting
npm run lint

---

🌐 URLs y Puertos

Frontend

• Aplicación Web: http://localhost:5173

Backend - API Gateway

• API Gateway: http://localhost:8080
• Health Check: http://localhost:8080/actuator/health

Microservicios

• Service Auth: http://localhost:8081
• Service Users: http://localhost:8082
• Service Products: http://localhost:8083
• Service Sales: http://localhost:8084
• Service Inventory: http://localhost:8085
• Service Prescriptions: http://localhost:8086
• Service Notifications: http://localhost:8087
• Service Analytics: http://localhost:8088
• Service Carts: http://localhost:8091
• Service ML (Python): http://localhost:9000

Infraestructura

• Eureka Dashboard: http://localhost:8761
• RabbitMQ Management: http://localhost:15672 (guest/guest)
• Kafka UI: http://localhost:8090
• Prometheus: http://localhost:9090
• Grafana: http://localhost:3000 (admin/admin)

Bases de Datos PostgreSQL

• Users DB: localhost:5434
• Products DB: localhost:5435
• Inventory DB: localhost:5436
• Prescriptions DB: localhost:5437
• Sales DB: localhost:5438
• Notifications DB: localhost:5439
• Analytics DB: localhost:5440
• ML DB: localhost:5441
• Carts DB: localhost:5443

Usuario/Contraseña para todas las BD: postgres/postgres

---

📚 Documentación Adicional

• Guía de Arquitectura Completa
• Implementación de Microservicios
• Arquitectura de Mensajería
• Guía de Frontend

---

🤝 Contribución

1. Fork el proyecto
2. Crea una rama feature (git checkout -b feature/AmazingFeature)
3. Commit tus cambios (git commit -m 'Add some AmazingFeature')
4. Push a la rama (git push origin feature/AmazingFeature)
5. Abre un Pull Request

📄 Licencia

Este proyecto está bajo la Licencia Apache 2.0 - ver el archivo LICENSE para más detalles.

👥 Autores

SoftPrime Solutions - TECSUP

🙏 Agradecimientos

• Spring Boot Team
• Clean Architecture by Robert C. Martin
• Domain-Driven Design by Eric Evans