How puj-course/fis_2610_3517_g1 works
Tipo de proyecto y propósito (qué estás diagramando)
MedTrack es una aplicación web simple (tipo “monolito ligero”) para ayudar a cuidadores novatos a registrar y dar seguimiento a la administración de medicamentos.
Por estructura y README, la solución es:
• Frontend: páginas HTML/CSS/Bootstrap (no SPA).
• Backend: Python + Flask, con endpoints (rutas) y lógica de autenticación.
• Persistencia: SQLite (archivo database.db).
Nota importante para precisión: el README muestra una estructura idealizada con src/main/..., pero el *file tree real* que recibiste es:
• backend/ y frontend/ en la raíz (no hay src/ aquí).
• No aparece app.py en el árbol, aunque el README lo menciona (tu diagrama debe reflejar lo que existe y, si incluyes app.py, marcarlo como “expected/entrypoint” o “missing in repo tree”).
Lectura arquitectónica del file tree (qué componentes existen)
Del árbol real:
Frontend (presentación)
• frontend/login.html
• frontend/dashboard.html
Esto sugiere:
• UI renderizada como archivos estáticos.
• Interacción con backend probablemente vía HTTP (fetch/AJAX) o formularios HTML.
Backend (API + lógica)
• backend/routes/auth_route.py
→ capa de rutas/controladores (Blueprint o endpoints Flask).
• backend/auth.py
→ servicio/módulo de autenticación (validación credenciales, hashing, sesiones/tokens).
• backend/models.py
→ modelo de datos y acceso a persistencia (posible ORM o SQL directo).
• backend/database.db
→ SQLite embebido en el repo (base de datos local).
• backend/requirements.txt y requirements.txt (raíz)
→ dependencias (posible duplicidad; anótalo como decisión/pendiente).
Config
• conf/.gitkeep
→ carpeta reservada para configuración; hoy no aporta runtime, pero en el diagrama puedes mostrar un “Config” externo si planean crecer.
Diagrama 1 — Contexto (System Context)
Objetivo: quién usa MedTrack y qué “sistemas externos” existen (aunque hoy sean mínimos).
Componentes recomendados:
• Actor: Cuidador (usuario final) en Browser.
• Sistema: MedTrack Web App.
• (Opcional, si está en alcance futuro) Notificaciones/Email/SMS/Calendario → márcalo como “Future/Out of scope” si no existe aún.
• Browser ⇄ MedTrack (HTTPS/HTTP).
Objetivo: separar claramente frontend, backend y DB.
Contenedores:
Static Frontend (HTML/Bootstrap)
• login.html, dashboard.html
Flask Backend (Python)
• “API Server / Web Server”
SQLite DB (database.db)
Relaciones y flujos (flechas dirigidas y etiquetadas):
• Browser → Frontend: “GET /login.html, /dashboard.html”
• Frontend → Backend: “POST /auth/login”, “GET/POST …” (según rutas)
• Backend → SQLite: “SQL queries / ORM operations”
• Backend → Frontend: “JSON responses / redirects / session cookies”
Tecnologías en labels: HTML/Bootstrap, Flask, SQLite.
Objetivo: mapear *archivos/módulos* del backend a responsabilidades, que es lo que el repo realmente evidencia.
Dentro de Flask Backend, dibuja:
• Routes Layer
• backend/routes/auth_route.py (AuthController / Blueprint)
• Auth Service
• backend/auth.py (password verify, session/token, decorators)
• Data Access / Domain Models
• backend/models.py (User model, queries, schema init/migrations si aplica)
• DB File
• backend/database.db (SQLite)
Flechas:
• auth_route.py → auth.py (invoca validación/autorización)
• auth_route.py → models.py (lee/escribe usuarios/sesiones)
• models.py → database.db (persistencia)
• auth.py → models.py (si auth consulta usuario/roles)
Si quieres máxima exactitud, etiqueta también:
• Dependency boundary: “Flask request/response lifecycle” (entrada/salida).
• “Session/Cookie” o “Token” (si el código lo confirma; si no, pon “Session/Token (TBD)”.
Diagrama 4 — Deployment / Runtime (opcional pero valioso)
Objetivo: cómo corre en dev/CI (aunque sea local).
Nodos:
• Developer laptop / Server
• Python runtime running Flask (port 5000/8000)
• Filesystem: SQLite database.db
• Browser
• (Si existiera realmente) GitHub Actions CI/CD (en el README aparece, pero no en el árbol real; márcalo como “documented, not present in repo tree”)
Trazabilidad al repo: cada caja del diagrama debe apuntar a un directorio/archivo real
• “Auth Routes” → backend/routes/auth_route.py
• “Auth Service” → backend/auth.py
• “Models/DB Access” → backend/models.py
• “DB” → backend/database.db
• “UI Pages” → frontend/login.html, frontend/dashboard.html
No inventar componentes: si incluyes app.py (mencionado en README), ponlo como
• “Entrypoint (README)” con nota: “not found in current tree”
o directamente omítelo si tu objetivo es *100% repo-truth*.
Interfaces explícitas: etiqueta flechas con
• protocolo (HTTP),
• tipo de payload (HTML vs JSON),
• endpoints conocidos (al menos /auth/* por el auth_route.py).
Separación de responsabilidades (patrón)
• Frontend estático (presentación)
• Flask (controladores/rutas)
• Servicios (auth)
• Acceso a datos (models)
• Persistencia (SQLite)
Qué relaciones e interacciones destacar (data-flow)
En el diagrama de contenedores + componentes, resalta 3 flujos típicos:
Login
• Browser loads login.html
• login.html submits credentials → Flask /auth/login
• auth_route.py calls auth.py + models.py
• models.py reads users in SQLite
• Response: cookie/session or token + redirect to dashboard.html
Dashboard
• Browser requests dashboard.html
• dashboard.html calls backend for patient/med schedules (si existe; si no está implementado aún, márcalo como futuro)
Persistencia
• Backend reads/writes SQLite file on local filesystem (single-node DB).
Convenciones visuales (para que el diagrama “lea” bien)
• Client / Frontend / Backend / Data
• Colores/estilos:
• Presentación (Frontend) = azul
• API/Backend = verde
• Data store = naranja
• Config/CI = gris
• Formas:
• Rectángulo: servicios/módulos
• Cilindro: base de datos (SQLite)
• Documento: HTML pages
• Flechas con etiqueta (obligatorio): HTTP GET, HTTP POST, SQL, JSON, Redirect.
Plantilla concreta (qué dibujar exactamente para este repo)
Si solo puedes hacer un diagrama “best overall”, haz este:
• Browser
• Frontend (Static HTML/Bootstrap)
• login.html
• dashboard.html
• Backend (Flask App)
• routes/auth_route.py
• auth.py
• models.py
• SQLite
• database.db
• Config (placeholder)
• conf/ (nota: “reserved / currently empty”)
Y estas flechas:
• Browser → Frontend: “GET /login.html /dashboard.html”
• Frontend → Backend: “POST /auth/* (credentials)”
• Backend → SQLite: “CRUD user/session data”
• Backend → Frontend: “JSON/redirect + cookie/session”
Si me pegas el contenido de backend/auth.py, backend/models.py y backend/routes/auth_route.py, te puedo decir exactamente qué endpoints etiquetar, si usan cookies vs JWT, y qué tablas/modelos mostrar (para que el diagrama quede 1:1 con el código).