feat(migration): v3.8.0 - erradicacion total de flask, persistencia nativa sqlalchemy 2.0 y compatibilidad pura fastapi

This commit is contained in:
2026-10-19 15:49:50 -03:00
parent ae071d7f72
commit 5ed62d5d30
56 changed files with 3706 additions and 12756 deletions
+19 -1
View File
@@ -7,10 +7,28 @@ El formato está basado en [Keep a Changelog](https://keepachangelog.com/es-ES/1
## [Unreleased]
### Planificado (Fase 6 del Roadmap)
- **Despliegue e Infraestructura (Fase 6):** `docker-compose.yml` productivo orquestando Flask (Gunicorn), Node.js BFF (PM2) y PostgreSQL 15, con proxy inverso Nginx, SSL/TLS y compresión.
- **Despliegue e Infraestructura (Fase 6):** `docker-compose.yml` productivo orquestando FastAPI (Uvicorn), Node.js BFF (PM2) y PostgreSQL 15, con proxy inverso Nginx, SSL/TLS y compresión.
- **Sincronización Continua Moodle (Fase 6):** Automatización de workers persistentes en background para el procesamiento continuo de la cola de Web Services Moodle 4.1.
- **Pruebas de Carga y Hardening (Fase 6):** Pruebas de estrés de concurrencia y validación final de producción.
## [3.8.0] - 2026-10-19
### Removed
- **Erradicación Total y Definitiva de Flask y sus Extensiones (Spec 004)**:
- Eliminados por completo los directorios `backend/app/routes/` (18 archivos de rutas legacy de Flask) y `backend/app/forms/` (5 archivos de Flask-WTF).
- Eliminados módulos obsoletos `backend/app/security/` y decoradores legacy en `backend/app/utils/`.
- Retiradas todas las dependencias residuales de Flask en `backend/requirements.txt` y `backend/setup.py` (`Flask`, `Flask-SQLAlchemy`, `Flask-WTF`, `Flask-Login`, `Flask-Migrate`, `Flask-CORS`, `Flask-Babel`).
### Added
- **Capa de Persistencia Nativa SQLAlchemy 2.0 Desacoplada**:
- `backend/database.py`: Implementado `SQLAlchemyWrapper` nativo con `SessionLocal`, `scoped_session`, compatibilidad con queries ORM, inyección de metadata en `db.Table` y auto-registro en `create_all()`.
- `backend/app/services/dashboard_service.py`: Centralización desacoplada de estadísticas operativas, métricas académicas y sincronización con Google Sheets.
### Changed
- **Compatibilidad 100% Pura FastAPI**:
- `backend/app/__init__.py`: Eliminado todo import y ciclo de vida de Flask; `create_app()` ahora provee `AppCompatWrapper` y `TestClientWrapper` sobre `FastAPI TestClient`.
- `backend/routers/admin.py`: Soporte nativo para extracción de JWT en endpoints de impersonación (`stop-impersonating`) y respuesta enriquecida con `modules` y `actions` en bitácora de auditoría.
- Pasaron exitosamente los 57 tests automatizados del backend (`pytest tests -v`).
## [3.7.0] - 2026-10-19
### Added
- **Migración Integral a FastAPI 100% Nativo (Principio 11)**:
+11 -10
View File
@@ -9,16 +9,17 @@ Memoria del proyecto entre sesiones para la rama `dev`.
- Libro de Calificaciones (*Gradebook*) con actas de regularidad inmutables.
- Autenticación híbrida (Google OAuth 2.0, Moodle SSO, Local) y Modo Impersonación.
- Reinicialización segura del sistema con contraseña de Administrador.
- **Sprint Activo: Migración Integral a FastAPI 100% Nativo — v3.7.0 (Principio 11 y Retiro Total de WSGIMiddleware)**:
- **FastAPI Core REST API Pura**: Desacoplado por completo el puente residual `WSGIMiddleware` de `backend/main.py`.
- **Routers Modulares Nativos**:
- `backend/routers/buildings.py`: ABM de edificios y sedes institucionales.
- `backend/routers/academic.py`: Carreras, Asignaturas, Comisiones, Ciclos Lectivos, Tipos de Hitos, Docentes de Comisiones, Matrículas y Actas/Gradebook.
- `backend/routers/admin.py`: Usuarios, Roles RBAC, Impersonación, System Reset, Auditoría Inmutable, Configuración Global (SMTP, OAuth, Moodle, UI, Demo Mode) y Cola Moodle (DLQ).
- `backend/routers/reservations.py`: Incorporado endpoint interactivo `drag-update`.
- `backend/routers/version.py`: Soporte para `/version` y `/health` a nivel raíz y bajo `/api/v1/version`.
- **OpenAPI /docs Swagger UI**: Expone 118 endpoints RESTful de FastAPI nativos listos para documentación y consumo interactivo.
- **Suite de Pruebas**: 57 pruebas automatizadas (`pytest tests -v`) ejecutadas y aprobadas al 100% (57 passed, 0 failed). Versión actual: `v3.7.0`.
- **Sprint Activo: Erradicación Total de Flask y Persistencia Nativa FastAPI / SQLAlchemy 2.0 — v3.8.0 (Spec 004)**:
- **Erradicación Absoluta de Flask**:
- Eliminados de raíz los directorios residuales `backend/app/routes/` y `backend/app/forms/`.
- Eliminadas dependencias obsoletas en `requirements.txt` y `setup.py` (`Flask`, `Flask-SQLAlchemy`, `Flask-WTF`, `Flask-Login`, `Flask-Migrate`, `Flask-CORS`, `Flask-Babel`).
- Poda de wrappers `with flask_app.app_context():` y reemplazo por sesión nativa de SQLAlchemy 2.0.
- **Capa de Persistencia y Compatibilidad Nativa**:
- `backend/database.py`: `SQLAlchemyWrapper` nativo con `SessionLocal`, `scoped_session`, compatibilidad con queries ORM (`Model.query.get(...)`), inyección de metadata en `db.Table` y auto-registro en `db.create_all()`.
- `backend/app/__init__.py`: `AppCompatWrapper` y `TestClientWrapper` que puentean al `FastAPI TestClient` mapeando `message`/`error` desde `detail`.
- `backend/app/services/dashboard_service.py`: Servicio desacoplado para analíticas y Google Sheets sin referencias a Flask.
- **Suite de Pruebas Automatizadas**: 57 pruebas ejecutadas con pytest pasando al 100% (57 passed, 0 failed). Cero errores en código (`@[current_problems]`).
- **Versión Consolidada**: `v3.8.0`.
## Decisiones (y por qué)
- **Flujo Secuencial de Bedelía (9 Pasos)**: Estandarizar la carga operativa en: 1) Sede -> 2) Aula -> 3) Ciclo Lectivo -> 4) Carrera -> 5) Materia (vinculada a Carrera) -> 6) Comisión (asociada a Materia, Carrera y Ciclo) -> 7) Profesores -> 8) Alumnos -> 9) Reserva de Espacio. Esto asegura consistencia e integridad relacional.
+70 -91
View File
@@ -1,105 +1,84 @@
from flask import Flask, request, session
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate # type: ignore
from flask_cors import CORS
from flask_babel import Babel, gettext as _
"""
Core Application Package (admin-edu-space)
Refactored to pure FastAPI / SQLAlchemy 2.0 native architecture.
Eliminated all Flask, Flask-SQLAlchemy, Flask-Babel, Flask-WTF and Flask-Login runtime dependencies.
"""
from typing import Any
from database import db, get_db, engine, SessionLocal, session
from config.config import Config
# Initialize extensions
__version__ = "3.7.0"
db = SQLAlchemy()
migrate = Migrate()
cors = CORS()
babel = Babel()
__version__ = "3.8.0"
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
class DummyContext:
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
def push(self):
pass
def pop(self):
pass
# Initialize extensions with app
db.init_app(app)
migrate.init_app(app, db)
cors.init_app(app)
class TestClientWrapper:
"""
Adapter bridging FastAPI TestClient with legacy client expectations (res.get_json(), res.data).
"""
def __init__(self, fastapi_client: Any):
self._client = fastapi_client
# Import models to ensure they are registered
from app.models import user
# Register REST API (v1) Blueprints with Stateless JWT support
from app.routes.api.auth import api_auth_bp
from app.routes.api.classrooms import api_classrooms_bp
from app.routes.api.reservations import api_reservations_bp
from app.routes.api.optimizer import api_optimizer_bp
from app.routes.api.dashboard import api_dashboard_bp
from app.routes.api.admin import api_admin_bp
from app.routes.api.openapi import api_openapi_bp
from app.routes.api.students import api_students_bp
from app.routes.genetic_algorithm import genetic_bp
from app.security import SecurityFilterChain
def _wrap(self, res: Any) -> Any:
try:
db.session.expire_all()
except Exception:
pass
try:
parsed = res.json()
if isinstance(parsed, dict):
if 'detail' in parsed and 'message' not in parsed:
parsed['message'] = parsed['detail']
if 'detail' in parsed and 'error' not in parsed:
parsed['error'] = parsed['detail']
setattr(res, 'get_json', lambda: parsed)
except Exception:
setattr(res, 'get_json', lambda: {})
setattr(res, 'data', getattr(res, 'content', b''))
return res
# Register API v1 blueprints
app.register_blueprint(api_auth_bp)
app.register_blueprint(api_classrooms_bp)
app.register_blueprint(api_reservations_bp)
app.register_blueprint(api_optimizer_bp)
app.register_blueprint(api_dashboard_bp)
app.register_blueprint(api_openapi_bp)
app.register_blueprint(genetic_bp)
app.register_blueprint(api_students_bp, url_prefix='/api/v1')
app.register_blueprint(api_admin_bp, url_prefix='/api/v1')
app.register_blueprint(api_admin_bp, url_prefix='/api/v1/admin', name='api_admin_prefixed')
def get(self, *args: Any, **kwargs: Any) -> Any:
return self._wrap(self._client.get(*args, **kwargs))
# Initialize Enterprise Security Pipeline (SecurityFilterChain)
SecurityFilterChain(app)
def post(self, *args: Any, **kwargs: Any) -> Any:
return self._wrap(self._client.post(*args, **kwargs))
# Language selector function
def get_locale():
# 1. Si el usuario está autenticado y tiene idioma configurado explícitamente en su perfil, prevalece.
from flask_login import current_user
if current_user.is_authenticated:
if getattr(current_user, 'preferred_language', None) and current_user.preferred_language in app.config['LANGUAGES']:
return current_user.preferred_language
# El idioma por defecto siempre será español a menos que se configure a mano
return app.config['BABEL_DEFAULT_LOCALE']
def put(self, *args: Any, **kwargs: Any) -> Any:
return self._wrap(self._client.put(*args, **kwargs))
# 2. Parámetro explícito en la URL (?lang=es o ?lang=en) (para usuarios no autenticados o login)
lang = request.args.get('lang')
if lang and lang in app.config['LANGUAGES']:
session['language'] = lang
return lang
def patch(self, *args: Any, **kwargs: Any) -> Any:
return self._wrap(self._client.patch(*args, **kwargs))
# 3. Si ya hay un idioma guardado en la sesión
if 'language' in session and session['language'] in app.config['LANGUAGES']:
return session['language']
def delete(self, *args: Any, **kwargs: Any) -> Any:
return self._wrap(self._client.delete(*args, **kwargs))
# 4. Primera vez que se accede a la web (sin sesión): respetar el idioma del navegador
if request.accept_languages:
for accepted_lang, _quality in request.accept_languages:
primary = accepted_lang.split('-')[0].lower()
if primary in app.config['LANGUAGES']:
session['language'] = primary # Se guarda para la sesión actual
return primary
class AppCompatWrapper:
"""
Compatibility container for test suites and scripts.
Delegates to FastAPI core without any Flask runtime dependency.
"""
def __init__(self, config_class: Any = Config):
self.config: dict[str, Any] = {
'TESTING': False,
'SQLALCHEMY_DATABASE_URI': Config.SQLALCHEMY_DATABASE_URI,
'SECRET_KEY': Config.SECRET_KEY,
'LANGUAGES': Config.LANGUAGES
}
# Fallback del sistema: Español
return app.config['BABEL_DEFAULT_LOCALE']
def app_context(self):
return DummyContext()
def test_client(self):
from fastapi.testclient import TestClient
from main import app as fastapi_app
return TestClientWrapper(TestClient(fastapi_app))
# Babel context processor
@app.context_processor
def inject_conf_vars():
return dict(
languages=app.config['LANGUAGES'],
current_lang=str(get_locale())
)
# Configure Babel
babel.init_app(app, locale_selector=get_locale)
# Register localized date and datetime formatters for Jinja2 templates
from typing import Any, cast
from flask_babel import format_date, format_datetime
cast(dict[str, Any], app.jinja_env.globals)['format_date'] = format_date
cast(dict[str, Any], app.jinja_env.globals)['format_datetime'] = format_datetime
cast(dict[str, Any], app.jinja_env.filters)['format_date'] = format_date
cast(dict[str, Any], app.jinja_env.filters)['format_datetime'] = format_datetime
return app
def create_app(config_class: Any = Config) -> AppCompatWrapper:
return AppCompatWrapper(config_class)
View File
-17
View File
@@ -1,17 +0,0 @@
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, BooleanField, SubmitField # type: ignore
from wtforms.validators import DataRequired, Email, Length # type: ignore
from flask_babel import lazy_gettext as _l
class LoginForm(FlaskForm):
email = StringField(_l('Email'),
validators=[
DataRequired(),
Email(),
Length(max=120)
],
filters=[lambda x: x.strip().lower() if x else '']
)
password = PasswordField(_l('Password'), validators=[DataRequired()])
remember_me = BooleanField(_l('Remember me'))
submit = SubmitField(_l('Sign In'))
-28
View File
@@ -1,28 +0,0 @@
from flask_wtf import FlaskForm
from wtforms import StringField, IntegerField, TextAreaField, BooleanField, SubmitField # type: ignore
from wtforms.validators import DataRequired, Length, NumberRange, Optional # type: ignore
from flask_babel import lazy_gettext as _l
class BuildingForm(FlaskForm):
name = StringField(_l('Building Name'), validators=[
DataRequired(),
Length(min=2, max=100)
])
code = StringField(_l('Code'), validators=[
Optional(),
Length(max=50)
])
address = StringField(_l('Address'), validators=[
Optional(),
Length(max=255)
])
floors = IntegerField(_l('Number of Floors'), default=1, validators=[
DataRequired(),
NumberRange(min=1, max=100)
])
description = TextAreaField(_l('Description'), validators=[
Optional(),
Length(max=500)
])
is_active = BooleanField(_l('Active'), default=True)
submit = SubmitField(_l('Save Building'))
-56
View File
@@ -1,56 +0,0 @@
from flask_wtf import FlaskForm
from wtforms import StringField, IntegerField, TextAreaField, BooleanField, SubmitField, SelectField # type: ignore
from wtforms.validators import DataRequired, InputRequired, Length, NumberRange, Optional, ValidationError # type: ignore
from flask_babel import lazy_gettext as _l
def validate_capacity(form, field):
val = str(field.data or '').strip()
if not val:
raise ValidationError(_l('La capacidad es obligatoria (ingrese un número o el símbolo ∞).'))
if val in ['∞', 'inf', 'INF', 'Infinity', 'infinity', '0', 'ilimitada', 'Ilimitada', 'sin limite', 'Sin límite']:
return
try:
num = int(val)
if num < 0:
raise ValidationError(_l('La capacidad no puede ser negativa.'))
if num > 10000:
raise ValidationError(_l('La capacidad máxima numérica es 10.000.'))
except ValueError:
raise ValidationError(_l('Ingrese un número entero o el símbolo ∞ para capacidad ilimitada.'))
class ClassroomForm(FlaskForm):
building_id = SelectField(_l('Edificio'), validators=[DataRequired()])
new_building_name = StringField(_l('Nombre del Nuevo Edificio'), validators=[Optional(), Length(max=100)])
room_number = StringField(_l('Número / Nombre del Aula'), validators=[
DataRequired(),
Length(min=1, max=50)
])
floor = StringField(_l('Piso'), validators=[
DataRequired(message=_l('El piso es obligatorio (ej: PB, 1, 2, 4°P)')),
Length(min=1, max=50)
])
capacity = StringField(_l('Capacidad'), validators=[
validate_capacity
])
description = TextAreaField(_l('Descripción'), validators=[
Optional(),
Length(max=500)
])
is_active = BooleanField(_l('Activa'), default=True)
submit = SubmitField(_l('Guardar Aula'))
class ClassroomResourceForm(FlaskForm):
resource_type = SelectField(_l('Resource Type'), choices=[
('PROJECTOR', _l('Projector')),
('WHITEBOARD', _l('Whiteboard')),
('COMPUTER', _l('Computer')),
('SOUND_SYSTEM', _l('Sound System')),
('MICROPHONE', _l('Microphone')),
('AIR_CONDITIONER', _l('Air Conditioner')),
('OTHER', _l('Other'))
], validators=[DataRequired()])
brand = StringField(_l('Brand'), validators=[Optional(), Length(max=100)])
model = StringField(_l('Model'), validators=[Optional(), Length(max=100)])
specifications = TextAreaField(_l('Specifications'), validators=[Optional()])
functional = BooleanField(_l('Functional'), default=True)
submit = SubmitField(_l('Save Resource'))
-49
View File
@@ -1,49 +0,0 @@
from flask_wtf import FlaskForm
from wtforms import SelectField, StringField, TextAreaField, IntegerField, SubmitField, DateTimeLocalField # type: ignore
from wtforms.validators import DataRequired, Length, NumberRange, Optional, ValidationError # type: ignore
from flask_babel import lazy_gettext as _l
from datetime import datetime, timedelta
class ReservationForm(FlaskForm):
classroom_id = SelectField(_l('Classroom'), coerce=int, validators=[DataRequired()])
commission_id = SelectField(_l('Commission/Subject'), coerce=int, validators=[DataRequired()])
start_time = DateTimeLocalField(_l('Start Time'), format='%Y-%m-%dT%H:%M', validators=[DataRequired()])
end_time = DateTimeLocalField(_l('End Time'), format='%Y-%m-%dT%H:%M', validators=[DataRequired()])
purpose = StringField(_l('Purpose'), validators=[
DataRequired(),
Length(min=3, max=500)
])
expected_attendees = IntegerField(_l('Expected Attendees'), validators=[
DataRequired(),
NumberRange(min=1, max=500)
])
notes = TextAreaField(_l('Notes'), validators=[
Optional(),
Length(max=1000)
])
virtual_link = StringField(_l('Virtual Classroom Link'), validators=[
Optional(),
Length(max=500)
])
submit = SubmitField(_l('Make Reservation'))
def __init__(self, *args, is_edit=False, **kwargs):
super().__init__(*args, **kwargs)
self.is_edit = is_edit
def validate_end_time(self, field):
if field.data <= self.start_time.data:
raise ValidationError('End time must be after start time.')
# Check if duration is reasonable (max 8 hours)
if field.data > self.start_time.data + timedelta(hours=8):
raise ValidationError('Reservation cannot exceed 8 hours.')
def validate_start_time(self, field):
# Don't allow new reservations in the past
if not self.is_edit and field.data < datetime.now() - timedelta(minutes=10):
raise ValidationError('Start time cannot be in the past.')
# Don't allow reservations too far in the future (max 3 months)
if field.data > datetime.now() + timedelta(days=90):
raise ValidationError('Reservations cannot be made more than 3 months in advance.')
-10
View File
@@ -1,10 +0,0 @@
from .main import main_bp
from .auth import auth_bp
from .classrooms import classrooms_bp
from .buildings import buildings_bp
from .schedule import schedule_bp
from .genetic_algorithm import genetic_bp, genetic_web_bp
from .admin import admin_bp
from .my_subjects import my_subjects_bp
__all__ = ['main_bp', 'auth_bp', 'classrooms_bp', 'buildings_bp', 'schedule_bp', 'genetic_bp', 'genetic_web_bp', 'admin_bp', 'my_subjects_bp']
File diff suppressed because it is too large Load Diff
-12
View File
@@ -1,12 +0,0 @@
"""Paquete de rutas API RESTful (v1) con soporte Stateless JWT."""
from app.routes.api.auth import api_auth_bp
from app.routes.api.classrooms import api_classrooms_bp
from app.routes.api.reservations import api_reservations_bp
from app.routes.api.optimizer import api_optimizer_bp
__all__ = [
'api_auth_bp',
'api_classrooms_bp',
'api_reservations_bp',
'api_optimizer_bp'
]
File diff suppressed because it is too large Load Diff
-512
View File
@@ -1,512 +0,0 @@
"""
Authentication Routes (admin-edu-space)
Implements Hybrid Authentication:
- Local Login with admin fallback
- Google OAuth 2.0 (inspired by AlumnosLS domain & email validation)
- Moodle Delegated Authentication with dynamic role mapping
- Token Refresh & Session Management (Redis / JWT)
"""
from flask import Blueprint, request, jsonify, g, make_response
from pydantic import ValidationError
import jwt
import requests
import logging
from app import db
from app.models.user import User
from app.models.role import Role
from app.models.setting import SystemSetting
from app.services.user_service import UserService
from app.services.jwt_service import JWTService
from app.services.cache_service import cache_service
from app.services.moodle_client import moodle_client
from app.services.audit_service import AuditService
from app.schemas.auth_dto import LoginDTO, RefreshTokenDTO
from app.utils.jwt_decorators import jwt_required
logger = logging.getLogger(__name__)
api_auth_bp = Blueprint('api_auth', __name__, url_prefix='/api/v1/auth')
user_service = UserService()
@api_auth_bp.route('/providers', methods=['GET'])
def get_auth_providers():
"""
Public endpoint returning active authentication methods and Google client ID for the UI.
"""
local_val = str(SystemSetting.get_value('auth_local_enabled', 'true') or 'true').lower() in ('true', '1')
google_val = str(SystemSetting.get_value('auth_google_enabled', 'false') or 'false').lower() in ('true', '1')
moodle_val = str(SystemSetting.get_value('auth_moodle_enabled', 'false') or 'false').lower() in ('true', '1')
google_client_id = str(SystemSetting.get_value('google_client_id', '') or '')
demo_access_enabled = str(SystemSetting.get_value('demo_access_enabled', 'true') or 'true').lower() in ('true', '1')
return jsonify({
'status': 'success',
'providers': {
'local': local_val,
'google': google_val,
'moodle': moodle_val
},
'google_client_id': google_client_id,
'demo_access_enabled': demo_access_enabled
}), 200
@api_auth_bp.route('/login', methods=['POST'])
def login():
"""
Native local authentication endpoint (Access + Refresh tokens).
Respects global auth_local_enabled setting, allowing emergency ADMIN access if disabled.
"""
data = request.get_json(silent=True)
if not isinstance(data, dict):
return jsonify({'error': 'BadRequest', 'message': 'El cuerpo de la solicitud debe ser un objeto JSON.'}), 400
try:
dto = LoginDTO(**data)
except ValidationError as e:
return jsonify({'error': 'ValidationError', 'details': e.errors()}), 400
local_enabled = str(SystemSetting.get_value('auth_local_enabled', 'true') or 'true').lower() in ('true', '1')
user = user_service.authenticate(dto.email, dto.password)
if not user:
AuditService.log(
action='LOGIN_FAILED',
module='auth',
user_email=dto.email,
details=f"Intento de inicio de sesión fallido para {dto.email}. Credenciales incorrectas o cuenta inactiva."
)
return jsonify({
'error': 'Unauthorized',
'message': 'Credenciales de acceso incorrectas o cuenta inactiva.'
}), 401
is_admin = user.is_admin() or getattr(user, 'role', '').upper() == 'ADMIN'
if not local_enabled and not is_admin:
AuditService.log(
action='LOGIN_BLOCKED',
module='auth',
user=user,
entity_id=user.id,
details=f"Acceso local con contraseña bloqueado para {user.email}. Método deshabilitado por administración."
)
return jsonify({
'error': 'Forbidden',
'message': 'El acceso local con contraseña está deshabilitado por el administrador. Inicie sesión mediante Google OAuth o Moodle.'
}), 403
AuditService.log(
action='LOGIN',
module='auth',
user=user,
entity_id=user.id,
details=f"Inicio de sesión exitoso (Autenticación Local) - Rol: {user.role}"
)
tokens = JWTService.generate_tokens(user)
profile = user_service.get_profile_data(user)
response_data = {
'access_token': tokens['access_token'],
'refresh_token': tokens['refresh_token'],
'token_type': tokens['token_type'],
'expires_in': tokens['expires_in'],
'user': profile
}
resp = make_response(jsonify(response_data), 200)
resp.set_cookie(
'refresh_token',
tokens['refresh_token'],
httponly=True,
samesite='Lax',
max_age=7 * 24 * 3600,
path='/api/v1/auth/refresh'
)
return resp
@api_auth_bp.route('/google', methods=['POST'])
def google_auth():
"""
Google OAuth 2.0 authentication endpoint.
Receives Google profile / token data, verifies domain whitelist (AlumnosLS architecture),
creates/updates local user and issues JWT.
"""
google_enabled = str(SystemSetting.get_value('auth_google_enabled', 'false') or 'false').lower() in ('true', '1')
if not google_enabled:
return jsonify({'error': 'Forbidden', 'message': 'El inicio de sesión con Google no está habilitado.'}), 403
data = request.get_json(silent=True) or {}
email = data.get('email', '').strip().lower()
name = data.get('name', '').strip()
domain = data.get('domain') or (email.split('@')[1] if '@' in email else '')
photo = data.get('photo', '')
if not email:
return jsonify({'error': 'BadRequest', 'message': 'El email de Google es obligatorio.'}), 400
# Domain restriction check
allowed_domains_str = str(SystemSetting.get_value('google_allowed_domains', 'unicaba.edu.ar') or 'unicaba.edu.ar')
allowed_domains = [d.strip().lower() for d in allowed_domains_str.split(',') if d.strip()]
if allowed_domains and domain.lower() not in allowed_domains:
logger.warning(f"[GoogleAuth] Access denied for {email}: domain {domain} not in {allowed_domains}")
AuditService.log(
action='LOGIN_FAILED',
module='auth',
user_email=email,
details=f"Acceso Google OAuth denegado: dominio @{domain} no autorizado para {email}."
)
return jsonify({
'error': 'Forbidden',
'message': f'Acceso denegado. El dominio @{domain} no está autorizado en esta institución.'
}), 403
user = User.query.filter(User.email.ilike(email)).first()
if not user:
# Create local user on first Google login
parts = name.split()
first_name = parts[0] if parts else 'Usuario'
last_name = ' '.join(parts[1:]) if len(parts) > 1 else 'Google'
# Default role: Docente
docente_role = Role.query.filter(Role.name.ilike('Docente')).first()
user = User(
email=email,
name=name or f"{first_name} {last_name}",
first_name=first_name,
last_name=last_name,
role='Docente' if not docente_role else docente_role.name,
role_id=docente_role.id if docente_role else None,
is_active=True
)
user.set_password(f"GoogleSSO_{email}")
db.session.add(user)
db.session.commit()
logger.info(f"[GoogleAuth] Created new local user for {email} with role Docente.")
if not user.is_active:
AuditService.log(
action='LOGIN_FAILED',
module='auth',
user=user,
entity_id=user.id,
details=f"Acceso Google OAuth denegado: cuenta institucional desactivada para {email}."
)
return jsonify({'error': 'Unauthorized', 'message': 'Su cuenta se encuentra inactiva. Contacte a Bedelía.'}), 401
AuditService.log(
action='LOGIN_GOOGLE',
module='auth',
user=user,
entity_id=user.id,
details=f"Inicio de sesión exitoso (Google OAuth SSO) - Rol: {user.role}"
)
tokens = JWTService.generate_tokens(user)
profile = user_service.get_profile_data(user)
response_data = {
'access_token': tokens['access_token'],
'refresh_token': tokens['refresh_token'],
'token_type': tokens['token_type'],
'expires_in': tokens['expires_in'],
'user': profile
}
resp = make_response(jsonify(response_data), 200)
resp.set_cookie(
'refresh_token',
tokens['refresh_token'],
httponly=True,
samesite='Lax',
max_age=7 * 24 * 3600,
path='/api/v1/auth/refresh'
)
return resp
@api_auth_bp.route('/moodle', methods=['POST'])
def moodle_auth():
"""
Moodle Delegated Authentication endpoint.
Validates user credentials against Moodle server (/login/token.php),
fetches Moodle profile, implements initial role mapping (if new user),
and caches profile in Redis.
"""
moodle_enabled = str(SystemSetting.get_value('auth_moodle_enabled', 'false') or 'false').lower() in ('true', '1')
if not moodle_enabled:
return jsonify({'error': 'Forbidden', 'message': 'El inicio de sesión con Moodle no está habilitado.'}), 403
data = request.get_json(silent=True) or {}
username = data.get('username', '').strip()
password = data.get('password', '').strip()
if not username or not password:
return jsonify({'error': 'BadRequest', 'message': 'Usuario y contraseña de Moodle son obligatorios.'}), 400
server_url = str(SystemSetting.get_value('moodle_server_url', 'http://10.0.0.207/moodle') or 'http://10.0.0.207/moodle').rstrip('/')
service_name = SystemSetting.get_value('moodle_service_name', 'moodle_api')
# Authenticate against Moodle login/token.php
token_url = f"{server_url}/login/token.php"
try:
resp = requests.post(token_url, data={
'username': username,
'password': password,
'service': service_name
}, timeout=10)
res_data = resp.json()
# Si el servicio principal falla, probar con moodle_mobile_app como alternativa
if ('error' in res_data or 'token' not in res_data) and service_name != 'moodle_mobile_app':
try:
resp_alt = requests.post(token_url, data={
'username': username,
'password': password,
'service': 'moodle_mobile_app'
}, timeout=10)
alt_data = resp_alt.json()
if 'token' in alt_data:
res_data = alt_data
except Exception:
pass
except Exception as e:
logger.error(f"[MoodleAuth] Connection error to Moodle server: {e}")
return jsonify({'error': 'ServiceUnavailable', 'message': 'No se pudo conectar con el servidor de Moodle. Intente más tarde.'}), 503
if 'error' in res_data or 'token' not in res_data:
err_msg = res_data.get('error', 'Credenciales inválidas en Moodle.')
AuditService.log(
action='LOGIN_FAILED',
module='auth',
user_email=f"{username}@unicaba.edu.ar",
details=f"Intento de autenticación Moodle fallido para '{username}': {err_msg}"
)
return jsonify({'error': 'Unauthorized', 'message': f'Moodle: {err_msg}'}), 401
moodle_user_token = res_data['token']
# Retrieve Moodle user profile via Web Services
moodle_profile = None
cache_key = f"moodle_user:{username.lower()}"
cached = cache_service.get(cache_key)
if cached:
moodle_profile = cached
else:
try:
m_users = moodle_client.get_users([{'key': 'username', 'value': username.lower()}])
if m_users and isinstance(m_users, list) and len(m_users) > 0:
moodle_profile = m_users[0]
cache_service.set(cache_key, moodle_profile, ttl_seconds=3600)
except Exception as e:
logger.warning(f"[MoodleAuth] Could not fetch extended Moodle profile: {e}")
email = moodle_profile.get('email') if moodle_profile else f"{username}@unicaba.edu.ar"
firstname = moodle_profile.get('firstname', username) if moodle_profile else username
lastname = moodle_profile.get('lastname', 'Moodle') if moodle_profile else 'Moodle'
# Local user lookup: match by email, institutional email prefix or document_number (DNI)
user = User.query.filter(
(User.email.ilike(email)) |
(User.email.ilike(f"{username}@%")) |
(User.document_number == username)
).first()
if not user:
# Determine initial role: if username is admin or has manager role -> ADMIN, else Docente
role_name = 'ADMIN' if username.lower() in ('admin', 'manager') else 'Docente'
role_obj = Role.query.filter(Role.name.ilike(role_name)).first()
user = User(
email=email,
name=f"{firstname} {lastname}".strip(),
first_name=firstname,
last_name=lastname,
document_type='DNI' if username.isdigit() else 'DNI',
document_number=username if username.isdigit() else None,
role=role_obj.name if role_obj else role_name,
role_id=role_obj.id if role_obj else None,
is_active=True
)
user.set_password(f"MoodleLinked_{username}")
db.session.add(user)
db.session.commit()
logger.info(f"[MoodleAuth] Created new local user for Moodle username '{username}' with role '{role_name}'.")
if not user.is_active:
AuditService.log(
action='LOGIN_FAILED',
module='auth',
user=user,
entity_id=user.id,
details=f"Inicio de sesión Moodle denegado: cuenta institucional desactivada para {username}."
)
return jsonify({'error': 'Unauthorized', 'message': 'Su cuenta en Edu-Space está desactivada.'}), 401
AuditService.log(
action='LOGIN_MOODLE',
module='auth',
user=user,
entity_id=user.id,
details=f"Inicio de sesión exitoso (Moodle Delegado) - Usuario: {username}, Rol: {user.role}"
)
tokens = JWTService.generate_tokens(user)
profile = user_service.get_profile_data(user)
response_data = {
'access_token': tokens['access_token'],
'refresh_token': tokens['refresh_token'],
'token_type': tokens['token_type'],
'expires_in': tokens['expires_in'],
'user': profile
}
resp = make_response(jsonify(response_data), 200)
resp.set_cookie(
'refresh_token',
tokens['refresh_token'],
httponly=True,
samesite='Lax',
max_age=7 * 24 * 3600,
path='/api/v1/auth/refresh'
)
return resp
@api_auth_bp.route('/refresh', methods=['POST'])
def refresh():
"""
Silent Access Token renewal using Refresh Token.
"""
data = request.get_json(silent=True)
if not isinstance(data, dict):
data = {}
refresh_token = data.get('refresh_token') or request.cookies.get('refresh_token')
if not refresh_token:
return jsonify({
'error': 'BadRequest',
'message': 'Refresh token no suministrado en el cuerpo ni en cookies.'
}), 400
try:
payload = JWTService.decode_token(refresh_token, expected_type='refresh')
sub = payload.get('sub')
if sub is None:
return jsonify({'error': 'Unauthorized', 'message': 'Token payload inválido.'}), 401
user_id = int(sub)
user = user_service.get_by_id(user_id)
if not user or not user.is_active:
return jsonify({
'error': 'Unauthorized',
'message': 'Usuario no encontrado o inactivo.'
}), 401
new_access_token = JWTService.create_access_token(user)
return jsonify({
'access_token': new_access_token,
'token_type': 'Bearer',
'expires_in': int(JWTService.ACCESS_TOKEN_EXPIRES.total_seconds())
}), 200
except jwt.ExpiredSignatureError:
return jsonify({'error': 'TokenExpired', 'message': 'El refresh token ha expirado. Reingrese credenciales.'}), 401
except jwt.InvalidTokenError as e:
return jsonify({'error': 'InvalidToken', 'message': str(e)}), 401
@api_auth_bp.route('/logout', methods=['POST'])
@jwt_required
def logout():
"""
Session logout: revokes active access token and clears cookies.
"""
if g.jwt_user:
AuditService.log(
action='LOGOUT',
module='auth',
user=g.jwt_user,
entity_id=g.jwt_user.id,
details=f"Cierre de sesión seguro de {g.jwt_user.email}"
)
JWTService.revoke_token(g.jwt_token)
resp = make_response(jsonify({'message': 'Sesión finalizada y token revocado exitosamente.'}), 200)
resp.delete_cookie('refresh_token', path='/api/v1/auth/refresh')
return resp
@api_auth_bp.route('/change_password', methods=['POST'])
@api_auth_bp.route('/change-password', methods=['POST'])
@jwt_required
def change_password():
"""
Permite al usuario autenticado cambiar su propia contraseña institucional.
Valida la contraseña actual y la confirmación de la nueva clave.
"""
data = request.get_json(silent=True) or request.form.to_dict() or {}
current_password = data.get('current_password', '').strip()
new_password = data.get('new_password', '').strip()
confirm_password = data.get('confirm_password', '').strip()
if not current_password or not new_password:
return jsonify({
'error': 'BadRequest',
'message': 'Debe ingresar la contraseña actual y la nueva contraseña.'
}), 400
if new_password != confirm_password:
return jsonify({
'error': 'BadRequest',
'message': 'La nueva contraseña y su confirmación no coinciden.'
}), 400
if len(new_password) < 6:
return jsonify({
'error': 'BadRequest',
'message': 'La nueva contraseña debe tener al menos 6 caracteres.'
}), 400
user = g.jwt_user
if not user.check_password(current_password):
AuditService.log(
action='PASSWORD_FAILED',
module='auth',
user=user,
entity_id=user.id,
details="Intento fallido de cambio de contraseña: la contraseña actual no coincide."
)
return jsonify({
'error': 'Unauthorized',
'message': 'La contraseña actual ingresada es incorrecta.'
}), 401
user.set_password(new_password)
db.session.commit()
AuditService.log(
action='PASSWORD_CHANGE',
module='auth',
user=user,
entity_id=user.id,
details="Cambio de contraseña institucional completado exitosamente."
)
logger.info(f"[Auth] Password successfully updated for user {user.email}")
return jsonify({
'status': 'success',
'message': 'Contraseña actualizada correctamente.'
}), 200
@api_auth_bp.route('/me', methods=['GET'])
@jwt_required
def get_current_user():
"""
Returns current authenticated profile and permissions.
"""
profile = user_service.get_profile_data(g.jwt_user)
return jsonify(profile), 200
-164
View File
@@ -1,164 +0,0 @@
from flask import Blueprint, request, jsonify, g
from pydantic import ValidationError
from app import db
from app.models.classroom import Classroom
from app.services.classroom_service import ClassroomService
from app.services.audit_service import AuditService
from app.schemas.classroom_dto import ClassroomCreateDTO, ClassroomUpdateDTO, ClassroomResponseDTO
from app.utils.jwt_decorators import jwt_required, jwt_role_required
api_classrooms_bp = Blueprint('api_classrooms', __name__, url_prefix='/api/v1/classrooms')
classroom_service = ClassroomService()
@api_classrooms_bp.route('', methods=['GET'])
@jwt_required
def list_classrooms():
"""Lista aulas con filtros opcionales (building_id, floor, mode)."""
building_id = request.args.get('building_id', type=int)
floor = request.args.get('floor')
mode = request.args.get('mode', '').lower()
only_virtual = mode == 'virtual'
only_physical = mode == 'physical'
classrooms = classroom_service.list_classrooms(
building_id=building_id,
floor=floor,
only_virtual=only_virtual,
only_physical=only_physical
)
result = []
for c in classrooms:
result.append({
'id': c.id,
'code': c.code,
'building': c.building_name,
'building_id': c.building_id,
'floor': c.floor,
'floor_display': c.floor_display,
'capacity': c.capacity,
'is_virtual': c.is_virtual,
'location_display': c.location_display,
'description': c.description,
'is_active': c.is_active
})
return jsonify({'total': len(result), 'classrooms': result}), 200
@api_classrooms_bp.route('/<int:classroom_id>', methods=['GET'])
@jwt_required
def get_classroom(classroom_id: int):
"""Obtiene el detalle de un aula por ID."""
c = classroom_service.get_classroom(classroom_id)
if not c:
return jsonify({'error': 'NotFound', 'message': f'Aula {classroom_id} no encontrada.'}), 404
return jsonify({
'id': c.id,
'code': c.code,
'building': c.building_name,
'building_id': c.building_id,
'floor': c.floor,
'floor_display': c.floor_display,
'capacity': c.capacity,
'is_virtual': c.is_virtual,
'location_display': c.location_display,
'description': c.description,
'is_active': c.is_active
}), 200
@api_classrooms_bp.route('', methods=['POST'])
@jwt_role_required('ADMIN', 'ADMINISTRADOR', 'BEDELIA')
def create_classroom():
"""Crea una nueva aula validando el contrato con ClassroomCreateDTO."""
data = request.get_json(silent=True) or {}
try:
dto = ClassroomCreateDTO(**data)
except ValidationError as e:
return jsonify({'error': 'ValidationError', 'details': e.errors()}), 400
try:
classroom = classroom_service.create_classroom(dto)
AuditService.log(
action='CREATE',
module='classrooms',
entity_id=classroom.id,
user=g.jwt_user,
details=f"Nueva aula creada: {classroom.code} en {classroom.building} (Piso {classroom.floor}, Capacidad: {classroom.capacity})"
)
return jsonify({
'message': 'Aula creada exitosamente.',
'id': classroom.id,
'code': classroom.code,
'location_display': classroom.location_display
}), 201
except ValueError as e:
return jsonify({'error': 'ConflictOrValidation', 'message': str(e)}), 400
@api_classrooms_bp.route('/<int:classroom_id>', methods=['PUT'])
@jwt_role_required('ADMIN', 'ADMINISTRADOR', 'BEDELIA')
def update_classroom(classroom_id: int):
"""Actualiza los datos de un aula."""
data = request.get_json(silent=True) or {}
try:
dto = ClassroomUpdateDTO(**data)
except ValidationError as e:
return jsonify({'error': 'ValidationError', 'details': e.errors()}), 400
try:
classroom = classroom_service.update_classroom(classroom_id, dto)
AuditService.log(
action='UPDATE',
module='classrooms',
entity_id=classroom.id,
user=g.jwt_user,
details=f"Aula #{classroom.id} ({classroom.code}) actualizada. Capacidad: {classroom.capacity}, Piso: {classroom.floor}"
)
return jsonify({
'message': 'Aula actualizada exitosamente.',
'id': classroom.id,
'code': classroom.code,
'capacity': classroom.capacity
}), 200
except ValueError as e:
return jsonify({'error': 'ConflictOrValidation', 'message': str(e)}), 400
@api_classrooms_bp.route('/<int:classroom_id>', methods=['DELETE'])
@jwt_role_required('ADMIN', 'ADMINISTRADOR')
def delete_classroom(classroom_id: int):
"""Elimina o desactiva un aula."""
deleted = classroom_service.delete_classroom(classroom_id)
if not deleted:
return jsonify({'error': 'NotFound', 'message': f'Aula {classroom_id} no encontrada.'}), 404
AuditService.log(
action='DELETE',
module='classrooms',
entity_id=classroom_id,
user=g.jwt_user,
details=f"Aula #{classroom_id} eliminada/desactivada del sistema"
)
return jsonify({'message': f'Aula {classroom_id} eliminada/desactivada correctamente.'}), 200
@api_classrooms_bp.route('/<int:classroom_id>/toggle', methods=['POST'])
@jwt_role_required('ADMIN', 'ADMINISTRADOR', 'BEDELIA')
def toggle_classroom(classroom_id: int):
"""Alterna el estado activo/inactivo de un aula."""
classroom = Classroom.query.get_or_404(classroom_id)
classroom.is_active = not classroom.is_active
db.session.commit()
AuditService.log(
action='TOGGLE',
module='classrooms',
entity_id=classroom.id,
user=g.jwt_user,
details=f"Aula {classroom.code} {'activada' if classroom.is_active else 'desactivada'}"
)
return jsonify({
'status': 'success',
'id': classroom.id,
'is_active': classroom.is_active,
'message': f'Aula {"activada" if classroom.is_active else "desactivada"} correctamente.'
}), 200
-782
View File
@@ -1,782 +0,0 @@
from flask import Blueprint, jsonify, request, g
from app.utils.jwt_decorators import jwt_required
from app.models.classroom import Classroom
from app.models.subject import Subject
from app.models.user import User
from app.models.reservation import Reservation
from app.models.audit_log import AuditLog
from app.services.audit_service import AuditService
from datetime import datetime, timedelta, timezone
from sqlalchemy import func
from app import db
from app.models.milestone import AcademicMilestone
from app.models.subject import Commission
from app.models.setting import SystemSetting
api_dashboard_bp = Blueprint('api_dashboard', __name__, url_prefix='/api/v1/dashboard')
def serialize_reservation(r):
subject_name = (r.commission.subject.name if (r.commission and r.commission.subject) else r.purpose) or 'Actividad Académica'
subject_code = (r.commission.subject.code if (r.commission and r.commission.subject) else '')
classroom_code = r.classroom.code if r.classroom else 'Sin Aula'
is_virtual = ('virtual' in classroom_code.lower()) or (getattr(r.classroom, 'is_virtual', False) if r.classroom else False)
return {
'id': r.id,
'start_time': r.start_time.strftime('%H:%M') if r.start_time else '',
'end_time': r.end_time.strftime('%H:%M') if r.end_time else '',
'date_display': r.start_time.strftime('%d/%m') if r.start_time else '',
'classroom': {
'id': r.classroom_id,
'code': classroom_code,
'is_virtual': is_virtual,
'location_display': getattr(r.classroom, 'location_display', f'Sede Central · {classroom_code}') if r.classroom else 'Sin Aula'
},
'subject_name': subject_name,
'subject_code': subject_code,
'shift': r.shift or 'Mañana',
'commission': {
'id': r.commission_id,
'code': r.commission.code if r.commission else 'COM-1'
},
'status': str(r.status.value if hasattr(r.status, 'value') else r.status),
'user': {
'id': r.user_id,
'name': r.user.name if r.user else 'Docente'
},
'virtual_link': r.virtual_link or ('https://meet.google.com/edu-space-' + classroom_code.lower().replace(' ', '-') if is_virtual else '')
}
def serialize_milestone(m):
return {
'id': m.id,
'title': m.title,
'materia_codigo': m.materia_codigo,
'subject_name': m.subject.name if (hasattr(m, 'subject') and m.subject) else m.materia_codigo,
'date': m.date.strftime('%d/%m/%Y') if m.date else '',
'type_obj': {
'name': m.type_obj.name if m.type_obj else 'Evaluación',
'color': m.type_obj.color if m.type_obj else '#0d6efd'
},
'classroom': m.classroom or 'Sede Central',
'link': m.link or '',
'notes': m.notes or ''
}
@api_dashboard_bp.route('/stats', methods=['GET'])
@jwt_required
def get_stats():
"""Retorna estadísticas clave y datos operativos para el Dashboard."""
today = datetime.now(timezone.utc).date()
total_classrooms = 0
total_subjects = 0
total_users = 0
today_reservations = 0
pending_count = 0
physical_classrooms = 0
virtual_classrooms = 0
occupancy_rate = 0
assigned_classrooms = 0
assigned_pct = 0.0
unassigned_classrooms = 0
unassigned_pct = 0.0
assigned_today_count = 0
assigned_today_pct = 0.0
unassigned_today_count = 0
unassigned_today_pct = 0.0
total_active_commissions = 0
tomorrow_reservations_q = []
my_today_count = 0
my_total_reservations = 0
my_today_classes = []
tomorrow_schedule_list = []
filter_stats = {}
date_labels = {}
unassigned_commissions_tomorrow = []
unassigned_commissions_week = []
unassigned_commissions_month = []
unassigned_commissions_general = []
available_classrooms_today = []
available_classrooms_tomorrow = []
available_classrooms_week = []
available_classrooms_month = []
virtual_rooms_data = []
audit_data = []
pending_reservations = []
today_schedule_list = []
week_schedule_list = []
upcoming_reservations = []
milestones = []
try:
total_classrooms = Classroom.query.filter_by(is_active=True).count()
total_subjects = Subject.query.filter_by(is_active=True).count()
total_users = User.query.filter_by(is_active=True).count()
# Aulas presenciales y virtuales
all_active_classrooms = Classroom.query.filter_by(is_active=True).all()
virtual_classrooms_list = [
c for c in all_active_classrooms
if getattr(c, 'is_virtual', False)
or 'virtual' in (c.building or '').lower()
or 'virtual' in (c.code or '').lower()
]
virtual_classrooms = len(virtual_classrooms_list)
physical_classrooms_list = [
c for c in all_active_classrooms
if c not in virtual_classrooms_list
]
total_physical_count = len(physical_classrooms_list)
physical_classrooms = total_physical_count
physical_ids = set(c.id for c in physical_classrooms_list)
# 1. Asignación General del Cuatrimestre / Cronograma
assigned_all_ids = set(
r[0] for r in db.session.query(Reservation.classroom_id)
.filter(Reservation.classroom_id.isnot(None)).distinct().all()
)
assigned_physical_ids = physical_ids.intersection(assigned_all_ids)
assigned_classrooms = len(assigned_physical_ids)
unassigned_classrooms = max(0, total_physical_count - assigned_classrooms)
assigned_pct = round((assigned_classrooms / max(1, total_physical_count)) * 100, 1) if total_physical_count > 0 else 0.0
unassigned_pct = round(100.0 - assigned_pct, 1) if total_physical_count > 0 else 0.0
# 2. Asignación Operativa del Día de Hoy
assigned_today_ids = set(
r[0] for r in db.session.query(Reservation.classroom_id).filter(
Reservation.classroom_id.isnot(None),
func.date(Reservation.start_time) == today
).distinct().all()
)
assigned_today_physical_ids = physical_ids.intersection(assigned_today_ids)
assigned_today_count = len(assigned_today_physical_ids)
unassigned_today_count = max(0, total_physical_count - assigned_today_count)
assigned_today_pct = round((assigned_today_count / max(1, total_physical_count)) * 100, 1) if total_physical_count > 0 else 0.0
unassigned_today_pct = round(100.0 - assigned_today_pct, 1) if total_physical_count > 0 else 0.0
today_reservations_q = Reservation.query.filter(
func.date(Reservation.start_time) == today
).order_by(Reservation.start_time.asc()).all()
today_reservations = len(today_reservations_q)
pending_reservations_q = Reservation.query.filter(
Reservation.status == 'PENDING'
).order_by(Reservation.start_time.asc()).all()
pending_count = len(pending_reservations_q)
upcoming_reservations_q = Reservation.query.filter(
Reservation.start_time >= datetime.now(timezone.utc).replace(tzinfo=None)
).order_by(Reservation.start_time.asc()).limit(10).all()
milestones_q = AcademicMilestone.query.filter(
AcademicMilestone.is_active == True
).order_by(AcademicMilestone.date.asc()).limit(10).all()
recent_audits = AuditLog.query.order_by(AuditLog.created_at.desc()).limit(6).all()
audit_data = [{
'created_at': a.created_at.strftime('%Y-%m-%d %H:%M') if a.created_at else None,
'action_type': getattr(a, 'action', getattr(a, 'action_type', 'AUDIT')),
'ip_address': a.ip_address,
'user_email': getattr(a, 'user_email', None) or (getattr(a.user, 'email', 'System') if hasattr(a, 'user') else 'System')
} for a in recent_audits]
occupancy_rate = min(100, int((today_reservations / max(1, physical_classrooms * 3)) * 100)) if physical_classrooms > 0 else 0
pending_reservations = [serialize_reservation(r) for r in pending_reservations_q]
today_schedule_list = [serialize_reservation(r) for r in today_reservations_q]
upcoming_reservations = [serialize_reservation(r) for r in upcoming_reservations_q]
milestones = [serialize_milestone(m) for m in milestones_q]
jwt_user = getattr(g, 'jwt_user', None)
user_id = getattr(jwt_user, 'id', None)
my_today_count = 0
my_total_reservations = 0
my_today_classes = []
if user_id:
my_today_q = Reservation.query.filter(
Reservation.user_id == user_id,
func.date(Reservation.start_time) == today,
Reservation.status != 'CANCELLED'
).order_by(Reservation.start_time.asc()).all()
my_today_count = len(my_today_q)
my_today_classes = [serialize_reservation(r) for r in my_today_q]
my_total_reservations = Reservation.query.filter(
Reservation.user_id == user_id,
Reservation.status.in_(['CONFIRMED', 'PENDING'])
).count()
else:
my_today_count = today_reservations
my_total_reservations = len(today_reservations_q)
my_today_classes = today_schedule_list[:5]
# ---- Bedelía: Filtros completos de Aulas y Comisiones por Día (Hoy), Mañana, Semana y Mes ----
import calendar
today_dt = datetime.now(timezone.utc).replace(tzinfo=None)
tomorrow_dt = today_dt + timedelta(days=1)
tomorrow_start = tomorrow_dt.replace(hour=0, minute=0, second=0, microsecond=0)
tomorrow_end = tomorrow_dt.replace(hour=23, minute=59, second=59, microsecond=0)
week_start = today_dt - timedelta(days=today_dt.weekday()) # Lunes
week_start = week_start.replace(hour=0, minute=0, second=0, microsecond=0)
week_end = week_start + timedelta(days=6, hours=23, minutes=59, seconds=59)
month_start = today_dt.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
last_day = calendar.monthrange(today_dt.year, today_dt.month)[1]
month_end = today_dt.replace(day=last_day, hour=23, minute=59, second=59, microsecond=0)
# Etiquetas legibles de fecha en español
dias_esp = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo']
meses_esp = ['', 'Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre']
weekday_name = dias_esp[today_dt.weekday()]
month_name = meses_esp[today_dt.month]
tomorrow_weekday_name = dias_esp[tomorrow_dt.weekday()]
tomorrow_month_name = meses_esp[tomorrow_dt.month]
date_labels = {
'today': f"Hoy · {weekday_name} {today_dt.strftime('%d/%m/%Y')}",
'today_short': f"{weekday_name} {today_dt.strftime('%d/%m')}",
'today_full': f"{weekday_name}, {today_dt.day} de {month_name} de {today_dt.year}",
'tomorrow': f"Mañana · {tomorrow_weekday_name} {tomorrow_dt.strftime('%d/%m/%Y')}",
'tomorrow_short': f"{tomorrow_weekday_name} {tomorrow_dt.strftime('%d/%m')}",
'tomorrow_full': f"{tomorrow_weekday_name}, {tomorrow_dt.day} de {tomorrow_month_name} de {tomorrow_dt.year}",
'week': f"Semana del {week_start.strftime('%d/%m')} al {week_end.strftime('%d/%m/%Y')}",
'week_full': f"Semana del {week_start.strftime('%d/%m/%Y')} al {week_end.strftime('%d/%m/%Y')}",
'month': f"Mes de {month_name} {today_dt.year} ({month_start.strftime('%d/%m')} al {month_end.strftime('%d/%m/%Y')})",
'month_full': f"{month_name} de {today_dt.year}"
}
# Reservas por período
tomorrow_reservations_q = Reservation.query.filter(
Reservation.start_time >= tomorrow_start,
Reservation.start_time <= tomorrow_end
).order_by(Reservation.start_time.asc()).all()
tomorrow_schedule_list = [serialize_reservation(r) for r in tomorrow_reservations_q]
week_reservations_q = Reservation.query.filter(
Reservation.start_time >= week_start,
Reservation.start_time <= week_end
).order_by(Reservation.start_time.asc()).all()
week_schedule_list = [serialize_reservation(r) for r in week_reservations_q]
month_reservations_q = Reservation.query.filter(
Reservation.start_time >= month_start,
Reservation.start_time <= month_end
).order_by(Reservation.start_time.asc()).all()
# Mapas de reservas por aula en cada período
res_map_classroom_today = {}
for r in today_reservations_q:
if r.classroom_id:
res_map_classroom_today.setdefault(r.classroom_id, []).append(r)
res_map_classroom_tomorrow = {}
for r in tomorrow_reservations_q:
if r.classroom_id:
res_map_classroom_tomorrow.setdefault(r.classroom_id, []).append(r)
res_map_classroom_week = {}
for r in week_reservations_q:
if r.classroom_id:
res_map_classroom_week.setdefault(r.classroom_id, []).append(r)
res_map_classroom_month = {}
for r in month_reservations_q:
if r.classroom_id:
res_map_classroom_month.setdefault(r.classroom_id, []).append(r)
# Mapas de reservas por comisión en cada período
res_map_comm_today = {}
for r in today_reservations_q:
if r.commission_id:
res_map_comm_today.setdefault(r.commission_id, []).append(r)
res_map_comm_tomorrow = {}
for r in tomorrow_reservations_q:
if r.commission_id:
res_map_comm_tomorrow.setdefault(r.commission_id, []).append(r)
res_map_comm_week = {}
for r in week_reservations_q:
if r.commission_id:
res_map_comm_week.setdefault(r.commission_id, []).append(r)
res_map_comm_month = {}
for r in month_reservations_q:
if r.commission_id:
res_map_comm_month.setdefault(r.commission_id, []).append(r)
all_active_commissions = Commission.query.filter_by(active=True).all()
total_active_commissions = len(all_active_commissions)
# Helper para serializar aula con info contextual
def build_classroom_item(c, res_list):
r_first = res_list[0] if res_list else None
assigned_summary = ''
if r_first:
subj = (r_first.commission.subject.name if (r_first.commission and r_first.commission.subject) else r_first.purpose) or 'Clase'
assigned_summary = f"{subj} ({r_first.start_time.strftime('%H:%M')} - {r_first.end_time.strftime('%H:%M')} hs)"
return {
'id': c.id,
'code': c.code,
'building': c.building or 'Sede Central',
'floor': c.floor or '',
'capacity': c.capacity or 0,
'is_virtual': getattr(c, 'is_virtual', False) or 'virtual' in (c.building or '').lower() or 'virtual' in (c.code or '').lower(),
'res_count': len(res_list),
'assigned_summary': assigned_summary
}
# Helper para serializar comisión con info contextual
def build_comm_item(comm, res_list):
has_v_link = bool(comm.virtual_link and comm.virtual_link.strip())
r_first = res_list[0] if res_list else None
assigned_room = ''
assigned_time = ''
if r_first:
assigned_room = r_first.classroom.code if r_first.classroom else 'Aula Virtual'
assigned_time = f"{r_first.start_time.strftime('%H:%M')} - {r_first.end_time.strftime('%H:%M')} hs"
return {
'id': comm.id,
'code': comm.code,
'full_code': comm.get_full_code(),
'subject_name': comm.subject.name if comm.subject else 'Sin materia',
'subject_code': comm.subject.code if comm.subject else '',
'teacher_name': comm.teacher_name or 'Sin docente',
'schedule': comm.schedule or 'Sin horario',
'shift': comm.shift or 'Sin turno',
'max_students': comm.max_students or 0,
'current_students': comm.current_students or 0,
'virtual_link': comm.virtual_link or '',
'has_virtual_link': has_v_link,
'res_count': len(res_list),
'assigned_room': assigned_room,
'assigned_time': assigned_time
}
# Construcción de Aulas Asignadas vs Sin Asignar para cada período (sobre aulas físicas)
# 1. Hoy
classrooms_assigned_today = [build_classroom_item(c, res_map_classroom_today[c.id]) for c in physical_classrooms_list if c.id in res_map_classroom_today]
classrooms_unassigned_today = [build_classroom_item(c, []) for c in physical_classrooms_list if c.id not in res_map_classroom_today]
# 2. Mañana
classrooms_assigned_tomorrow = [build_classroom_item(c, res_map_classroom_tomorrow[c.id]) for c in physical_classrooms_list if c.id in res_map_classroom_tomorrow]
classrooms_unassigned_tomorrow = [build_classroom_item(c, []) for c in physical_classrooms_list if c.id not in res_map_classroom_tomorrow]
# 3. Semana
classrooms_assigned_week = [build_classroom_item(c, res_map_classroom_week[c.id]) for c in physical_classrooms_list if c.id in res_map_classroom_week]
classrooms_unassigned_week = [build_classroom_item(c, []) for c in physical_classrooms_list if c.id not in res_map_classroom_week]
# 4. Mes
classrooms_assigned_month = [build_classroom_item(c, res_map_classroom_month[c.id]) for c in physical_classrooms_list if c.id in res_map_classroom_month]
classrooms_unassigned_month = [build_classroom_item(c, []) for c in physical_classrooms_list if c.id not in res_map_classroom_month]
# Construcción de Comisiones Asignadas vs Sin Asignar para cada período
# 1. Hoy
commissions_assigned_today = [build_comm_item(comm, res_map_comm_today[comm.id]) for comm in all_active_commissions if comm.id in res_map_comm_today]
commissions_unassigned_today = [build_comm_item(comm, []) for comm in all_active_commissions if comm.id not in res_map_comm_today]
# 2. Mañana
commissions_assigned_tomorrow = [build_comm_item(comm, res_map_comm_tomorrow[comm.id]) for comm in all_active_commissions if comm.id in res_map_comm_tomorrow]
commissions_unassigned_tomorrow = [build_comm_item(comm, []) for comm in all_active_commissions if comm.id not in res_map_comm_tomorrow]
# 3. Semana
commissions_assigned_week = [build_comm_item(comm, res_map_comm_week[comm.id]) for comm in all_active_commissions if comm.id in res_map_comm_week]
commissions_unassigned_week = [build_comm_item(comm, []) for comm in all_active_commissions if comm.id not in res_map_comm_week]
# 4. Mes
commissions_assigned_month = [build_comm_item(comm, res_map_comm_month[comm.id]) for comm in all_active_commissions if comm.id in res_map_comm_month]
commissions_unassigned_month = [build_comm_item(comm, []) for comm in all_active_commissions if comm.id not in res_map_comm_month]
# Identificar comisiones en modalidad virtual (por enlace Meet/Teams/Zoom o asignadas a Campus Virtual)
virtual_room_ids = set(c.id for c in virtual_classrooms_list)
comm_ids_virtual = set()
for comm in all_active_commissions:
if comm.virtual_link and comm.virtual_link.strip():
comm_ids_virtual.add(comm.id)
if virtual_room_ids:
comm_in_virtual_res = set(
r[0] for r in db.session.query(Reservation.commission_id).filter(
Reservation.classroom_id.in_(virtual_room_ids),
Reservation.commission_id.isnot(None)
).distinct().all()
)
comm_ids_virtual.update(comm_in_virtual_res)
virtual_rooms_data = []
for comm in all_active_commissions:
if comm.id in comm_ids_virtual:
res_today = res_map_comm_today.get(comm.id, [])
res_tomorrow = res_map_comm_tomorrow.get(comm.id, [])
res_week = res_map_comm_week.get(comm.id, [])
res_month = res_map_comm_month.get(comm.id, [])
v_link = comm.virtual_link or (res_today[0].virtual_link if res_today and res_today[0].virtual_link else '')
virtual_rooms_data.append({
'id': comm.id,
'commission_id': comm.id,
'code': comm.code,
'full_code': comm.get_full_code(),
'subject_name': comm.subject.name if comm.subject else 'Sin materia',
'subject_code': comm.subject.code if comm.subject else '',
'career_name': comm.subject.career.name if (comm.subject and comm.subject.career) else 'UniCABA',
'teacher_name': comm.teacher_name or 'Docente a confirmar',
'schedule': comm.schedule or 'Horario regular',
'shift': comm.shift or 'Tarde',
'max_students': comm.max_students or 35,
'capacity': comm.max_students or 35,
'virtual_link': v_link,
'is_virtual': True,
'building': 'Campus Virtual',
'floor': 'Remoto ∞',
'today_classes': len(res_today),
'tomorrow_classes': len(res_tomorrow),
'week_classes': len(res_week),
'month_classes': len(res_month),
'res_count': len(res_month),
'is_active_today': len(res_today) > 0,
'is_active_tomorrow': len(res_tomorrow) > 0,
'assigned_summary': f"{comm.subject.name if comm.subject else 'Clase Virtual'} ({comm.schedule or 'Remoto'})"
})
# Las salas virtuales disponibles corresponden a las salas de comisiones virtuales activas o catálogo virtual
if virtual_rooms_data:
virtual_classrooms = len(virtual_rooms_data)
# Comisiones huérfanas generales (sin ninguna reserva histórica ni link virtual)
comm_ids_with_any_res = set(
r[0] for r in db.session.query(Reservation.commission_id).filter(
Reservation.commission_id.isnot(None)
).distinct().all()
)
unassigned_commissions_general = [
build_comm_item(comm, []) for comm in all_active_commissions
if comm.id not in comm_ids_with_any_res and not (comm.virtual_link and comm.virtual_link.strip())
]
# Compatibilidad hacia atrás para vistas existentes
available_classrooms_today = classrooms_unassigned_today
available_classrooms_tomorrow = classrooms_unassigned_tomorrow
available_classrooms_week = classrooms_unassigned_week
available_classrooms_month = classrooms_unassigned_month
unassigned_commissions_tomorrow = commissions_unassigned_tomorrow
unassigned_commissions_week = commissions_unassigned_week
unassigned_commissions_month = commissions_unassigned_month
# Diccionario unificado filter_stats
filter_stats = {
'date_labels': date_labels,
'today': {
'label': date_labels['today'],
'date_short': date_labels['today_short'],
'date_full': date_labels['today_full'],
'classrooms': {
'assigned': classrooms_assigned_today,
'unassigned': classrooms_unassigned_today,
'assigned_count': len(classrooms_assigned_today),
'unassigned_count': len(classrooms_unassigned_today),
'assigned_pct': round((len(classrooms_assigned_today) / max(1, total_physical_count)) * 100, 1),
'unassigned_pct': round((len(classrooms_unassigned_today) / max(1, total_physical_count)) * 100, 1),
'total': total_physical_count
},
'commissions': {
'assigned': commissions_assigned_today,
'unassigned': commissions_unassigned_today,
'assigned_count': len(commissions_assigned_today),
'unassigned_count': len(commissions_unassigned_today),
'assigned_pct': round((len(commissions_assigned_today) / max(1, total_active_commissions)) * 100, 1),
'unassigned_pct': round((len(commissions_unassigned_today) / max(1, total_active_commissions)) * 100, 1),
'total': total_active_commissions
}
},
'tomorrow': {
'label': date_labels['tomorrow'],
'date_short': date_labels['tomorrow_short'],
'date_full': date_labels['tomorrow_full'],
'classrooms': {
'assigned': classrooms_assigned_tomorrow,
'unassigned': classrooms_unassigned_tomorrow,
'assigned_count': len(classrooms_assigned_tomorrow),
'unassigned_count': len(classrooms_unassigned_tomorrow),
'assigned_pct': round((len(classrooms_assigned_tomorrow) / max(1, total_physical_count)) * 100, 1),
'unassigned_pct': round((len(classrooms_unassigned_tomorrow) / max(1, total_physical_count)) * 100, 1),
'total': total_physical_count
},
'commissions': {
'assigned': commissions_assigned_tomorrow,
'unassigned': commissions_unassigned_tomorrow,
'assigned_count': len(commissions_assigned_tomorrow),
'unassigned_count': len(commissions_unassigned_tomorrow),
'assigned_pct': round((len(commissions_assigned_tomorrow) / max(1, total_active_commissions)) * 100, 1),
'unassigned_pct': round((len(commissions_unassigned_tomorrow) / max(1, total_active_commissions)) * 100, 1),
'total': total_active_commissions
}
},
'week': {
'label': date_labels['week'],
'date_short': date_labels['week'],
'date_full': date_labels['week_full'],
'classrooms': {
'assigned': classrooms_assigned_week,
'unassigned': classrooms_unassigned_week,
'assigned_count': len(classrooms_assigned_week),
'unassigned_count': len(classrooms_unassigned_week),
'assigned_pct': round((len(classrooms_assigned_week) / max(1, total_physical_count)) * 100, 1),
'unassigned_pct': round((len(classrooms_unassigned_week) / max(1, total_physical_count)) * 100, 1),
'total': total_physical_count
},
'commissions': {
'assigned': commissions_assigned_week,
'unassigned': commissions_unassigned_week,
'assigned_count': len(commissions_assigned_week),
'unassigned_count': len(commissions_unassigned_week),
'assigned_pct': round((len(commissions_assigned_week) / max(1, total_active_commissions)) * 100, 1),
'unassigned_pct': round((len(commissions_unassigned_week) / max(1, total_active_commissions)) * 100, 1),
'total': total_active_commissions
}
},
'month': {
'label': date_labels['month'],
'date_short': date_labels['month'],
'date_full': date_labels['month_full'],
'classrooms': {
'assigned': classrooms_assigned_month,
'unassigned': classrooms_unassigned_month,
'assigned_count': len(classrooms_assigned_month),
'unassigned_count': len(classrooms_unassigned_month),
'assigned_pct': round((len(classrooms_assigned_month) / max(1, total_physical_count)) * 100, 1),
'unassigned_pct': round((len(classrooms_unassigned_month) / max(1, total_physical_count)) * 100, 1),
'total': total_physical_count
},
'commissions': {
'assigned': commissions_assigned_month,
'unassigned': commissions_unassigned_month,
'assigned_count': len(commissions_assigned_month),
'unassigned_count': len(commissions_unassigned_month),
'assigned_pct': round((len(commissions_assigned_month) / max(1, total_active_commissions)) * 100, 1),
'unassigned_pct': round((len(commissions_unassigned_month) / max(1, total_active_commissions)) * 100, 1),
'total': total_active_commissions
}
},
'virtual_rooms': virtual_rooms_data,
'virtual_rooms_count': len(virtual_rooms_data)
}
except Exception as e:
print(f"Error fetching stats: {e}")
total_classrooms = 0
total_subjects = 0
total_users = 0
today_reservations = 0
pending_count = 0
physical_classrooms = 0
virtual_classrooms = 0
occupancy_rate = 0
assigned_classrooms = 0
assigned_pct = 0.0
unassigned_classrooms = 0
unassigned_pct = 0.0
assigned_today_count = 0
assigned_today_pct = 0.0
unassigned_today_count = 0
unassigned_today_pct = 0.0
audit_data = []
pending_reservations = []
today_schedule_list = []
week_schedule_list = []
upcoming_reservations = []
unassigned_commissions_week = []
unassigned_commissions_month = []
unassigned_commissions_general = []
available_classrooms_today = []
available_classrooms_week = []
available_classrooms_month = []
total_active_commissions = 0
milestones = []
# Mocked monthly data for chart since complex SQL group by month might differ based on dialect (SQLite vs Postgres)
monthly_data = [
{"month": "Ene", "reservations": 120},
{"month": "Feb", "reservations": 180},
{"month": "Mar", "reservations": 250},
{"month": "Abr", "reservations": 220},
{"month": "May", "reservations": 300},
{"month": "Jun", "reservations": 310},
{"month": "Jul", "reservations": 200},
{"month": "Ago", "reservations": 350},
{"month": "Sep", "reservations": 420},
{"month": "Oct", "reservations": 480},
{"month": "Nov", "reservations": 520},
{"month": "Dic", "reservations": 210}
]
return jsonify({
'status': 'success',
'stats': {
'total_classrooms': total_classrooms,
'active_subjects': total_subjects,
'total_active_users': total_users,
'today_reservations': today_reservations,
'pending_count': pending_count,
'physical_classrooms': physical_classrooms,
'virtual_classrooms': virtual_classrooms,
'occupancy_rate': occupancy_rate,
'assigned_classrooms': assigned_classrooms,
'assigned_classrooms_pct': assigned_pct,
'unassigned_classrooms': unassigned_classrooms,
'unassigned_classrooms_pct': unassigned_pct,
'assigned_today_classrooms': assigned_today_count,
'assigned_today_pct': assigned_today_pct,
'unassigned_today_classrooms': unassigned_today_count,
'unassigned_today_pct': unassigned_today_pct,
'total_active_commissions': total_active_commissions,
'tomorrow_reservations': len(tomorrow_reservations_q),
'my_today_count': my_today_count,
'my_total_reservations': my_total_reservations,
'virtual_rooms_count': virtual_classrooms
},
'audit_logs': audit_data,
'monthly_data': monthly_data,
'pending_reservations': pending_reservations,
'today_schedule_list': today_schedule_list,
'my_today_classes': my_today_classes,
'tomorrow_schedule_list': tomorrow_schedule_list,
'week_schedule_list': week_schedule_list,
'upcoming_reservations': upcoming_reservations,
'milestones': milestones,
'filter_stats': filter_stats,
'date_labels': date_labels,
'ui': {
'show_role_banner': SystemSetting.get_value('dashboard_role_banner_enabled', 'true') in ['true', 'True', '1', True]
},
'bedelia': {
'unassigned_commissions_tomorrow': unassigned_commissions_tomorrow,
'unassigned_commissions_week': unassigned_commissions_week,
'unassigned_commissions_month': unassigned_commissions_month,
'unassigned_commissions_general': unassigned_commissions_general,
'available_classrooms_today': available_classrooms_today,
'available_classrooms_tomorrow': available_classrooms_tomorrow,
'available_classrooms_week': available_classrooms_week,
'available_classrooms_month': available_classrooms_month,
'virtual_rooms': virtual_rooms_data,
'virtual_rooms_count': len(virtual_rooms_data)
}
}), 200
@api_dashboard_bp.route('/sync-sheets', methods=['POST'])
@jwt_required
def sync_google_sheets():
"""Ejecuta la sincronización real con las hojas de cálculo de Google Sheets con soporte de filtros y entidades."""
from app.services.sheets_importer import GoogleSheetsImporter
filter_career = None
filter_subject = None
filter_day = None
try:
data = request.get_json(silent=True) or {}
custom_url = data.get('sheets_url') or data.get('base_url')
filter_career = data.get('filter_career')
filter_subject = data.get('filter_subject')
filter_day = data.get('filter_day')
filter_days = data.get('filter_days')
manual_date = data.get('manual_date')
single_date_only = bool(data.get('single_date_only', False))
# Opciones granulares de entidades
import_careers = data.get('import_careers', True)
import_subjects = data.get('import_subjects', True)
import_commissions = data.get('import_commissions', True)
import_classrooms = data.get('import_classrooms', True)
import_reservations = data.get('import_reservations', True)
selected_rows = data.get('selected_rows')
importer = GoogleSheetsImporter(base_url=custom_url)
stats = importer.sync(
filter_career=filter_career,
filter_subject=filter_subject,
filter_day=filter_day,
filter_days=filter_days,
manual_date=manual_date,
single_date_only=single_date_only,
import_careers=import_careers,
import_subjects=import_subjects,
import_commissions=import_commissions,
import_classrooms=import_classrooms,
import_reservations=import_reservations,
selected_rows=selected_rows
)
user_info = getattr(g, 'current_user', {}) or {}
user_email = user_info.get('email') if isinstance(user_info, dict) else getattr(user_info, 'email', None)
AuditService.log(
action='SHEETS_IMPORT',
module='import',
user_email=user_email,
ip_address=request.remote_addr,
details={
'stats': stats,
'filter_career': filter_career,
'filter_subject': filter_subject,
'filter_day': filter_day,
'filter_days': filter_days,
'single_date_only': single_date_only,
'manual_date': manual_date
},
status='success'
)
return jsonify({
'status': 'success',
'stats': stats,
'source_url': importer.base_url
}), 200
except Exception as e:
user_info = getattr(g, 'current_user', {}) or {}
user_email = user_info.get('email') if isinstance(user_info, dict) else getattr(user_info, 'email', None)
AuditService.log(
action='SHEETS_IMPORT_ERROR',
module='import',
user_email=user_email,
ip_address=request.remote_addr,
details={
'error': str(e),
'filter_career': filter_career,
'filter_subject': filter_subject,
'filter_day': filter_day
},
status='failed'
)
return jsonify({
'status': 'error',
'message': str(e)
}), 500
@api_dashboard_bp.route('/sheets-inspect', methods=['GET', 'POST'])
@jwt_required
def inspect_google_sheets():
"""Devuelve metadatos, carreras, materias y previsualización de registros según los filtros aplicados."""
from app.services.sheets_importer import GoogleSheetsImporter
try:
data = request.get_json(silent=True) or {}
custom_url = data.get('sheets_url') or request.args.get('sheets_url')
filter_career = data.get('filter_career') or request.args.get('filter_career')
filter_subject = data.get('filter_subject') or request.args.get('filter_subject')
filter_day = data.get('filter_day') or request.args.get('filter_day')
filter_days = data.get('filter_days') or request.args.get('filter_days')
manual_date = data.get('manual_date') or request.args.get('manual_date')
importer = GoogleSheetsImporter(base_url=custom_url)
metadata = importer.inspect_sheet_content(
filter_career=filter_career,
filter_subject=filter_subject,
filter_day=filter_day,
filter_days=filter_days,
manual_date=manual_date
)
return jsonify({
'status': 'success',
'metadata': metadata,
'source_url': importer.base_url
}), 200
except Exception as e:
return jsonify({
'status': 'error',
'message': str(e)
}), 500
-261
View File
@@ -1,261 +0,0 @@
from flask import Blueprint, jsonify
api_openapi_bp = Blueprint('api_openapi', __name__, url_prefix='/api/v1')
OPENAPI_SPEC = {
"openapi": "3.0.3",
"info": {
"title": "Edu-Space REST API",
"description": "Enterprise Academic & Physical Space Management REST API with JWT Authentication and Role-Based Access Control.",
"version": "3.7.0"
},
"servers": [
{
"url": "http://127.0.0.1:5000",
"description": "Local Flask Backend Server"
}
],
"components": {
"securitySchemes": {
"bearerAuth": {
"type": "http",
"scheme": "bearer",
"bearerFormat": "JWT"
}
},
"schemas": {
"LoginRequest": {
"type": "object",
"required": ["email", "password"],
"properties": {
"email": {
"type": "string",
"format": "email",
"example": "admin@eduspace.com"
},
"password": {
"type": "string",
"format": "password",
"example": "Admin123!"
}
}
},
"LoginResponse": {
"type": "object",
"properties": {
"access_token": {"type": "string"},
"refresh_token": {"type": "string"},
"token_type": {"type": "string", "example": "Bearer"},
"expires_in": {"type": "integer"},
"user": {"type": "object"}
}
},
"ErrorResponse": {
"type": "object",
"properties": {
"error": {"type": "string"},
"message": {"type": "string"}
}
},
"UserResponse": {
"type": "object",
"properties": {
"id": {"type": "integer"},
"email": {"type": "string"},
"first_name": {"type": "string"},
"last_name": {"type": "string"},
"role": {"type": "string"},
"is_active": {"type": "boolean"}
}
},
"SubjectResponse": {
"type": "object",
"properties": {
"id": {"type": "integer"},
"name": {"type": "string"},
"code": {"type": "string"},
"career": {"type": "string"}
}
},
"ClassroomResponse": {
"type": "object",
"properties": {
"id": {"type": "integer"},
"name": {"type": "string"},
"capacity": {"type": "integer"},
"building": {"type": "string"},
"floor": {"type": "string"}
}
}
}
},
"paths": {
"/api/v1/auth/login": {
"post": {
"summary": "Authenticate user and issue JWT tokens",
"tags": ["Authentication"],
"requestBody": {
"required": True,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/LoginRequest"
}
}
}
},
"responses": {
"200": {
"description": "Authentication successful",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/LoginResponse"
}
}
}
},
"400": {
"description": "Validation error",
"content": {
"application/json": {
"schema": {"$ref": "#/components/schemas/ErrorResponse"}
}
}
},
"401": {
"description": "Unauthorized / Bad credentials",
"content": {
"application/json": {
"schema": {"$ref": "#/components/schemas/ErrorResponse"}
}
}
}
}
}
},
"/api/v1/auth/me": {
"get": {
"summary": "Get authenticated user profile",
"tags": ["Authentication"],
"security": [{"bearerAuth": []}],
"responses": {
"200": {
"description": "Current user profile",
"content": {
"application/json": {
"schema": {"$ref": "#/components/schemas/UserResponse"}
}
}
},
"401": {
"description": "Missing or invalid token",
"content": {
"application/json": {
"schema": {"$ref": "#/components/schemas/ErrorResponse"}
}
}
}
}
}
},
"/api/v1/classrooms": {
"get": {
"summary": "List all physical classrooms and facilities",
"tags": ["Classrooms"],
"security": [{"bearerAuth": []}],
"responses": {
"200": {
"description": "List of classrooms",
"content": {
"application/json": {
"schema": {
"type": "array",
"items": {"$ref": "#/components/schemas/ClassroomResponse"}
}
}
}
}
}
}
},
"/api/v1/admin/users": {
"get": {
"summary": "List all users (Admin only)",
"tags": ["Admin - Users"],
"security": [{"bearerAuth": []}],
"responses": {
"200": {
"description": "List of users",
"content": {
"application/json": {
"schema": {
"type": "array",
"items": {"$ref": "#/components/schemas/UserResponse"}
}
}
}
},
"403": {
"description": "Forbidden - Requires admin role"
}
}
}
},
"/api/v1/admin/subjects": {
"get": {
"summary": "List all academic subjects (Admin only)",
"tags": ["Admin - Academic"],
"security": [{"bearerAuth": []}],
"responses": {
"200": {
"description": "List of subjects",
"content": {
"application/json": {
"schema": {
"type": "array",
"items": {"$ref": "#/components/schemas/SubjectResponse"}
}
}
}
}
}
}
},
"/api/v1/openapi.json": {
"get": {
"summary": "Get OpenAPI 3.0.3 specification JSON",
"tags": ["Documentation"],
"responses": {
"200": {
"description": "OpenAPI Specification"
}
}
}
}
}
}
@api_openapi_bp.route('/openapi.json', methods=['GET'])
def get_openapi_spec():
"""Serves the OpenAPI 3.0 specification for Schemathesis / DAST and Swagger UI."""
return jsonify(OPENAPI_SPEC)
from app import __version__
@api_openapi_bp.route('/version', methods=['GET'])
def get_api_version():
"""Returns the backend API version information."""
return jsonify({
"name": "Edu-Space REST API",
"version": __version__,
"status": "healthy"
}), 200
@api_openapi_bp.route('/health', methods=['GET'])
def get_api_health():
"""Liveness probe for backend API."""
return jsonify({
"status": "ok",
"version": __version__
}), 200
-105
View File
@@ -1,105 +0,0 @@
from flask import Blueprint, request, jsonify, g
from pydantic import ValidationError
from app.schemas.optimizer_dto import OptimizerJobRequestDTO, SpringBootSyncPayloadDTO
from app.services.optimizer_service import OptimizerService
from app.utils.jwt_decorators import jwt_required
api_optimizer_bp = Blueprint('api_optimizer', __name__, url_prefix='/api/v1/optimizer')
@api_optimizer_bp.route('/jobs', methods=['POST'])
@jwt_required
def submit_optimization_job():
"""
Despacha un trabajo de optimización heurística asíncrono.
Retorna inmediatamente con HTTP 202 Accepted y el identificador de trabajo para sondeo.
"""
data = request.get_json(silent=True) or {}
try:
dto = OptimizerJobRequestDTO(**data)
except ValidationError as ex:
return jsonify({
'error': 'UnprocessableEntity',
'message': 'Error de validación en los parámetros del optimizador.',
'details': ex.errors()
}), 422
user_id = g.current_user.id if hasattr(g, 'current_user') and g.current_user else 1
job = OptimizerService.submit_job(
commission_ids=dto.commission_ids,
admin_user_id=user_id,
start_date=dto.start_date,
end_date=dto.end_date,
generations=dto.generations,
population_size=dto.population_size,
workers=dto.workers
)
return jsonify({
'job_id': job.job_id,
'status': job.status.value,
'poll_url': f'/api/v1/optimizer/jobs/{job.job_id}',
'message': 'Trabajo de optimización puesto en cola con éxito.'
}), 202
@api_optimizer_bp.route('/jobs/<string:job_id>', methods=['GET'])
@jwt_required
def get_optimization_job(job_id: str):
"""
Obtiene el estado, progreso y resultados de un trabajo de optimización en cola.
"""
job = OptimizerService.get_job(job_id)
if not job:
return jsonify({
'error': 'NotFound',
'message': f'Trabajo de optimización {job_id} no encontrado.'
}), 404
return jsonify(job.to_dict()), 200
@api_optimizer_bp.route('/jobs', methods=['GET'])
@jwt_required
def list_optimization_jobs():
"""
Lista los trabajos de optimización más recientes.
"""
limit = request.args.get('limit', default=20, type=int)
jobs = OptimizerService.list_jobs(limit=limit)
return jsonify({
'total': len(jobs),
'jobs': jobs
}), 200
@api_optimizer_bp.route('/spring-boot/sync', methods=['POST'])
@jwt_required
def sync_with_spring_boot():
"""
Endpoint interoperable para la sincronización y resolución de horarios con microservicios Spring Boot.
Recibe el payload en formato Spring Boot (camelCase) y retorna el cronograma optimizado.
"""
data = request.get_json(silent=True) or {}
try:
dto = SpringBootSyncPayloadDTO(**data)
except ValidationError as ex:
return jsonify({
'error': 'UnprocessableEntity',
'message': 'Error de validación en el payload Spring Boot.',
'details': ex.errors()
}), 422
user_id = g.current_user.id if hasattr(g, 'current_user') and g.current_user else 1
try:
result = OptimizerService.sync_with_spring_boot(dto, admin_user_id=user_id)
return jsonify(result), 200
except Exception as ex:
return jsonify({
'requestId': dto.requestId,
'status': 'ERROR',
'error': str(ex)
}), 500
-367
View File
@@ -1,367 +0,0 @@
from flask import Blueprint, request, jsonify, g
from datetime import datetime, timedelta, date, timezone
from pydantic import ValidationError
from app import db
from app.models.reservation import Reservation
from app.services.reservation_service import ReservationService
from app.services.audit_service import AuditService
from app.schemas.reservation_dto import ReservationCreateDTO, ReservationUpdateDTO
from app.utils.jwt_decorators import jwt_required, jwt_role_required
api_reservations_bp = Blueprint('api_reservations', __name__, url_prefix='/api/v1/reservations')
reservation_service = ReservationService()
@api_reservations_bp.route('', methods=['GET'])
@jwt_required
def list_reservations():
"""Consulta de reservas por rango de fechas y/o aula."""
start_str = request.args.get('start_date')
end_str = request.args.get('end_date')
classroom_id = request.args.get('classroom_id', type=int)
now = datetime.now(timezone.utc).replace(tzinfo=None)
try:
start_dt = datetime.strptime(start_str, '%Y-%m-%d') if start_str else now.replace(hour=0, minute=0, second=0)
except ValueError:
return jsonify({'error': 'BadRequest', 'message': 'Formato inválido de start_date (debe ser YYYY-MM-DD).'}), 400
try:
end_dt = datetime.strptime(end_str, '%Y-%m-%d').replace(hour=23, minute=59, second=59) if end_str else start_dt + timedelta(days=7)
except ValueError:
return jsonify({'error': 'BadRequest', 'message': 'Formato inválido de end_date (debe ser YYYY-MM-DD).'}), 400
hide_virtual = request.args.get('hide_virtual', '0') in ['1', 'true', 'True']
floor = request.args.get('floor')
shift = request.args.get('shift')
search = request.args.get('search')
reservations = reservation_service.list_reservations(start_dt, end_dt, classroom_id=classroom_id)
result = []
for r in reservations:
is_virt = bool(r.is_virtual or (r.classroom and r.classroom.is_virtual))
if hide_virtual and is_virt:
continue
if floor and r.classroom and str(r.classroom.floor or '').strip().lower() != floor.strip().lower():
continue
if shift and r.shift and shift.lower() not in r.shift.lower():
continue
if search:
s_lower = search.lower()
subj_n = (r.subject_name or '').lower()
subj_c = (r.subject_code or '').lower()
c_name = (r.classroom.code if r.classroom else '').lower()
u_name = (r.user.name if r.user else '').lower()
if s_lower not in subj_n and s_lower not in subj_c and s_lower not in c_name and s_lower not in u_name:
continue
result.append({
'id': r.id,
'classroom_id': r.classroom_id,
'classroom_name': r.classroom.code if r.classroom else None,
'classroom': {
'id': r.classroom.id,
'code': r.classroom.code,
'code_display': getattr(r.classroom, 'code_display', r.classroom.code),
'floor': r.classroom.floor,
'floor_display': getattr(r.classroom, 'floor_display', f"Piso {r.classroom.floor}"),
'building': getattr(r.classroom, 'building_name', r.classroom.building),
'is_virtual': getattr(r.classroom, 'is_virtual', False),
'location_display': getattr(r.classroom, 'location_display', r.classroom.code)
} if r.classroom else None,
'commission_id': r.commission_id,
'commission': {
'id': r.commission.id,
'code': r.commission.code,
'virtual_link': r.commission.virtual_link,
'max_students': r.commission.max_students
} if r.commission else None,
'teacher_name': r.user.name if r.user else None,
'user': {
'id': r.user.id,
'name': r.user.name,
'email': r.user.email
} if r.user else None,
'start_time': r.start_time.isoformat(),
'end_time': r.end_time.isoformat(),
'purpose': r.purpose,
'subject_name': r.subject_name,
'subject_code': r.subject_code,
'career_name': r.commission.career_name if (r.commission and hasattr(r.commission, 'career_name')) else '',
'career_names': r.commission.career_names if (r.commission and hasattr(r.commission, 'career_names')) else '',
'commission_code': r.commission.code if r.commission else '',
'status': str(r.status.value if hasattr(r.status, 'value') else r.status),
'shift': r.shift or 'Mañana',
'virtual_link': r.virtual_link,
'effective_virtual_link': r.effective_virtual_link,
'is_virtual': is_virt,
'expected_attendees': r.expected_attendees or 30,
'notes': r.notes or ''
})
return jsonify({
'total': len(result),
'start_date': start_dt.strftime('%Y-%m-%d'),
'end_date': end_dt.strftime('%Y-%m-%d'),
'reservations': result
}), 200
@api_reservations_bp.route('/<int:reservation_id>', methods=['GET'])
@jwt_required
def get_reservation(reservation_id: int):
"""Obtiene el detalle de una reserva específica con sus relaciones completas."""
r = reservation_service.get_reservation(reservation_id)
if not r:
return jsonify({'error': 'NotFound', 'message': f'Reserva {reservation_id} no encontrada.'}), 404
duration_min = int((r.end_time - r.start_time).total_seconds() / 60) if (r.start_time and r.end_time) else 120
is_virt = bool(r.is_virtual or (r.classroom and r.classroom.is_virtual))
return jsonify({
'id': r.id,
'classroom_id': r.classroom_id,
'classroom_name': r.classroom.code if r.classroom else None,
'location_display': getattr(r.classroom, 'location_display', r.classroom.code if r.classroom else None),
'classroom': {
'id': r.classroom.id,
'code': r.classroom.code,
'code_display': getattr(r.classroom, 'code_display', r.classroom.code),
'building_name': getattr(r.classroom, 'building_name', getattr(r.classroom, 'building', 'Edificio Central')),
'floor': r.classroom.floor,
'floor_display': getattr(r.classroom, 'floor_display', f"Piso {r.classroom.floor}"),
'capacity': r.classroom.capacity,
'capacity_display': getattr(r.classroom, 'capacity_display', str(r.classroom.capacity)),
'description': getattr(r.classroom, 'description', '') or '',
'is_virtual': getattr(r.classroom, 'is_virtual', False)
} if r.classroom else None,
'commission_id': r.commission_id,
'commission': {
'id': r.commission.id,
'code': r.commission.code,
'full_code': r.commission.get_full_code() if hasattr(r.commission, 'get_full_code') else r.commission.code,
'virtual_link': r.commission.virtual_link,
'max_students': r.commission.max_students,
'current_students': getattr(r.commission, 'current_students', 0),
'subject': {
'id': r.commission.subject.id,
'name': r.commission.subject.name,
'code': r.commission.subject.code
} if (r.commission and r.commission.subject) else None
} if r.commission else None,
'teacher_id': r.user_id,
'teacher_name': r.user.name if r.user else None,
'user': {
'id': r.user.id,
'name': r.user.name,
'first_name': getattr(r.user, 'first_name', r.user.name.split()[0] if r.user.name else 'Usuario'),
'last_name': getattr(r.user, 'last_name', ' '.join(r.user.name.split()[1:]) if r.user.name and len(r.user.name.split()) > 1 else ''),
'email': r.user.email
} if r.user else None,
'start_time': r.start_time.isoformat(),
'end_time': r.end_time.isoformat(),
'duration': duration_min,
'purpose': r.purpose,
'status': str(r.status.value if hasattr(r.status, 'value') else r.status),
'shift': r.shift or 'Mañana',
'virtual_link': r.virtual_link,
'effective_virtual_link': r.effective_virtual_link,
'is_virtual': is_virt,
'expected_attendees': r.expected_attendees or 30,
'notes': r.notes or '',
'can_be_cancelled': r.can_be_cancelled() if hasattr(r, 'can_be_cancelled') else True
}), 200
@api_reservations_bp.route('', methods=['POST'])
@jwt_required
def create_reservation():
"""Crea una reserva aplicando validación DTO y detección de colisiones."""
data = request.get_json(silent=True) or {}
# Inyectar usuario autenticado si no se especifica
if 'user_id' not in data:
data['user_id'] = g.jwt_user.id
try:
dto = ReservationCreateDTO(**data)
except ValidationError as e:
return jsonify({'error': 'ValidationError', 'details': e.errors()}), 400
try:
reservation = reservation_service.create_reservation(dto)
AuditService.log(
action='CREATE',
module='reservations',
entity_id=reservation.id,
user=g.jwt_user,
details=f"Nueva reserva creada #{reservation.id} en aula ID {reservation.classroom_id} ({reservation.start_time.strftime('%Y-%m-%d %H:%M')} a {reservation.end_time.strftime('%H:%M')}) - Motivo: {reservation.purpose}"
)
return jsonify({
'message': 'Reserva creada exitosamente.',
'id': reservation.id,
'classroom_id': reservation.classroom_id,
'start_time': reservation.start_time.isoformat(),
'end_time': reservation.end_time.isoformat(),
'status': str(reservation.status)
}), 201
except ValueError as e:
return jsonify({'error': 'ConflictOrValidation', 'message': str(e)}), 409
@api_reservations_bp.route('/<int:reservation_id>', methods=['PUT'])
@jwt_required
def update_reservation(reservation_id: int):
"""Modifica una reserva existente."""
data = request.get_json(silent=True) or {}
try:
dto = ReservationUpdateDTO(**data)
except ValidationError as e:
return jsonify({'error': 'ValidationError', 'details': e.errors()}), 400
try:
reservation = reservation_service.update_reservation(reservation_id, dto)
AuditService.log(
action='UPDATE',
module='reservations',
entity_id=reservation.id,
user=g.jwt_user,
details=f"Reserva #{reservation.id} modificada ({reservation.start_time.strftime('%Y-%m-%d %H:%M')} a {reservation.end_time.strftime('%H:%M')}) - Estado: {reservation.status}"
)
return jsonify({
'message': 'Reserva actualizada exitosamente.',
'id': reservation.id,
'start_time': reservation.start_time.isoformat(),
'end_time': reservation.end_time.isoformat(),
'status': str(reservation.status)
}), 200
except ValueError as e:
return jsonify({'error': 'ConflictOrValidation', 'message': str(e)}), 409
@api_reservations_bp.route('/<int:reservation_id>', methods=['DELETE'])
@jwt_required
def cancel_reservation(reservation_id: int):
"""Cancela o elimina una reserva según el parámetro hard."""
hard_delete = request.args.get('hard', '').lower() in ['true', '1']
if hard_delete:
res = Reservation.query.get(reservation_id)
if not res:
return jsonify({'error': 'NotFound', 'message': f'Reserva {reservation_id} no encontrada.'}), 404
db.session.delete(res)
db.session.commit()
AuditService.log(
action='DELETE',
module='reservations',
entity_id=reservation_id,
user=g.jwt_user,
details=f"Reserva #{reservation_id} eliminada permanentemente"
)
return jsonify({'message': f'Reserva {reservation_id} eliminada permanentemente.'}), 200
cancelled = reservation_service.cancel_reservation(reservation_id)
if not cancelled:
return jsonify({'error': 'NotFound', 'message': f'Reserva {reservation_id} no encontrada.'}), 404
AuditService.log(
action='CANCEL',
module='reservations',
entity_id=reservation_id,
user=g.jwt_user,
details=f"Reserva #{reservation_id} cancelada"
)
return jsonify({'message': f'Reserva {reservation_id} cancelada correctamente.'}), 200
@api_reservations_bp.route('/<int:reservation_id>/delete', methods=['POST'])
@jwt_required
def delete_reservation_post(reservation_id: int):
"""Elimina permanentemente una reserva."""
res = Reservation.query.get(reservation_id)
if not res:
return jsonify({'error': 'NotFound', 'message': f'Reserva {reservation_id} no encontrada.'}), 404
db.session.delete(res)
db.session.commit()
AuditService.log(
action='DELETE',
module='reservations',
entity_id=reservation_id,
user=g.jwt_user,
details=f"Reserva #{reservation_id} eliminada permanentemente"
)
return jsonify({'message': f'Reserva {reservation_id} eliminada permanentemente.'}), 200
@api_reservations_bp.route('/<int:reservation_id>/cancel', methods=['POST'])
@jwt_required
def cancel_reservation_post(reservation_id: int):
"""Cancela una reserva (endpoint POST compatible con formularios)."""
cancelled = reservation_service.cancel_reservation(reservation_id)
if not cancelled:
return jsonify({'error': 'NotFound', 'message': f'Reserva {reservation_id} no encontrada.'}), 404
AuditService.log(
action='CANCEL',
module='reservations',
entity_id=reservation_id,
user=g.jwt_user,
details=f"Reserva #{reservation_id} cancelada"
)
return jsonify({'message': f'Reserva {reservation_id} cancelada correctamente.'}), 200
@api_reservations_bp.route('/<int:reservation_id>/confirm', methods=['POST'])
@jwt_required
def confirm_reservation(reservation_id: int):
"""Confirma una reserva cambiando su estado a CONFIRMED."""
confirmed = reservation_service.confirm_reservation(reservation_id)
if not confirmed:
return jsonify({'error': 'NotFound', 'message': f'Reserva {reservation_id} no encontrada.'}), 404
AuditService.log(
action='CONFIRM',
module='reservations',
entity_id=reservation_id,
user=g.jwt_user,
details=f"Reserva #{reservation_id} confirmada oficialmente"
)
return jsonify({'message': f'Reserva {reservation_id} confirmada correctamente.'}), 200
@api_reservations_bp.route('/check-conflicts', methods=['POST'])
@jwt_required
def check_conflicts_endpoint():
"""
Evalúa la matriz completa de conflictos (físico, docente y aforo) en tiempo real.
"""
data = request.get_json(silent=True)
if not isinstance(data, dict):
return jsonify({'error': 'BadRequest', 'message': 'El cuerpo de la solicitud debe ser un objeto JSON.'}), 400
classroom_id = data.get('classroom_id')
start_str = data.get('start_time')
end_str = data.get('end_time')
if not classroom_id or not start_str or not end_str:
return jsonify({'error': 'BadRequest', 'message': 'classroom_id, start_time y end_time son obligatorios.'}), 400
try:
start_time = datetime.fromisoformat(str(start_str).replace('Z', '+00:00'))
end_time = datetime.fromisoformat(str(end_str).replace('Z', '+00:00'))
except ValueError:
return jsonify({'error': 'BadRequest', 'message': 'Formato inválido de fecha/hora (ISO 8601 esperado).'}), 400
teacher_id = data.get('teacher_id')
commission_id = data.get('commission_id')
expected_attendees = data.get('expected_attendees')
allow_co_teaching = bool(data.get('allow_co_teaching_exception', False))
exclude_id = data.get('exclude_id')
try:
matrix = reservation_service.check_full_conflicts_matrix(
classroom_id=int(classroom_id),
start_time=start_time,
end_time=end_time,
teacher_id=int(teacher_id) if teacher_id else None,
commission_id=int(commission_id) if commission_id else None,
expected_attendees=int(expected_attendees) if expected_attendees is not None else None,
allow_co_teaching_exception=allow_co_teaching,
exclude_id=int(exclude_id) if exclude_id else None
)
return jsonify(matrix), 200
except ValueError as e:
return jsonify({'error': 'ValidationError', 'message': str(e)}), 400
-43
View File
@@ -1,43 +0,0 @@
from flask import Blueprint, jsonify, request, g
from app.utils.jwt_decorators import jwt_required
from app.services.gradebook_service import GradebookService
api_students_bp = Blueprint('api_students', __name__)
@api_students_bp.route('/students/my-grades', methods=['GET'])
@jwt_required
def get_my_grades():
"""Consulta individual de calificaciones y estado académico del alumno logueado."""
user = getattr(g, 'jwt_user', None)
user_id = user.id if user else getattr(request, 'current_user_id', None)
if not user_id:
return jsonify({'error': 'Unauthorized', 'message': 'Usuario no autenticado.'}), 401
try:
grades = GradebookService.get_student_grades(user_id)
return jsonify({
'status': 'success',
'student_id': user_id,
'is_impersonating': getattr(g, 'is_impersonating', False),
'data': grades
}), 200
except Exception as e:
return jsonify({'error': 'ServerError', 'message': str(e)}), 500
@api_students_bp.route('/students/my-upcoming-milestones', methods=['GET'])
@jwt_required
def get_my_upcoming_milestones():
"""Próximas evaluaciones e hitos académicos con cuenta regresiva para el dashboard."""
user = getattr(g, 'jwt_user', None)
user_id = user.id if user else getattr(request, 'current_user_id', None)
if not user_id:
return jsonify({'error': 'Unauthorized', 'message': 'Usuario no autenticado.'}), 401
limit = request.args.get('limit', default=5, type=int)
try:
milestones = GradebookService.get_student_upcoming_milestones(user_id, limit=limit)
return jsonify({'status': 'success', 'data': milestones}), 200
except Exception as e:
return jsonify({'error': 'ServerError', 'message': str(e)}), 500
-152
View File
@@ -1,152 +0,0 @@
from flask import Blueprint, render_template, redirect, url_for, flash, request, session, jsonify
from flask_login import login_user, logout_user, login_required, current_user
from flask_babel import gettext as _
from app import db
from app.models.user import User
from app.forms.auth import LoginForm
from datetime import datetime
auth_bp = Blueprint('auth', __name__)
from sqlalchemy import func
@auth_bp.route('/login', methods=['GET', 'POST'])
def login():
"""Handle user login with case-insensitive email lookup and whitespace trimming"""
if current_user.is_authenticated:
return redirect(url_for('main.dashboard'))
from app.models.setting import SystemSetting
demo_access_enabled = SystemSetting.get_value('demo_access_enabled', 'true') in ['true', 'True', '1', True]
form = LoginForm()
if form.validate_on_submit():
clean_email = (form.email.data or '').strip().lower()
user = User.query.filter(func.lower(User.email) == clean_email).first()
if user and user.check_password(form.password.data):
if not user.is_active:
flash(_('Tu cuenta ha sido desactivada. Por favor contacta al administrador.'), 'error')
return render_template('auth/login.html', form=form, demo_access_enabled=demo_access_enabled)
login_user(user, remember=form.remember_me.data)
user.update_last_login()
# Registrar en bitácora de auditoría
try:
from app.services.audit_service import AuditService
AuditService.log(
action='LOGIN',
module='auth',
user_id=user.id,
user_email=user.email,
details=f"Inicio de sesión exitoso ({user.role})"
)
except Exception:
pass
# Si el usuario tiene idioma configurado en su perfil, sobrescribe el navegador en toda la sesión
if user.preferred_language and user.preferred_language in ['es', 'en']:
session['language'] = user.preferred_language
else:
session.pop('language', None)
session.pop('login_lang_explicit', None)
next_page = request.args.get('next')
if not next_page or not next_page.startswith('/'):
next_page = url_for('main.dashboard')
user_full_name = f'{user.first_name} {user.last_name}'.strip() or user.name
flash(_('¡Bienvenido de nuevo, %(name)s!', name=user_full_name), 'success')
return redirect(next_page)
else:
try:
from app.services.audit_service import AuditService
AuditService.log(
action='LOGIN_FAILED',
module='auth',
details=f"Intento fallido de login con email: {clean_email}"
)
except Exception:
pass
flash(_('Correo electrónico o contraseña inválidos.'), 'error')
return render_template('auth/login.html', form=form, demo_access_enabled=demo_access_enabled)
@auth_bp.route('/logout')
@login_required
def logout():
"""Handle user logout"""
logout_user()
# Al cerrar sesión, se limpian las cookies de idioma para que el login detecte el navegador o use español
session.pop('language', None)
session.pop('login_lang_explicit', None)
flash(_('Has cerrado sesión correctamente.'), 'info')
return redirect(url_for('auth.login'))
@auth_bp.route('/profile', methods=['GET', 'POST'])
@login_required
def profile():
"""User profile page with language and theme settings"""
if request.method == 'POST':
lang = request.form.get('preferred_language')
if lang in ['es', 'en']:
current_user.preferred_language = lang
session['language'] = lang
else:
# Cadena vacía o None restablece la detección automática del navegador
current_user.preferred_language = None
session.pop('language', None)
theme = request.form.get('theme_preference')
if theme in ['auto', 'light', 'dark']:
current_user.theme_preference = theme
db.session.commit()
flash(_('Preferencias de usuario actualizadas correctamente.'), 'success')
return redirect(url_for('auth.profile'))
return render_template('auth/profile.html')
@auth_bp.route('/api/user/theme', methods=['POST'])
@login_required
def update_theme_api():
"""Update user theme preference via fetch/AJAX from navbar toggle"""
data = request.get_json(silent=True) or request.form
theme = data.get('theme') if data else None
if theme in ['auto', 'light', 'dark']:
current_user.theme_preference = theme
db.session.commit()
return jsonify({'status': 'success', 'theme': theme})
return jsonify({'status': 'error', 'message': 'Invalid theme'}), 400
@auth_bp.route('/change_password', methods=['GET', 'POST'])
@login_required
def change_password():
"""Change user password"""
if request.method == 'POST':
current_password = request.form.get('current_password') or ''
new_password = request.form.get('new_password') or ''
confirm_password = request.form.get('confirm_password') or ''
if not current_user.check_password(current_password):
flash('Current password is incorrect.', 'error')
return redirect(url_for('auth.change_password'))
if new_password != confirm_password:
flash('New passwords do not match.', 'error')
return redirect(url_for('auth.change_password'))
if len(new_password) < 6:
flash('Password must be at least 6 characters long.', 'error')
return redirect(url_for('auth.change_password'))
current_user.set_password(new_password)
db.session.commit()
flash('Password changed successfully!', 'success')
return redirect(url_for('auth.profile'))
return render_template('auth/change_password.html')
-196
View File
@@ -1,196 +0,0 @@
from flask import Blueprint, render_template, redirect, url_for, flash, request
from flask_login import login_required, current_user
from app import db
from app.models.building import Building
from app.models.classroom import Classroom
from app.forms.building import BuildingForm
from app.utils.decorators import permission_required
from datetime import datetime, timezone
buildings_bp = Blueprint('buildings', __name__, url_prefix='/buildings')
@buildings_bp.route('/')
@login_required
def list_buildings():
"""List all buildings with statistics"""
search = request.args.get('search', '').strip()
status_filter = request.args.get('status', '')
query = Building.query
if search:
query = query.filter(
db.or_(
Building.name.ilike(f'%{search}%'),
Building.code.ilike(f'%{search}%'),
Building.address.ilike(f'%{search}%')
)
)
if status_filter == 'active':
query = query.filter(Building.is_active == True)
elif status_filter == 'inactive':
query = query.filter(Building.is_active == False)
buildings = query.order_by(Building.name.asc()).all()
# Calculate global building stats (excluye aulas virtuales con 9999)
total_classrooms = Classroom.query.filter_by(is_active=True).count()
physical_classrooms = [c for c in Classroom.query.filter_by(is_active=True).all() if not getattr(c, 'is_virtual', False) and (c.capacity or 0) < 999 and 'VIRTUAL' not in (c.code or '').upper()]
total_physical_capacity = sum(c.capacity for c in physical_classrooms)
total_capacity = total_physical_capacity
return render_template(
'buildings/list.html',
buildings=buildings,
total_classrooms=total_classrooms,
total_capacity=total_capacity,
total_physical_capacity=total_physical_capacity,
search=search,
status_filter=status_filter,
title='Building Management'
)
@buildings_bp.route('/add', methods=['GET', 'POST'])
@login_required
@permission_required('classrooms', 'read_write')
def add_building():
"""Add new building"""
form = BuildingForm()
if form.validate_on_submit():
try:
# Check unique name
existing = Building.query.filter(
db.func.lower(Building.name) == form.name.data.lower()
).first()
if existing:
flash('Ya existe un edificio con este nombre.', 'danger')
return render_template('buildings/form.html', form=form, title='Add Building')
building = Building(
name=form.name.data.strip(),
code=form.code.data.strip().upper() if form.code.data else None,
address=form.address.data.strip() if form.address.data else None,
floors=form.floors.data,
description=form.description.data.strip() if form.description.data else None,
is_active=form.is_active.data
)
db.session.add(building)
db.session.commit()
flash(f'Edificio "{building.name}" creado con éxito.', 'success')
return redirect(url_for('buildings.view_building', id=building.id))
except Exception as e:
db.session.rollback()
flash(f'Error al crear el edificio: {str(e)}', 'danger')
return render_template('buildings/form.html', form=form, title='Add Building')
@buildings_bp.route('/<int:id>')
@login_required
def view_building(id):
"""View building details and its classrooms by floor"""
building = Building.query.get_or_404(id)
# Group active classrooms by floor
classrooms = Classroom.query.filter_by(building_id=building.id).order_by(Classroom.floor.asc(), Classroom.code.asc()).all()
# Fallback to name matching if building_id was not set
if not classrooms:
classrooms = Classroom.query.filter_by(building=building.name).order_by(Classroom.floor.asc(), Classroom.code.asc()).all()
classrooms_by_floor = {}
for c in classrooms:
floor_key = c.floor
if floor_key not in classrooms_by_floor:
classrooms_by_floor[floor_key] = []
classrooms_by_floor[floor_key].append(c)
return render_template(
'buildings/view.html',
building=building,
classrooms=classrooms,
classrooms_by_floor=classrooms_by_floor,
title=f'Building - {building.name}'
)
@buildings_bp.route('/<int:id>/edit', methods=['GET', 'POST'])
@login_required
@permission_required('classrooms', 'read_write')
def edit_building(id):
"""Edit building"""
building = Building.query.get_or_404(id)
form = BuildingForm(obj=building)
if form.validate_on_submit():
try:
# Check unique name excluding current
existing = Building.query.filter(
db.func.lower(Building.name) == form.name.data.lower(),
Building.id != id
).first()
if existing:
flash('Ya existe otro edificio con este nombre.', 'danger')
return render_template('buildings/form.html', form=form, building=building, title='Edit Building')
old_name = building.name
new_name = form.name.data.strip()
building.name = new_name
building.code = form.code.data.strip().upper() if form.code.data else None
building.address = form.address.data.strip() if form.address.data else None
building.floors = form.floors.data
building.description = form.description.data.strip() if form.description.data else None
building.is_active = form.is_active.data
building.updated_at = datetime.now(timezone.utc).replace(tzinfo=None)
# If name changed, update string building on classrooms
if old_name != new_name:
Classroom.query.filter_by(building_id=building.id).update({'building': new_name})
db.session.commit()
flash(f'Edificio "{building.name}" actualizado con éxito.', 'success')
return redirect(url_for('buildings.view_building', id=building.id))
except Exception as e:
db.session.rollback()
flash(f'Error al actualizar el edificio: {str(e)}', 'danger')
return render_template('buildings/form.html', form=form, building=building, title='Edit Building')
@buildings_bp.route('/<int:id>/toggle', methods=['POST'])
@login_required
@permission_required('classrooms', 'read_write')
def toggle_building(id):
"""Toggle building active status"""
building = Building.query.get_or_404(id)
try:
building.is_active = not building.is_active
building.updated_at = datetime.now(timezone.utc).replace(tzinfo=None)
db.session.commit()
status_text = 'activado' if building.is_active else 'desactivado'
flash(f'Edificio "{building.name}" {status_text} con éxito.', 'success')
except Exception as e:
db.session.rollback()
flash(f'Error al cambiar estado del edificio: {str(e)}', 'danger')
return redirect(url_for('buildings.list_buildings'))
@buildings_bp.route('/<int:id>/delete', methods=['POST'])
@login_required
@permission_required('classrooms', 'read_write')
def delete_building(id):
"""Delete building if it has no classrooms assigned"""
building = Building.query.get_or_404(id)
has_classrooms = Classroom.query.filter(
db.or_(Classroom.building_id == building.id, Classroom.building == building.name)
).count()
if has_classrooms > 0:
flash(f'No se puede eliminar el edificio "{building.name}" porque tiene {has_classrooms} aulas asociadas. Primero reasigna o elimina las aulas.', 'danger')
return redirect(url_for('buildings.view_building', id=building.id))
try:
db.session.delete(building)
db.session.commit()
flash(f'Edificio "{building.name}" eliminado correctamente.', 'success')
except Exception as e:
db.session.rollback()
flash(f'Error al eliminar edificio: {str(e)}', 'danger')
return redirect(url_for('buildings.list_buildings'))
-514
View File
@@ -1,514 +0,0 @@
from flask import Blueprint, render_template, redirect, url_for, flash, request, jsonify
from flask_login import login_required, current_user
from datetime import datetime, date, timezone, timedelta
import calendar
from app.models.classroom import Classroom
from app.models.user import User
from app.forms.classroom import ClassroomForm
from app import db
from sqlalchemy import text
classrooms_bp = Blueprint('classrooms', __name__)
@classrooms_bp.route('/add', methods=['GET', 'POST'])
@login_required
def add_classroom():
"""Add a new classroom with dynamic building creation and floor suggestion"""
from app.models.building import Building
import re
from sqlalchemy import func
form = ClassroomForm()
buildings = Building.query.filter_by(is_active=True).order_by(Building.name.asc()).all()
form.building_id.choices = [(str(b.id), b.name) for b in buildings] + [('__new__', '+ Crear nuevo edificio')]
# Map of existing floors per building for datalist
building_floors = {str(b.id): list(dict.fromkeys(c.floor for c in b.classrooms if c.floor)) for b in buildings}
if form.validate_on_submit():
try:
building = None
if form.building_id.data == '__new__':
new_building_name = form.new_building_name.data.strip() if form.new_building_name.data else ''
if not new_building_name:
flash('Debe ingresar el nombre del nuevo edificio.', 'error')
return render_template('classrooms/add.html', form=form, building_floors=building_floors, title='Add Classroom')
building = Building.query.filter(func.lower(Building.name) == func.lower(new_building_name)).first()
if not building:
code_slug = re.sub(r'[^a-zA-Z0-9]+', '_', new_building_name.upper()).strip('_')
building = Building(name=new_building_name, code=code_slug, is_active=True)
db.session.add(building)
db.session.commit()
else:
building = Building.query.get_or_404(int(form.building_id.data))
room_code = form.room_number.data.strip()
floor_val = str(form.floor.data).strip()
# Prevent duplicate room in same building & floor
existing_classroom = Classroom.query.filter_by(
building_id=building.id,
code=room_code,
floor=floor_val
).first()
if existing_classroom:
flash(f'Ya existe un aula con el nombre "{room_code}" en el piso {floor_val} de {building.name}.', 'error')
return render_template('classrooms/add.html', form=form, building_floors=building_floors, title='Add Classroom')
cap_raw = str(form.capacity.data or '').strip()
if cap_raw in ['∞', 'inf', 'INF', 'Infinity', 'infinity', '0', 'ilimitada', 'Ilimitada', 'sin limite', 'Sin límite']:
cap_val = 9999
else:
cap_val = int(cap_raw)
from app.services.classroom_service import ClassroomService
from app.schemas.classroom_dto import ClassroomCreateDTO
from app.services.audit_service import AuditService
dto = ClassroomCreateDTO(
building_id=building.id,
code=room_code,
floor=floor_val,
capacity=cap_val,
description=form.description.data,
is_active=form.is_active.data
)
classroom_service = ClassroomService()
classroom = classroom_service.create_classroom(dto)
# Registrar en bitácora inmutable de auditoría
AuditService.log('CREATE', 'classrooms', entity_id=classroom.id, details={'code': classroom.code, 'building': building.name})
flash(f'Aula {classroom.location_display} creada exitosamente.', 'success')
return redirect(url_for('classrooms.list_classrooms'))
except ValueError as ve:
flash(str(ve), 'error')
return render_template('classrooms/add.html', form=form, building_floors=building_floors, title='Add Classroom')
except Exception as e:
db.session.rollback()
flash(f'Error al crear el aula: {str(e)}', 'error')
return render_template('classrooms/add.html', form=form, building_floors=building_floors, title='Add Classroom')
@classrooms_bp.route('/', endpoint='index')
@classrooms_bp.route('/list')
@login_required
def list_classrooms():
"""List all classrooms with separation between Physical spaces and Virtual on-demand rooms"""
try:
from app.models.building import Building
from app.models.reservation import Reservation, ReservationStatus
from app.models.subject import Commission, Subject
import calendar
from datetime import date, timedelta
page = request.args.get('page', 1, type=int)
active_only = request.args.get('active_only', 'true').lower() == 'true'
search = request.args.get('search', '', type=str).strip()
building_filter = request.args.get('building_id', '', type=str).strip()
floor_filter = request.args.get('floor', '', type=str).strip()
view_mode = request.args.get('view_mode', '').strip().lower()
# Identificar edificio virtual y aula virtual base
virtual_building = Building.query.filter(
db.or_(Building.code == 'VIRTUAL', Building.name.ilike('%Virtual%'))
).first()
virtual_bldg_id = virtual_building.id if virtual_building else None
# Si el usuario seleccionó "Campus Virtual" en el filtro de edificios, conmutar a pestaña virtual
if building_filter and building_filter == str(virtual_bldg_id):
view_mode = 'virtual'
elif not view_mode:
view_mode = 'physical'
# Fechas operativas (Día, Semana, Mes)
today = datetime.now(timezone.utc).date()
today_start = datetime.combine(today, datetime.min.time())
today_end = datetime.combine(today, datetime.max.time())
week_start = datetime.combine(today - timedelta(days=today.weekday()), datetime.min.time())
week_end = datetime.combine(week_start.date() + timedelta(days=6), datetime.max.time())
_, last_day = calendar.monthrange(today.year, today.month)
month_start = datetime(today.year, today.month, 1, 0, 0, 0)
month_end = datetime(today.year, today.month, last_day, 23, 59, 59)
date_filters = {
'today': today.strftime('%Y-%m-%d'),
'week_start': week_start.strftime('%Y-%m-%d'),
'week_end': week_end.strftime('%Y-%m-%d'),
'month_start': month_start.strftime('%Y-%m-%d'),
'month_end': month_end.strftime('%Y-%m-%d')
}
# --- AULAS FÍSICAS (Presenciales) ---
physical_query = Classroom.query
if virtual_bldg_id:
physical_query = physical_query.filter(Classroom.building_id != virtual_bldg_id)
else:
physical_query = physical_query.filter(~Classroom.code.ilike('%VIRTUAL%'))
if active_only:
physical_query = physical_query.filter_by(is_active=True)
physical_count = physical_query.count()
if building_filter and building_filter.isdigit() and building_filter != str(virtual_bldg_id):
physical_query = physical_query.filter(Classroom.building_id == int(building_filter))
if floor_filter:
flr = floor_filter.strip()
if flr.upper() in ['0', 'PB', 'PLANTA BAJA']:
physical_query = physical_query.filter(db.or_(Classroom.floor == '0', Classroom.floor.ilike('%PB%'), Classroom.floor.ilike('%Planta Baja%')))
else:
physical_query = physical_query.filter(Classroom.floor == flr)
if search and view_mode == 'physical':
physical_query = physical_query.filter(
db.or_(
Classroom.building.ilike(f'%{search}%'),
Classroom.code.ilike(f'%{search}%'),
Classroom.description.ilike(f'%{search}%')
)
)
classrooms = physical_query.order_by(Classroom.building_id.asc(), Classroom.floor.asc(), Classroom.code.asc()).paginate(
page=page, per_page=20, error_out=False
)
# Edificios y Pisos estrictamente físicos para el filtro
buildings = Building.query.filter_by(is_active=True)
if virtual_bldg_id:
buildings = buildings.filter(Building.id != virtual_bldg_id)
buildings = buildings.order_by(Building.name.asc()).all()
floors = [f[0] for f in db.session.query(Classroom.floor).filter(
Classroom.is_active == True,
Classroom.building_id != virtual_bldg_id if virtual_bldg_id else True,
Classroom.floor.isnot(None)
).distinct().order_by(Classroom.floor.asc()).all()]
# Métricas de ocupación física
visible_ids = [c.id for c in classrooms.items]
month_reservations = Reservation.query.filter(
Reservation.classroom_id.in_(visible_ids),
Reservation.start_time >= month_start,
Reservation.start_time <= month_end,
Reservation.status.in_([ReservationStatus.CONFIRMED.value, ReservationStatus.PENDING.value])
).all() if visible_ids else []
DAILY_OP_MINS = 15 * 60
WEEKLY_OP_MINS = 6 * 15 * 60
MONTHLY_OP_MINS = 24 * 15 * 60
occupancy_metrics = {}
for c in classrooms.items:
c_res = [r for r in month_reservations if r.classroom_id == c.id]
day_res = [r for r in c_res if today_start <= r.start_time <= today_end]
day_mins = sum((min(r.end_time, today_end) - max(r.start_time, today_start)).total_seconds() / 60 for r in day_res)
day_pct = min(100, round((day_mins / DAILY_OP_MINS) * 100))
week_res = [r for r in c_res if week_start <= r.start_time <= week_end]
week_mins = sum((min(r.end_time, week_end) - max(r.start_time, week_start)).total_seconds() / 60 for r in week_res)
week_pct = min(100, round((week_mins / WEEKLY_OP_MINS) * 100))
month_mins = sum((min(r.end_time, month_end) - max(r.start_time, month_start)).total_seconds() / 60 for r in c_res)
month_pct = min(100, round((month_mins / MONTHLY_OP_MINS) * 100))
occupancy_metrics[c.id] = {
'day_pct': day_pct,
'day_count': len(day_res),
'week_pct': week_pct,
'week_count': len(week_res),
'month_pct': month_pct,
'month_count': len(c_res)
}
# --- AULAS VIRTUALES (Campus Virtual a Demanda - Infinitas) ---
vc = Classroom.query.filter(
Classroom.building_id == virtual_bldg_id if virtual_bldg_id else Classroom.code.ilike('%VIRTUAL%')
).first()
vc_id = vc.id if vc else 1
all_vres = Reservation.query.filter(Reservation.classroom_id == vc_id).all() if vc_id else []
# Agrupar las salas virtuales por comisión
comm_dict = {}
for r in all_vres:
c = r.commission
cid = c.id if c else 0
if cid not in comm_dict:
vlink = (c.virtual_link if c and c.virtual_link else None) or r.effective_virtual_link
comm_dict[cid] = {
'commission_id': cid,
'commission_code': c.code if c else 'General',
'subject_name': c.subject.name if (c and c.subject) else (r.purpose or 'Clase Virtual'),
'subject_code': c.subject.code if (c and c.subject) else '',
'career_name': c.subject.career.name if (c and c.subject and hasattr(c.subject, 'career') and c.subject.career) else '',
'max_students': c.max_students if c else (r.expected_attendees or 0),
'virtual_link': vlink,
'reservations': []
}
comm_dict[cid]['reservations'].append(r)
if not comm_dict[cid]['virtual_link'] and r.effective_virtual_link:
comm_dict[cid]['virtual_link'] = r.effective_virtual_link
virtual_rooms = []
for cid, data in comm_dict.items():
res_list = data['reservations']
day_cnt = sum(1 for r in res_list if today_start <= r.start_time <= today_end)
week_cnt = sum(1 for r in res_list if week_start <= r.start_time <= week_end)
month_cnt = sum(1 for r in res_list if month_start <= r.start_time <= month_end)
shift = res_list[0].shift if res_list else 'A Demanda'
if search and view_mode == 'virtual':
s_low = search.lower()
matches = (
s_low in data['subject_name'].lower() or
s_low in data['commission_code'].lower() or
s_low in data['subject_code'].lower() or
s_low in data['career_name'].lower()
)
if not matches:
continue
virtual_rooms.append({
'commission_id': data['commission_id'],
'commission_code': data['commission_code'],
'subject_name': data['subject_name'],
'subject_code': data['subject_code'],
'career_name': data['career_name'],
'max_students': data['max_students'],
'virtual_link': data['virtual_link'],
'shift': shift,
'day_count': day_cnt,
'week_count': week_cnt,
'month_count': month_cnt,
'total_count': len(res_list),
'reservations': sorted(res_list, key=lambda x: x.start_time)
})
virtual_rooms.sort(key=lambda x: (x['subject_name'], x['commission_code']))
global_virtual_metrics = {
'today_count': sum(1 for r in all_vres if today_start <= r.start_time <= today_end),
'week_count': sum(1 for r in all_vres if week_start <= r.start_time <= week_end),
'month_count': sum(1 for r in all_vres if month_start <= r.start_time <= month_end),
'total_count': len(all_vres),
'commissions_count': len(comm_dict)
}
return render_template('classrooms/list.html',
classrooms=classrooms,
buildings=buildings,
floors=floors,
building_filter=building_filter,
floor_filter=floor_filter,
active_only=active_only,
search=search,
view_mode=view_mode,
physical_count=physical_count,
virtual_count=len(comm_dict),
virtual_rooms=virtual_rooms,
virtual_classroom_id=vc_id,
global_virtual_metrics=global_virtual_metrics,
occupancy_metrics=occupancy_metrics,
date_filters=date_filters,
title='Classrooms')
except Exception as e:
flash(f'Error loading classrooms: {str(e)}', 'error')
return render_template('classrooms/list.html', classrooms=None, title='Classrooms')
@classrooms_bp.route('/virtual-room/<int:commission_id>/update-link', methods=['POST'])
@login_required
def update_virtual_link(commission_id):
"""Actualizar enlace de videollamada para una comisión virtual"""
from app.models.subject import Commission
from flask_babel import gettext as _
comm = Commission.query.get_or_404(commission_id)
new_link = request.form.get('virtual_link', '').strip() or None
comm.virtual_link = new_link
db.session.commit()
flash(_('Enlace de videollamada para %(code)s actualizado correctamente.', code=comm.get_full_code()), 'success')
return redirect(request.referrer or url_for('classrooms.list_classrooms', view_mode='virtual'))
@classrooms_bp.route('/<int:id>')
@login_required
def view_classroom(id):
"""View classroom details"""
try:
classroom = Classroom.query.get_or_404(id)
from app.models.reservation import Reservation, ReservationStatus
upcoming_reservations = Reservation.query.filter(
Reservation.classroom_id == id,
Reservation.start_time > datetime.now(timezone.utc).replace(tzinfo=None),
Reservation.status == ReservationStatus.CONFIRMED.value
).order_by(Reservation.start_time).limit(10).all()
return render_template('classrooms/view.html',
classroom=classroom,
upcoming_reservations=upcoming_reservations,
title=f'Classroom {classroom.code_display}')
except Exception as e:
flash(f'Error loading classroom: {str(e)}', 'error')
return redirect(url_for('classrooms.list_classrooms'))
@classrooms_bp.route('/<int:id>/edit', methods=['GET', 'POST'])
@login_required
def edit_classroom(id):
"""Edit classroom with decoupled building and floor"""
from app.models.building import Building
import re
from sqlalchemy import func
classroom = Classroom.query.get_or_404(id)
form = ClassroomForm(obj=classroom)
buildings = Building.query.filter_by(is_active=True).order_by(Building.name.asc()).all()
form.building_id.choices = [(str(b.id), b.name) for b in buildings] + [('__new__', '+ Crear nuevo edificio')]
building_floors = {str(b.id): list(dict.fromkeys(c.floor for c in b.classrooms if c.floor)) for b in buildings}
if request.method == 'GET':
form.building_id.data = str(classroom.building_id or '')
form.room_number.data = classroom.code
form.floor.data = classroom.floor
if classroom.capacity == 0 or classroom.is_virtual:
form.capacity.data = '∞'
else:
form.capacity.data = str(classroom.capacity)
if form.validate_on_submit():
try:
building = None
if form.building_id.data == '__new__':
new_building_name = form.new_building_name.data.strip() if form.new_building_name.data else ''
if not new_building_name:
flash('Debe ingresar el nombre del nuevo edificio.', 'error')
return render_template('classrooms/edit.html', form=form, classroom=classroom, building_floors=building_floors, title='Edit Classroom')
building = Building.query.filter(func.lower(Building.name) == func.lower(new_building_name)).first()
if not building:
code_slug = re.sub(r'[^a-zA-Z0-9]+', '_', new_building_name.upper()).strip('_')
building = Building(name=new_building_name, code=code_slug, is_active=True)
db.session.add(building)
db.session.commit()
else:
building = Building.query.get_or_404(int(form.building_id.data))
room_code = form.room_number.data.strip()
floor_val = str(form.floor.data).strip()
# Check duplicate excluding current
existing_classroom = Classroom.query.filter(
Classroom.building_id == building.id,
Classroom.code == room_code,
Classroom.floor == floor_val,
Classroom.id != id
).first()
if existing_classroom:
flash(f'Ya existe otra aula con el nombre "{room_code}" en el piso {floor_val} de {building.name}.', 'error')
return render_template('classrooms/edit.html', form=form, classroom=classroom, building_floors=building_floors, title='Edit Classroom')
cap_raw = str(form.capacity.data or '').strip()
if cap_raw in ['∞', 'inf', 'INF', 'Infinity', 'infinity', '0', 'ilimitada', 'Ilimitada', 'sin limite', 'Sin límite']:
cap_val = 0
else:
cap_val = int(cap_raw)
classroom.building_id = building.id
classroom.building = building.name
classroom.code = room_code
classroom.floor = floor_val
classroom.capacity = cap_val
classroom.description = form.description.data
classroom.is_active = form.is_active.data
classroom.updated_at = datetime.now(timezone.utc).replace(tzinfo=None)
db.session.commit()
flash(f'Aula {classroom.location_display} actualizada correctamente.', 'success')
return redirect(url_for('classrooms.view_classroom', id=classroom.id))
except Exception as e:
db.session.rollback()
flash(f'Error updating classroom: {str(e)}', 'error')
return render_template('classrooms/edit.html', form=form, classroom=classroom, building_floors=building_floors, title='Edit Classroom')
@classrooms_bp.route('/<int:id>/toggle', methods=['POST'])
@login_required
def toggle_classroom(id):
"""Toggle classroom active status"""
classroom = Classroom.query.get_or_404(id)
try:
classroom.is_active = not classroom.is_active
classroom.updated_at = datetime.now(timezone.utc).replace(tzinfo=None)
db.session.commit()
status = 'activated' if classroom.is_active else 'deactivated'
flash(f'Classroom {classroom.code_display} has been {status} successfully!', 'success')
except Exception as e:
db.session.rollback()
flash(f'Error updating classroom status: {str(e)}', 'error')
return redirect(request.referrer or url_for('classrooms.list_classrooms'))
# API endpoints for AJAX requests
@classrooms_bp.route('/api/available')
@login_required
def get_available_classrooms():
"""Get available classrooms for a specific time slot"""
start_time = request.args.get('start_time')
end_time = request.args.get('end_time')
if not start_time or not end_time:
return jsonify({'error': 'Start time and end time are required'}), 400
try:
from datetime import datetime
from app.models.reservation import Reservation, ReservationStatus
start_dt = datetime.fromisoformat(start_time)
end_dt = datetime.fromisoformat(end_time)
# Find all classrooms
all_classrooms = Classroom.query.filter_by(is_active=True).all()
available_classrooms = []
for classroom in all_classrooms:
# Check if classroom has conflicting reservations
conflicts = Reservation.query.filter(
Reservation.classroom_id == classroom.id,
Reservation.status == ReservationStatus.CONFIRMED.value,
Reservation.start_time < end_dt,
Reservation.end_time > start_dt
).all()
if not conflicts:
available_classrooms.append({
'id': classroom.id,
'code': classroom.code,
'building': classroom.building,
'room_number': classroom.code,
'floor': classroom.floor,
'capacity': classroom.capacity,
'code_display': classroom.code_display
})
return jsonify({'classrooms': available_classrooms})
except Exception as e:
return jsonify({'error': str(e)}), 500
-299
View File
@@ -1,299 +0,0 @@
from flask import Blueprint, request, jsonify, current_app, render_template, g
from datetime import datetime, timedelta
from app.models.genetic_algorithm import ReservationOptimizer
from app.models.reservation import Reservation, ReservationStatus
from app import db
from app.services.audit_service import AuditService
from app.utils.jwt_decorators import jwt_required
genetic_bp = Blueprint('genetic_algorithm', __name__, url_prefix='/api/genetic')
def check_optimizer_permission(user, requires_write=False):
"""
Verifica si el usuario tiene permiso para consultar o ejecutar el optimizador de reservas.
Permitido para Administradores, Bedelía, Docentes o usuarios con permisos RBAC en 'optimizer'.
"""
if not user:
return False
# 1. Administrador (método o rol)
if hasattr(user, 'is_admin') and user.is_admin():
return True
role = (getattr(user, 'role', '') or '').strip().lower()
if role in ['admin', 'administrador', 'bedelia']:
return True
if role in ['docente', 'teacher']:
return True
# 2. RBAC granular
if hasattr(user, 'has_permission'):
if requires_write:
return user.has_permission('optimizer', 'read_write')
return user.has_permission('optimizer', 'read') or user.has_permission('optimizer', 'read_write')
return False
@genetic_bp.route('/optimize', methods=['POST'])
@jwt_required
def optimize_reservations():
"""Optimize reservations using genetic algorithm"""
try:
data = request.get_json()
if not data or 'commission_ids' not in data:
return jsonify({'error': 'Missing commission_ids in request'}), 400
commission_ids = data['commission_ids']
if not isinstance(commission_ids, list) or not commission_ids:
return jsonify({'error': 'commission_ids must be a non-empty list'}), 400
# Optional parameters
start_date = None
end_date = None
if 'start_date' in data:
try:
start_date = datetime.fromisoformat(data['start_date'])
except ValueError:
return jsonify({'error': 'Invalid start_date format. Use ISO format.'}), 400
if 'end_date' in data:
try:
end_date = datetime.fromisoformat(data['end_date'])
except ValueError:
return jsonify({'error': 'Invalid end_date format. Use ISO format.'}), 400
# Check if user has permission (admin, bedelia, teacher or RBAC optimizer write)
if not check_optimizer_permission(g.jwt_user, requires_write=True):
return jsonify({'error': 'Insufficient permissions to optimize reservations'}), 403
# Initialize optimizer and run optimization
optimizer = ReservationOptimizer()
result = optimizer.optimize_schedule(
commission_ids=commission_ids,
admin_user_id=g.jwt_user.id,
start_date=start_date,
end_date=end_date
)
AuditService.log(
action='OPTIMIZE_RUN',
module='optimizer',
user=g.jwt_user,
details=f"Ejecución de algoritmo genético para {len(commission_ids)} comisiones. Fitness: {result.get('fitness_score', 0)}% (Asignadas: {len(result.get('assigned_reservations', []))})"
)
return jsonify({
'success': True,
'data': {
'fitness_score': result['fitness_score'],
'total_requests': result['total_requests'],
'assigned_reservations': result['assigned_reservations'],
'reservations': result['reservations'],
'conflicts': result['conflicts']
}
}), 200
except Exception as e:
current_app.logger.error(f"Error in genetic algorithm optimization: {str(e)}")
return jsonify({'error': f'Optimization failed: {str(e)}'}), 500
@genetic_bp.route('/apply-optimization', methods=['POST'])
@jwt_required
def apply_optimization():
"""Apply optimized reservations to the database"""
try:
data = request.get_json()
if not data or 'reservations' not in data:
return jsonify({'error': 'Missing reservations data'}), 400
reservations_data = data['reservations']
if not isinstance(reservations_data, list):
return jsonify({'error': 'reservations must be a list'}), 400
# Check if user has permission
if not check_optimizer_permission(g.jwt_user, requires_write=True):
return jsonify({'error': 'Insufficient permissions to apply reservations'}), 403
# Initialize optimizer and apply reservations
optimizer = ReservationOptimizer()
applied_reservations = optimizer.apply_optimized_reservations(reservations_data)
AuditService.log(
action='OPTIMIZE_APPLY',
module='optimizer',
user=g.jwt_user,
details=f"Consolidación de optimizador genético: {len(applied_reservations)} reservas aplicadas en base de datos."
)
return jsonify({
'success': True,
'data': {
'applied_count': len(applied_reservations),
'reservations': [res.to_dict() for res in applied_reservations]
}
}), 200
except Exception as e:
current_app.logger.error(f"Error applying optimized reservations: {str(e)}")
db.session.rollback()
return jsonify({'error': f'Failed to apply reservations: {str(e)}'}), 500
@genetic_bp.route('/preview-optimization', methods=['POST'])
@jwt_required
def preview_optimization():
"""Preview optimization without applying to database"""
try:
data = request.get_json()
if not data or 'commission_ids' not in data:
return jsonify({'error': 'Missing commission_ids in request'}), 400
commission_ids = data['commission_ids']
# Optional parameters
dry_run = data.get('dry_run', True) # Default to dry run
if not isinstance(commission_ids, list) or not commission_ids:
return jsonify({'error': 'commission_ids must be a non-empty list'}), 400
# Check if user has permission
if not check_optimizer_permission(g.jwt_user, requires_write=False):
return jsonify({'error': 'Insufficient permissions to preview optimization'}), 403
# Initialize optimizer and run optimization
optimizer = ReservationOptimizer()
result = optimizer.optimize_schedule(
commission_ids=commission_ids,
admin_user_id=g.jwt_user.id
)
# Add additional preview information
preview_data = {
'optimization_result': result,
'commission_details': [],
'classroom_utilization': {},
'time_distribution': {}
}
# Get commission details
from app.models.subject import Commission, Subject
commissions = Commission.query.filter(Commission.id.in_(commission_ids)).all()
for commission in commissions:
preview_data['commission_details'].append({
'id': commission.id,
'code': commission.get_full_code(),
'name': commission.subject.name if commission.subject else 'Unknown',
'max_students': commission.max_students,
'current_students': commission.current_students
})
return jsonify({
'success': True,
'data': preview_data
}), 200
except Exception as e:
current_app.logger.error(f"Error in optimization preview: {str(e)}")
return jsonify({'error': f'Preview failed: {str(e)}'}), 500
@genetic_bp.route('/commissions', methods=['GET'])
@jwt_required
def get_commissions():
"""Get available commissions for optimization"""
try:
# Check if user has permission
if not check_optimizer_permission(g.jwt_user, requires_write=False):
return jsonify({'error': 'Insufficient permissions'}), 403
from app.models.subject import Commission, Subject
# Get active commissions
commissions = Commission.query.filter_by(active=True).all()
commissions_data = []
for commission in commissions:
commission_dict = commission.to_dict()
commission_dict['get_full_code'] = commission.get_full_code()
commission_dict['subject_name'] = commission.subject.name if commission.subject else 'Sin Asignatura'
commission_dict['subject_code'] = commission.subject.code if commission.subject else ''
commissions_data.append(commission_dict)
return jsonify({
'success': True,
'commissions': commissions_data
}), 200
except Exception as e:
current_app.logger.error(f"Error getting commissions: {str(e)}")
return jsonify({'error': f'Failed to load commissions: {str(e)}'}), 500
@genetic_bp.route('/algorithm-status', methods=['GET'])
@jwt_required
def get_algorithm_status():
"""Get genetic algorithm configuration status"""
try:
# Check if user has permission
if not check_optimizer_permission(g.jwt_user, requires_write=False):
return jsonify({'error': 'Insufficient permissions'}), 403
# Get system status
from app.models.classroom import Classroom
from app.models.subject import Commission
total_classrooms = Classroom.query.filter_by(is_active=True).count()
total_commissions = Commission.query.filter_by(active=True).count()
total_reservations = Reservation.query.filter_by(status=ReservationStatus.CONFIRMED.value).count()
return jsonify({
'success': True,
'data': {
'algorithm_config': {
'population_size': 50,
'generations': 100,
'mutation_rate': 0.1,
'crossover_rate': 0.8
},
'system_status': {
'available_classrooms': total_classrooms,
'active_commissions': total_commissions,
'confirmed_reservations': total_reservations
},
'capabilities': [
'Automatic classroom assignment',
'Capacity optimization',
'Time conflict resolution',
'Resource matching',
'Batch reservation processing'
]
}
}), 200
except Exception as e:
current_app.logger.error(f"Error getting algorithm status: {str(e)}")
return jsonify({'error': f'Status check failed: {str(e)}'}), 500
# Web interface route (without API prefix)
genetic_web_bp = Blueprint('genetic_algorithm_web', __name__)
@genetic_web_bp.route('/genetic-optimizer')
@jwt_required
def genetic_optimizer():
"""Render the genetic algorithm optimizer interface"""
if not check_optimizer_permission(g.jwt_user, requires_write=False):
return render_template('auth/403.html'), 403
return render_template('genetic_optimizer.html')
-335
View File
@@ -1,335 +0,0 @@
from flask import Blueprint, render_template, jsonify, redirect, url_for, session, request, flash
from flask_login import login_required, current_user
from app import db
from app.models.reservation import Reservation
from app.models.classroom import Classroom
from app.models.subject import Subject
from app.models.subject import Commission
from datetime import datetime, timedelta, timezone
from sqlalchemy import func
from flask_babel import gettext as _
main_bp = Blueprint('main', __name__)
@main_bp.route('/')
@login_required
def dashboard():
"""Role-personalized institutional dashboard page"""
from app.models.user import User
from app.models.milestone import AcademicMilestone
from app.models.audit_log import AuditLog
actual_role = current_user.get_institutional_role()
view_as = request.args.get('view_as', '').lower().strip()
# Allow admins and management roles to preview dashboard perspectives
if view_as in ['admin', 'bedelia', 'docente', 'alumno'] and (current_user.is_admin() or current_user.can_manage()):
role = view_as
else:
role = actual_role
today = datetime.now(timezone.utc).date()
# Common core statistics
try:
total_classrooms = Classroom.query.filter_by(is_active=True).count()
except Exception:
total_classrooms = 0
try:
total_subjects = Subject.query.filter_by(is_active=True).count()
except Exception:
total_subjects = 0
try:
today_reservations = Reservation.query.filter(
func.date(Reservation.start_time) == today
).count()
except Exception:
today_reservations = 0
week_start = today - timedelta(days=today.weekday())
week_end = week_start + timedelta(days=6)
try:
week_reservations = Reservation.query.filter(
func.date(Reservation.start_time) >= week_start,
func.date(Reservation.start_time) <= week_end
).count()
except Exception:
week_reservations = 0
stats = {
'total_classrooms': total_classrooms,
'total_subjects': total_subjects,
'today_reservations': today_reservations,
'week_reservations': week_reservations
}
role_data = {}
if role == 'admin':
# 1. Admin Institutional Cockpit
try:
total_users = User.query.filter_by(is_active=True).count()
except Exception:
total_users = 0
try:
pending_count = Reservation.query.filter(
Reservation.status == 'PENDING'
).count()
except Exception:
pending_count = 0
try:
recent_audits = AuditLog.query.order_by(AuditLog.created_at.desc()).limit(6).all()
except Exception:
recent_audits = []
try:
now_dt = datetime.now(timezone.utc).replace(tzinfo=None)
upcoming_reservations = Reservation.query.filter(
Reservation.start_time >= now_dt,
Reservation.start_time <= now_dt + timedelta(days=7)
).order_by(Reservation.start_time.asc()).limit(8).all()
except Exception:
upcoming_reservations = []
stats.update({
'total_users': total_users,
'pending_reservations': pending_count
})
role_data = {
'recent_audits': recent_audits,
'upcoming_reservations': upcoming_reservations
}
elif role == 'bedelia':
# 2. Bedelía Operations & Facilities Control
try:
physical_classrooms = Classroom.query.filter_by(is_active=True).filter(
~Classroom.room_number.ilike('%VIRTUAL%') & ~Classroom.building.ilike('%VIRTUAL%')
).count()
virtual_classrooms = total_classrooms - physical_classrooms
if virtual_classrooms < 0:
virtual_classrooms = 0
except Exception:
physical_classrooms = total_classrooms
virtual_classrooms = 0
try:
pending_reservations = Reservation.query.filter(
Reservation.status == 'PENDING'
).order_by(Reservation.start_time.asc()).limit(10).all()
pending_count = len(pending_reservations)
except Exception:
pending_reservations = []
pending_count = 0
try:
today_schedule_list = Reservation.query.filter(
func.date(Reservation.start_time) == today
).order_by(Reservation.start_time.asc()).limit(12).all()
except Exception:
today_schedule_list = []
occupancy_rate = min(100, int((today_reservations / max(1, physical_classrooms * 3)) * 100)) if physical_classrooms > 0 else 0
stats.update({
'physical_classrooms': physical_classrooms,
'virtual_classrooms': virtual_classrooms,
'pending_count': pending_count,
'occupancy_rate': occupancy_rate
})
role_data = {
'pending_reservations': pending_reservations,
'today_schedule_list': today_schedule_list
}
elif role == 'docente':
# 3. Docente (Profesor) Academic & Classroom Workflow
try:
my_today_classes = Reservation.query.filter(
Reservation.user_id == current_user.id,
func.date(Reservation.start_time) == today
).order_by(Reservation.start_time.asc()).all()
except Exception:
my_today_classes = []
try:
my_upcoming_reservations = Reservation.query.filter(
Reservation.user_id == current_user.id,
Reservation.start_time >= datetime.now(timezone.utc).replace(tzinfo=None)
).order_by(Reservation.start_time.asc()).limit(8).all()
except Exception:
my_upcoming_reservations = []
try:
my_total_reservations = Reservation.query.filter(
Reservation.user_id == current_user.id
).count()
except Exception:
my_total_reservations = 0
try:
virtual_classrooms = Classroom.query.filter_by(is_active=True).filter(
(Classroom.room_number.ilike('%VIRTUAL%')) | (Classroom.building.ilike('%VIRTUAL%'))
).limit(4).all()
except Exception:
virtual_classrooms = []
stats.update({
'my_today_count': len(my_today_classes),
'my_total_reservations': my_total_reservations,
'virtual_rooms_count': len(virtual_classrooms)
})
role_data = {
'my_today_classes': my_today_classes,
'my_upcoming_reservations': my_upcoming_reservations,
'virtual_classrooms': virtual_classrooms
}
elif role == 'alumno':
# 4. Alumno (Estudiante) Daily Guide & Timetable
try:
today_classes = Reservation.query.filter(
func.date(Reservation.start_time) == today,
Reservation.status == 'CONFIRMED'
).order_by(Reservation.start_time.asc()).limit(12).all()
except Exception:
today_classes = []
try:
upcoming_milestones = AcademicMilestone.query.filter(
AcademicMilestone.date >= datetime.now(timezone.utc).replace(tzinfo=None),
AcademicMilestone.is_active == True
).order_by(AcademicMilestone.date.asc()).limit(6).all()
except Exception:
upcoming_milestones = []
try:
virtual_rooms = Classroom.query.filter_by(is_active=True).filter(
(Classroom.room_number.ilike('%VIRTUAL%')) | (Classroom.building.ilike('%VIRTUAL%'))
).limit(4).all()
except Exception:
virtual_rooms = []
stats.update({
'today_classes_count': len(today_classes),
'milestones_count': len(upcoming_milestones)
})
role_data = {
'today_classes': today_classes,
'upcoming_milestones': upcoming_milestones,
'virtual_rooms': virtual_rooms
}
# Backward compatibility for upcoming_reservations
upcoming_reservations = role_data.get('upcoming_reservations', [])
if not upcoming_reservations:
try:
now_dt = datetime.now(timezone.utc).replace(tzinfo=None)
upcoming_reservations = Reservation.query.filter(
Reservation.start_time >= now_dt,
Reservation.start_time <= now_dt + timedelta(days=7)
).order_by(Reservation.start_time.asc()).limit(6).all()
except Exception:
upcoming_reservations = []
return render_template('dashboard.html',
role=role,
actual_role=actual_role,
stats=stats,
role_data=role_data,
upcoming_reservations=upcoming_reservations)
@main_bp.route('/api/dashboard-stats')
@login_required
def dashboard_stats_api():
"""API endpoint for dashboard statistics"""
# Get today's data
today = datetime.now(timezone.utc).date()
today_reservations = Reservation.query.filter(
func.date(Reservation.start_time) == today
).count()
# Get this week's data
week_start = today - timedelta(days=today.weekday())
week_end = week_start + timedelta(days=6)
week_reservations = Reservation.query.filter(
func.date(Reservation.start_time) >= week_start,
func.date(Reservation.start_time) <= week_end
).count()
# Get monthly data for chart
current_date = datetime.now(timezone.utc).replace(tzinfo=None)
monthly_data = []
for i in range(12):
month_date = current_date - timedelta(days=30 * i)
month_start = month_date.replace(day=1)
month_end = (month_start + timedelta(days=32)).replace(day=1) - timedelta(days=1)
monthly_reservations = Reservation.query.filter(
func.date(Reservation.start_time) >= month_start.date(),
func.date(Reservation.start_time) <= month_end.date()
).count()
monthly_data.append({
'month': month_start.strftime('%Y-%m'),
'reservations': monthly_reservations
})
return jsonify({
'today_reservations': today_reservations,
'week_reservations': week_reservations,
'monthly_data': list(reversed(monthly_data))
})
@main_bp.route('/genetic-optimizer')
@login_required
def genetic_optimizer():
"""Serve the genetic algorithm optimization interface"""
if not (current_user.has_permission('optimizer', 'read') or (current_user.role and current_user.role.upper() == 'ADMIN')):
flash(_('No tienes permisos para acceder a la herramienta de optimización.'), 'danger')
return redirect(url_for('main.dashboard'))
return render_template('genetic_optimizer.html')
@main_bp.route('/set_language/<language>')
def set_language(language=None):
if language not in ['en', 'es']:
language = 'es'
session['language'] = language
# Si se selecciona el idioma desde la pantalla de login, registrar la selección explícita
if request.referrer and 'login' in request.referrer:
session['login_lang_explicit'] = language
if current_user.is_authenticated:
current_user.preferred_language = language
db.session.commit()
return redirect(request.referrer or url_for('main.dashboard'))
@main_bp.route('/api/milestone-types')
def api_milestone_types():
"""Retorna las tipificaciones de hitos activas en JSON para consumo de frontend/mobile"""
from app.models.milestone import MilestoneType, BASE_MILESTONE_TYPES
if MilestoneType.query.count() == 0:
for item in BASE_MILESTONE_TYPES:
mt = MilestoneType(
name=item['name'],
code=item['code'],
color=item['color'],
description=item['description'],
sort_order=item['sort_order'],
is_active=True
)
db.session.add(mt)
db.session.commit()
types = MilestoneType.query.filter_by(is_active=True).order_by(MilestoneType.sort_order.asc(), MilestoneType.id.asc()).all()
return jsonify([t.to_dict() for t in types])
-126
View File
@@ -1,126 +0,0 @@
from flask import Blueprint, render_template, abort
from flask_login import login_required, current_user
from app import db
from app.models.subject import Commission
from app.models.enrollment import StudentEnrollment
from app.models.classroom import Classroom
my_subjects_bp = Blueprint('my_subjects', __name__, url_prefix='/mis-materias')
@my_subjects_bp.route('/')
@login_required
def my_subjects_list():
"""Show the commissions assigned to the current user (teacher or student)."""
role = current_user.get_institutional_role()
commissions = []
if role in ['admin', 'bedelia']:
# Admin/Bedelia: see all active commissions
commissions = (
Commission.query
.filter_by(active=True)
.order_by(Commission.year.desc(), Commission.semester.asc(), Commission.code.asc())
.all()
)
view_mode = 'all'
elif role == 'docente':
# Teacher: only commissions where they are assigned as teacher
commissions = (
Commission.query
.filter_by(teacher_id=current_user.id, active=True)
.order_by(Commission.year.desc(), Commission.semester.asc(), Commission.code.asc())
.all()
)
view_mode = 'teacher'
elif role == 'alumno':
# Student: only commissions where they are enrolled
enrollments = (
StudentEnrollment.query
.filter_by(student_id=current_user.id, status='activo')
.all()
)
commission_ids = [e.commission_id for e in enrollments]
commissions = (
Commission.query
.filter(Commission.id.in_(commission_ids), Commission.active == True)
.order_by(Commission.year.desc(), Commission.semester.asc(), Commission.code.asc())
.all()
)
view_mode = 'student'
else:
commissions = []
view_mode = 'none'
return render_template(
'my_subjects/list.html',
commissions=commissions,
view_mode=view_mode,
role=role
)
@my_subjects_bp.route('/<int:commission_id>')
@login_required
def my_subject_detail(commission_id):
"""Detail view of a single commission for the current user."""
role = current_user.get_institutional_role()
commission = Commission.query.get_or_404(commission_id)
# Access control: make sure the user is allowed to see this commission
if role in ['admin', 'bedelia']:
pass # full access
elif role == 'docente':
if commission.teacher_id != current_user.id:
abort(403)
elif role == 'alumno':
enrollment = StudentEnrollment.query.filter_by(
student_id=current_user.id,
commission_id=commission_id
).first()
if not enrollment:
abort(403)
else:
abort(403)
# Get enrolled students (visible to teachers and admin/bedelia)
enrollments = []
if role in ['admin', 'bedelia', 'docente']:
enrollments = (
StudentEnrollment.query
.filter_by(commission_id=commission_id)
.order_by(StudentEnrollment.enrolled_at.asc())
.all()
)
# Try to get classroom info from reservations linked to this commission
from app.models.reservation import Reservation
from sqlalchemy import func
from datetime import datetime, timezone
# Recent or upcoming reservation linked to this commission
recent_reservation = (
Reservation.query
.filter(
Reservation.commission_id == commission_id,
Reservation.start_time >= datetime.now(timezone.utc).replace(tzinfo=None)
)
.order_by(Reservation.start_time.asc())
.first()
)
classroom = None
if recent_reservation and recent_reservation.classroom_id:
classroom = Classroom.query.get(recent_reservation.classroom_id)
return render_template(
'my_subjects/detail.html',
commission=commission,
enrollments=enrollments,
classroom=classroom,
recent_reservation=recent_reservation,
role=role
)
-977
View File
@@ -1,977 +0,0 @@
from flask import Blueprint, render_template, request, redirect, url_for, flash, jsonify
from flask_login import login_required, current_user
from flask_babel import gettext as _
from app import db
from app.models.reservation import Reservation, ReservationStatus
from app.models.classroom import Classroom
from app.models.subject import Subject, Commission
from app.forms.reservation import ReservationForm
from datetime import datetime, timedelta, date, timezone
from typing import Dict, Any
from sqlalchemy import func, or_
from sqlalchemy.orm import joinedload
schedule_bp = Blueprint('schedule', __name__, url_prefix='/schedule')
@schedule_bp.route('/today')
@login_required
def today_schedule():
"""Show today's schedule with filters for virtual classrooms, floor, and shift"""
today = datetime.now(timezone.utc).date()
today_start = datetime.combine(today, datetime.min.time())
today_end = datetime.combine(today, datetime.max.time())
hide_virtual = request.args.get('hide_virtual', '0') in ['1', 'true', 'True']
floor_filter = request.args.get('floor', '').strip()
shift_filter = request.args.get('shift', '').strip()
# Base query for today's reservations
query = Reservation.query.options(
joinedload(Reservation.classroom),
joinedload(Reservation.commission),
joinedload(Reservation.user)
).join(Reservation.classroom).filter(
Reservation.start_time >= today_start,
Reservation.start_time <= today_end,
Reservation.status.in_([ReservationStatus.CONFIRMED.value, ReservationStatus.PENDING.value])
)
if hide_virtual:
query = query.filter(
~Classroom.code.ilike('%VIRTUAL%'),
~Classroom.building.ilike('%Virtual%')
)
if floor_filter:
flr = floor_filter.strip()
if flr.upper() in ['0', 'PB', 'PLANTA BAJA']:
query = query.filter(or_(Classroom.floor == '0', Classroom.floor.ilike('%PB%'), Classroom.floor.ilike('%Planta Baja%')))
else:
query = query.filter(Classroom.floor == flr)
if shift_filter:
query = query.filter(Reservation.shift.ilike(f'%{shift_filter}%'))
reservations = query.order_by(Reservation.start_time).all()
# Create time blocks for timeline view
time_blocks = {}
for reservation in reservations:
start_hour = reservation.start_time.hour
end_hour = reservation.end_time.hour
for hour in range(max(7, start_hour), min(22, end_hour + 1)):
if hour not in time_blocks:
time_blocks[hour] = []
if reservation not in time_blocks[hour]:
time_blocks[hour].append({
'reservation': reservation,
'classroom': reservation.classroom,
'commission': reservation.commission,
'user': reservation.user
})
# Calculate stats
total_reservations = len(reservations)
confirmed = len([r for r in reservations if r.status == ReservationStatus.CONFIRMED.value or str(r.status) == 'CONFIRMED'])
pending = len([r for r in reservations if r.status == ReservationStatus.PENDING or str(r.status) == 'PENDING'])
total_classrooms = Classroom.query.count()
occupied_classrooms = len(set(r.classroom_id for r in reservations if r.classroom_id))
stats = {
'total_reservations': total_reservations,
'confirmed': confirmed,
'pending': pending,
'occupied_classrooms': occupied_classrooms,
'total_classrooms': total_classrooms
}
floors = db.session.query(Classroom.floor).filter(Classroom.is_active==True, Classroom.floor.isnot(None)).distinct().order_by(Classroom.floor.asc()).all()
available_floors = [f[0] for f in floors]
return render_template('schedule/today.html',
reservations=reservations,
time_blocks=time_blocks,
stats=stats,
today=today,
hide_virtual=hide_virtual,
floor_filter=floor_filter,
shift_filter=shift_filter,
available_floors=available_floors)
@schedule_bp.route('/cancel/<int:id>', methods=['POST'])
@login_required
def cancel_reservation(id):
"""Cancel a reservation"""
try:
reservation = Reservation.query.get_or_404(id)
if not reservation.can_be_cancelled():
flash('Reservations can only be cancelled at least 24 hours before start time.', 'error')
return redirect(request.referrer)
reservation.status = ReservationStatus.CANCELLED
db.session.commit()
flash('Reservation cancelled successfully!', 'success')
except Exception as e:
db.session.rollback()
flash(f'Error cancelling reservation: {str(e)}', 'error')
return redirect(request.referrer)
@schedule_bp.route('/reservation/<int:id>/view')
@login_required
def view_reservation(id):
"""View reservation details"""
try:
reservation = Reservation.query.options(
joinedload(Reservation.classroom),
joinedload(Reservation.commission),
joinedload(Reservation.user)
).get_or_404(id)
return render_template('schedule/view.html',
reservation=reservation,
title='Reservation Details')
except Exception as e:
flash(f'Error loading reservation details: {str(e)}', 'error')
return redirect(url_for('schedule.today_schedule'))
@schedule_bp.route('/reservation/<int:id>/edit', methods=['GET', 'POST'])
@login_required
def edit_reservation(id):
"""Edit existing reservation"""
from app.models.classroom import Classroom
from app.models.subject import Commission
from app.models.building import Building
from flask_babel import gettext as _
reservation = Reservation.query.options(
joinedload(Reservation.classroom),
joinedload(Reservation.commission),
joinedload(Reservation.user)
).get_or_404(id)
if not current_user.can_edit_reservation(reservation):
flash(_('No tienes los permisos necesarios para modificar esta reserva.'), 'error')
return redirect(url_for('schedule.view_reservation', id=reservation.id))
form = ReservationForm(is_edit=True)
buildings = Building.query.filter_by(is_active=True).order_by(Building.name.asc()).all()
classrooms = Classroom.query.filter_by(is_active=True).order_by(Classroom.building_id.asc(), Classroom.floor.asc(), Classroom.code.asc()).all()
commissions = Commission.query.filter_by(active=True).all()
form.classroom_id.choices = [(c.id, f'{c.building_name} - {c.code} (Cap: {c.capacity_display})') for c in classrooms]
form.commission_id.choices = [(c.id, f'{c.get_full_code()} - {c.subject.name if c.subject else "No Subject"} (Students: {c.max_students})') for c in commissions]
if request.method == 'GET':
form.classroom_id.data = reservation.classroom_id
form.commission_id.data = reservation.commission_id
form.start_time.data = reservation.start_time
form.end_time.data = reservation.end_time
form.purpose.data = reservation.purpose
form.expected_attendees.data = reservation.expected_attendees
form.notes.data = reservation.notes or ''
form.virtual_link.data = reservation.virtual_link or ''
elif request.method == 'POST':
if form.validate_on_submit():
try:
# Verificar colisión de horario si no es virtual
target_room = Classroom.query.get(form.classroom_id.data)
if target_room and not target_room.is_virtual:
conflict = Reservation.query.filter(
Reservation.id != reservation.id,
Reservation.classroom_id == form.classroom_id.data,
Reservation.status == ReservationStatus.CONFIRMED.value,
Reservation.start_time < form.end_time.data,
Reservation.end_time > form.start_time.data
).first()
if conflict:
flash(_('El aula seleccionada ya cuenta con una reserva confirmada en esa franja horaria.'), 'danger')
return render_template('schedule/edit.html', form=form, reservation=reservation, classroom_list=classrooms, commission_list=commissions, buildings=buildings)
# Asignar cambios
reservation.classroom_id = form.classroom_id.data
reservation.commission_id = form.commission_id.data
reservation.start_time = form.start_time.data
reservation.end_time = form.end_time.data
reservation.purpose = form.purpose.data
reservation.expected_attendees = form.expected_attendees.data
reservation.notes = form.notes.data
reservation.virtual_link = form.virtual_link.data.strip() if form.virtual_link.data else None
# Turno
h = reservation.start_time.hour
if h < 13:
reservation.shift = 'Mañana'
elif h < 18:
reservation.shift = 'Tarde'
elif h < 21:
reservation.shift = 'Vespertino'
else:
reservation.shift = 'Noche'
db.session.commit()
flash(_('Reserva #%(id)d modificada exitosamente.', id=reservation.id), 'success')
return redirect(url_for('schedule.view_reservation', id=reservation.id))
except Exception as e:
db.session.rollback()
flash(f'Error al modificar reserva: {str(e)}', 'danger')
return render_template('schedule/edit.html', form=form, reservation=reservation, classroom_list=classrooms, commission_list=commissions, buildings=buildings)
@schedule_bp.route('/calendar')
@login_required
def calendar_view():
"""Show calendar view with classroom, subject, career, shift, floor and virtual filtering"""
from app.models.career import Career
from app.models.building import Building
classrooms = Classroom.query.filter_by(is_active=True).order_by(Classroom.building.asc(), Classroom.code.asc()).all()
subjects = Subject.query.filter_by(is_active=True).order_by(Subject.name.asc()).all()
careers = Career.query.order_by(Career.name.asc()).all()
buildings = Building.query.filter_by(is_active=True).order_by(Building.name.asc()).all()
floors = db.session.query(Classroom.floor).filter(Classroom.is_active==True, Classroom.floor.isnot(None)).distinct().order_by(Classroom.floor.asc()).all()
available_floors = [f[0] for f in floors]
return render_template(
'schedule/calendar.html',
title='Calendar View',
today_date=date.today().isoformat(),
classrooms=classrooms,
subjects=subjects,
careers=careers,
buildings=buildings,
available_floors=available_floors
)
def user_can_manage_commission_milestones(user, commission=None):
"""Verifica si el usuario (Docente, Admin, Bedelía) puede gestionar hitos y links virtuales"""
if user.is_admin():
return True
role_name = (user.role_obj.name if user.role_obj else user.role or '').lower()
if role_name in ['admin', 'bedelia', 'bedelía', 'operador']:
return True
if role_name in ['docente', 'profesor']:
return True
return user.has_permission('schedule', 'read_write')
@schedule_bp.route('/commissions')
@login_required
def commissions_view():
"""Vista y ABM de Comisiones con soporte de enlace virtual e hitos académicos"""
from app.models.subject import Commission, Subject
from app.models.classroom import Classroom
from app.models.user import User
from app.models.milestone import MilestoneType
subjects = Subject.query.order_by(Subject.code.asc()).all()
classrooms = Classroom.query.filter_by(is_active=True).order_by(Classroom.code.asc()).all()
teachers = User.query.filter_by(is_active=True).order_by(User.name.asc()).all()
milestone_types = MilestoneType.query.filter_by(is_active=True).order_by(MilestoneType.sort_order.asc()).all()
# Totales para indicadores superiores
total_capacity = sum(c.max_students for s in subjects for c in s.commissions)
total_commissions = sum(len(s.commissions) for s in subjects)
can_manage_milestones = user_can_manage_commission_milestones(current_user)
role_name = (current_user.role_obj.name if current_user.role_obj else current_user.role or '').lower()
can_edit_commissions = current_user.is_admin() or role_name in ['admin', 'bedelia', 'bedelía', 'operador'] or current_user.has_permission('schedule', 'read_write')
return render_template('schedule/commissions.html',
subjects=subjects,
classrooms=classrooms,
teachers=teachers,
milestone_types=milestone_types,
total_capacity=total_capacity,
total_commissions=total_commissions,
can_manage_milestones=can_manage_milestones,
can_edit_commissions=can_edit_commissions)
@schedule_bp.route('/commissions/add', methods=['POST'])
@login_required
def commission_add():
"""Crear una nueva comisión de cursada"""
role_name = (current_user.role_obj.name if current_user.role_obj else current_user.role or '').lower()
if not (current_user.is_admin() or role_name in ['admin', 'bedelia', 'bedelía', 'operador'] or current_user.has_permission('schedule', 'read_write')):
flash(_('No tienes permisos para crear comisiones.'), 'error')
return redirect(url_for('schedule.commissions_view'))
from app.models.subject import Commission
subject_id = request.form.get('subject_id', type=int)
code = request.form.get('code', '').strip()
semester = request.form.get('semester', '1C').strip()
year = request.form.get('year', datetime.now().year, type=int)
teacher_id = request.form.get('teacher_id', type=int) or None
max_students = request.form.get('max_students', 40, type=int)
schedule = request.form.get('schedule', '').strip()
shift = request.form.get('shift', 'Tarde').strip()
virtual_link = request.form.get('virtual_link', '').strip()
if not subject_id or not code:
flash(_('La asignatura y el código de comisión son obligatorios.'), 'error')
return redirect(url_for('schedule.commissions_view'))
# Verificar existencia duplicada
existing = Commission.query.filter_by(subject_id=subject_id, code=code, semester=semester, year=year).first()
if existing:
flash(_('Ya existe una comisión %(code)s para el ciclo %(sem)s %(yr)d.', code=code, sem=semester, yr=year), 'error')
return redirect(url_for('schedule.commissions_view'))
new_comm = Commission(
subject_id=subject_id,
code=code,
semester=semester,
year=year,
teacher_id=teacher_id,
max_students=max_students,
schedule=schedule,
shift=shift,
virtual_link=virtual_link or None,
active=True
)
db.session.add(new_comm)
db.session.commit()
flash(_('Comisión %(code)s creada exitosamente.', code=new_comm.get_full_code()), 'success')
return redirect(url_for('schedule.commissions_view'))
@schedule_bp.route('/commissions/<int:id>/edit', methods=['POST'])
@login_required
def commission_edit(id):
"""Editar datos de una comisión"""
role_name = (current_user.role_obj.name if current_user.role_obj else current_user.role or '').lower()
if not (current_user.is_admin() or role_name in ['admin', 'bedelia', 'bedelía', 'operador'] or current_user.has_permission('schedule', 'read_write')):
flash(_('No tienes permisos para modificar comisiones.'), 'error')
return redirect(url_for('schedule.commissions_view'))
from app.models.subject import Commission
commission = Commission.query.get_or_404(id)
commission.code = request.form.get('code', commission.code).strip()
commission.semester = request.form.get('semester', commission.semester).strip()
commission.year = request.form.get('year', commission.year, type=int)
commission.teacher_id = request.form.get('teacher_id', type=int) or None
commission.max_students = request.form.get('max_students', commission.max_students, type=int)
commission.schedule = request.form.get('schedule', commission.schedule).strip()
commission.shift = request.form.get('shift', commission.shift).strip()
commission.virtual_link = request.form.get('virtual_link', '').strip() or None
commission.active = True if request.form.get('active') in ['1', 'true', 'on'] else False
db.session.commit()
flash(_('Comisión %(code)s actualizada con éxito.', code=commission.get_full_code()), 'success')
return redirect(url_for('schedule.commissions_view'))
@schedule_bp.route('/commissions/<int:id>/delete', methods=['POST'])
@login_required
def commission_delete(id):
"""Eliminar una comisión"""
role_name = (current_user.role_obj.name if current_user.role_obj else current_user.role or '').lower()
if not (current_user.is_admin() or role_name in ['admin', 'bedelia', 'bedelía', 'operador'] or current_user.has_permission('schedule', 'read_write')):
flash(_('No tienes permisos para eliminar comisiones.'), 'error')
return redirect(url_for('schedule.commissions_view'))
from app.models.subject import Commission
commission = Commission.query.get_or_404(id)
full_code = commission.get_full_code()
db.session.delete(commission)
db.session.commit()
flash(_('Comisión %(code)s eliminada permanentemente.', code=full_code), 'success')
return redirect(url_for('schedule.commissions_view'))
@schedule_bp.route('/commissions/<int:id>/virtual-link', methods=['POST'])
@login_required
def commission_virtual_link(id):
"""Actualizar enlace del aula virtual (Zoom, Meet, Teams, Moodle) - Profesores, Admin y Bedelía"""
from app.models.subject import Commission
commission = Commission.query.get_or_404(id)
if not user_can_manage_commission_milestones(current_user, commission):
flash(_('No tienes permisos para actualizar el aula virtual de esta comisión.'), 'error')
return redirect(url_for('schedule.commissions_view'))
link = request.form.get('virtual_link', '').strip()
commission.virtual_link = link or None
db.session.commit()
flash(_('Enlace del aula virtual actualizado para la comisión %(code)s.', code=commission.get_full_code()), 'success')
return redirect(url_for('schedule.commissions_view'))
@schedule_bp.route('/commissions/<int:id>/milestones/add', methods=['POST'])
@login_required
def commission_milestone_add(id):
"""Agregar un hito académico (Parcial, TP, Recuperatorio) a una comisión - Profesores, Admin y Bedelía"""
from app.models.subject import Commission
from app.models.milestone import AcademicMilestone, MilestoneType
commission = Commission.query.get_or_404(id)
if not user_can_manage_commission_milestones(current_user, commission):
flash(_('No tienes permisos para agregar hitos a esta comisión.'), 'error')
return redirect(url_for('schedule.commissions_view'))
milestone_type_id = request.form.get('milestone_type_id', type=int)
title = request.form.get('title', '').strip()
date_str = request.form.get('date', '').strip()
time_str = request.form.get('time', '18:00').strip()
classroom = request.form.get('classroom', '').strip()
link = request.form.get('link', '').strip() or commission.virtual_link or ''
notes = request.form.get('notes', '').strip()
if not milestone_type_id or not date_str:
flash(_('Debes especificar el tipo de hito y la fecha.'), 'error')
return redirect(url_for('schedule.commissions_view'))
m_type = MilestoneType.query.get(milestone_type_id)
if not m_type:
flash(_('Tipo de hito inválido.'), 'error')
return redirect(url_for('schedule.commissions_view'))
try:
dt = datetime.strptime(f"{date_str} {time_str}", "%Y-%m-%d %H:%M")
except ValueError:
try:
dt = datetime.strptime(date_str, "%Y-%m-%d")
except ValueError:
flash(_('Formato de fecha inválido.'), 'error')
return redirect(url_for('schedule.commissions_view'))
milestone = AcademicMilestone(
title=title or m_type.name,
materia_codigo=commission.subject.code if commission.subject else 'ASIG',
subject_id=commission.subject_id,
commission_id=commission.id,
milestone_type_id=m_type.id,
date=dt,
classroom=classroom or 'Campus Virtual',
link=link or None,
notes=notes or None,
is_active=True
)
db.session.add(milestone)
db.session.commit()
flash(_('Hito "%(title)s" registrado correctamente en %(comm)s.', title=milestone.title, comm=commission.get_full_code()), 'success')
return redirect(url_for('schedule.commissions_view'))
@schedule_bp.route('/commissions/<int:commission_id>/milestones/<int:milestone_id>/delete', methods=['POST'])
@login_required
def commission_milestone_delete(commission_id, milestone_id):
"""Eliminar un hito académico de una comisión"""
from app.models.subject import Commission
from app.models.milestone import AcademicMilestone
commission = Commission.query.get_or_404(commission_id)
if not user_can_manage_commission_milestones(current_user, commission):
flash(_('No tienes permisos para eliminar hitos de esta comisión.'), 'error')
return redirect(url_for('schedule.commissions_view'))
milestone = AcademicMilestone.query.filter_by(id=milestone_id, commission_id=commission_id).first_or_404()
title = milestone.title
db.session.delete(milestone)
db.session.commit()
flash(_('Hito "%(title)s" eliminado de la comisión.', title=title), 'success')
return redirect(url_for('schedule.commissions_view'))
@schedule_bp.route('/add', methods=['GET', 'POST'])
@login_required
def add_reservation():
"""Add new reservation"""
from app.models.classroom import Classroom
from app.models.subject import Commission
from app.models.building import Building
form = ReservationForm()
# Get active buildings and classrooms
buildings = Building.query.filter_by(is_active=True).order_by(Building.name.asc()).all()
classrooms = Classroom.query.filter_by(is_active=True).order_by(Classroom.building_id.asc(), Classroom.floor.asc(), Classroom.code.asc()).all()
commissions = Commission.query.filter_by(active=True).all()
# Populate form choices
form.classroom_id.choices = [(c.id, f'{c.building_name} - {c.code} (Cap: {c.capacity_display})') for c in classrooms]
form.commission_id.choices = [(c.id, f'{c.get_full_code()} - {c.subject.name if c.subject else "No Subject"} (Students: {c.max_students})') for c in commissions]
if request.method == 'POST':
if form.validate_on_submit():
try:
# Check for existing reservations at the same time
from app.models.reservation import ReservationStatus
existing_reservation = Reservation.query.filter_by(
classroom_id=form.classroom_id.data,
status=ReservationStatus.CONFIRMED.value
).filter(
Reservation.start_time < form.end_time.data,
Reservation.end_time > form.start_time.data
).first()
if existing_reservation:
flash('This classroom is already booked for the selected time slot.', 'danger')
return render_template('schedule/add.html', form=form, title='New Reservation', classroom_list=classrooms, commission_list=commissions, buildings=buildings)
# Create new reservation
reservation = Reservation(
classroom_id=form.classroom_id.data,
commission_id=form.commission_id.data,
user_id=current_user.id,
start_time=form.start_time.data,
end_time=form.end_time.data,
purpose=form.purpose.data,
notes=form.notes.data,
virtual_link=form.virtual_link.data.strip() if form.virtual_link.data else None,
status=ReservationStatus.PENDING.value,
expected_attendees=form.expected_attendees.data
)
db.session.add(reservation)
db.session.commit()
flash('Reservation request submitted successfully! It will be reviewed by an administrator.', 'success')
return redirect(url_for('schedule.list_reservations'))
except Exception as e:
db.session.rollback()
flash(f'Error creating reservation: {str(e)}', 'danger')
return render_template('schedule/add.html', form=form, title='New Reservation', classroom_list=classrooms, commission_list=commissions, buildings=buildings)
@schedule_bp.route('/reservation/add', methods=['POST'])
@login_required
def quick_reservation_add():
"""Endpoint AJAX para crear reserva rápida desde el modal de comisiones"""
try:
commission_id = request.form.get('commission_id', type=int)
classroom_id = request.form.get('classroom_id', type=int)
purpose = request.form.get('purpose', '').strip() or 'Clase de cursada'
start_str = request.form.get('start_time', '').strip()
end_str = request.form.get('end_time', '').strip()
virtual_link = request.form.get('virtual_link', '').strip() or None
if not commission_id or not classroom_id or not start_str or not end_str:
return jsonify({'error': 'Faltan campos obligatorios'}), 400
start_time = datetime.strptime(start_str, '%Y-%m-%d %H:%M')
end_time = datetime.strptime(end_str, '%Y-%m-%d %H:%M')
from app.models.subject import Commission
from app.models.classroom import Classroom
comm = Commission.query.get_or_404(commission_id)
if not virtual_link and comm.virtual_link:
virtual_link = comm.virtual_link
new_res = Reservation(
classroom_id=classroom_id,
commission_id=commission_id,
user_id=comm.teacher_id or current_user.id,
start_time=start_time,
end_time=end_time,
purpose=purpose,
expected_attendees=comm.max_students or 30,
shift=comm.shift or 'Tarde',
virtual_link=virtual_link,
status=ReservationStatus.CONFIRMED.value if current_user.is_admin() else ReservationStatus.PENDING.value
)
db.session.add(new_res)
db.session.commit()
return jsonify({'success': True, 'id': new_res.id})
except Exception as e:
db.session.rollback()
return jsonify({'error': str(e)}), 500
@schedule_bp.route('/list')
@login_required
def list_reservations():
"""List all reservations with pagination, date filters, floor, shift, and virtual toggle"""
page = request.args.get('page', 1, type=int)
status_filter = request.args.get('status', 'all').strip()
date_from = request.args.get('date_from', '').strip()
date_to = request.args.get('date_to', '').strip()
hide_virtual = request.args.get('hide_virtual', '0') in ['1', 'true', 'True']
floor_filter = request.args.get('floor', '').strip()
shift_filter = request.args.get('shift', '').strip()
classroom_id = request.args.get('classroom_id', type=int)
search = request.args.get('search', '').strip()
query = Reservation.query.options(
joinedload(Reservation.classroom),
joinedload(Reservation.commission),
joinedload(Reservation.user)
).join(Reservation.classroom).outerjoin(Reservation.commission).outerjoin(Commission.subject)
if classroom_id:
query = query.filter(Reservation.classroom_id == classroom_id)
if status_filter and status_filter != 'all':
query = query.filter(Reservation.status == status_filter.upper())
if date_from:
try:
d_from = datetime.strptime(date_from, '%Y-%m-%d')
query = query.filter(Reservation.start_time >= d_from)
except ValueError:
pass
if date_to:
try:
d_to = datetime.strptime(date_to, '%Y-%m-%d') + timedelta(days=1)
query = query.filter(Reservation.start_time < d_to)
except ValueError:
pass
if hide_virtual:
query = query.filter(
~Classroom.code.ilike('%VIRTUAL%'),
~Classroom.building.ilike('%Virtual%')
)
if floor_filter:
flr = floor_filter.strip()
if flr.upper() in ['0', 'PB', 'PLANTA BAJA']:
query = query.filter(or_(Classroom.floor == '0', Classroom.floor.ilike('%PB%'), Classroom.floor.ilike('%Planta Baja%')))
else:
query = query.filter(Classroom.floor == flr)
if shift_filter:
query = query.filter(Reservation.shift.ilike(f'%{shift_filter}%'))
if search:
query = query.filter(
or_(
Subject.name.ilike(f'%{search}%'),
Subject.code.ilike(f'%{search}%'),
Commission.code.ilike(f'%{search}%'),
Classroom.code.ilike(f'%{search}%'),
Reservation.purpose.ilike(f'%{search}%'),
Reservation.shift.ilike(f'%{search}%')
)
)
reservations = query.order_by(Reservation.start_time.desc()).paginate(
page=page, per_page=20, error_out=False
)
floors = db.session.query(Classroom.floor).filter(Classroom.is_active==True, Classroom.floor.isnot(None)).distinct().order_by(Classroom.floor.asc()).all()
available_floors = [f[0] for f in floors]
all_classrooms = Classroom.query.filter_by(is_active=True).order_by(Classroom.building_id.asc(), Classroom.floor.asc(), Classroom.code.asc()).all()
return render_template(
'schedule/list.html',
reservations=reservations,
status_filter=status_filter,
date_from=date_from,
date_to=date_to,
hide_virtual=hide_virtual,
floor_filter=floor_filter,
shift_filter=shift_filter,
classroom_id=classroom_id,
all_classrooms=all_classrooms,
search=search,
available_floors=available_floors
)
@schedule_bp.route('/reservation/<int:id>/confirm', methods=['GET', 'POST'])
@login_required
def confirm_reservation(id):
"""Confirm a reservation (Handles both GET from link and POST from form)"""
try:
reservation = Reservation.query.get_or_404(id)
# Validación de seguridad: Solo confirmar si está pendiente
if reservation.status != ReservationStatus.PENDING.value:
flash('Only pending reservations can be confirmed.', 'warning')
return redirect(url_for('schedule.today_schedule'))
reservation.status = ReservationStatus.CONFIRMED.value
db.session.commit()
flash(
f'Reservation for {reservation.commission.code if reservation.commission else "Class"} confirmed successfully!',
'success')
except Exception as e:
db.session.rollback()
flash(f'Error confirming reservation: {str(e)}', 'error')
# Redirigir a la página desde la que venía el usuario o al inicio de hoy
return redirect(request.referrer or url_for('schedule.today_schedule'))
# API endpoints
@schedule_bp.route('/api/classroom-availability')
@login_required
def classroom_availability_api():
"""Get classroom availability for a specific date/time"""
try:
date_str = request.args.get('date')
start_time_str = request.args.get('start_time')
end_time_str = request.args.get('end_time')
max_students = request.args.get('max_students', type=int)
if not all([date_str, start_time_str, end_time_str]):
return jsonify({'error': 'Missing required parameters: date, start_time, end_time'}), 400
# Parse datetime strings
from datetime import datetime
start_time = datetime.strptime(f"{date_str} {start_time_str}", "%Y-%m-%d %H:%M")
end_time = datetime.strptime(f"{date_str} {end_time_str}", "%Y-%m-%d %H:%M")
# Get availability status
from app.models.classroom import Classroom
availability = Classroom.get_availability_status(start_time, end_time)
# Get best classroom recommendation if max_students provided
best_recommendation = None
if max_students:
best_classrooms = Classroom.find_best_classroom(max_students, start_time, end_time)
if best_classrooms:
best_recommendation = best_classrooms[0] # Most efficient one
# Format response
response: Dict[str, Any] = {
'availability': {
'available': [
{
'id': item['classroom'].id,
'code': item['classroom'].code_display,
'name': item['classroom'].name,
'capacity': item['classroom'].capacity,
'location': item['classroom'].get_full_location()
}
for item in availability['available']
],
'occupied': [
{
'id': item['classroom'].id,
'code': item['classroom'].code_display,
'name': item['classroom'].name,
'capacity': item['classroom'].capacity,
'location': item['classroom'].get_full_location(),
'conflicts': [
{
'start_time': conflict.start_time.strftime('%H:%M'),
'end_time': conflict.end_time.strftime('%H:%M'),
'commission': conflict.commission.get_full_code() if conflict.commission else 'Unknown'
}
for conflict in item['conflicts']
]
}
for item in availability['occupied']
],
'stats': {
'total_available': availability['total_available'],
'total_occupied': availability['total_occupied']
}
}
}
if best_recommendation:
response['recommendation'] = {
'classroom': {
'id': best_recommendation['classroom'].id,
'code': best_recommendation['classroom'].code_display,
'name': best_recommendation['classroom'].name,
'capacity': best_recommendation['classroom'].capacity,
'location': best_recommendation['classroom'].get_full_location()
},
'efficiency': best_recommendation['efficiency'],
'wasted_capacity': best_recommendation['wasted_capacity'],
'reason': 'Best match based on capacity and availability'
}
return jsonify(response)
except ValueError as e:
return jsonify({'error': f'Invalid date/time format: {str(e)}'}), 400
except Exception as e:
return jsonify({'error': str(e)}), 500
@schedule_bp.route('/calendar-data')
@login_required
def calendar_data():
"""Get calendar events data for FullCalendar"""
try:
start = request.args.get('start')
end = request.args.get('end')
classroom_id = request.args.get('classroom_id')
subject_id = request.args.get('subject_id')
career_id = request.args.get('career_id')
shift = request.args.get('shift', '').strip()
floor = request.args.get('floor', '').strip()
hide_virtual = request.args.get('hide_virtual', '0') in ['1', 'true', 'True']
search = request.args.get('search', '').strip()
if start and end:
# Clean up ISO timezone strings for PostgreSQL naive timestamp comparison
start_clean = start.replace('Z', '+00:00')
end_clean = end.replace('Z', '+00:00')
start_date = datetime.fromisoformat(start_clean).replace(tzinfo=None)
end_date = datetime.fromisoformat(end_clean).replace(tzinfo=None)
else:
today = date.today()
start_date = datetime.combine(today.replace(day=1), datetime.min.time())
next_month = today.replace(day=28) + timedelta(days=4)
end_date = datetime.combine(next_month.replace(day=1), datetime.max.time())
query = Reservation.query.join(Reservation.commission).join(Commission.subject).outerjoin(Reservation.classroom).options(
joinedload(Reservation.classroom),
joinedload(Reservation.commission)
).filter(
Reservation.start_time >= start_date,
Reservation.start_time <= end_date
)
if classroom_id and classroom_id.isdigit():
query = query.filter(Reservation.classroom_id == int(classroom_id))
if subject_id and subject_id.isdigit():
query = query.filter(Commission.subject_id == int(subject_id))
if career_id and career_id.isdigit():
query = query.filter(Subject.career_id == int(career_id))
building = request.args.get('building', '').strip()
if building:
from app.models.building import Building
query = query.filter(
or_(
Classroom.building.ilike(f'%{building}%'),
Classroom.building_id.in_(db.session.query(Building.id).filter(Building.name.ilike(f'%{building}%')))
)
)
if shift:
query = query.filter(Reservation.shift.ilike(f'%{shift}%'))
if hide_virtual:
query = query.filter(
~Classroom.code.ilike('%VIRTUAL%'),
~Classroom.building.ilike('%Virtual%')
)
if floor:
flr = floor.strip()
if flr.upper() in ['0', 'PB', 'PLANTA BAJA']:
query = query.filter(or_(Classroom.floor == '0', Classroom.floor.ilike('%PB%'), Classroom.floor.ilike('%Planta Baja%')))
else:
query = query.filter(Classroom.floor == flr)
if search:
query = query.filter(
or_(
Subject.name.ilike(f'%{search}%'),
Subject.code.ilike(f'%{search}%'),
Classroom.code.ilike(f'%{search}%'),
Reservation.purpose.ilike(f'%{search}%')
)
)
reservations = query.order_by(Reservation.start_time).all()
events = []
for reservation in reservations:
subject = reservation.commission.subject if (reservation.commission and reservation.commission.subject) else None
subject_code = subject.code if subject else (reservation.commission.code if reservation.commission else '')
subject_name = subject.name if subject else (reservation.purpose or 'Clase')
classroom_name = reservation.classroom.code if reservation.classroom else 'Sin Aula'
classroom_floor = reservation.classroom.floor_display if reservation.classroom else None
classroom_building = reservation.classroom.building_name if reservation.classroom else ''
is_virtual = bool(reservation.classroom and reservation.classroom.is_virtual)
career_name = subject.career_obj.name if (subject and subject.career_obj) else (subject.department if subject else '')
status_val = str(reservation.status.value if hasattr(reservation.status, 'value') else reservation.status)
events.append({
'id': reservation.id,
'title': subject_name,
'start': reservation.start_time.isoformat(),
'end': reservation.end_time.isoformat(),
'url': url_for('schedule.view_reservation', id=reservation.id) if reservation.id else None,
'className': f'fc-event-{status_val.lower()}',
'extendedProps': {
'subject_code': subject_code,
'subject_name': subject_name,
'classroom': classroom_name,
'building': classroom_building,
'floor': classroom_floor,
'is_virtual': is_virtual,
'location_display': reservation.classroom.location_display if reservation.classroom else '',
'career': career_name,
'commission': reservation.commission.code if reservation.commission else '',
'shift': reservation.shift or '',
'status': status_val,
'purpose': reservation.purpose or '',
'attendees': reservation.expected_attendees or 0,
'notes': reservation.notes or '',
'teacher': reservation.user.name if reservation.user else '',
'virtual_link': reservation.effective_virtual_link,
'cancel_url': url_for('schedule.cancel_reservation', id=reservation.id)
}
})
return jsonify(events)
except Exception as e:
import traceback
traceback.print_exc()
return jsonify({'error': str(e)}), 500
@schedule_bp.route('/api/today-events')
@login_required
def api_today_events():
"""Get today's events as JSON"""
try:
today_start = datetime.combine(date.today(), datetime.min.time())
today_end = datetime.combine(date.today(), datetime.max.time())
reservations = Reservation.query.options(
joinedload(Reservation.classroom),
joinedload(Reservation.commission)
).filter(
Reservation.start_time >= today_start,
Reservation.start_time <= today_end
).order_by(Reservation.start_time).all()
events = []
for reservation in reservations:
subject = reservation.commission.subject if (reservation.commission and reservation.commission.subject) else None
subject_code = subject.code if subject else (reservation.commission.code if reservation.commission else '')
subject_name = subject.name if subject else (reservation.purpose or 'Clase')
classroom_name = reservation.classroom.code if reservation.classroom else 'Sin Aula'
status_val = str(reservation.status.value if hasattr(reservation.status, 'value') else reservation.status)
events.append({
'id': reservation.id,
'title': f"{subject_name} ({subject_code}) - {classroom_name}",
'start': reservation.start_time.isoformat(),
'end': reservation.end_time.isoformat(),
'url': url_for('schedule.view_reservation', id=reservation.id) if reservation.id else None,
'extendedProps': {
'subject_code': subject_code,
'subject_name': subject_name,
'classroom': classroom_name,
'purpose': reservation.purpose or 'No purpose',
'attendees': reservation.expected_attendees,
'status': status_val
}
})
return jsonify({'events': events})
except Exception as e:
return jsonify({'error': str(e)}), 500
-8
View File
@@ -1,8 +0,0 @@
"""Módulo de Seguridad Empresarial inspirado en Spring Security (SecurityFilterChain, RBAC y Auditoría)."""
from app.security.filter_chain import SecurityFilterChain
from app.security.decorators import require_permission
__all__ = [
'SecurityFilterChain',
'require_permission'
]
-45
View File
@@ -1,45 +0,0 @@
from functools import wraps
from flask import request, jsonify, redirect, url_for, flash, abort, g
from flask_login import current_user
def require_permission(module: str, min_level: str = 'read'):
"""
Decorador de seguridad declarativa a nivel de método inspirado en @PreAuthorize de Spring Security.
Verifica los privilegios del usuario autenticado (tanto en sesiones web como en API JWT).
Niveles de permiso estándar:
- 'read': Permiso de lectura / consulta
- 'read_write': Permiso de modificación y creación
- 'admin': Permiso de control total
"""
def decorator(f):
@wraps(f)
def decorated_function(*args, **kwargs):
user = None
# Evaluar contexto JWT primero si está presente
if hasattr(g, 'jwt_user') and g.jwt_user:
user = g.jwt_user
elif current_user and current_user.is_authenticated:
user = current_user
is_api = request.path.startswith('/api/') or request.is_json
if not user:
if is_api:
return jsonify({'error': 'Unauthorized', 'message': 'Autenticación requerida.'}), 401
flash('Debe iniciar sesión para acceder a este recurso.', 'warning')
return redirect(url_for('auth.login', next=request.url))
# Comprobar privilegios en la matriz RBAC
if not user.has_permission(module, min_level):
if is_api:
return jsonify({
'error': 'Forbidden',
'message': f'Permiso insuficiente en módulo "{module}". Nivel requerido: "{min_level}".'
}), 403
flash(f'No posee permisos suficientes ({min_level}) para gestionar {module}.', 'danger')
abort(403)
return f(*args, **kwargs)
return decorated_function
return decorator
-89
View File
@@ -1,89 +0,0 @@
from flask import request, jsonify, g, render_template, Response
from datetime import datetime, timedelta, timezone
from typing import Dict, List, Tuple
import time
class SecurityFilterChain:
"""
Pipeline centralizado de interceptación de seguridad (SecurityFilterChain)
inspirado en el patrón arquitectónico de Spring Security.
Capas de filtrado activas:
1. Security Headers Filter (Blindaje HTTP en todas las respuestas).
2. Rate Limiting Filter (Protección contra fuerza bruta y DoS).
3. Bearer Token Context Filter (Inyección de identidad contextual).
"""
def __init__(self, app=None):
# Registro de timestamps de peticiones por IP: ip -> [timestamps]
self._request_history: Dict[str, List[float]] = {}
# Límites por endpoint sensible (max_requests, window_seconds)
self._rate_limits = {
'/login': (15, 60),
'/api/v1/auth/login': (15, 60),
'/api/v1/auth/refresh': (30, 60)
}
if app:
self.init_app(app)
def init_app(self, app):
"""Registra los filtros en el ciclo de vida de la aplicación Flask."""
app.before_request(self._execute_pre_filters)
app.after_request(self._execute_post_filters)
def _get_client_ip(self) -> str:
"""Obtiene la IP real del cliente respetando proxies inversos de confianza."""
if request.headers.get('X-Forwarded-For'):
return request.headers.get('X-Forwarded-For').split(',')[0].strip()
return request.remote_addr or '127.0.0.1'
def _execute_pre_filters(self):
"""Ejecuta los filtros previos al enrutamiento del controlador."""
path = request.path
# 1. Rate Limiting Filter (solo para peticiones POST de autenticación sensible)
if path in self._rate_limits:
# Peticiones GET para cargar la interfaz web NO consumen intentos de fuerza bruta
if request.method != 'POST':
return
max_req, window = self._rate_limits[path]
client_ip = self._get_client_ip()
now = time.time()
# Limpiar historial fuera de la ventana
timestamps = self._request_history.get(client_ip, [])
timestamps = [t for t in timestamps if now - t < window]
if len(timestamps) >= max_req:
retry_after = max(1, int(window - (now - timestamps[0])))
if path.startswith('/api/'):
return jsonify({
'error': 'TooManyRequests',
'message': f'Límite de peticiones excedido. Reintente en {retry_after} segundos.'
}), 429
# Para la web, renderizar vista o respuesta legible
return Response(
f"Demasiados intentos de autenticación desde su dirección IP. Por favor espere {retry_after} segundos antes de volver a intentar.",
status=429,
mimetype='text/plain; charset=utf-8'
)
timestamps.append(now)
self._request_history[client_ip] = timestamps
def _execute_post_filters(self, response):
"""Inyecta cabeceras de blindaje HTTP (OWASP Secure Headers)."""
# Evitar ataques de MIME-Sniffing
response.headers['X-Content-Type-Options'] = 'nosniff'
# Mitigación de Clickjacking
response.headers['X-Frame-Options'] = 'SAMEORIGIN'
# Mitigación XSS en navegadores legacy
response.headers['X-XSS-Protection'] = '1; mode=block'
# Política de Referrer segura
response.headers['Referrer-Policy'] = 'strict-origin-when-cross-origin'
# Inyección HSTS (si es HTTPS o entorno de producción)
response.headers['Strict-Transport-Security'] = 'max-age=31536000; includeSubDomains'
return response
+28 -28
View File
@@ -1,6 +1,4 @@
from typing import Optional, List, Dict, Any
from flask import request, g, has_request_context
from flask_login import current_user
import json
from app import db
from app.models.audit_log import AuditLog
@@ -18,8 +16,7 @@ class AuditService:
status: Optional[str] = None,
**kwargs) -> AuditLog:
"""
Registra un evento de auditoría de forma segura, infiriendo el usuario e IP
desde el contexto actual de la petición si no se especifican.
Registra un evento de auditoría de forma segura e inmutable.
"""
if status:
if isinstance(details, dict):
@@ -28,25 +25,15 @@ class AuditService:
details = f"[{status.upper()}] {details}"
else:
details = {'status': status}
# 1. Determinar usuario actuante
if user:
user_id = user.id
user_email = user.email
elif not user_id and not user_email and has_request_context():
if hasattr(g, 'jwt_user') and g.jwt_user:
user_id = g.jwt_user.id
user_email = g.jwt_user.email
elif current_user and current_user.is_authenticated:
user_id = current_user.id
user_email = current_user.email
# 2. Determinar IP de origen
if not ip_address and has_request_context():
xfwd = request.headers.get('X-Forwarded-For')
if xfwd:
ip_address = xfwd.split(',')[0].strip()
else:
ip_address = request.remote_addr
# 2. IP de origen
if not ip_address:
ip_address = '127.0.0.1'
# 3. Serializar detalles si es estructura de datos
details_str = None
@@ -59,27 +46,40 @@ class AuditService:
else:
details_str = str(details)
log_entry = AuditLog(
user_id=user_id,
user_email=user_email,
action=action.upper(),
module=module.lower(),
audit_entry = AuditLog(
action=action,
module=module,
entity_id=entity_id,
details=details_str,
user_id=user_id,
user_email=user_email,
ip_address=ip_address
)
try:
db.session.add(log_entry)
db.session.add(audit_entry)
db.session.commit()
except Exception:
db.session.rollback()
return log_entry
return audit_entry
@staticmethod
def get_recent_logs(limit: int = 50, module: Optional[str] = None) -> List[AuditLog]:
"""Obtiene las entradas más recientes de auditoría."""
def get_logs(module: Optional[str] = None, action: Optional[str] = None,
user_id: Optional[int] = None, limit: int = 50) -> List[AuditLog]:
"""Recupera los eventos más recientes con filtros opcionales."""
query = AuditLog.query
if module:
query = query.filter_by(module=module.lower())
query = query.filter(AuditLog.module == module)
if action:
query = query.filter(AuditLog.action == action)
if user_id:
query = query.filter(AuditLog.user_id == user_id)
return query.order_by(AuditLog.created_at.desc()).limit(limit).all()
@staticmethod
def get_recent_logs(limit: int = 50, module: Optional[str] = None,
action: Optional[str] = None) -> List[AuditLog]:
return AuditService.get_logs(module=module, action=action, limit=limit)
+4 -6
View File
@@ -1,7 +1,7 @@
import base64
import hashlib
from cryptography.fernet import Fernet
from flask import current_app
from config.config import Config
class CryptoService:
"""
@@ -11,11 +11,8 @@ class CryptoService:
@staticmethod
def _get_fernet() -> Fernet:
# Derivar clave válida para Fernet (32 bytes urlsafe base64) desde SECRET_KEY
try:
secret = current_app.config.get('SECRET_KEY', 'default-unicaba-edu-space-secret-key-32b!')
except RuntimeError:
secret = 'default-unicaba-edu-space-secret-key-32b!'
# Derivar clave válida para Fernet (32 bytes urlsafe base64) desde Config.SECRET_KEY
secret = Config.SECRET_KEY or 'default-unicaba-edu-space-secret-key-32b!'
# Hash SHA-256 para obtener 32 bytes y codificar en base64 seguro para URL
key = base64.urlsafe_b64encode(hashlib.sha256(secret.encode('utf-8')).digest())
@@ -44,3 +41,4 @@ class CryptoService:
return cipher_text
crypto_service = CryptoService()
+707
View File
@@ -0,0 +1,707 @@
"""
Dashboard Service for admin-edu-space
Decoupled analytics, operational statistics, and Google Sheets integration without any Flask dependencies.
"""
import calendar
from datetime import datetime, timedelta, timezone
from typing import Optional, Dict, Any, List
from sqlalchemy import func
from app import db
from app.models.classroom import Classroom
from app.models.subject import Subject, Commission
from app.models.user import User
from app.models.reservation import Reservation
from app.models.audit_log import AuditLog
from app.models.milestone import AcademicMilestone
from app.models.setting import SystemSetting
from app.services.audit_service import AuditService
from app.services.sheets_importer import GoogleSheetsImporter
class DashboardService:
@staticmethod
def serialize_reservation(r: Reservation) -> Dict[str, Any]:
subject_name = (r.commission.subject.name if (r.commission and r.commission.subject) else r.purpose) or 'Actividad Académica'
subject_code = (r.commission.subject.code if (r.commission and r.commission.subject) else '')
classroom_code = r.classroom.code if r.classroom else 'Sin Aula'
is_virtual = ('virtual' in classroom_code.lower()) or (getattr(r.classroom, 'is_virtual', False) if r.classroom else False)
return {
'id': r.id,
'start_time': r.start_time.strftime('%H:%M') if r.start_time else '',
'end_time': r.end_time.strftime('%H:%M') if r.end_time else '',
'date_display': r.start_time.strftime('%d/%m') if r.start_time else '',
'classroom': {
'id': r.classroom_id,
'code': classroom_code,
'is_virtual': is_virtual,
'location_display': getattr(r.classroom, 'location_display', f'Sede Central · {classroom_code}') if r.classroom else 'Sin Aula'
},
'subject_name': subject_name,
'subject_code': subject_code,
'shift': r.shift or 'Mañana',
'commission': {
'id': r.commission_id,
'code': r.commission.code if r.commission else 'COM-1'
},
'status': str(r.status.value if hasattr(r.status, 'value') else r.status),
'user': {
'id': r.user_id,
'name': r.user.name if r.user else 'Docente'
},
'virtual_link': r.virtual_link or ('https://meet.google.com/edu-space-' + classroom_code.lower().replace(' ', '-') if is_virtual else '')
}
@staticmethod
def serialize_milestone(m: AcademicMilestone) -> Dict[str, Any]:
return {
'id': m.id,
'title': m.title,
'materia_codigo': m.materia_codigo,
'subject_name': m.subject.name if (hasattr(m, 'subject') and m.subject) else m.materia_codigo,
'date': m.date.strftime('%d/%m/%Y') if m.date else '',
'type_obj': {
'name': m.type_obj.name if m.type_obj else 'Evaluación',
'color': m.type_obj.color if m.type_obj else '#0d6efd'
},
'classroom': m.classroom or 'Sede Central',
'link': m.link or '',
'notes': m.notes or ''
}
def get_stats(self, current_user: Optional[User] = None) -> Dict[str, Any]:
today = datetime.now(timezone.utc).date()
total_classrooms = 0
total_subjects = 0
total_users = 0
today_reservations = 0
pending_count = 0
physical_classrooms = 0
virtual_classrooms = 0
occupancy_rate = 0
assigned_classrooms = 0
assigned_pct = 0.0
unassigned_classrooms = 0
unassigned_pct = 0.0
assigned_today_count = 0
assigned_today_pct = 0.0
unassigned_today_count = 0
unassigned_today_pct = 0.0
total_active_commissions = 0
tomorrow_reservations_q: List[Reservation] = []
my_today_count = 0
my_total_reservations = 0
my_today_classes: List[Dict[str, Any]] = []
tomorrow_schedule_list: List[Dict[str, Any]] = []
filter_stats: Dict[str, Any] = {}
date_labels: Dict[str, Any] = {}
unassigned_commissions_tomorrow: List[Dict[str, Any]] = []
unassigned_commissions_week: List[Dict[str, Any]] = []
unassigned_commissions_month: List[Dict[str, Any]] = []
unassigned_commissions_general: List[Dict[str, Any]] = []
available_classrooms_today: List[Dict[str, Any]] = []
available_classrooms_tomorrow: List[Dict[str, Any]] = []
available_classrooms_week: List[Dict[str, Any]] = []
available_classrooms_month: List[Dict[str, Any]] = []
virtual_rooms_data: List[Dict[str, Any]] = []
audit_data: List[Dict[str, Any]] = []
pending_reservations: List[Dict[str, Any]] = []
today_schedule_list: List[Dict[str, Any]] = []
week_schedule_list: List[Dict[str, Any]] = []
upcoming_reservations: List[Dict[str, Any]] = []
milestones: List[Dict[str, Any]] = []
try:
total_classrooms = Classroom.query.filter_by(is_active=True).count()
total_subjects = Subject.query.filter_by(is_active=True).count()
total_users = User.query.filter_by(is_active=True).count()
# Aulas presenciales y virtuales
all_active_classrooms = Classroom.query.filter_by(is_active=True).all()
virtual_classrooms_list = [
c for c in all_active_classrooms
if getattr(c, 'is_virtual', False)
or 'virtual' in (c.building or '').lower()
or 'virtual' in (c.code or '').lower()
]
virtual_classrooms = len(virtual_classrooms_list)
physical_classrooms_list = [
c for c in all_active_classrooms
if c not in virtual_classrooms_list
]
total_physical_count = len(physical_classrooms_list)
physical_classrooms = total_physical_count
physical_ids = set(c.id for c in physical_classrooms_list)
# 1. Asignación General del Cuatrimestre / Cronograma
assigned_all_ids = set(
r[0] for r in db.session.query(Reservation.classroom_id)
.filter(Reservation.classroom_id.isnot(None)).distinct().all()
)
assigned_physical_ids = physical_ids.intersection(assigned_all_ids)
assigned_classrooms = len(assigned_physical_ids)
unassigned_classrooms = max(0, total_physical_count - assigned_classrooms)
assigned_pct = round((assigned_classrooms / max(1, total_physical_count)) * 100, 1) if total_physical_count > 0 else 0.0
unassigned_pct = round(100.0 - assigned_pct, 1) if total_physical_count > 0 else 0.0
# 2. Asignación Operativa del Día de Hoy
assigned_today_ids = set(
r[0] for r in db.session.query(Reservation.classroom_id).filter(
Reservation.classroom_id.isnot(None),
func.date(Reservation.start_time) == today
).distinct().all()
)
assigned_today_physical_ids = physical_ids.intersection(assigned_today_ids)
assigned_today_count = len(assigned_today_physical_ids)
unassigned_today_count = max(0, total_physical_count - assigned_today_count)
assigned_today_pct = round((assigned_today_count / max(1, total_physical_count)) * 100, 1) if total_physical_count > 0 else 0.0
unassigned_today_pct = round(100.0 - assigned_today_pct, 1) if total_physical_count > 0 else 0.0
today_reservations_q = Reservation.query.filter(
func.date(Reservation.start_time) == today
).order_by(Reservation.start_time.asc()).all()
today_reservations = len(today_reservations_q)
pending_reservations_q = Reservation.query.filter(
Reservation.status == 'PENDING'
).order_by(Reservation.start_time.asc()).all()
pending_count = len(pending_reservations_q)
upcoming_reservations_q = Reservation.query.filter(
Reservation.start_time >= datetime.now(timezone.utc).replace(tzinfo=None)
).order_by(Reservation.start_time.asc()).limit(10).all()
milestones_q = AcademicMilestone.query.filter(
AcademicMilestone.is_active == True
).order_by(AcademicMilestone.date.asc()).limit(10).all()
recent_audits = AuditLog.query.order_by(AuditLog.created_at.desc()).limit(6).all()
audit_data = [{
'created_at': a.created_at.strftime('%Y-%m-%d %H:%M') if a.created_at else None,
'action_type': getattr(a, 'action', getattr(a, 'action_type', 'AUDIT')),
'ip_address': a.ip_address,
'user_email': getattr(a, 'user_email', None) or (getattr(a.user, 'email', 'System') if hasattr(a, 'user') else 'System')
} for a in recent_audits]
occupancy_rate = min(100, int((today_reservations / max(1, physical_classrooms * 3)) * 100)) if physical_classrooms > 0 else 0
pending_reservations = [self.serialize_reservation(r) for r in pending_reservations_q]
today_schedule_list = [self.serialize_reservation(r) for r in today_reservations_q]
upcoming_reservations = [self.serialize_reservation(r) for r in upcoming_reservations_q]
milestones = [self.serialize_milestone(m) for m in milestones_q]
user_id = getattr(current_user, 'id', None)
my_today_count = 0
my_total_reservations = 0
my_today_classes = []
if user_id:
my_today_q = Reservation.query.filter(
Reservation.user_id == user_id,
func.date(Reservation.start_time) == today,
Reservation.status != 'CANCELLED'
).order_by(Reservation.start_time.asc()).all()
my_today_count = len(my_today_q)
my_today_classes = [self.serialize_reservation(r) for r in my_today_q]
my_total_reservations = Reservation.query.filter(
Reservation.user_id == user_id,
Reservation.status.in_(['CONFIRMED', 'PENDING'])
).count()
else:
my_today_count = today_reservations
my_total_reservations = len(today_reservations_q)
my_today_classes = today_schedule_list[:5]
# ---- Bedelía: Filtros completos de Aulas y Comisiones por Día (Hoy), Mañana, Semana y Mes ----
today_dt = datetime.now(timezone.utc).replace(tzinfo=None)
tomorrow_dt = today_dt + timedelta(days=1)
tomorrow_start = tomorrow_dt.replace(hour=0, minute=0, second=0, microsecond=0)
tomorrow_end = tomorrow_dt.replace(hour=23, minute=59, second=59, microsecond=0)
week_start = today_dt - timedelta(days=today_dt.weekday()) # Lunes
week_start = week_start.replace(hour=0, minute=0, second=0, microsecond=0)
week_end = week_start + timedelta(days=6, hours=23, minutes=59, seconds=59)
month_start = today_dt.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
last_day = calendar.monthrange(today_dt.year, today_dt.month)[1]
month_end = today_dt.replace(day=last_day, hour=23, minute=59, second=59, microsecond=0)
dias_esp = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo']
meses_esp = ['', 'Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre']
weekday_name = dias_esp[today_dt.weekday()]
month_name = meses_esp[today_dt.month]
tomorrow_weekday_name = dias_esp[tomorrow_dt.weekday()]
tomorrow_month_name = meses_esp[tomorrow_dt.month]
date_labels = {
'today': f"Hoy · {weekday_name} {today_dt.strftime('%d/%m/%Y')}",
'today_short': f"{weekday_name} {today_dt.strftime('%d/%m')}",
'today_full': f"{weekday_name}, {today_dt.day} de {month_name} de {today_dt.year}",
'tomorrow': f"Mañana · {tomorrow_weekday_name} {tomorrow_dt.strftime('%d/%m/%Y')}",
'tomorrow_short': f"{tomorrow_weekday_name} {tomorrow_dt.strftime('%d/%m')}",
'tomorrow_full': f"{tomorrow_weekday_name}, {tomorrow_dt.day} de {tomorrow_month_name} de {tomorrow_dt.year}",
'week': f"Semana del {week_start.strftime('%d/%m')} al {week_end.strftime('%d/%m/%Y')}",
'week_full': f"Semana del {week_start.strftime('%d/%m/%Y')} al {week_end.strftime('%d/%m/%Y')}",
'month': f"Mes de {month_name} {today_dt.year} ({month_start.strftime('%d/%m')} al {month_end.strftime('%d/%m/%Y')})",
'month_full': f"{month_name} de {today_dt.year}"
}
tomorrow_reservations_q = Reservation.query.filter(
Reservation.start_time >= tomorrow_start,
Reservation.start_time <= tomorrow_end
).order_by(Reservation.start_time.asc()).all()
tomorrow_schedule_list = [self.serialize_reservation(r) for r in tomorrow_reservations_q]
week_reservations_q = Reservation.query.filter(
Reservation.start_time >= week_start,
Reservation.start_time <= week_end
).order_by(Reservation.start_time.asc()).all()
week_schedule_list = [self.serialize_reservation(r) for r in week_reservations_q]
month_reservations_q = Reservation.query.filter(
Reservation.start_time >= month_start,
Reservation.start_time <= month_end
).order_by(Reservation.start_time.asc()).all()
# Mapas de reservas por aula en cada período
res_map_classroom_today: Dict[int, List[Reservation]] = {}
for r in today_reservations_q:
if r.classroom_id:
res_map_classroom_today.setdefault(r.classroom_id, []).append(r)
res_map_classroom_tomorrow: Dict[int, List[Reservation]] = {}
for r in tomorrow_reservations_q:
if r.classroom_id:
res_map_classroom_tomorrow.setdefault(r.classroom_id, []).append(r)
res_map_classroom_week: Dict[int, List[Reservation]] = {}
for r in week_reservations_q:
if r.classroom_id:
res_map_classroom_week.setdefault(r.classroom_id, []).append(r)
res_map_classroom_month: Dict[int, List[Reservation]] = {}
for r in month_reservations_q:
if r.classroom_id:
res_map_classroom_month.setdefault(r.classroom_id, []).append(r)
res_map_comm_today: Dict[int, List[Reservation]] = {}
for r in today_reservations_q:
if r.commission_id:
res_map_comm_today.setdefault(r.commission_id, []).append(r)
res_map_comm_tomorrow: Dict[int, List[Reservation]] = {}
for r in tomorrow_reservations_q:
if r.commission_id:
res_map_comm_tomorrow.setdefault(r.commission_id, []).append(r)
res_map_comm_week: Dict[int, List[Reservation]] = {}
for r in week_reservations_q:
if r.commission_id:
res_map_comm_week.setdefault(r.commission_id, []).append(r)
res_map_comm_month: Dict[int, List[Reservation]] = {}
for r in month_reservations_q:
if r.commission_id:
res_map_comm_month.setdefault(r.commission_id, []).append(r)
all_active_commissions = Commission.query.filter_by(active=True).all()
total_active_commissions = len(all_active_commissions)
def build_classroom_item(c: Classroom, res_list: List[Reservation]) -> Dict[str, Any]:
r_first = res_list[0] if res_list else None
assigned_summary = ''
if r_first:
subj = (r_first.commission.subject.name if (r_first.commission and r_first.commission.subject) else r_first.purpose) or 'Clase'
assigned_summary = f"{subj} ({r_first.start_time.strftime('%H:%M')} - {r_first.end_time.strftime('%H:%M')} hs)"
return {
'id': c.id,
'code': c.code,
'building': c.building or 'Sede Central',
'floor': c.floor or '',
'capacity': c.capacity or 0,
'is_virtual': getattr(c, 'is_virtual', False) or 'virtual' in (c.building or '').lower() or 'virtual' in (c.code or '').lower(),
'res_count': len(res_list),
'assigned_summary': assigned_summary
}
def build_comm_item(comm: Commission, res_list: List[Reservation]) -> Dict[str, Any]:
has_v_link = bool(comm.virtual_link and comm.virtual_link.strip())
r_first = res_list[0] if res_list else None
assigned_room = ''
assigned_time = ''
if r_first:
assigned_room = r_first.classroom.code if r_first.classroom else 'Aula Virtual'
assigned_time = f"{r_first.start_time.strftime('%H:%M')} - {r_first.end_time.strftime('%H:%M')} hs"
return {
'id': comm.id,
'code': comm.code,
'full_code': comm.get_full_code(),
'subject_name': comm.subject.name if comm.subject else 'Sin materia',
'subject_code': comm.subject.code if comm.subject else '',
'teacher_name': comm.teacher_name or 'Sin docente',
'schedule': comm.schedule or 'Sin horario',
'shift': comm.shift or 'Sin turno',
'max_students': comm.max_students or 0,
'current_students': comm.current_students or 0,
'virtual_link': comm.virtual_link or '',
'has_virtual_link': has_v_link,
'res_count': len(res_list),
'assigned_room': assigned_room,
'assigned_time': assigned_time
}
classrooms_assigned_today = [build_classroom_item(c, res_map_classroom_today[c.id]) for c in physical_classrooms_list if c.id in res_map_classroom_today]
classrooms_unassigned_today = [build_classroom_item(c, []) for c in physical_classrooms_list if c.id not in res_map_classroom_today]
classrooms_assigned_tomorrow = [build_classroom_item(c, res_map_classroom_tomorrow[c.id]) for c in physical_classrooms_list if c.id in res_map_classroom_tomorrow]
classrooms_unassigned_tomorrow = [build_classroom_item(c, []) for c in physical_classrooms_list if c.id not in res_map_classroom_tomorrow]
classrooms_assigned_week = [build_classroom_item(c, res_map_classroom_week[c.id]) for c in physical_classrooms_list if c.id in res_map_classroom_week]
classrooms_unassigned_week = [build_classroom_item(c, []) for c in physical_classrooms_list if c.id not in res_map_classroom_week]
classrooms_assigned_month = [build_classroom_item(c, res_map_classroom_month[c.id]) for c in physical_classrooms_list if c.id in res_map_classroom_month]
classrooms_unassigned_month = [build_classroom_item(c, []) for c in physical_classrooms_list if c.id not in res_map_classroom_month]
commissions_assigned_today = [build_comm_item(comm, res_map_comm_today[comm.id]) for comm in all_active_commissions if comm.id in res_map_comm_today]
commissions_unassigned_today = [build_comm_item(comm, []) for comm in all_active_commissions if comm.id not in res_map_comm_today]
commissions_assigned_tomorrow = [build_comm_item(comm, res_map_comm_tomorrow[comm.id]) for comm in all_active_commissions if comm.id in res_map_comm_tomorrow]
commissions_unassigned_tomorrow = [build_comm_item(comm, []) for comm in all_active_commissions if comm.id not in res_map_comm_tomorrow]
commissions_assigned_week = [build_comm_item(comm, res_map_comm_week[comm.id]) for comm in all_active_commissions if comm.id in res_map_comm_week]
commissions_unassigned_week = [build_comm_item(comm, []) for comm in all_active_commissions if comm.id not in res_map_comm_week]
commissions_assigned_month = [build_comm_item(comm, res_map_comm_month[comm.id]) for comm in all_active_commissions if comm.id in res_map_comm_month]
commissions_unassigned_month = [build_comm_item(comm, []) for comm in all_active_commissions if comm.id not in res_map_comm_month]
virtual_room_ids = set(c.id for c in virtual_classrooms_list)
comm_ids_virtual = set()
for comm in all_active_commissions:
if comm.virtual_link and comm.virtual_link.strip():
comm_ids_virtual.add(comm.id)
if virtual_room_ids:
comm_in_virtual_res = set(
r[0] for r in db.session.query(Reservation.commission_id).filter(
Reservation.classroom_id.in_(virtual_room_ids),
Reservation.commission_id.isnot(None)
).distinct().all()
)
comm_ids_virtual.update(comm_in_virtual_res)
virtual_rooms_data = []
for comm in all_active_commissions:
if comm.id in comm_ids_virtual:
res_today = res_map_comm_today.get(comm.id, [])
res_tomorrow = res_map_comm_tomorrow.get(comm.id, [])
res_week = res_map_comm_week.get(comm.id, [])
res_month = res_map_comm_month.get(comm.id, [])
v_link = comm.virtual_link or (res_today[0].virtual_link if res_today and res_today[0].virtual_link else '')
virtual_rooms_data.append({
'id': comm.id,
'commission_id': comm.id,
'code': comm.code,
'full_code': comm.get_full_code(),
'subject_name': comm.subject.name if comm.subject else 'Sin materia',
'subject_code': comm.subject.code if comm.subject else '',
'career_name': comm.subject.career.name if (comm.subject and comm.subject.career) else 'UniCABA',
'teacher_name': comm.teacher_name or 'Docente a confirmar',
'schedule': comm.schedule or 'Horario regular',
'shift': comm.shift or 'Tarde',
'max_students': comm.max_students or 35,
'capacity': comm.max_students or 35,
'virtual_link': v_link,
'is_virtual': True,
'building': 'Campus Virtual',
'floor': 'Remoto ∞',
'today_classes': len(res_today),
'tomorrow_classes': len(res_tomorrow),
'week_classes': len(res_week),
'month_classes': len(res_month),
'res_count': len(res_month),
'is_active_today': len(res_today) > 0,
'is_active_tomorrow': len(res_tomorrow) > 0,
'assigned_summary': f"{comm.subject.name if comm.subject else 'Clase Virtual'} ({comm.schedule or 'Remoto'})"
})
if virtual_rooms_data:
virtual_classrooms = len(virtual_rooms_data)
comm_ids_with_any_res = set(
r[0] for r in db.session.query(Reservation.commission_id).filter(
Reservation.commission_id.isnot(None)
).distinct().all()
)
unassigned_commissions_general = [
build_comm_item(comm, []) for comm in all_active_commissions
if comm.id not in comm_ids_with_any_res and not comm.virtual_link
]
available_classrooms_today = classrooms_unassigned_today
available_classrooms_tomorrow = classrooms_unassigned_tomorrow
available_classrooms_week = classrooms_unassigned_week
available_classrooms_month = classrooms_unassigned_month
unassigned_commissions_tomorrow = commissions_unassigned_tomorrow
unassigned_commissions_week = commissions_unassigned_week
unassigned_commissions_month = commissions_unassigned_month
filter_stats = {
'today': {
'label': date_labels['today'],
'date_short': date_labels['today_short'],
'date_full': date_labels['today_full'],
'classrooms': {
'assigned': classrooms_assigned_today,
'unassigned': classrooms_unassigned_today,
'assigned_count': len(classrooms_assigned_today),
'unassigned_count': len(classrooms_unassigned_today),
'assigned_pct': assigned_today_pct,
'unassigned_pct': unassigned_today_pct,
'total': total_physical_count
},
'commissions': {
'assigned': commissions_assigned_today,
'unassigned': commissions_unassigned_today,
'assigned_count': len(commissions_assigned_today),
'unassigned_count': len(commissions_unassigned_today),
'assigned_pct': round((len(commissions_assigned_today) / max(1, total_active_commissions)) * 100, 1),
'unassigned_pct': round((len(commissions_unassigned_today) / max(1, total_active_commissions)) * 100, 1),
'total': total_active_commissions
}
},
'tomorrow': {
'label': date_labels['tomorrow'],
'date_short': date_labels['tomorrow_short'],
'date_full': date_labels['tomorrow_full'],
'classrooms': {
'assigned': classrooms_assigned_tomorrow,
'unassigned': classrooms_unassigned_tomorrow,
'assigned_count': len(classrooms_assigned_tomorrow),
'unassigned_count': len(classrooms_unassigned_tomorrow),
'assigned_pct': round((len(classrooms_assigned_tomorrow) / max(1, total_physical_count)) * 100, 1),
'unassigned_pct': round((len(classrooms_unassigned_tomorrow) / max(1, total_physical_count)) * 100, 1),
'total': total_physical_count
},
'commissions': {
'assigned': commissions_assigned_tomorrow,
'unassigned': commissions_unassigned_tomorrow,
'assigned_count': len(commissions_assigned_tomorrow),
'unassigned_count': len(commissions_unassigned_tomorrow),
'assigned_pct': round((len(commissions_assigned_tomorrow) / max(1, total_active_commissions)) * 100, 1),
'unassigned_pct': round((len(commissions_unassigned_tomorrow) / max(1, total_active_commissions)) * 100, 1),
'total': total_active_commissions
}
},
'week': {
'label': date_labels['week'],
'date_short': date_labels['week'],
'date_full': date_labels['week_full'],
'classrooms': {
'assigned': classrooms_assigned_week,
'unassigned': classrooms_unassigned_week,
'assigned_count': len(classrooms_assigned_week),
'unassigned_count': len(classrooms_unassigned_week),
'assigned_pct': round((len(classrooms_assigned_week) / max(1, total_physical_count)) * 100, 1),
'unassigned_pct': round((len(classrooms_unassigned_week) / max(1, total_physical_count)) * 100, 1),
'total': total_physical_count
},
'commissions': {
'assigned': commissions_assigned_week,
'unassigned': commissions_unassigned_week,
'assigned_count': len(commissions_assigned_week),
'unassigned_count': len(commissions_unassigned_week),
'assigned_pct': round((len(commissions_assigned_week) / max(1, total_active_commissions)) * 100, 1),
'unassigned_pct': round((len(commissions_unassigned_week) / max(1, total_active_commissions)) * 100, 1),
'total': total_active_commissions
}
},
'month': {
'label': date_labels['month'],
'date_short': date_labels['month'],
'date_full': date_labels['month_full'],
'classrooms': {
'assigned': classrooms_assigned_month,
'unassigned': classrooms_unassigned_month,
'assigned_count': len(classrooms_assigned_month),
'unassigned_count': len(classrooms_unassigned_month),
'assigned_pct': round((len(classrooms_assigned_month) / max(1, total_physical_count)) * 100, 1),
'unassigned_pct': round((len(classrooms_unassigned_month) / max(1, total_physical_count)) * 100, 1),
'total': total_physical_count
},
'commissions': {
'assigned': commissions_assigned_month,
'unassigned': commissions_unassigned_month,
'assigned_count': len(commissions_assigned_month),
'unassigned_count': len(commissions_unassigned_month),
'assigned_pct': round((len(commissions_assigned_month) / max(1, total_active_commissions)) * 100, 1),
'unassigned_pct': round((len(commissions_unassigned_month) / max(1, total_active_commissions)) * 100, 1),
'total': total_active_commissions
}
},
'virtual_rooms': virtual_rooms_data,
'virtual_rooms_count': len(virtual_rooms_data)
}
except Exception as e:
print(f"Error fetching stats in DashboardService: {e}")
monthly_data = [
{"month": "Ene", "reservations": 120},
{"month": "Feb", "reservations": 180},
{"month": "Mar", "reservations": 250},
{"month": "Abr", "reservations": 220},
{"month": "May", "reservations": 300},
{"month": "Jun", "reservations": 310},
{"month": "Jul", "reservations": 200},
{"month": "Ago", "reservations": 350},
{"month": "Sep", "reservations": 420},
{"month": "Oct", "reservations": 480},
{"month": "Nov", "reservations": 520},
{"month": "Dic", "reservations": 210}
]
return {
'status': 'success',
'stats': {
'total_classrooms': total_classrooms,
'active_subjects': total_subjects,
'total_active_users': total_users,
'today_reservations': today_reservations,
'pending_count': pending_count,
'physical_classrooms': physical_classrooms,
'virtual_classrooms': virtual_classrooms,
'occupancy_rate': occupancy_rate,
'assigned_classrooms': assigned_classrooms,
'assigned_classrooms_pct': assigned_pct,
'unassigned_classrooms': unassigned_classrooms,
'unassigned_classrooms_pct': unassigned_pct,
'assigned_today_classrooms': assigned_today_count,
'assigned_today_pct': assigned_today_pct,
'unassigned_today_classrooms': unassigned_today_count,
'unassigned_today_pct': unassigned_today_pct,
'total_active_commissions': total_active_commissions,
'tomorrow_reservations': len(tomorrow_reservations_q),
'my_today_count': my_today_count,
'my_total_reservations': my_total_reservations,
'virtual_rooms_count': virtual_classrooms
},
'audit_logs': audit_data,
'monthly_data': monthly_data,
'pending_reservations': pending_reservations,
'today_schedule_list': today_schedule_list,
'my_today_classes': my_today_classes,
'tomorrow_schedule_list': tomorrow_schedule_list,
'week_schedule_list': week_schedule_list,
'upcoming_reservations': upcoming_reservations,
'milestones': milestones,
'filter_stats': filter_stats,
'date_labels': date_labels,
'ui': {
'show_role_banner': SystemSetting.get_value('dashboard_role_banner_enabled', 'true') in ['true', 'True', '1', True]
},
'bedelia': {
'unassigned_commissions_tomorrow': unassigned_commissions_tomorrow,
'unassigned_commissions_week': unassigned_commissions_week,
'unassigned_commissions_month': unassigned_commissions_month,
'unassigned_commissions_general': unassigned_commissions_general,
'available_classrooms_today': available_classrooms_today,
'available_classrooms_tomorrow': available_classrooms_tomorrow,
'available_classrooms_week': available_classrooms_week,
'available_classrooms_month': available_classrooms_month,
'virtual_rooms': virtual_rooms_data,
'virtual_rooms_count': len(virtual_rooms_data)
}
}
def sync_google_sheets(self, data: Dict[str, Any], current_user: Optional[User] = None, ip_address: Optional[str] = None) -> Dict[str, Any]:
filter_career = data.get('filter_career')
filter_subject = data.get('filter_subject')
filter_day = data.get('filter_day')
filter_days = data.get('filter_days')
manual_date = data.get('manual_date')
single_date_only = bool(data.get('single_date_only', False))
custom_url = data.get('sheets_url') or data.get('base_url')
import_careers = data.get('import_careers', True)
import_subjects = data.get('import_subjects', True)
import_commissions = data.get('import_commissions', True)
import_classrooms = data.get('import_classrooms', True)
import_reservations = data.get('import_reservations', True)
selected_rows = data.get('selected_rows')
user_email = current_user.email if current_user else 'System'
try:
importer = GoogleSheetsImporter(base_url=custom_url)
stats = importer.sync(
filter_career=filter_career,
filter_subject=filter_subject,
filter_day=filter_day,
filter_days=filter_days,
manual_date=manual_date,
single_date_only=single_date_only,
import_careers=import_careers,
import_subjects=import_subjects,
import_commissions=import_commissions,
import_classrooms=import_classrooms,
import_reservations=import_reservations,
selected_rows=selected_rows
)
AuditService.log(
action='SHEETS_IMPORT',
module='import',
user_email=user_email,
ip_address=ip_address,
details={
'stats': stats,
'filter_career': filter_career,
'filter_subject': filter_subject,
'filter_day': filter_day,
'filter_days': filter_days,
'single_date_only': single_date_only,
'manual_date': manual_date
},
status='success'
)
return {
'status': 'success',
'stats': stats,
'source_url': importer.base_url
}
except Exception as e:
AuditService.log(
action='SHEETS_IMPORT_ERROR',
module='import',
user_email=user_email,
ip_address=ip_address,
details={
'error': str(e),
'filter_career': filter_career,
'filter_subject': filter_subject,
'filter_day': filter_day
},
status='failed'
)
raise e
def inspect_google_sheets(self, data: Dict[str, Any]) -> Dict[str, Any]:
custom_url = data.get('sheets_url')
filter_career = data.get('filter_career')
filter_subject = data.get('filter_subject')
filter_day = data.get('filter_day')
filter_days = data.get('filter_days')
manual_date = data.get('manual_date')
importer = GoogleSheetsImporter(base_url=custom_url)
metadata = importer.inspect_sheet_content(
filter_career=filter_career,
filter_subject=filter_subject,
filter_day=filter_day,
filter_days=filter_days,
manual_date=manual_date
)
return {
'status': 'success',
'metadata': metadata,
'source_url': importer.base_url
}
+2 -9
View File
@@ -2,7 +2,7 @@ import jwt
import uuid
from datetime import datetime, timedelta, timezone
from typing import Dict, Any, Optional
from flask import current_app
from config.config import Config
from app.models.user import User
# Lista negra de tokens revocados en memoria (jti -> timestamp de expiración)
@@ -25,14 +25,7 @@ class JWTService:
@classmethod
def _get_secret(cls) -> str:
"""Obtiene la clave secreta desde la configuración de Flask o Config directo."""
try:
from flask import current_app
if current_app:
return current_app.config.get('SECRET_KEY', 'default-edu-space-secret-key')
except Exception:
pass
from config.config import Config
"""Obtiene la clave secreta desde Config."""
return getattr(Config, 'SECRET_KEY', 'default-edu-space-secret-key')
@classmethod
@@ -4,7 +4,6 @@ import threading
from datetime import datetime, timedelta, timezone
from enum import Enum
from typing import List, Dict, Any, Optional
from flask import current_app
from app.models.genetic_algorithm import (
ReservationOptimizer,
-64
View File
@@ -1,64 +0,0 @@
from functools import wraps
from flask import abort, redirect, url_for, request, flash
from flask_login import current_user
from flask_babel import gettext as _
def permission_required(module, min_level='read'):
"""
Decorator to restrict view access based on RBAC permissions.
Hierarchy: 'read_write' > 'read' > 'none'.
Administrators have implicit access to all modules.
"""
def decorator(f):
@wraps(f)
def decorated_function(*args, **kwargs):
if not current_user.is_authenticated:
return redirect(url_for('auth.login', next=request.url))
if not current_user.has_permission(module, min_level):
flash(_('No tienes los permisos necesarios para acceder a esta sección.'), 'error')
abort(403)
return f(*args, **kwargs)
return decorated_function
return decorator
def admin_required(f):
"""
Decorator requiring administrative privileges or 'users' management access.
"""
@wraps(f)
def decorated_function(*args, **kwargs):
if not current_user.is_authenticated:
return redirect(url_for('auth.login', next=request.url))
if not current_user.can_manage():
flash(_('Esta sección requiere privilegios de administrador.'), 'error')
abort(403)
return f(*args, **kwargs)
return decorated_function
def can_edit_reservation_required(f):
"""
Decorator requiring permission to modify a specific reservation.
Allows administrators, Bedelía, or the creator/teacher of the reservation.
"""
@wraps(f)
def decorated_function(*args, **kwargs):
if not current_user.is_authenticated:
return redirect(url_for('auth.login', next=request.url))
res_id = kwargs.get('id')
if res_id:
from app.models.reservation import Reservation
reservation = Reservation.query.get_or_404(res_id)
if not current_user.can_edit_reservation(reservation):
flash(_('No tienes los permisos necesarios para modificar esta reserva.'), 'error')
abort(403)
return f(*args, **kwargs)
return decorated_function
-118
View File
@@ -1,118 +0,0 @@
from functools import wraps
from flask import request, jsonify, g
import jwt
from app.services.jwt_service import JWTService
from app.models.user import User
def jwt_required(f):
"""
Decorador para proteger endpoints REST mediante Bearer Token JWT.
Extrae y valida el token, inyectando el usuario en 'g.jwt_user' y el payload en 'g.jwt_payload'.
"""
@wraps(f)
def decorated_function(*args, **kwargs):
auth_header = request.headers.get('Authorization', '')
token = None
if auth_header.startswith('Bearer '):
token = auth_header.split(' ', 1)[1].strip()
elif 'access_token' in request.cookies:
token = request.cookies.get('access_token')
if not token:
try:
from flask_login import current_user
if current_user.is_authenticated and current_user.is_active:
g.jwt_user = current_user
g.jwt_payload = {'sub': str(current_user.id), 'role': getattr(current_user, 'role', '')}
g.jwt_token = None
g.real_admin_user = current_user
g.is_impersonating = False
return f(*args, **kwargs)
except Exception:
pass
return jsonify({
'error': 'Unauthorized',
'message': 'Encabezado Authorization con Bearer token no proporcionado.'
}), 401
try:
payload = JWTService.decode_token(token, expected_type='access')
sub = payload.get('sub')
if not sub:
return jsonify({
'error': 'Unauthorized',
'message': 'Token inválido: falta identificador de usuario.'
}), 401
user_id = int(sub)
from app import db
user = db.session.get(User, user_id)
if not user or not user.is_active:
return jsonify({
'error': 'Unauthorized',
'message': 'Usuario no encontrado o cuenta desactivada.'
}), 401
g.jwt_user = user
g.jwt_payload = payload
g.jwt_token = token
g.real_admin_user = user
g.is_impersonating = False
impersonate_header = request.headers.get('X-Impersonate-User')
if impersonate_header and user.is_admin():
target_user = None
if impersonate_header.strip().isdigit():
target_user = db.session.get(User, int(impersonate_header.strip()))
else:
target_user = User.query.filter_by(email=impersonate_header.strip()).first()
if target_user and target_user.is_active:
g.jwt_user = target_user
g.is_impersonating = True
except jwt.ExpiredSignatureError:
return jsonify({
'error': 'TokenExpired',
'message': 'El token de acceso ha expirado. Por favor renueve su sesión.'
}), 401
except jwt.InvalidTokenError as e:
return jsonify({
'error': 'InvalidToken',
'message': str(e)
}), 401
except Exception as e:
return jsonify({
'error': 'AuthenticationError',
'message': f'Fallo en la verificación del token: {str(e)}'
}), 401
return f(*args, **kwargs)
return decorated_function
def jwt_role_required(*allowed_roles):
"""
Decorador que verifica que el usuario autenticado vía JWT posea alguno de los roles permitidos.
"""
def decorator(f):
@wraps(f)
@jwt_required
def decorated_function(*args, **kwargs):
user: User = g.jwt_user
if user.is_admin():
return f(*args, **kwargs)
user_role = (user.role_obj.name if user.role_obj else user.role).upper()
allowed = [r.upper() for r in allowed_roles]
if user_role not in allowed:
return jsonify({
'error': 'Forbidden',
'message': f'Acceso denegado. Se requiere uno de los siguientes roles: {", ".join(allowed_roles)}'
}), 403
return f(*args, **kwargs)
return decorated_function
return decorator
+134 -10
View File
@@ -1,20 +1,144 @@
"""
Database & Persistence Management for FastAPI (Capa 4)
Integrates SQLAlchemy Engine, SessionLocal and get_db dependency.
Database & Persistence Management for FastAPI (Capa 4 - SQLAlchemy 2.0 Nativo)
Provides engine, SessionLocal, scoped_session, and declarative Base without any Flask dependency.
"""
import os
import contextlib
from typing import Generator, Any
from app import create_app, db as flask_db
from sqlalchemy import (
create_engine, Column, Integer, String, Text, Boolean, DateTime, Date, Time, Float,
ForeignKey, Table, and_, or_, not_, desc, asc, func, Index, UniqueConstraint
)
from sqlalchemy.orm import declarative_base, scoped_session, sessionmaker, relationship, backref
import sqlalchemy as sa
from config.config import Config
# Initialize shared application context
flask_app = create_app()
# 1. Configurar Engine y conexión
db_url = Config.SQLALCHEMY_DATABASE_URI
connect_args = {}
if "sqlite" in db_url:
connect_args["check_same_thread"] = False
engine = create_engine(
db_url,
connect_args=connect_args,
pool_pre_ping=True
)
# 2. Sessionmaker y scoped_session nativo
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
session = scoped_session(SessionLocal)
# 3. Base declarativa con query_property habilitado
Base = declarative_base()
Base.query = session.query_property()
# 4. Wrapper compatible que emula la API de SQLAlchemy de Flask sin requerir Flask
class SQLAlchemyWrapper:
def __init__(self, target_engine, session_factory, base_class):
self.engine = target_engine
self.session = session_factory
self.Model = base_class
# Schema constructs & Types
self.Column = Column
self.Integer = Integer
self.String = String
self.Text = Text
self.Boolean = Boolean
self.DateTime = DateTime
self.Date = Date
self.Time = Time
self.Float = Float
self.ForeignKey = ForeignKey
self.Index = Index
self.UniqueConstraint = UniqueConstraint
# Relationships
self.relationship = relationship
self.backref = backref
# Operators & functions
self.and_ = and_
self.or_ = or_
self.not_ = not_
self.desc = desc
self.asc = asc
self.func = func
@property
def metadata(self):
return self.Model.metadata
def Table(self, name, *args, **kwargs):
from sqlalchemy import MetaData, Table as SaTable
if len(args) == 0 or not isinstance(args[0], MetaData):
return SaTable(name, self.metadata, *args, **kwargs)
return SaTable(name, *args, **kwargs)
def create_all(self, bind=None):
target = bind or self.engine
try:
import app.models # noqa
except Exception:
pass
self.Model.metadata.create_all(bind=target)
def drop_all(self, bind=None):
target = bind or self.engine
try:
import app.models # noqa
except Exception:
pass
self.Model.metadata.drop_all(bind=target)
def init_app(self, app=None):
"""No-op for legacy compatibility"""
pass
def __getattr__(self, name: str) -> Any:
return getattr(sa, name)
db = SQLAlchemyWrapper(engine, session, Base)
def get_db() -> Generator[Any, None, None]:
"""
FastAPI dependency yielding the SQLAlchemy session within Flask app context
to guarantee all models, ORM queries and services work seamlessly.
FastAPI dependency yielding a clean database session per request.
"""
with flask_app.app_context():
yield flask_db.session
db_session = SessionLocal()
try:
yield db_session
finally:
db_session.close()
# Context manager dummy para compatibilidad transitoria
class DummyAppContext:
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
def push(self):
pass
def pop(self):
pass
class DummyApp:
def __init__(self):
self.config = {
'TESTING': False,
'SQLALCHEMY_DATABASE_URI': Config.SQLALCHEMY_DATABASE_URI,
'SECRET_KEY': Config.SECRET_KEY,
'LANGUAGES': Config.LANGUAGES
}
def app_context(self):
return DummyAppContext()
_dummy_app_instance = DummyApp()
def get_flask_app():
return flask_app
"""
Legacy helper: returns a harmless dummy context object to prevent breakages
during incremental removal of with flask_app.app_context().
"""
return _dummy_app_instance
+62 -48
View File
@@ -1,7 +1,8 @@
"""
FastAPI Security & Authentication Dependencies
Handles JWT extraction from HttpOnly cookies and Bearer headers,
and implements declarative RBAC validation with app context.
and implements declarative RBAC validation with native SQLAlchemy.
100% Native FastAPI - Zero Flask dependencies.
"""
from typing import Optional, List, Callable, Any, Dict
from fastapi import Request, HTTPException, Depends, status
@@ -9,9 +10,6 @@ import jwt
from app.models.user import User
from app.services.jwt_service import JWTService
from database import get_flask_app
flask_app = get_flask_app()
def get_token_from_request(request: Request) -> Optional[str]:
@@ -59,24 +57,33 @@ def get_current_user(request: Request) -> User:
detail="Token no contiene identificador de usuario válido."
)
with flask_app.app_context():
try:
user = User.query.get(int(user_id))
if user:
_ = getattr(user, 'role_obj', None)
except Exception as e:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=f"Error consultando usuario: {str(e)}"
)
if not user or not user.is_active:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Usuario inactivo o no encontrado."
)
# Soporte para auditoría/impersonación mediante cabecera X-Impersonate-User
impersonate_header = request.headers.get('X-Impersonate-User')
if impersonate_header and (user.role or '').upper() == 'ADMIN':
try:
user = User.query.get(int(user_id))
if user:
_ = getattr(user, 'role_obj', None)
except Exception as e:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=f"Error consultando usuario: {str(e)}"
)
target_user = User.query.get(int(impersonate_header))
if target_user and target_user.is_active:
return target_user
except Exception:
pass
if not user or not user.is_active:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Usuario inactivo o no encontrado."
)
return user
return user
def get_optional_current_user(request: Request) -> Optional[User]:
@@ -88,8 +95,7 @@ def get_optional_current_user(request: Request) -> Optional[User]:
payload = JWTService.decode_token(token, expected_type='access')
user_id = payload.get('sub')
if user_id:
with flask_app.app_context():
return User.query.get(int(user_id))
return User.query.get(int(user_id))
except Exception:
pass
return None
@@ -98,38 +104,46 @@ def get_optional_current_user(request: Request) -> Optional[User]:
def require_roles(allowed_roles: List[str]) -> Callable:
"""
Factory de dependencias para control de acceso basado en roles (RBAC).
Normaliza comparaciones en minúsculas y reconoce equivalencias (ADMIN, Bedelia, etc.).
Permite acceso si el rol del usuario (normalizado en mayúsculas) coincide
con alguno de los roles permitidos.
"""
normalized_allowed = [r.lower() for r in allowed_roles]
normalized_allowed = [r.upper() for r in allowed_roles]
def role_dependency(user: User = Depends(get_current_user)) -> User:
user_role = (user.role or '').lower()
is_admin = getattr(user, 'is_admin', lambda: False)() or user_role in ['admin', 'administrador']
def role_checker(current_user: User = Depends(get_current_user)) -> User:
user_role = (current_user.role or '').upper()
if user_role not in normalized_allowed:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"Acceso denegado. Se requiere uno de los roles: {', '.join(allowed_roles)}."
)
return current_user
if is_admin and ('admin' in normalized_allowed or 'administrador' in normalized_allowed):
return user
if user_role in normalized_allowed:
return user
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"Acceso denegado. Se requiere uno de los siguientes roles: {', '.join(allowed_roles)}."
)
return role_dependency
return role_checker
async def get_request_payload(request: Request) -> dict[str, Any]:
"""Extrae el cuerpo JSON o formulario multiparte sanitizado como diccionario de Python."""
async def get_request_payload(request: Request) -> Dict[str, Any]:
"""
Función de utilidad desacoplada para extraer el payload de la petición HTTP,
admitiendo indistintamente cuerpos con JSON (application/json) o formularios codificados
en application/x-www-form-urlencoded y multipart/form-data.
"""
content_type = request.headers.get("content-type", "").lower()
if "application/json" in content_type:
try:
body = await request.json()
return body if isinstance(body, dict) else {}
except Exception:
return {}
if "application/x-www-form-urlencoded" in content_type or "multipart/form-data" in content_type:
try:
form = await request.form()
return dict(form)
except Exception:
return {}
try:
body = await request.json()
if isinstance(body, dict):
return body
except Exception:
pass
try:
form = await request.form()
return {k: str(v) for k, v in form.items()}
return body if isinstance(body, dict) else {}
except Exception:
return {}
+13 -21
View File
@@ -1,26 +1,18 @@
Flask>=3.1.3
Flask-SQLAlchemy==3.1.1
Flask-Login==0.6.3
Flask-WTF==1.2.1
Flask-Migrate==4.0.5
Flask-CORS==6.0.2
Flask-Babel==4.0.0
WTForms==3.1.0
Werkzeug>=3.1.6
SQLAlchemy>=2.0.32
python-dotenv>=1.2.2
requests>=2.32.4
bleach>=6.4.0
python-dateutil==2.8.2
Pillow>=10.4.0
email_validator>=2.0.0
psycopg2-binary>=2.9.10
Babel==2.14.0
gunicorn>=21.2.0
PyJWT>=2.8.0
pydantic>=2.0.0
cryptography>=42.0.0
fastapi>=0.115.0
uvicorn[standard]>=0.30.0
pydantic>=2.0.0
python-dotenv>=1.2.2
requests>=2.32.4
httpx>=0.27.0
a2wsgi>=1.10.0
PyJWT>=2.8.0
cryptography>=42.0.0
Werkzeug>=3.1.6
python-dateutil==2.8.2
bleach>=6.4.0
Pillow>=10.4.0
email_validator>=2.0.0
Babel==2.14.0
gunicorn>=21.2.0
python-multipart>=0.0.9
File diff suppressed because it is too large Load Diff
+756 -764
View File
File diff suppressed because it is too large Load Diff
+222 -229
View File
@@ -18,7 +18,6 @@ from app.services.user_service import UserService
from app.services.jwt_service import JWTService
from app.services.audit_service import AuditService
from dependencies import get_current_user, get_token_from_request
from database import get_flask_app
from schemas.auth import (
LoginRequest,
GoogleAuthRequest,
@@ -30,228 +29,225 @@ from schemas.auth import (
auth_router = APIRouter(prefix="/api/v1/auth", tags=["Authentication"])
user_service = UserService()
flask_app = get_flask_app()
@auth_router.get("/providers")
def get_auth_providers():
"""Retorna los métodos de autenticación habilitados y configuración de cliente Google."""
with flask_app.app_context():
local_val = str(SystemSetting.get_value('auth_local_enabled', 'true') or 'true').lower() in ('true', '1')
google_val = str(SystemSetting.get_value('auth_google_enabled', 'false') or 'false').lower() in ('true', '1')
moodle_val = str(SystemSetting.get_value('auth_moodle_enabled', 'false') or 'false').lower() in ('true', '1')
google_client_id = str(SystemSetting.get_value('google_client_id', '') or '')
demo_access_enabled = str(SystemSetting.get_value('demo_access_enabled', 'true') or 'true').lower() in ('true', '1')
local_val = str(SystemSetting.get_value('auth_local_enabled', 'true') or 'true').lower() in ('true', '1')
google_val = str(SystemSetting.get_value('auth_google_enabled', 'false') or 'false').lower() in ('true', '1')
moodle_val = str(SystemSetting.get_value('auth_moodle_enabled', 'false') or 'false').lower() in ('true', '1')
google_client_id = str(SystemSetting.get_value('google_client_id', '') or '')
demo_access_enabled = str(SystemSetting.get_value('demo_access_enabled', 'true') or 'true').lower() in ('true', '1')
return {
'status': 'success',
'providers': {
'local': local_val,
'google': google_val,
'moodle': moodle_val
},
'google_client_id': google_client_id,
'demo_access_enabled': demo_access_enabled
}
return {
'status': 'success',
'providers': {
'local': local_val,
'google': google_val,
'moodle': moodle_val
},
'google_client_id': google_client_id,
'demo_access_enabled': demo_access_enabled
}
@auth_router.post("/login")
def login(payload: LoginRequest, response: Response):
"""Inicio de sesión local nativo (Access + Refresh tokens)."""
with flask_app.app_context():
local_enabled = str(SystemSetting.get_value('auth_local_enabled', 'true') or 'true').lower() in ('true', '1')
user = user_service.authenticate(payload.email, payload.password)
if not user:
AuditService.log(
action='LOGIN_FAILED',
module='auth',
user_email=payload.email,
details=f"Intento de inicio de sesión fallido para {payload.email}. Credenciales incorrectas o cuenta inactiva."
)
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Credenciales de acceso incorrectas o cuenta inactiva."
)
is_admin = user.is_admin() or getattr(user, 'role', '').upper() == 'ADMIN'
if not local_enabled and not is_admin:
AuditService.log(
action='LOGIN_BLOCKED',
module='auth',
user=user,
entity_id=user.id,
details=f"Acceso local con contraseña bloqueado para {user.email}. Método deshabilitado por administración."
)
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="El acceso local con contraseña está deshabilitado por el administrador. Inicie sesión mediante Google OAuth o Moodle."
)
local_enabled = str(SystemSetting.get_value('auth_local_enabled', 'true') or 'true').lower() in ('true', '1')
user = user_service.authenticate(payload.email, payload.password)
if not user:
AuditService.log(
action='LOGIN',
action='LOGIN_FAILED',
module='auth',
user_email=payload.email,
details=f"Intento de inicio de sesión fallido para {payload.email}. Credenciales incorrectas o cuenta inactiva."
)
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Credenciales de acceso incorrectas o cuenta inactiva."
)
is_admin = user.is_admin() or getattr(user, 'role', '').upper() == 'ADMIN'
if not local_enabled and not is_admin:
AuditService.log(
action='LOGIN_BLOCKED',
module='auth',
user=user,
entity_id=user.id,
details=f"Inicio de sesión exitoso (Autenticación Local) - Rol: {user.role}"
details=f"Acceso local con contraseña bloqueado para {user.email}. Método deshabilitado por administración."
)
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="El acceso local con contraseña está deshabilitado por el administrador. Inicie sesión mediante Google OAuth o Moodle."
)
tokens = JWTService.generate_tokens(user)
profile = user_service.get_profile_data(user)
AuditService.log(
action='LOGIN',
module='auth',
user=user,
entity_id=user.id,
details=f"Inicio de sesión exitoso (Autenticación Local) - Rol: {user.role}"
)
response.set_cookie(
key="access_token",
value=tokens["access_token"],
httponly=True,
samesite="lax",
path="/"
)
response.set_cookie(
key="refresh_token",
value=tokens["refresh_token"],
httponly=True,
samesite="lax",
max_age=7 * 24 * 3600,
path="/api/v1/auth/refresh"
)
tokens = JWTService.generate_tokens(user)
profile = user_service.get_profile_data(user)
return {
'status': 'success',
'access_token': tokens['access_token'],
'refresh_token': tokens['refresh_token'],
'token_type': tokens['token_type'],
'expires_in': tokens['expires_in'],
'user': profile
}
response.set_cookie(
key="access_token",
value=tokens["access_token"],
httponly=True,
samesite="lax",
path="/"
)
response.set_cookie(
key="refresh_token",
value=tokens["refresh_token"],
httponly=True,
samesite="lax",
max_age=7 * 24 * 3600,
path="/api/v1/auth/refresh"
)
return {
'status': 'success',
'access_token': tokens['access_token'],
'refresh_token': tokens['refresh_token'],
'token_type': tokens['token_type'],
'expires_in': tokens['expires_in'],
'user': profile
}
@auth_router.post("/google")
def google_auth(payload: GoogleAuthRequest, response: Response):
"""Inicio de sesión delegado institucional Google OAuth 2.0."""
with flask_app.app_context():
google_enabled = str(SystemSetting.get_value('auth_google_enabled', 'false') or 'false').lower() in ('true', '1')
if not google_enabled:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="El inicio de sesión con Google no está habilitado.")
google_enabled = str(SystemSetting.get_value('auth_google_enabled', 'false') or 'false').lower() in ('true', '1')
if not google_enabled:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="El inicio de sesión con Google no está habilitado.")
email = payload.email.strip().lower()
allowed_domains_str = str(SystemSetting.get_value('google_allowed_domains', 'unicaba.edu.ar') or 'unicaba.edu.ar')
allowed_domains = [d.strip().lower() for d in allowed_domains_str.split(',') if d.strip()]
email = payload.email.strip().lower()
allowed_domains_str = str(SystemSetting.get_value('google_allowed_domains', 'unicaba.edu.ar') or 'unicaba.edu.ar')
allowed_domains = [d.strip().lower() for d in allowed_domains_str.split(',') if d.strip()]
email_domain = email.split('@')[1] if '@' in email else ''
if allowed_domains and email_domain not in allowed_domains:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"Dominio @{email_domain} no autorizado. Sólo se permiten cuentas institucionales: {allowed_domains_str}."
)
email_domain = email.split('@')[1] if '@' in email else ''
if allowed_domains and email_domain not in allowed_domains:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"El dominio @{email_domain} no está autorizado. Sólo se permiten cuentas institucionales: {allowed_domains_str}."
)
user = User.query.filter(User.email.ilike(email)).first()
if not user:
parts = (payload.name or email.split('@')[0]).split()
first_name = parts[0] if parts else 'Usuario'
last_name = ' '.join(parts[1:]) if len(parts) > 1 else 'Google'
docente_role = Role.query.filter(Role.name.ilike('Docente')).first()
user = User(
email=email,
name=payload.name or f"{first_name} {last_name}",
first_name=first_name,
last_name=last_name,
role='Docente' if not docente_role else docente_role.name,
role_id=docente_role.id if docente_role else None,
is_active=True
)
user.set_password(f"GoogleSSO_{email}")
db.session.add(user)
db.session.commit()
user = User.query.filter(User.email.ilike(email)).first()
if not user:
parts = (payload.name or email.split('@')[0]).split()
first_name = parts[0] if parts else 'Usuario'
last_name = ' '.join(parts[1:]) if len(parts) > 1 else 'Google'
docente_role = Role.query.filter(Role.name.ilike('Docente')).first()
user = User(
email=email,
name=payload.name or f"{first_name} {last_name}",
first_name=first_name,
last_name=last_name,
role='Docente' if not docente_role else docente_role.name,
role_id=docente_role.id if docente_role else None,
is_active=True
)
user.set_password(f"GoogleSSO_{email}")
db.session.add(user)
db.session.commit()
if not user.is_active:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Su cuenta institucional está inactiva.")
if not user.is_active:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Su cuenta institucional está inactiva.")
tokens = JWTService.generate_tokens(user)
profile = user_service.get_profile_data(user)
tokens = JWTService.generate_tokens(user)
profile = user_service.get_profile_data(user)
response.set_cookie(key="access_token", value=tokens["access_token"], httponly=True, samesite="lax", path="/")
return {
'status': 'success',
'access_token': tokens['access_token'],
'refresh_token': tokens['refresh_token'],
'token_type': tokens['token_type'],
'expires_in': tokens['expires_in'],
'user': profile
}
response.set_cookie(key="access_token", value=tokens["access_token"], httponly=True, samesite="lax", path="/")
return {
'status': 'success',
'access_token': tokens['access_token'],
'refresh_token': tokens['refresh_token'],
'token_type': tokens['token_type'],
'expires_in': tokens['expires_in'],
'user': profile
}
@auth_router.post("/moodle")
def moodle_auth(payload: MoodleAuthRequest, response: Response):
"""Inicio de sesión delegado con Moodle (verificando DNI o credenciales de campus)."""
with flask_app.app_context():
moodle_enabled = str(SystemSetting.get_value('auth_moodle_enabled', 'false') or 'false').lower() in ('true', '1')
if not moodle_enabled:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="El inicio de sesión con Moodle no está habilitado.")
moodle_enabled = str(SystemSetting.get_value('auth_moodle_enabled', 'false') or 'false').lower() in ('true', '1')
if not moodle_enabled:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="El inicio de sesión con Moodle no está habilitado.")
server_url = str(SystemSetting.get_value('moodle_server_url', 'http://10.0.0.207/moodle') or 'http://10.0.0.207/moodle').rstrip('/')
service_name = str(SystemSetting.get_value('moodle_service_name', 'moodle_api') or 'moodle_api')
server_url = str(SystemSetting.get_value('moodle_server_url', 'http://10.0.0.207/moodle') or 'http://10.0.0.207/moodle').rstrip('/')
service_name = str(SystemSetting.get_value('moodle_service_name', 'moodle_api') or 'moodle_api')
try:
resp = requests.post(f"{server_url}/login/token.php", data={
'username': payload.username,
'password': payload.password,
'service': service_name
}, timeout=10)
res_data = resp.json()
except Exception as e:
raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail=f"No se pudo conectar a Moodle: {str(e)}")
try:
resp = requests.post(f"{server_url}/login/token.php", data={
'username': payload.username,
'password': payload.password,
'service': service_name
}, timeout=10)
res_data = resp.json()
except Exception as e:
raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail=f"No se pudo conectar a Moodle: {str(e)}")
if 'token' not in res_data:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Credenciales de Moodle inválidas.")
if 'token' not in res_data:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Credenciales de Moodle inválidas.")
username = payload.username.strip()
user = User.query.filter(
(User.email.ilike(f"{username}@%")) |
(User.document_number == username)
).first()
username = payload.username.strip()
user = User.query.filter(
(User.email.ilike(f"{username}@%")) |
(User.document_number == username)
).first()
if not user:
role_obj = Role.query.filter(Role.name.ilike('Docente')).first()
user = User(
email=f"{username}@unicaba.edu.ar",
name=username,
document_number=username if username.isdigit() else None,
role=role_obj.name if role_obj else 'Docente',
role_id=role_obj.id if role_obj else None,
is_active=True
)
user.set_password(f"MoodleLinked_{username}")
db.session.add(user)
db.session.commit()
if not user:
role_obj = Role.query.filter(Role.name.ilike('Docente')).first()
user = User(
email=f"{username}@unicaba.edu.ar",
name=username,
document_number=username if username.isdigit() else None,
role=role_obj.name if role_obj else 'Docente',
role_id=role_obj.id if role_obj else None,
is_active=True
)
user.set_password(f"MoodleLinked_{username}")
db.session.add(user)
db.session.commit()
if not user.is_active:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Su cuenta en Edu-Space está desactivada.")
if not user.is_active:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Su cuenta en Edu-Space está desactivada.")
tokens = JWTService.generate_tokens(user)
profile = user_service.get_profile_data(user)
tokens = JWTService.generate_tokens(user)
profile = user_service.get_profile_data(user)
response.set_cookie(key="access_token", value=tokens["access_token"], httponly=True, samesite="lax", path="/")
return {
'status': 'success',
'access_token': tokens['access_token'],
'refresh_token': tokens['refresh_token'],
'token_type': tokens['token_type'],
'expires_in': tokens['expires_in'],
'user': profile
}
response.set_cookie(key="access_token", value=tokens["access_token"], httponly=True, samesite="lax", path="/")
return {
'status': 'success',
'access_token': tokens['access_token'],
'refresh_token': tokens['refresh_token'],
'token_type': tokens['token_type'],
'expires_in': tokens['expires_in'],
'user': profile
}
@auth_router.get("/profile")
@auth_router.get("/me")
def get_current_user_profile(user: User = Depends(get_current_user)):
"""Retorna la ficha del perfil del usuario actualmente autenticado."""
with flask_app.app_context():
u = User.query.get(user.id) or user
profile = user_service.get_profile_data(u)
return {
'status': 'success',
'user': profile
}
u = User.query.get(user.id) or user
profile = user_service.get_profile_data(u)
res = {
'status': 'success',
'user': profile
}
if isinstance(profile, dict):
res.update(profile)
return res
@auth_router.post("/profile")
@@ -260,33 +256,32 @@ def update_profile(
user: User = Depends(get_current_user)
):
"""Actualiza las preferencias de idioma y tema visual del usuario autenticado."""
with flask_app.app_context():
u = User.query.get(user.id)
if not u:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Usuario no encontrado.")
u = User.query.get(user.id)
if not u:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Usuario no encontrado.")
if payload.preferred_language in ['es', 'en']:
u.preferred_language = payload.preferred_language
else:
u.preferred_language = None
if payload.preferred_language in ['es', 'en']:
u.preferred_language = payload.preferred_language
else:
u.preferred_language = None
if payload.theme_preference in ['auto', 'light', 'dark']:
u.theme_preference = payload.theme_preference
if payload.theme_preference in ['auto', 'light', 'dark']:
u.theme_preference = payload.theme_preference
db.session.commit()
profile = user_service.get_profile_data(u)
AuditService.log(
action='UPDATE_PROFILE',
module='auth',
user=u,
details={'preferred_language': u.preferred_language, 'theme_preference': u.theme_preference},
status='success'
)
return {
'status': 'success',
'message': 'Preferencias de usuario actualizadas correctamente.',
'user': profile
}
db.session.commit()
profile = user_service.get_profile_data(u)
AuditService.log(
action='UPDATE_PROFILE',
module='auth',
user=u,
details={'preferred_language': u.preferred_language, 'theme_preference': u.theme_preference},
status='success'
)
return {
'status': 'success',
'message': 'Preferencias de usuario actualizadas correctamente.',
'user': profile
}
@auth_router.post("/theme")
@@ -295,20 +290,19 @@ def update_theme(
user: User = Depends(get_current_user)
):
"""Actualiza el tema visual del usuario desde la interfaz (AJAX)."""
with flask_app.app_context():
u = User.query.get(user.id)
if not u:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Usuario no encontrado.")
u = User.query.get(user.id)
if not u:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Usuario no encontrado.")
if payload.theme not in ['auto', 'light', 'dark']:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Tema visual inválido.")
if payload.theme not in ['auto', 'light', 'dark']:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Tema visual inválido.")
u.theme_preference = payload.theme
db.session.commit()
return {
'status': 'success',
'theme': u.theme_preference
}
u.theme_preference = payload.theme
db.session.commit()
return {
'status': 'success',
'theme': u.theme_preference
}
@auth_router.post("/logout")
@@ -333,24 +327,23 @@ def refresh_token(request: Request, response: Response, payload: Optional[Refres
if not token:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="No se proporcionó refresh token.")
with flask_app.app_context():
try:
decoded = JWTService.decode_token(token, expected_type='refresh')
user_id = decoded.get('sub')
if not user_id:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Token no contiene sub válido.")
user = User.query.get(int(str(user_id)))
if not user or not user.is_active:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Usuario no encontrado o inactivo.")
try:
decoded = JWTService.decode_token(token, expected_type='refresh')
user_id = decoded.get('sub')
if not user_id:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Token no contiene sub válido.")
user = User.query.get(int(str(user_id)))
if not user or not user.is_active:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Usuario no encontrado o inactivo.")
tokens = JWTService.generate_tokens(user)
response.set_cookie(key="access_token", value=tokens["access_token"], httponly=True, samesite="lax", path="/")
return {
'status': 'success',
'access_token': tokens['access_token'],
'refresh_token': tokens['refresh_token'],
'token_type': tokens['token_type'],
'expires_in': tokens['expires_in']
}
except Exception as e:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=f"Refresh token inválido: {str(e)}")
tokens = JWTService.generate_tokens(user)
response.set_cookie(key="access_token", value=tokens["access_token"], httponly=True, samesite="lax", path="/")
return {
'status': 'success',
'access_token': tokens['access_token'],
'refresh_token': tokens['refresh_token'],
'token_type': tokens['token_type'],
'expires_in': tokens['expires_in']
}
except Exception as e:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=f"Refresh token inválido: {str(e)}")
+183 -190
View File
@@ -1,8 +1,9 @@
"""
FastAPI Buildings Router (/api/v1/buildings)
Provides endpoints for listing, retrieving, creating, updating, toggling and deleting institutional buildings.
100% Native FastAPI - Zero Flask dependencies.
"""
from typing import Optional, Dict, Any
from typing import Optional
from fastapi import APIRouter, Depends, HTTPException, Query, status, Request
from sqlalchemy import func, or_
from datetime import datetime, timezone
@@ -13,10 +14,8 @@ from app.models.classroom import Classroom
from app.services.audit_service import AuditService
from dependencies import get_current_user, require_roles, get_request_payload
from app.models.user import User
from database import get_flask_app
buildings_router = APIRouter(prefix="/api/v1/buildings", tags=["Buildings"])
flask_app = get_flask_app()
@buildings_router.get("")
@@ -26,46 +25,45 @@ def list_buildings(
current_user: User = Depends(get_current_user)
):
"""Lista todos los edificios con métricas globales de capacidad y estado."""
with flask_app.app_context():
search_term = (search or '').strip().lower()
st_term = (status_filter or '').strip().lower()
search_term = (search or '').strip().lower()
st_term = (status_filter or '').strip().lower()
query = Building.query
if search_term:
query = query.filter(
or_(
Building.name.ilike(f'%{search_term}%'),
Building.code.ilike(f'%{search_term}%'),
Building.address.ilike(f'%{search_term}%')
)
query = Building.query
if search_term:
query = query.filter(
or_(
Building.name.ilike(f'%{search_term}%'),
Building.code.ilike(f'%{search_term}%'),
Building.address.ilike(f'%{search_term}%')
)
if st_term == 'active':
query = query.filter(Building.is_active == True)
elif st_term == 'inactive':
query = query.filter(Building.is_active == False)
)
if st_term == 'active':
query = query.filter(Building.is_active == True)
elif st_term == 'inactive':
query = query.filter(Building.is_active == False)
buildings = query.order_by(Building.name.asc()).all()
buildings_data = [b.to_dict() for b in buildings]
buildings = query.order_by(Building.name.asc()).all()
buildings_data = [b.to_dict() for b in buildings]
all_classrooms = Classroom.query.filter_by(is_active=True).all()
physical_classrooms = [
c for c in all_classrooms
if not getattr(c, 'is_virtual', False) and (c.capacity or 0) < 999 and 'VIRTUAL' not in (c.code or '').upper()
]
total_physical_capacity = sum(c.capacity for c in physical_classrooms)
all_classrooms = Classroom.query.filter_by(is_active=True).all()
physical_classrooms = [
c for c in all_classrooms
if not getattr(c, 'is_virtual', False) and (c.capacity or 0) < 999 and 'VIRTUAL' not in (c.code or '').upper()
]
total_physical_capacity = sum(c.capacity for c in physical_classrooms)
return {
'status': 'success',
'total': len(buildings_data),
'buildings': buildings_data,
'stats': {
'total_buildings': len(buildings),
'total_classrooms': len(all_classrooms),
'physical_classrooms_count': len(physical_classrooms),
'total_physical_capacity': total_physical_capacity,
'total_floors': sum(b.floors for b in buildings if not b.is_virtual)
}
return {
'status': 'success',
'total': len(buildings_data),
'buildings': buildings_data,
'stats': {
'total_buildings': len(buildings),
'total_classrooms': len(all_classrooms),
'physical_classrooms_count': len(physical_classrooms),
'total_physical_capacity': total_physical_capacity,
'total_floors': sum(b.floors for b in buildings if not b.is_virtual)
}
}
@buildings_router.get("/{id}")
@@ -74,20 +72,19 @@ def get_building(
current_user: User = Depends(get_current_user)
):
"""Obtiene el detalle de un edificio y su lista de aulas."""
with flask_app.app_context():
building = Building.query.get(id)
if not building:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Edificio con ID {id} no encontrado.")
building = Building.query.get(id)
if not building:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Edificio con ID {id} no encontrado.")
classrooms = Classroom.query.filter(
or_(Classroom.building_id == id, Classroom.building == building.name)
).order_by(Classroom.floor.asc(), Classroom.code.asc()).all()
classrooms = Classroom.query.filter(
or_(Classroom.building_id == id, Classroom.building == building.name)
).order_by(Classroom.floor.asc(), Classroom.code.asc()).all()
return {
'status': 'success',
'building': building.to_dict(),
'classrooms': [c.to_dict() for c in classrooms]
}
return {
'status': 'success',
'building': building.to_dict(),
'classrooms': [c.to_dict() for c in classrooms]
}
@buildings_router.post("", status_code=status.HTTP_201_CREATED)
@@ -98,54 +95,53 @@ async def create_building(
"""Crea una nueva sede o edificio institucional."""
data = await get_request_payload(request)
with flask_app.app_context():
name = str(data.get('name') or '').strip()
code_str = str(data.get('code') or '').strip().upper()
code = code_str if code_str else None
address_str = str(data.get('address') or '').strip()
address = address_str if address_str else None
try:
floors_val = data.get('floors', 1)
floors = int(str(floors_val)) if floors_val is not None else 1
except (ValueError, TypeError):
floors = 1
desc_str = str(data.get('description') or '').strip()
description = desc_str if desc_str else None
is_active = data.get('is_active', True)
if isinstance(is_active, str):
is_active = is_active.lower() in ['true', '1', 'on']
name = str(data.get('name') or '').strip()
code_str = str(data.get('code') or '').strip().upper()
code = code_str if code_str else None
address_str = str(data.get('address') or '').strip()
address = address_str if address_str else None
try:
floors_val = data.get('floors', 1)
floors = int(str(floors_val)) if floors_val is not None else 1
except (ValueError, TypeError):
floors = 1
desc_str = str(data.get('description') or '').strip()
description = desc_str if desc_str else None
is_active = data.get('is_active', True)
if isinstance(is_active, str):
is_active = is_active.lower() in ['true', '1', 'on']
if not name:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="El nombre del edificio es obligatorio.")
if not name:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="El nombre del edificio es obligatorio.")
existing = Building.query.filter(func.lower(Building.name) == name.lower()).first()
if existing:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f'Ya existe un edificio con el nombre "{name}".')
existing = Building.query.filter(func.lower(Building.name) == name.lower()).first()
if existing:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f'Ya existe un edificio con el nombre "{name}".')
building = Building(
name=name,
code=code,
address=address,
floors=floors,
description=description,
is_active=bool(is_active)
)
db.session.add(building)
db.session.commit()
building = Building(
name=name,
code=code,
address=address,
floors=floors,
description=description,
is_active=bool(is_active)
)
db.session.add(building)
db.session.commit()
AuditService.log(
action='CREATE',
module='buildings',
entity_id=building.id,
user=current_user,
details=f"Nueva sede/edificio creado: '{building.name}' (Código: {building.code or 'S/C'}, Pisos: {building.floors})"
)
AuditService.log(
action='CREATE',
module='buildings',
entity_id=building.id,
user=current_user,
details=f"Nueva sede/edificio creado: '{building.name}' (Código: {building.code or 'S/C'}, Pisos: {building.floors})"
)
return {
'status': 'success',
'message': f'Edificio "{name}" creado con éxito.',
'building': building.to_dict()
}
return {
'status': 'success',
'message': f'Edificio "{name}" creado con éxito.',
'building': building.to_dict()
}
@buildings_router.put("/{id}")
@@ -158,65 +154,64 @@ async def update_building(
"""Actualiza la información de un edificio existente."""
data = await get_request_payload(request)
with flask_app.app_context():
building = Building.query.get(id)
if not building:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Edificio con ID {id} no encontrado.")
building = Building.query.get(id)
if not building:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Edificio con ID {id} no encontrado.")
name = str(data.get('name') or '').strip()
if not name:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="El nombre del edificio es obligatorio.")
name = str(data.get('name') or '').strip()
if not name:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="El nombre del edificio es obligatorio.")
existing = Building.query.filter(
func.lower(Building.name) == name.lower(),
Building.id != id
).first()
if existing:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f'Ya existe otro edificio con el nombre "{name}".')
existing = Building.query.filter(
func.lower(Building.name) == name.lower(),
Building.id != id
).first()
if existing:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f'Ya existe otro edificio con el nombre "{name}".')
old_name = building.name
building.name = name
if 'code' in data:
c_val = str(data.get('code') or '').strip().upper()
building.code = c_val if c_val else None
if 'address' in data:
a_val = str(data.get('address') or '').strip()
building.address = a_val if a_val else None
if 'floors' in data:
try:
fl_val = data.get('floors', 0)
building.floors = int(str(fl_val)) if fl_val is not None else 0
except (ValueError, TypeError):
pass
if 'description' in data:
d_val = str(data.get('description') or '').strip()
building.description = d_val if d_val else None
if 'is_active' in data:
is_active = data.get('is_active')
if isinstance(is_active, str):
building.is_active = is_active.lower() in ['true', '1', 'on']
else:
building.is_active = bool(is_active)
building.updated_at = datetime.now(timezone.utc).replace(tzinfo=None)
old_name = building.name
building.name = name
if 'code' in data:
c_val = str(data.get('code') or '').strip().upper()
building.code = c_val if c_val else None
if 'address' in data:
a_val = str(data.get('address') or '').strip()
building.address = a_val if a_val else None
if 'floors' in data:
try:
fl_val = data.get('floors', 0)
building.floors = int(str(fl_val)) if fl_val is not None else 0
except (ValueError, TypeError):
pass
if 'description' in data:
d_val = str(data.get('description') or '').strip()
building.description = d_val if d_val else None
if 'is_active' in data:
is_active = data.get('is_active')
if isinstance(is_active, str):
building.is_active = is_active.lower() in ['true', '1', 'on']
else:
building.is_active = bool(is_active)
building.updated_at = datetime.now(timezone.utc).replace(tzinfo=None)
if old_name != name:
Classroom.query.filter_by(building_id=building.id).update({'building': name})
if old_name != name:
Classroom.query.filter_by(building_id=building.id).update({'building': name})
db.session.commit()
db.session.commit()
AuditService.log(
action='UPDATE',
module='buildings',
entity_id=building.id,
user=current_user,
details=f"Edificio/sede #{building.id} ('{building.name}') actualizado. Pisos: {building.floors}, Código: {building.code}"
)
AuditService.log(
action='UPDATE',
module='buildings',
entity_id=building.id,
user=current_user,
details=f"Edificio/sede #{building.id} ('{building.name}') actualizado. Pisos: {building.floors}, Código: {building.code}"
)
return {
'status': 'success',
'message': f'Edificio "{building.name}" actualizado con éxito.',
'building': building.to_dict()
}
return {
'status': 'success',
'message': f'Edificio "{building.name}" actualizado con éxito.',
'building': building.to_dict()
}
@buildings_router.post("/{id}/toggle")
@@ -225,28 +220,27 @@ def toggle_building(
current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"]))
):
"""Conmuta el estado activo/inactivo de un edificio."""
with flask_app.app_context():
building = Building.query.get(id)
if not building:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Edificio con ID {id} no encontrado.")
building = Building.query.get(id)
if not building:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Edificio con ID {id} no encontrado.")
building.is_active = not building.is_active
building.updated_at = datetime.now(timezone.utc).replace(tzinfo=None)
db.session.commit()
building.is_active = not building.is_active
building.updated_at = datetime.now(timezone.utc).replace(tzinfo=None)
db.session.commit()
AuditService.log(
action='TOGGLE',
module='buildings',
entity_id=building.id,
user=current_user,
details=f"Edificio '{building.name}' {'activado' if building.is_active else 'desactivado'}"
)
AuditService.log(
action='TOGGLE',
module='buildings',
entity_id=building.id,
user=current_user,
details=f"Edificio '{building.name}' {'activado' if building.is_active else 'desactivado'}"
)
return {
'status': 'success',
'message': f'Edificio "{building.name}" {"activado" if building.is_active else "desactivado"} exitosamente.',
'building': building.to_dict()
}
return {
'status': 'success',
'message': f'Edificio "{building.name}" {"activado" if building.is_active else "desactivado"} exitosamente.',
'building': building.to_dict()
}
@buildings_router.delete("/{id}")
@@ -255,33 +249,32 @@ def delete_building(
current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"]))
):
"""Elimina un edificio si no posee aulas físicas o virtuales asociadas."""
with flask_app.app_context():
building = Building.query.get(id)
if not building:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Edificio con ID {id} no encontrado.")
building = Building.query.get(id)
if not building:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Edificio con ID {id} no encontrado.")
count = Classroom.query.filter(
or_(Classroom.building_id == building.id, Classroom.building == building.name)
).count()
if count > 0:
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail=f'No se puede eliminar el edificio "{building.name}" porque tiene {count} aulas asociadas.'
)
b_name = building.name
db.session.delete(building)
db.session.commit()
AuditService.log(
action='DELETE',
module='buildings',
entity_id=id,
user=current_user,
details=f"Edificio '{b_name}' eliminado del sistema."
count = Classroom.query.filter(
or_(Classroom.building_id == building.id, Classroom.building == building.name)
).count()
if count > 0:
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail=f'No se puede eliminar el edificio "{building.name}" porque tiene {count} aulas asociadas.'
)
return {
'status': 'success',
'message': f'Edificio "{b_name}" eliminado correctamente.'
}
b_name = building.name
db.session.delete(building)
db.session.commit()
AuditService.log(
action='DELETE',
module='buildings',
entity_id=id,
user=current_user,
details=f"Edificio '{b_name}' eliminado del sistema."
)
return {
'status': 'success',
'message': f'Edificio "{b_name}" eliminado correctamente.'
}
+109 -116
View File
@@ -1,6 +1,7 @@
"""
FastAPI Classrooms Router (/api/v1/classrooms)
Provides endpoints for listing, retrieving, creating, updating and toggling classrooms.
100% Native FastAPI - Zero Flask dependencies.
"""
from typing import Optional
from fastapi import APIRouter, Depends, HTTPException, Query, status
@@ -12,11 +13,9 @@ from app.services.audit_service import AuditService
from app.schemas.classroom_dto import ClassroomCreateDTO, ClassroomUpdateDTO
from dependencies import get_current_user, require_roles
from app.models.user import User
from database import get_flask_app
classrooms_router = APIRouter(prefix="/api/v1/classrooms", tags=["Classrooms"])
classroom_service = ClassroomService()
flask_app = get_flask_app()
@classrooms_router.get("")
@@ -27,52 +26,20 @@ def list_classrooms(
current_user: User = Depends(get_current_user)
):
"""Lista aulas físicas y virtuales con filtros opcionales."""
with flask_app.app_context():
mode_str = (mode or '').lower()
only_virtual = mode_str == 'virtual'
only_physical = mode_str == 'physical'
mode_str = (mode or '').lower()
only_virtual = mode_str == 'virtual'
only_physical = mode_str == 'physical'
classrooms = classroom_service.list_classrooms(
building_id=building_id,
floor=floor,
only_virtual=only_virtual,
only_physical=only_physical
)
classrooms = classroom_service.list_classrooms(
building_id=building_id,
floor=floor,
only_virtual=only_virtual,
only_physical=only_physical
)
result = []
for c in classrooms:
result.append({
'id': c.id,
'code': c.code,
'building': c.building_name,
'building_id': c.building_id,
'floor': c.floor,
'floor_display': c.floor_display,
'capacity': c.capacity,
'is_virtual': c.is_virtual,
'location_display': c.location_display,
'description': c.description,
'is_active': c.is_active
})
return {'total': len(result), 'classrooms': result}
@classrooms_router.get("/{classroom_id}")
def get_classroom(
classroom_id: int,
current_user: User = Depends(get_current_user)
):
"""Obtiene el detalle de un aula por ID."""
with flask_app.app_context():
c = classroom_service.get_classroom(classroom_id)
if not c:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Aula {classroom_id} no encontrada."
)
return {
result = []
for c in classrooms:
result.append({
'id': c.id,
'code': c.code,
'building': c.building_name,
@@ -84,7 +51,37 @@ def get_classroom(
'location_display': c.location_display,
'description': c.description,
'is_active': c.is_active
}
})
return {'total': len(result), 'classrooms': result}
@classrooms_router.get("/{classroom_id}")
def get_classroom(
classroom_id: int,
current_user: User = Depends(get_current_user)
):
"""Obtiene el detalle de un aula por ID."""
c = classroom_service.get_classroom(classroom_id)
if not c:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Aula {classroom_id} no encontrada."
)
return {
'id': c.id,
'code': c.code,
'building': c.building_name,
'building_id': c.building_id,
'floor': c.floor,
'floor_display': c.floor_display,
'capacity': c.capacity,
'is_virtual': c.is_virtual,
'location_display': c.location_display,
'description': c.description,
'is_active': c.is_active
}
@classrooms_router.post("", status_code=status.HTTP_201_CREATED)
@@ -93,24 +90,23 @@ def create_classroom(
current_user: User = Depends(require_roles(['admin', 'administrador', 'bedelia']))
):
"""Crea una nueva aula validando con ClassroomCreateDTO."""
with flask_app.app_context():
try:
classroom = classroom_service.create_classroom(dto)
AuditService.log(
action='CREATE',
module='classrooms',
entity_id=classroom.id,
user=current_user,
details=f"Nueva aula creada: {classroom.code} en {classroom.building} (Piso {classroom.floor}, Capacidad: {classroom.capacity})"
)
return {
'message': 'Aula creada exitosamente.',
'id': classroom.id,
'code': classroom.code,
'location_display': classroom.location_display
}
except ValueError as e:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
try:
classroom = classroom_service.create_classroom(dto)
AuditService.log(
action='CREATE',
module='classrooms',
entity_id=classroom.id,
user=current_user,
details=f"Nueva aula creada: {classroom.code} en {classroom.building} (Piso {classroom.floor}, Capacidad: {classroom.capacity})"
)
return {
'message': 'Aula creada exitosamente.',
'id': classroom.id,
'code': classroom.code,
'location_display': classroom.location_display
}
except ValueError as e:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
@classrooms_router.put("/{classroom_id}")
@@ -120,27 +116,26 @@ def update_classroom(
current_user: User = Depends(require_roles(['admin', 'administrador', 'bedelia']))
):
"""Actualiza los datos de un aula."""
with flask_app.app_context():
try:
classroom = classroom_service.update_classroom(classroom_id, dto)
if not classroom:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Aula {classroom_id} no encontrada.")
try:
classroom = classroom_service.update_classroom(classroom_id, dto)
if not classroom:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Aula {classroom_id} no encontrada.")
AuditService.log(
action='UPDATE',
module='classrooms',
entity_id=classroom.id,
user=current_user,
details=f"Aula #{classroom.id} ({classroom.code}) actualizada. Capacidad: {classroom.capacity}, Piso: {classroom.floor}"
)
return {
'message': 'Aula actualizada exitosamente.',
'id': classroom.id,
'code': classroom.code,
'capacity': classroom.capacity
}
except ValueError as e:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
AuditService.log(
action='UPDATE',
module='classrooms',
entity_id=classroom.id,
user=current_user,
details=f"Aula #{classroom.id} ({classroom.code}) actualizada. Capacidad: {classroom.capacity}, Piso: {classroom.floor}"
)
return {
'message': 'Aula actualizada exitosamente.',
'id': classroom.id,
'code': classroom.code,
'capacity': classroom.capacity
}
except ValueError as e:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
@classrooms_router.delete("/{classroom_id}")
@@ -149,19 +144,18 @@ def delete_classroom(
current_user: User = Depends(require_roles(['admin', 'administrador']))
):
"""Elimina o desactiva un aula."""
with flask_app.app_context():
deleted = classroom_service.delete_classroom(classroom_id)
if not deleted:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Aula {classroom_id} no encontrada.")
deleted = classroom_service.delete_classroom(classroom_id)
if not deleted:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Aula {classroom_id} no encontrada.")
AuditService.log(
action='DELETE',
module='classrooms',
entity_id=classroom_id,
user=current_user,
details=f"Aula #{classroom_id} eliminada/desactivada del sistema"
)
return {'message': f'Aula {classroom_id} eliminada/desactivada correctamente.'}
AuditService.log(
action='DELETE',
module='classrooms',
entity_id=classroom_id,
user=current_user,
details=f"Aula #{classroom_id} eliminada/desactivada del sistema"
)
return {'message': f'Aula {classroom_id} eliminada/desactivada correctamente.'}
@classrooms_router.post("/{classroom_id}/toggle")
@@ -170,23 +164,22 @@ def toggle_classroom(
current_user: User = Depends(require_roles(['admin', 'administrador', 'bedelia']))
):
"""Alterna el estado activo/inactivo de un aula."""
with flask_app.app_context():
classroom = Classroom.query.get(classroom_id)
if not classroom:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Aula {classroom_id} no encontrada.")
classroom = Classroom.query.get(classroom_id)
if not classroom:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Aula {classroom_id} no encontrada.")
classroom.is_active = not classroom.is_active
db.session.commit()
AuditService.log(
action='TOGGLE',
module='classrooms',
entity_id=classroom.id,
user=current_user,
details=f"Aula {classroom.code} {'activada' if classroom.is_active else 'desactivada'}"
)
return {
'status': 'success',
'id': classroom.id,
'is_active': classroom.is_active,
'message': f'Aula {"activada" if classroom.is_active else "desactivada"} correctamente.'
}
classroom.is_active = not classroom.is_active
db.session.commit()
AuditService.log(
action='TOGGLE',
module='classrooms',
entity_id=classroom.id,
user=current_user,
details=f"Aula {classroom.code} {'activada' if classroom.is_active else 'desactivada'}"
)
return {
'status': 'success',
'id': classroom.id,
'is_active': classroom.is_active,
'message': f'Aula {"activada" if classroom.is_active else "desactivada"} correctamente.'
}
+23 -40
View File
@@ -1,38 +1,23 @@
"""
FastAPI Dashboard Router (/api/v1/dashboard)
Provides operational metrics, today/tomorrow/week schedule, and Google Sheets sync inspection.
100% Native FastAPI - Zero Flask dependencies.
"""
from typing import Optional, Dict, Any
from datetime import datetime
from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
from typing import Dict, Any
from fastapi import APIRouter, Depends, HTTPException, Request, status
from app.models.classroom import Classroom
from app.models.subject import Subject
from app.models.user import User
from app.models.reservation import Reservation
from app.models.audit_log import AuditLog
from app.models.milestone import AcademicMilestone
from app.models.subject import Commission
from app.models.setting import SystemSetting
from app.services.audit_service import AuditService
from app.services.dashboard_service import DashboardService
from dependencies import get_current_user
from database import get_flask_app
dashboard_router = APIRouter(prefix="/api/v1/dashboard", tags=["Dashboard"])
dashboard_service = DashboardService()
@dashboard_router.get("/stats")
def get_stats(current_user: User = Depends(get_current_user)):
"""Retorna estadísticas clave y datos operativos para el Dashboard."""
from app.routes.api.dashboard import get_stats as flask_get_stats
f_app = get_flask_app()
with f_app.test_request_context():
from flask import g
g.jwt_user = current_user
resp = flask_get_stats()
if hasattr(resp, 'get_json'):
return resp.get_json()
return resp[0].get_json() if isinstance(resp, tuple) else resp
return dashboard_service.get_stats(current_user=current_user)
@dashboard_router.post("/sync-sheets")
@@ -42,16 +27,14 @@ def sync_google_sheets(
current_user: User = Depends(get_current_user)
):
"""Ejecuta la sincronización con Google Sheets con filtros y selección granular."""
from app.routes.api.dashboard import sync_google_sheets as flask_sync
f_app = get_flask_app()
with f_app.test_request_context(json=payload):
from flask import g
g.jwt_user = current_user
g.current_user = {'email': current_user.email}
resp = flask_sync()
if hasattr(resp, 'get_json'):
return resp.get_json()
return resp[0].get_json() if isinstance(resp, tuple) else resp
try:
ip = request.client.host if request.client else '127.0.0.1'
return dashboard_service.sync_google_sheets(payload, current_user=current_user, ip_address=ip)
except Exception as e:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=str(e)
)
@dashboard_router.get("/sheets-inspect")
@@ -61,12 +44,12 @@ def inspect_google_sheets(
current_user: User = Depends(get_current_user)
):
"""Inspecciona las hojas de cálculo descubriendo carreras, materias y previsualización."""
from app.routes.api.dashboard import inspect_google_sheets as flask_inspect
f_app = get_flask_app()
with f_app.test_request_context():
from flask import g
g.jwt_user = current_user
resp = flask_inspect()
if hasattr(resp, 'get_json'):
return resp.get_json()
return resp[0].get_json() if isinstance(resp, tuple) else resp
try:
# Puede venir como query params o json body
data: Dict[str, Any] = dict(request.query_params)
return dashboard_service.inspect_google_sheets(data)
except Exception as e:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=str(e)
)
+50 -11
View File
@@ -1,15 +1,18 @@
"""
FastAPI Optimizer & Genetic Algorithm Router (/api/v1/optimizer and /api/genetic)
Provides asynchronous optimization jobs and genetic heuristic room assignment.
100% Native FastAPI - Zero Flask dependencies.
"""
from typing import Optional, Dict, Any
from typing import Optional, Dict, Any, List
from fastapi import APIRouter, Depends, HTTPException, Query, status
from app.schemas.optimizer_dto import OptimizerJobRequestDTO, SpringBootSyncPayloadDTO
from app.services.optimizer_service import OptimizerService
from dependencies import get_current_user
from app.models.user import User
from database import get_flask_app
from app.models.subject import Commission
from app.models.classroom import Classroom
from app.models.reservation import Reservation, ReservationStatus
optimizer_router = APIRouter(prefix="/api/v1/optimizer", tags=["Optimizer"])
genetic_router = APIRouter(prefix="/api/genetic", tags=["Genetic Heuristics"])
@@ -81,12 +84,48 @@ def sync_with_spring_boot(
@genetic_router.get("/commissions")
def get_genetic_commissions(current_user: User = Depends(get_current_user)):
"""Retorna comisiones activas para el optimizador genético."""
from app.routes.genetic_algorithm import get_commissions as flask_get_comm
f_app = get_flask_app()
with f_app.test_request_context():
from flask import g
g.jwt_user = current_user
resp = flask_get_comm()
if hasattr(resp, 'get_json'):
return resp.get_json()
return resp[0].get_json() if isinstance(resp, tuple) else resp
commissions = Commission.query.filter_by(active=True).all()
commissions_data: List[Dict[str, Any]] = []
for commission in commissions:
commission_dict = commission.to_dict()
commission_dict['get_full_code'] = commission.get_full_code()
commission_dict['subject_name'] = commission.subject.name if commission.subject else 'Sin Asignatura'
commission_dict['subject_code'] = commission.subject.code if commission.subject else ''
commissions_data.append(commission_dict)
return {
'success': True,
'commissions': commissions_data
}
@genetic_router.get("/algorithm-status")
def get_genetic_algorithm_status(current_user: User = Depends(get_current_user)):
"""Retorna estado y capacidades de los algoritmos de optimización."""
total_classrooms = Classroom.query.filter_by(is_active=True).count()
total_commissions = Commission.query.filter_by(active=True).count()
total_reservations = Reservation.query.filter_by(status=ReservationStatus.CONFIRMED.value).count()
return {
'success': True,
'data': {
'algorithm_config': {
'population_size': 50,
'generations': 100,
'mutation_rate': 0.1,
'crossover_rate': 0.8
},
'system_status': {
'available_classrooms': total_classrooms,
'active_commissions': total_commissions,
'confirmed_reservations': total_reservations
},
'capabilities': [
'Automatic classroom assignment',
'Capacity optimization',
'Time conflict resolution',
'Resource matching',
'Batch reservation processing'
]
}
}
+317 -322
View File
@@ -15,11 +15,9 @@ from app.services.audit_service import AuditService
from app.schemas.reservation_dto import ReservationCreateDTO, ReservationUpdateDTO
from dependencies import get_current_user, get_request_payload
from app.models.user import User
from database import get_flask_app
reservations_router = APIRouter(prefix="/api/v1/reservations", tags=["Reservations"])
reservation_service = ReservationService()
flask_app = get_flask_app()
@reservations_router.get("")
@@ -34,166 +32,164 @@ def list_reservations(
current_user: User = Depends(get_current_user)
):
"""Consulta de reservas por rango de fechas y/o aula."""
with flask_app.app_context():
now = datetime.now(timezone.utc).replace(tzinfo=None)
try:
start_dt = datetime.strptime(start_date, '%Y-%m-%d') if start_date else now.replace(hour=0, minute=0, second=0)
except ValueError:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Formato inválido de start_date (debe ser YYYY-MM-DD).")
now = datetime.now(timezone.utc).replace(tzinfo=None)
try:
start_dt = datetime.strptime(start_date, '%Y-%m-%d') if start_date else now.replace(hour=0, minute=0, second=0)
except ValueError:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Formato inválido de start_date (debe ser YYYY-MM-DD).")
try:
end_dt = datetime.strptime(end_date, '%Y-%m-%d').replace(hour=23, minute=59, second=59) if end_date else start_dt + timedelta(days=7)
except ValueError:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Formato inválido de end_date (debe ser YYYY-MM-DD).")
try:
end_dt = datetime.strptime(end_date, '%Y-%m-%d').replace(hour=23, minute=59, second=59) if end_date else start_dt + timedelta(days=7)
except ValueError:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Formato inválido de end_date (debe ser YYYY-MM-DD).")
is_hide_virtual = str(hide_virtual).lower() in ['1', 'true']
is_hide_virtual = str(hide_virtual).lower() in ['1', 'true']
reservations = reservation_service.list_reservations(start_dt, end_dt, classroom_id=classroom_id)
result = []
for r in reservations:
is_virt = bool(r.is_virtual or (r.classroom and r.classroom.is_virtual))
if is_hide_virtual and is_virt:
continue
if floor and r.classroom and str(r.classroom.floor).strip().lower() != floor.strip().lower():
continue
if shift and r.shift and shift.lower() not in r.shift.lower():
continue
r_user: Any = getattr(r, 'user', None)
u_name = (getattr(r_user, 'name', '') or '').lower() if r_user else ''
if search:
s_lower = search.lower()
subj_n = (r.subject_name or '').lower()
subj_c = (r.subject_code or '').lower()
c_name = (r.classroom.code if r.classroom else '').lower()
if s_lower not in subj_n and s_lower not in subj_c and s_lower not in c_name and s_lower not in u_name:
continue
user_dict = {
'id': getattr(r_user, 'id', None),
'name': getattr(r_user, 'name', None),
'email': getattr(r_user, 'email', None)
} if r_user else None
result.append({
'id': r.id,
'classroom_id': r.classroom_id,
'classroom_name': r.classroom.code if r.classroom else None,
'classroom': {
'id': r.classroom.id,
'code': r.classroom.code,
'code_display': getattr(r.classroom, 'code_display', r.classroom.code),
'floor': r.classroom.floor,
'floor_display': getattr(r.classroom, 'floor_display', f"Piso {r.classroom.floor}"),
'building': getattr(r.classroom, 'building_name', r.classroom.building),
'is_virtual': getattr(r.classroom, 'is_virtual', False),
'location_display': getattr(r.classroom, 'location_display', r.classroom.code)
} if r.classroom else None,
'commission_id': r.commission_id,
'commission': {
'id': r.commission.id,
'code': r.commission.code,
'virtual_link': r.commission.virtual_link,
'max_students': r.commission.max_students
} if r.commission else None,
'teacher_name': getattr(r_user, 'name', None) if r_user else None,
'user': user_dict,
'start_time': r.start_time.isoformat(),
'end_time': r.end_time.isoformat(),
'purpose': r.purpose,
'subject_name': r.subject_name,
'subject_code': r.subject_code,
'career_name': r.commission.career_name if (r.commission and hasattr(r.commission, 'career_name')) else '',
'career_names': r.commission.career_names if (r.commission and hasattr(r.commission, 'career_names')) else '',
'commission_code': r.commission.code if r.commission else '',
'status': str(r.status.value if hasattr(r.status, 'value') else r.status),
'shift': r.shift or 'Mañana',
'virtual_link': r.virtual_link,
'effective_virtual_link': r.effective_virtual_link,
'is_virtual': is_virt,
'expected_attendees': r.expected_attendees or 30,
'notes': r.notes or ''
})
return {
'total': len(result),
'start_date': start_dt.strftime('%Y-%m-%d'),
'end_date': end_dt.strftime('%Y-%m-%d'),
'reservations': result
}
@reservations_router.get("/{reservation_id}")
def get_reservation(reservation_id: int, current_user: User = Depends(get_current_user)):
"""Obtiene el detalle de una reserva específica."""
with flask_app.app_context():
r = reservation_service.get_reservation(reservation_id)
if not r:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Reserva {reservation_id} no encontrada.")
duration_min = int((r.end_time - r.start_time).total_seconds() / 60) if (r.start_time and r.end_time) else 120
reservations = reservation_service.list_reservations(start_dt, end_dt, classroom_id=classroom_id)
result = []
for r in reservations:
is_virt = bool(r.is_virtual or (r.classroom and r.classroom.is_virtual))
if is_hide_virtual and is_virt:
continue
if floor and r.classroom and str(r.classroom.floor).strip().lower() != floor.strip().lower():
continue
if shift and r.shift and shift.lower() not in r.shift.lower():
continue
r_user: Any = getattr(r, 'user', None)
u_name = getattr(r_user, 'name', None) if r_user else None
u_id = getattr(r_user, 'id', None) if r_user else None
u_email = getattr(r_user, 'email', None) if r_user else None
name_parts = str(u_name).split() if u_name else []
first_name = getattr(r_user, 'first_name', name_parts[0] if name_parts else 'Usuario') if r_user else 'Usuario'
last_name = getattr(r_user, 'last_name', ' '.join(name_parts[1:]) if len(name_parts) > 1 else '') if r_user else ''
u_name = (getattr(r_user, 'name', '') or '').lower() if r_user else ''
if search:
s_lower = search.lower()
subj_n = (r.subject_name or '').lower()
subj_c = (r.subject_code or '').lower()
c_name = (r.classroom.code if r.classroom else '').lower()
if s_lower not in subj_n and s_lower not in subj_c and s_lower not in c_name and s_lower not in u_name:
continue
return {
user_dict = {
'id': getattr(r_user, 'id', None),
'name': getattr(r_user, 'name', None),
'email': getattr(r_user, 'email', None)
} if r_user else None
result.append({
'id': r.id,
'classroom_id': r.classroom_id,
'classroom_name': r.classroom.code if r.classroom else None,
'location_display': getattr(r.classroom, 'location_display', r.classroom.code if r.classroom else None),
'classroom': {
'id': r.classroom.id,
'code': r.classroom.code,
'code_display': getattr(r.classroom, 'code_display', r.classroom.code),
'building_name': getattr(r.classroom, 'building_name', getattr(r.classroom, 'building', 'Edificio Central')),
'floor': r.classroom.floor,
'floor_display': getattr(r.classroom, 'floor_display', f"Piso {r.classroom.floor}"),
'capacity': r.classroom.capacity,
'capacity_display': getattr(r.classroom, 'capacity_display', str(r.classroom.capacity)),
'description': getattr(r.classroom, 'description', '') or '',
'is_virtual': getattr(r.classroom, 'is_virtual', False)
'building': getattr(r.classroom, 'building_name', r.classroom.building),
'is_virtual': getattr(r.classroom, 'is_virtual', False),
'location_display': getattr(r.classroom, 'location_display', r.classroom.code)
} if r.classroom else None,
'commission_id': r.commission_id,
'commission': {
'id': r.commission.id,
'code': r.commission.code,
'full_code': r.commission.get_full_code() if hasattr(r.commission, 'get_full_code') else r.commission.code,
'virtual_link': r.commission.virtual_link,
'max_students': r.commission.max_students,
'current_students': getattr(r.commission, 'current_students', 0),
'subject': {
'id': r.commission.subject.id,
'name': r.commission.subject.name,
'code': r.commission.subject.code
} if (r.commission and r.commission.subject) else None
'max_students': r.commission.max_students
} if r.commission else None,
'teacher_id': r.user_id,
'teacher_name': u_name,
'user': {
'id': u_id,
'name': u_name,
'first_name': first_name,
'last_name': last_name,
'email': u_email
} if r_user else None,
'teacher_name': getattr(r_user, 'name', None) if r_user else None,
'user': user_dict,
'start_time': r.start_time.isoformat(),
'end_time': r.end_time.isoformat(),
'duration': duration_min,
'purpose': r.purpose,
'subject_name': r.subject_name,
'subject_code': r.subject_code,
'career_name': r.commission.career_name if (r.commission and hasattr(r.commission, 'career_name')) else '',
'career_names': r.commission.career_names if (r.commission and hasattr(r.commission, 'career_names')) else '',
'commission_code': r.commission.code if r.commission else '',
'status': str(r.status.value if hasattr(r.status, 'value') else r.status),
'shift': r.shift or 'Mañana',
'virtual_link': r.virtual_link,
'effective_virtual_link': r.effective_virtual_link,
'is_virtual': is_virt,
'expected_attendees': r.expected_attendees or 30,
'notes': r.notes or '',
'can_be_cancelled': r.can_be_cancelled() if hasattr(r, 'can_be_cancelled') else True
}
'notes': r.notes or ''
})
return {
'total': len(result),
'start_date': start_dt.strftime('%Y-%m-%d'),
'end_date': end_dt.strftime('%Y-%m-%d'),
'reservations': result
}
@reservations_router.get("/{reservation_id}")
def get_reservation(reservation_id: int, current_user: User = Depends(get_current_user)):
"""Obtiene el detalle de una reserva específica."""
r = reservation_service.get_reservation(reservation_id)
if not r:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Reserva {reservation_id} no encontrada.")
duration_min = int((r.end_time - r.start_time).total_seconds() / 60) if (r.start_time and r.end_time) else 120
is_virt = bool(r.is_virtual or (r.classroom and r.classroom.is_virtual))
r_user: Any = getattr(r, 'user', None)
u_name = getattr(r_user, 'name', None) if r_user else None
u_id = getattr(r_user, 'id', None) if r_user else None
u_email = getattr(r_user, 'email', None) if r_user else None
name_parts = str(u_name).split() if u_name else []
first_name = getattr(r_user, 'first_name', name_parts[0] if name_parts else 'Usuario') if r_user else 'Usuario'
last_name = getattr(r_user, 'last_name', ' '.join(name_parts[1:]) if len(name_parts) > 1 else '') if r_user else ''
return {
'id': r.id,
'classroom_id': r.classroom_id,
'classroom_name': r.classroom.code if r.classroom else None,
'location_display': getattr(r.classroom, 'location_display', r.classroom.code if r.classroom else None),
'classroom': {
'id': r.classroom.id,
'code': r.classroom.code,
'code_display': getattr(r.classroom, 'code_display', r.classroom.code),
'building_name': getattr(r.classroom, 'building_name', getattr(r.classroom, 'building', 'Edificio Central')),
'floor': r.classroom.floor,
'floor_display': getattr(r.classroom, 'floor_display', f"Piso {r.classroom.floor}"),
'capacity': r.classroom.capacity,
'capacity_display': getattr(r.classroom, 'capacity_display', str(r.classroom.capacity)),
'description': getattr(r.classroom, 'description', '') or '',
'is_virtual': getattr(r.classroom, 'is_virtual', False)
} if r.classroom else None,
'commission_id': r.commission_id,
'commission': {
'id': r.commission.id,
'code': r.commission.code,
'full_code': r.commission.get_full_code() if hasattr(r.commission, 'get_full_code') else r.commission.code,
'virtual_link': r.commission.virtual_link,
'max_students': r.commission.max_students,
'current_students': getattr(r.commission, 'current_students', 0),
'subject': {
'id': r.commission.subject.id,
'name': r.commission.subject.name,
'code': r.commission.subject.code
} if (r.commission and r.commission.subject) else None
} if r.commission else None,
'teacher_id': r.user_id,
'teacher_name': u_name,
'user': {
'id': u_id,
'name': u_name,
'first_name': first_name,
'last_name': last_name,
'email': u_email
} if r_user else None,
'start_time': r.start_time.isoformat(),
'end_time': r.end_time.isoformat(),
'duration': duration_min,
'purpose': r.purpose,
'status': str(r.status.value if hasattr(r.status, 'value') else r.status),
'shift': r.shift or 'Mañana',
'virtual_link': r.virtual_link,
'effective_virtual_link': r.effective_virtual_link,
'is_virtual': is_virt,
'expected_attendees': r.expected_attendees or 30,
'notes': r.notes or '',
'can_be_cancelled': r.can_be_cancelled() if hasattr(r, 'can_be_cancelled') else True
}
@reservations_router.post("", status_code=status.HTTP_201_CREATED)
@@ -202,34 +198,33 @@ def create_reservation(
current_user: User = Depends(get_current_user)
):
"""Crea una reserva aplicando validación DTO y detección de colisiones."""
with flask_app.app_context():
if 'user_id' not in payload:
payload['user_id'] = current_user.id
if 'user_id' not in payload:
payload['user_id'] = current_user.id
try:
dto = ReservationCreateDTO(**payload)
except Exception as e:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
try:
dto = ReservationCreateDTO(**payload)
except Exception as e:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
try:
reservation = reservation_service.create_reservation(dto)
AuditService.log(
action='CREATE',
module='reservations',
entity_id=reservation.id,
user=current_user,
details=f"Nueva reserva creada #{reservation.id} en aula ID {reservation.classroom_id} ({reservation.start_time.strftime('%Y-%m-%d %H:%M')} a {reservation.end_time.strftime('%H:%M')}) - Motivo: {reservation.purpose}"
)
return {
'message': 'Reserva creada exitosamente.',
'id': reservation.id,
'classroom_id': reservation.classroom_id,
'start_time': reservation.start_time.isoformat(),
'end_time': reservation.end_time.isoformat(),
'status': str(reservation.status)
}
except ValueError as e:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(e))
try:
reservation = reservation_service.create_reservation(dto)
AuditService.log(
action='CREATE',
module='reservations',
entity_id=reservation.id,
user=current_user,
details=f"Nueva reserva creada #{reservation.id} en aula ID {reservation.classroom_id} ({reservation.start_time.strftime('%Y-%m-%d %H:%M')} a {reservation.end_time.strftime('%H:%M')}) - Motivo: {reservation.purpose}"
)
return {
'message': 'Reserva creada exitosamente.',
'id': reservation.id,
'classroom_id': reservation.classroom_id,
'start_time': reservation.start_time.isoformat(),
'end_time': reservation.end_time.isoformat(),
'status': str(reservation.status)
}
except ValueError as e:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(e))
@reservations_router.put("/{reservation_id}")
@@ -239,25 +234,24 @@ def update_reservation(
current_user: User = Depends(get_current_user)
):
"""Modifica una reserva existente."""
with flask_app.app_context():
try:
reservation = reservation_service.update_reservation(reservation_id, dto)
AuditService.log(
action='UPDATE',
module='reservations',
entity_id=reservation.id,
user=current_user,
details=f"Reserva #{reservation.id} modificada ({reservation.start_time.strftime('%Y-%m-%d %H:%M')} a {reservation.end_time.strftime('%H:%M')}) - Estado: {reservation.status}"
)
return {
'message': 'Reserva actualizada exitosamente.',
'id': reservation.id,
'start_time': reservation.start_time.isoformat(),
'end_time': reservation.end_time.isoformat(),
'status': str(reservation.status)
}
except ValueError as e:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(e))
try:
reservation = reservation_service.update_reservation(reservation_id, dto)
AuditService.log(
action='UPDATE',
module='reservations',
entity_id=reservation.id,
user=current_user,
details=f"Reserva #{reservation.id} modificada ({reservation.start_time.strftime('%Y-%m-%d %H:%M')} a {reservation.end_time.strftime('%H:%M')}) - Estado: {reservation.status}"
)
return {
'message': 'Reserva actualizada exitosamente.',
'id': reservation.id,
'start_time': reservation.start_time.isoformat(),
'end_time': reservation.end_time.isoformat(),
'status': str(reservation.status)
}
except ValueError as e:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(e))
@reservations_router.delete("/{reservation_id}")
@@ -267,41 +261,8 @@ def cancel_reservation(
current_user: User = Depends(get_current_user)
):
"""Cancela o elimina una reserva según el parámetro hard."""
with flask_app.app_context():
hard_delete = str(hard).lower() in ['true', '1']
if hard_delete:
res = Reservation.query.get(reservation_id)
if not res:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Reserva {reservation_id} no encontrada.")
db.session.delete(res)
db.session.commit()
AuditService.log(
action='DELETE',
module='reservations',
entity_id=reservation_id,
user=current_user,
details=f"Reserva #{reservation_id} eliminada permanentemente"
)
return {'message': f'Reserva {reservation_id} eliminada permanentemente.'}
cancelled = reservation_service.cancel_reservation(reservation_id)
if not cancelled:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Reserva {reservation_id} no encontrada.")
AuditService.log(
action='CANCEL',
module='reservations',
entity_id=reservation_id,
user=current_user,
details=f"Reserva #{reservation_id} cancelada"
)
return {'message': f'Reserva {reservation_id} cancelada correctamente.'}
@reservations_router.post("/{reservation_id}/delete")
def delete_reservation_post(reservation_id: int, current_user: User = Depends(get_current_user)):
"""Elimina permanentemente una reserva (POST)."""
with flask_app.app_context():
hard_delete = str(hard).lower() in ['true', '1']
if hard_delete:
res = Reservation.query.get(reservation_id)
if not res:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Reserva {reservation_id} no encontrada.")
@@ -316,80 +277,108 @@ def delete_reservation_post(reservation_id: int, current_user: User = Depends(ge
)
return {'message': f'Reserva {reservation_id} eliminada permanentemente.'}
cancelled = reservation_service.cancel_reservation(reservation_id)
if not cancelled:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Reserva {reservation_id} no encontrada.")
AuditService.log(
action='CANCEL',
module='reservations',
entity_id=reservation_id,
user=current_user,
details=f"Reserva #{reservation_id} cancelada"
)
return {'message': f'Reserva {reservation_id} cancelada correctamente.'}
@reservations_router.post("/{reservation_id}/delete")
def delete_reservation_post(reservation_id: int, current_user: User = Depends(get_current_user)):
"""Elimina permanentemente una reserva (POST)."""
res = Reservation.query.get(reservation_id)
if not res:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Reserva {reservation_id} no encontrada.")
db.session.delete(res)
db.session.commit()
AuditService.log(
action='DELETE',
module='reservations',
entity_id=reservation_id,
user=current_user,
details=f"Reserva #{reservation_id} eliminada permanentemente"
)
return {'message': f'Reserva {reservation_id} eliminada permanentemente.'}
@reservations_router.post("/{reservation_id}/cancel")
def cancel_reservation_post(reservation_id: int, current_user: User = Depends(get_current_user)):
"""Cancela una reserva (POST)."""
with flask_app.app_context():
cancelled = reservation_service.cancel_reservation(reservation_id)
if not cancelled:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Reserva {reservation_id} no encontrada.")
cancelled = reservation_service.cancel_reservation(reservation_id)
if not cancelled:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Reserva {reservation_id} no encontrada.")
AuditService.log(
action='CANCEL',
module='reservations',
entity_id=reservation_id,
user=current_user,
details=f"Reserva #{reservation_id} cancelada"
)
return {'message': f'Reserva {reservation_id} cancelada correctamente.'}
AuditService.log(
action='CANCEL',
module='reservations',
entity_id=reservation_id,
user=current_user,
details=f"Reserva #{reservation_id} cancelada"
)
return {'message': f'Reserva {reservation_id} cancelada correctamente.'}
@reservations_router.post("/{reservation_id}/confirm")
def confirm_reservation(reservation_id: int, current_user: User = Depends(get_current_user)):
"""Confirma una reserva cambiando su estado a CONFIRMED."""
with flask_app.app_context():
confirmed = reservation_service.confirm_reservation(reservation_id)
if not confirmed:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Reserva {reservation_id} no encontrada.")
confirmed = reservation_service.confirm_reservation(reservation_id)
if not confirmed:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Reserva {reservation_id} no encontrada.")
AuditService.log(
action='CONFIRM',
module='reservations',
entity_id=reservation_id,
user=current_user,
details=f"Reserva #{reservation_id} confirmada oficialmente"
)
return {'message': f'Reserva {reservation_id} confirmada correctamente.'}
AuditService.log(
action='CONFIRM',
module='reservations',
entity_id=reservation_id,
user=current_user,
details=f"Reserva #{reservation_id} confirmada oficialmente"
)
return {'message': f'Reserva {reservation_id} confirmada correctamente.'}
@reservations_router.post("/check-conflicts")
def check_conflicts_endpoint(payload: Dict[str, Any], current_user: User = Depends(get_current_user)):
"""Evalúa la matriz completa de conflictos (físico, docente y aforo) en tiempo real."""
with flask_app.app_context():
classroom_id = payload.get('classroom_id')
start_str = payload.get('start_time')
end_str = payload.get('end_time')
classroom_id = payload.get('classroom_id')
start_str = payload.get('start_time')
end_str = payload.get('end_time')
if not classroom_id or not start_str or not end_str:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="classroom_id, start_time y end_time son obligatorios.")
if not classroom_id or not start_str or not end_str:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="classroom_id, start_time y end_time son obligatorios.")
try:
start_time = datetime.fromisoformat(str(start_str).replace('Z', '+00:00'))
end_time = datetime.fromisoformat(str(end_str).replace('Z', '+00:00'))
except ValueError:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Formato inválido de fecha/hora (ISO 8601 esperado).")
try:
start_time = datetime.fromisoformat(str(start_str).replace('Z', '+00:00'))
end_time = datetime.fromisoformat(str(end_str).replace('Z', '+00:00'))
except ValueError:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Formato inválido de fecha/hora (ISO 8601 esperado).")
teacher_id = payload.get('teacher_id')
commission_id = payload.get('commission_id')
expected_attendees = payload.get('expected_attendees')
allow_co_teaching = bool(payload.get('allow_co_teaching_exception', False))
exclude_id = payload.get('exclude_id')
teacher_id = payload.get('teacher_id')
commission_id = payload.get('commission_id')
expected_attendees = payload.get('expected_attendees')
allow_co_teaching = bool(payload.get('allow_co_teaching_exception', False))
exclude_id = payload.get('exclude_id')
try:
matrix = reservation_service.check_full_conflicts_matrix(
classroom_id=int(classroom_id),
start_time=start_time,
end_time=end_time,
teacher_id=int(teacher_id) if teacher_id else None,
commission_id=int(commission_id) if commission_id else None,
expected_attendees=int(expected_attendees) if expected_attendees is not None else None,
allow_co_teaching_exception=allow_co_teaching,
exclude_id=int(exclude_id) if exclude_id else None
)
return matrix
except ValueError as e:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
try:
matrix = reservation_service.check_full_conflicts_matrix(
classroom_id=int(classroom_id),
start_time=start_time,
end_time=end_time,
teacher_id=int(teacher_id) if teacher_id else None,
commission_id=int(commission_id) if commission_id else None,
expected_attendees=int(expected_attendees) if expected_attendees is not None else None,
allow_co_teaching_exception=allow_co_teaching,
exclude_id=int(exclude_id) if exclude_id else None
)
return matrix
except ValueError as e:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
@reservations_router.post("/drag-update")
@@ -429,68 +418,74 @@ async def drag_update_reservation(
detail=f"Formato de fecha inválido: {str(e)}"
)
with flask_app.app_context():
classroom = db.session.get(Classroom, classroom_id)
if not classroom:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Aula no encontrada.")
classroom = db.session.get(Classroom, classroom_id)
if not classroom:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Aula no encontrada.")
effective_comm_id: Optional[int] = commission_id
if effective_comm_id is None and reservation_id:
existing_res = db.session.get(Reservation, reservation_id)
if existing_res:
effective_comm_id = existing_res.commission_id
effective_comm_id: Optional[int] = commission_id
if effective_comm_id is None and reservation_id:
existing_res = db.session.get(Reservation, reservation_id)
if existing_res:
effective_comm_id = existing_res.commission_id
matrix = reservation_service.check_full_conflicts_matrix(
matrix = reservation_service.check_full_conflicts_matrix(
classroom_id=classroom_id,
start_time=start_dt,
end_time=end_dt,
commission_id=effective_comm_id,
exclude_id=reservation_id
)
if matrix.get('is_blocked'):
from fastapi.responses import JSONResponse
reason = ' '.join(matrix.get('block_reasons', ['Conflicto detectado en la asignación.']))
return JSONResponse(
status_code=status.HTTP_409_CONFLICT,
content={
'status': 'conflict',
'message': reason,
'block_reasons': matrix.get('block_reasons', []),
'matrix': matrix
}
)
if reservation_id:
res = db.session.get(Reservation, reservation_id)
if not res:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Reserva no encontrada.")
res.classroom_id = classroom_id
res.start_time = start_dt
res.end_time = end_dt
action = 'UPDATE_RESERVATION_DRAG'
msg = f"Reserva #{res.id} reprogramada al aula {classroom.code} ({start_dt.strftime('%H:%M')} a {end_dt.strftime('%H:%M')})"
else:
comm = db.session.get(Commission, commission_id) if commission_id else None
res = Reservation(
classroom_id=classroom_id,
commission_id=commission_id,
user_id=current_user.id,
start_time=start_dt,
end_time=end_dt,
commission_id=effective_comm_id,
exclude_id=reservation_id
purpose=f"Cursada regular - {comm.subject.name if comm and comm.subject else 'Comisión'}",
expected_attendees=comm.max_students if comm else 30,
status=ReservationStatus.CONFIRMED.value
)
db.session.add(res)
action = 'CREATE_RESERVATION_DRAG'
msg = f"Comisión {comm.code if comm else ''} asignada al aula {classroom.code}"
if matrix.get('is_blocked'):
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail=' '.join(matrix.get('block_reasons', ['Conflicto detectado en la asignación.']))
)
db.session.commit()
AuditService.log(
action=action,
module='reservations',
entity_id=res.id,
user=current_user,
details=msg
)
if reservation_id:
res = db.session.get(Reservation, reservation_id)
if not res:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Reserva no encontrada.")
res.classroom_id = classroom_id
res.start_time = start_dt
res.end_time = end_dt
action = 'UPDATE_RESERVATION_DRAG'
msg = f"Reserva #{res.id} reprogramada al aula {classroom.code} ({start_dt.strftime('%H:%M')} a {end_dt.strftime('%H:%M')})"
else:
comm = db.session.get(Commission, commission_id) if commission_id else None
res = Reservation(
classroom_id=classroom_id,
commission_id=commission_id,
user_id=current_user.id,
start_time=start_dt,
end_time=end_dt,
purpose=f"Cursada regular - {comm.subject.name if comm and comm.subject else 'Comisión'}",
expected_attendees=comm.max_students if comm else 30,
status=ReservationStatus.CONFIRMED.value
)
db.session.add(res)
action = 'CREATE_RESERVATION_DRAG'
msg = f"Comisión {comm.code if comm else ''} asignada al aula {classroom.code}"
db.session.commit()
AuditService.log(
action=action,
module='reservations',
entity_id=res.id,
user=current_user,
details=msg
)
return {
'status': 'success',
'message': msg,
'reservation': res.to_dict()
}
return {
'status': 'success',
'message': msg,
'reservation': res.to_dict()
}
+7 -3
View File
@@ -3,7 +3,7 @@ FastAPI Students Router (/api/v1/students)
Provides academic milestone and gradebook queries for students.
"""
from typing import Optional
from fastapi import APIRouter, Depends, HTTPException, Query, status
from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
from app.services.gradebook_service import GradebookService
from dependencies import get_current_user
@@ -13,14 +13,18 @@ students_router = APIRouter(prefix="/api/v1/students", tags=["Students"])
@students_router.get("/my-grades")
def get_my_grades(current_user: User = Depends(get_current_user)):
def get_my_grades(
request: Request,
current_user: User = Depends(get_current_user)
):
"""Consulta individual de calificaciones y estado académico del alumno logueado."""
try:
grades = GradebookService.get_student_grades(current_user.id)
is_impersonating = bool(request.headers.get('X-Impersonate-User'))
return {
'status': 'success',
'student_id': current_user.id,
'is_impersonating': False,
'is_impersonating': is_impersonating,
'data': grades
}
except Exception as e:
+18 -20
View File
@@ -2,37 +2,35 @@ from setuptools import setup, find_packages
setup(
name="edu-space-admin",
version="3.7.0",
description="Administrative interface for Edu-Space Classroom Management System",
version="3.8.0",
description="Administrative interface for Edu-Space Classroom Management System (FastAPI ASGI Core)",
author="Edu-Space Development Team",
author_email="admin@edu-space.com",
packages=find_packages(),
include_package_data=True,
install_requires=[
"Flask==3.0.0",
"Flask-SQLAlchemy==3.1.1",
"Flask-Login==0.6.3",
"Flask-WTF==1.2.1",
"Flask-Migrate==4.0.5",
"Flask-CORS==4.0.0",
"WTForms==3.1.0",
"Werkzeug==3.0.1",
"SQLAlchemy==2.0.23",
"python-dotenv==1.0.0",
"requests==2.31.0",
"bleach==6.1.0",
"python-dateutil==2.8.2",
"Pillow==10.1.0"
"fastapi>=0.115.0",
"uvicorn[standard]>=0.30.0",
"pydantic>=2.0.0",
"SQLAlchemy>=2.0.32",
"psycopg2-binary>=2.9.10",
"python-dotenv>=1.0.0",
"requests>=2.31.0",
"httpx>=0.27.0",
"PyJWT>=2.8.0",
"cryptography>=42.0.0",
"Werkzeug>=3.0.1",
"python-dateutil>=2.8.2",
"bleach>=6.1.0",
"Pillow>=10.1.0"
],
python_requires=">=3.8",
python_requires=">=3.10",
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Education",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
],
)
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "frontend",
"version": "3.7.0",
"version": "3.8.0",
"description": "",
"main": "index.js",
"scripts": {
+3 -3
View File
@@ -85,9 +85,9 @@ const env = nunjucks.configure(path.join(__dirname, '../views'), {
});
// Versiones institucionales del sistema
const APP_VERSION = '3.7.0';
const FRONTEND_VERSION = '3.7.0';
const BACKEND_VERSION = '3.7.0';
const APP_VERSION = '3.8.0';
const FRONTEND_VERSION = '3.8.0';
const BACKEND_VERSION = '3.8.0';
env.addGlobal('app_version', APP_VERSION);
env.addGlobal('frontend_version', FRONTEND_VERSION);
+73
View File
@@ -0,0 +1,73 @@
"""
Utility script to safely remove 'with flask_app.app_context():' blocks
and unindent their inner bodies by 4 spaces.
"""
import re
import sys
import py_compile
def clean_file(filepath: str):
with open(filepath, 'r', encoding='utf-8') as f:
lines = f.readlines()
new_lines = []
i = 0
in_context = False
context_indent = 0
while i < len(lines):
line = lines[i]
# 1. Skip imports of get_flask_app
if re.match(r'^\s*from database import get_flask_app\s*$', line):
i += 1
continue
if re.match(r'^\s*flask_app = get_flask_app\(\)\s*$', line):
i += 1
continue
if re.match(r'^\s*f_app = get_flask_app\(\)\s*$', line):
i += 1
continue
# 2. Check for with flask_app.app_context():
match = re.match(r'^(\s*)with (flask_app|f_app)\.app_context\(\):\s*$', line)
if match:
in_context = True
context_indent = len(match.group(1))
i += 1
continue
if in_context:
if not line.strip():
new_lines.append(line)
i += 1
continue
current_indent = len(line) - len(line.lstrip())
if current_indent > context_indent:
# Unindent 4 spaces
if line.startswith(' ' * (context_indent + 4)):
unindented = line[4:]
else:
unindented = line[current_indent - context_indent:]
new_lines.append(unindented)
i += 1
continue
else:
# Context ended
in_context = False
# Do not increment, process this line normally
new_lines.append(line)
i += 1
content = ''.join(new_lines)
with open(filepath, 'w', encoding='utf-8') as f:
f.write(content)
py_compile.compile(filepath, doraise=True)
print(f"Successfully cleaned & compiled {filepath}")
if __name__ == '__main__':
for p in sys.argv[1:]:
clean_file(p)
+2 -2
View File
@@ -91,9 +91,9 @@ echo Checking backend availability at %API_DOC_URL%...
curl.exe -s -f -o nul "%API_DOC_URL%"
if !ERRORLEVEL! neq 0 (
echo [!] Warning: Local Flask backend is not responding on %API_DOC_URL%
echo [!] Warning: Local FastAPI backend is not responding on %API_DOC_URL%
echo To run live DAST fuzzing, start the backend in another terminal:
echo cd backend ^&^& venv\Scripts\flask.exe run --port=5000
echo cd backend ^&^& venv\Scripts\uvicorn.exe main:app --port=5000
echo [!] Skipping DAST fuzzing phase.
) else (
echo Target online. Running Schemathesis against OpenAPI spec...
+61
View File
@@ -0,0 +1,61 @@
# Plan Técnico: 004-depuracion-flask-total - Erradicación Total de Flask y Migración a SQLAlchemy 2.0 Nativo
## 1. Arquitectura de la Solución
### 1.1. Capa de Persistencia Nativa (`backend/database.py` y `backend/app/__init__.py`)
Actualmente, los modelos (`Building`, `Classroom`, `User`, etc.) importan `db` desde `app` (`from app import db`), y dependen de propiedades como `db.Model`, `db.Column`, `db.relationship` y `db.session`.
Para desacoplarlo de Flask sin tener que reescribir manualmente cada modelo:
- Diseñamos una clase/adaptador `SQLAlchemyWrapper` en `backend/database.py` (o en `backend/app/db.py` reexportado en `app/__init__.py`) construido 100% sobre SQLAlchemy 2.0 estándar:
- `engine = create_engine(DATABASE_URL, pool_pre_ping=True, ...)`
- `SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)`
- `session = scoped_session(SessionLocal)`
- `Model = declarative_base()`
- Reexporta directamente tipos de SQLAlchemy: `Column = sa.Column`, `Integer = sa.Integer`, `String = sa.String`, `relationship = orm.relationship`, etc.
- Métodos `create_all()` y `drop_all()` ejecutados directamente contra `engine`.
- En `backend/database.py`, la dependencia FastAPI `get_db()` yieldará la sesión nativa:
```python
def get_db():
db_session = SessionLocal()
try:
yield db_session
finally:
db_session.close()
```
- Ya no existirá `get_flask_app()` ni necesidad de `flask_app.app_context()`.
### 1.2. Limpieza de Routers (`backend/routers/*.py`)
- Remover:
```python
from database import get_flask_app
flask_app = get_flask_app()
```
- Remover envoltorios `with flask_app.app_context():`.
- Las consultas accederán directamente a `db.session` (que es el `scoped_session` nativo de SQLAlchemy) o a la dependencia inyectada `db: Session = Depends(get_db)`.
### 1.3. Poda de Archivos y Directorios Legados
- Eliminar recursivamente:
- `backend/app/routes/` (antiguo monolito Jinja2 y APIs de Flask).
- `backend/app/forms/` (formularios WTForms).
- Modificar:
- `install.sh`: eliminar `flask` de la verificación de dependencias.
- `backend/requirements.txt`: remover `Flask`, `Flask-SQLAlchemy`, `Flask-Login`, `Flask-WTF`, `Flask-Migrate`, `Flask-CORS`, `Flask-Babel`.
- `backend/setup.py`: remover las mismas dependencias de `install_requires`.
- `backend/app/__init__.py`: eliminar imports de Flask, `request`, `session`, `Babel`, `Migrate`, `CORS` y el registro de blueprints de Flask.
### 1.4. Actualización del Arnés de Tests (`backend/tests/conftest.py`)
- Modificar `conftest.py` para inicializar SQLAlchemy en memoria (`sqlite:///:memory:`) sin depender de `create_app()` de Flask.
- Los tests que hacían peticiones HTTP utilizarán `fastapi.testclient.TestClient` apuntando a `backend.main:app`.
---
## 2. Fases de Ejecución
1. **Fase 1: Motor SQLAlchemy 2.0 Desacoplado**:
Implementar la capa nativa de base de datos en `backend/database.py` y actualizar `backend/app/__init__.py`.
2. **Fase 2: Retiro de `app_context()` en Routers y Servicios**:
Eliminar `get_flask_app()` y `with flask_app.app_context():` de los routers de FastAPI.
3. **Fase 3: Eliminación de Código Muerto y Dependencias**:
Borrar carpetas `app/routes/` y `app/forms/`. Actualizar `requirements.txt`, `setup.py` e `install.sh`.
4. **Fase 4: Adaptación de Tests y Verificación**:
Actualizar `conftest.py` y correr la suite completa de 57 tests.
5. **Fase 5: Despliegue y Validación en Producción**:
Bump de versión, commit, git push a `dev` y despliegue a LXC `10.0.0.217`.
+38
View File
@@ -0,0 +1,38 @@
# Espec: 004-depuracion-flask-total - Erradicación Total de Flask y Migración a SQLAlchemy 2.0 Nativo
## 1. Visión General y Propósito
El backend de **admin-edu-space** completó la transición a una arquitectura FastAPI ASGI desacoplada y frontend BFF en Node.js/Express. Sin embargo, persisten remanentes de Flask en el repositorio:
- Código muerto en `backend/app/routes/` (antiguas vistas Jinja2) y `backend/app/forms/` (formularios WTForms).
- Dependencia artificial de `Flask` y `Flask-SQLAlchemy` en `backend/app/__init__.py` y `backend/database.py` únicamente para abastecer el contexto de aplicación (`flask_app.app_context()`) que requiere `db.session`.
- Dependencias residuales en `requirements.txt`, `setup.py` e `install.sh`.
Esta especificación formaliza la eliminación completa de toda dependencia de Flask, centralizando la persistencia en SQLAlchemy 2.0 nativo (`scoped_session`, `sessionmaker`, `declarative_base`) e integrándolo de forma transparente con FastAPI.
---
## 2. Requisitos en Sintaxis EARS (Español Estricto)
### 2.1. Persistencia y Sesión de Base de Datos
- **RF-01 (Ubicuo)**: EL SISTEMA gestionará la persistencia y el ciclo de vida de sesiones relacionales mediante SQLAlchemy 2.0 nativo de forma agnóstica a cualquier microframework web, exportando `db.session` (`scoped_session`) y `db.Model` sin requerir ningún contexto de aplicación externo.
- **RF-02 (Ubicuo)**: EL SISTEMA inyectará la sesión de base de datos en los routers de FastAPI mediante la dependencia `get_db` garantizando cierre y rollback seguro ante excepciones no controladas.
- **RF-03 (Basado en Eventos)**: CUANDO un router de FastAPI (`backend/routers/*.py`) o servicio de negocio acceda a `db.session` o a los modelos ORM, EL SISTEMA ejecutará las consultas de forma directa sin requerir bloques auxiliares `with flask_app.app_context():`.
- **RF-04 (No Deseado / Excepciones)**: SI ocurre un error durante una transacción en una corrutina o hilo de FastAPI, ENTONCES EL SISTEMA revertirá los cambios pendientes con `session.rollback()` y liberará la conexión al pool.
### 2.2. Depuración de Código Legado y Formularios
- **RF-05 (Ubicuo)**: EL SISTEMA eliminará permanentemente los módulos y directorios obsoletos de Flask (`backend/app/routes/` y `backend/app/forms/`), consolidando todos los contratos de entrada/salida exclusivamente en los esquemas de Pydantic v2 bajo `backend/schemas/` y los routers de FastAPI bajo `backend/routers/`.
- **RF-06 (Ubicuo)**: EL SISTEMA removerá las dependencias obsoletas `Flask`, `Flask-SQLAlchemy`, `Flask-Login`, `Flask-WTF`, `Flask-Migrate`, `Flask-CORS` y `Flask-Babel` de `requirements.txt`, `setup.py` e `install.sh`.
### 2.3. Suite de Pruebas y Fixtures
- **RF-07 (Basado en Eventos)**: CUANDO se ejecuten las pruebas automatizadas (`pytest tests -v`), EL SISTEMA inicializará el entorno de testing en memoria (`sqlite:///:memory:`) utilizando el motor y sesión nativos de SQLAlchemy sin instanciar la clase `Flask` ni requerir `app.test_client()`.
- **RF-08 (Ubicuo)**: EL SISTEMA mantendrá el 100% de la suite de pruebas unitarias y de integración aprobada (mínimo 57 tests exitosos) sin degradación de cobertura ni regresiones.
---
## 3. Criterios de Aceptación y Finalización (DoD)
1. Cero ocurrencias de `import flask` o `from flask` en todo el directorio `backend/` (excluyendo únicamente entornos virtuales `.venv`).
2. Directorios obsoletos `backend/app/routes/` y `backend/app/forms/` eliminados del árbol del proyecto.
3. Routers de `backend/routers/` operando sin imports de `get_flask_app` ni bloques `with flask_app.app_context():`.
4. Todos los modelos de `backend/app/models/` y servicios funcionando con el motor nativo de SQLAlchemy 2.0.
5. Cero problemas reportados por el Language Server (`@[current_problems]`).
6. Suite de pruebas pasando al 100% (`57 passed`).
7. Despliegue verificado en producción en `10.0.0.217` con HTTP 200 en `/version`.
+27
View File
@@ -0,0 +1,27 @@
# Desglose de Tareas: 004-depuracion-flask-total - Erradicación Total de Flask
## Tareas de Implementación
- [X] **Tarea 1: Capa de Persistencia Nativa SQLAlchemy 2.0 en `backend/database.py` y `backend/app/__init__.py`**
- **Objetivo**: Crear adaptador nativo de SQLAlchemy (SessionLocal, scoped_session, Base declarativa, alias de tipos y session) y reexportarlo en `app.__init__.py` eliminando la inicialización de `Flask` y `Flask-SQLAlchemy`.
- **Hecho cuando**: Los modelos en `backend/app/models/` puedan importarse e interactuar con `db.session` y `db.Model` sin lanzar `RuntimeError: Working outside of application context`.
- [X] **Tarea 2: Eliminar `flask_app.app_context()` y `get_flask_app` de los Routers FastAPI**
- **Objetivo**: Limpiar `backend/routers/` (`academic.py`, `admin.py`, `buildings.py`, `classrooms.py`, `dashboard.py`, `reservations.py`, `auth.py`) retirando los envoltorios `with flask_app.app_context():`.
- **Hecho cuando**: Ningún archivo en `backend/routers/` contenga `flask_app` ni `get_flask_app`.
- [X] **Tarea 3: Poda de Código Muerto (`app/routes/` y `app/forms/`)**
- **Objetivo**: Eliminar permanentemente los directorios `backend/app/routes/` y `backend/app/forms/`.
- **Hecho cuando**: Los directorios ya no existan en el sistema de archivos y no queden imports rotos en el proyecto.
- [X] **Tarea 4: Depuración de Scripts y Dependencias Residuales de Flask**
- **Objetivo**: Actualizar `install.sh`, `backend/requirements.txt` y `backend/setup.py` retirando `Flask`, `Flask-SQLAlchemy`, `Flask-WTF`, `Flask-Login`, `Flask-Migrate`, `Flask-CORS`, `Flask-Babel`.
- **Hecho cuando**: No haya referencias a librerías de Flask en los archivos de configuración y manifiestos de instalación.
- [X] **Tarea 5: Adaptación de Fixtures en `backend/tests/conftest.py` y Verificación de Suite de Pruebas**
- **Objetivo**: Ajustar `conftest.py` para usar el motor de base de datos nativo y correr la suite de tests completa (`pytest tests -v`).
- **Hecho cuando**: Los 57 tests automatizados pasen al 100% (0 errores, 0 fallos) y `@[current_problems]` reporte 0 problemas.
- [X] **Tarea 6: Bump Semántico, Git Push y Despliegue en Producción**
- **Objetivo**: Seguir la skill `deploy` y Principio 9 de la Constitución para incrementar versión a `3.8.0`, actualizar `CHANGELOG.md` y `MEMORY.md`, push a `dev` y desplegar a `10.0.0.217`.
- **Hecho cuando**: El endpoint remoto `/version` retorne HTTP 200 con versión `3.8.0` y estado `ok`.