carlostellocba/admin-edu-space
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(abm): abm completo de ciclos lectivos, aulas y reservas con proteccion de integridad y pruebas automatizadas

Browse Source
This commit is contained in:
carlostellocba
2026-09-23 20:35:54 -03:00
parent a188c3bd8f
commit ddd1714eb2
15 changed files with 477 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/app/routes/api/admin.py
+47
View File
@@ -1387,6 +1387,53 @@ def set_current_academic_term(id):
'message': f'"{term.name}" establecido como ciclo activo.'
}), 200
@api_admin_bp.route('/academic-terms/<int:id>/toggle', methods=['POST'])
@jwt_required
def toggle_academic_term(id):
term = AcademicTerm.query.get_or_404(id)
if term.is_current and term.is_active:
return jsonify({
'error': 'Conflict',
'message': 'No se puede desactivar el ciclo lectivo actualmente activo. Seleccione otro ciclo activo primero.'
}), 400
term.is_active = not term.is_active
db.session.commit()
return jsonify({
'status': 'success',
'id': term.id,
'is_active': term.is_active,
'message': f'Ciclo lectivo {"habilitado" if term.is_active else "desactivado"} correctamente.'
}), 200
@api_admin_bp.route('/academic-terms/<int:id>', methods=['DELETE'])
@jwt_required
def delete_academic_term(id):
term = AcademicTerm.query.get_or_404(id)
if term.is_current:
return jsonify({
'error': 'Conflict',
'message': 'No se puede eliminar el ciclo lectivo actualmente activo. Seleccione otro ciclo activo primero.'
}), 400
commissions_count = Commission.query.filter_by(academic_term_id=id).count()
if commissions_count > 0:
# Soft delete para preservar integridad de comisiones
term.is_active = False
db.session.commit()
return jsonify({
'status': 'success',
'soft_deleted': True,
'message': f'El ciclo lectivo tiene {commissions_count} comisiones asociadas. Ha sido desactivado para proteger el historial académico.'
}), 200
db.session.delete(term)
db.session.commit()
return jsonify({
'status': 'success',
'soft_deleted': False,
'message': 'Ciclo lectivo eliminado permanentemente.'
}), 200
# ---------------------------------------------------------
# MILESTONE TYPES CRUD
# ---------------------------------------------------------
backend/app/routes/api/classrooms.py
+16
View File
@@ -1,6 +1,8 @@
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.schemas.classroom_dto import ClassroomCreateDTO, ClassroomUpdateDTO, ClassroomResponseDTO
from app.utils.jwt_decorators import jwt_required, jwt_role_required
@@ -117,3 +119,17 @@ def delete_classroom(classroom_id: int):
return jsonify({'error': 'NotFound', 'message': f'Aula {classroom_id} no encontrada.'}), 404
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()
return jsonify({
'status': 'success',
'id': classroom.id,
'is_active': classroom.is_active,
'message': f'Aula {"activada" if classroom.is_active else "desactivada"} correctamente.'
}), 200
backend/app/routes/api/reservations.py
+23 -1
View File
@@ -2,6 +2,8 @@ from flask import Blueprint, request, jsonify, g
from datetime import datetime, timedelta, date
from pydantic import ValidationError
from app import db
from app.models.reservation import Reservation
from app.services.reservation_service import ReservationService
from app.schemas.reservation_dto import ReservationCreateDTO, ReservationUpdateDTO
from app.utils.jwt_decorators import jwt_required, jwt_role_required
@@ -218,13 +220,33 @@ def update_reservation(reservation_id: int):
@api_reservations_bp.route('/<int:reservation_id>', methods=['DELETE'])
@jwt_required
def cancel_reservation(reservation_id: int):
"""Cancela una reserva."""
"""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()
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
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()
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):
backend/app/utils/jwt_decorators.py
+11 -8
View File
@@ -20,14 +20,17 @@ def jwt_required(f):
token = request.cookies.get('access_token')
if not token:
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)
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',
backend/tests/test_abm_endpoints.py
+156
View File
@@ -0,0 +1,156 @@
import pytest
from app import create_app, db
from app.models.user import User
from app.models.role import Role
from app.models.academic_term import AcademicTerm
from app.models.classroom import Classroom
from app.models.building import Building
from app.models.subject import Subject, Commission
from app.models.reservation import Reservation
from app.services.jwt_service import JWTService
from datetime import datetime, timedelta
@pytest.fixture
def app():
app = create_app()
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
app.config['TESTING'] = True
with app.app_context():
db.create_all()
admin_role = Role.query.filter_by(name='ADMIN').first()
if not admin_role:
admin_role = Role(name='ADMIN', description='Administrator')
db.session.add(admin_role)
db.session.commit()
user = User(
email='admin_abm@unicaba.edu.ar',
name='Admin ABM',
first_name='Admin',
last_name='ABM',
role='ADMIN',
role_id=admin_role.id,
is_active=True
)
user.set_password('Admin1234!')
db.session.add(user)
db.session.commit()
yield app
db.session.remove()
db.drop_all()
@pytest.fixture
def client(app):
return app.test_client()
@pytest.fixture
def auth_headers(app):
with app.app_context():
user = User.query.filter_by(email='admin_abm@unicaba.edu.ar').first()
token = JWTService.generate_tokens(user)['access_token']
return {
'Authorization': f'Bearer {token}',
'Content-Type': 'application/json'
}
def test_academic_term_abm(client, auth_headers):
# 1. Crear término
res = client.post('/api/v1/admin/academic-terms', headers=auth_headers, json={
'name': '2026-Segundo Cuatrimestre Test',
'code': '2026-2C-TEST',
'year': 2026,
'period_type': 'Segundo Cuatrimestre',
'is_active': True,
'is_current': False
})
assert res.status_code == 201
data = res.get_json()
term_id = data['term']['id']
# 2. Toggle active
res_toggle = client.post(f'/api/v1/admin/academic-terms/{term_id}/toggle', headers=auth_headers)
assert res_toggle.status_code == 200
assert res_toggle.get_json()['is_active'] is False
# 3. Delete término
res_del = client.delete(f'/api/v1/admin/academic-terms/{term_id}', headers=auth_headers)
assert res_del.status_code == 200
assert 'eliminado' in res_del.get_json()['message']
def test_classroom_toggle(client, auth_headers):
# Crear edificio y aula
building = Building(name='Sede Central Test', code='SC-TEST', address='Av Test 123')
db.session.add(building)
db.session.commit()
classroom = Classroom(
building=building.name,
code='A-101-TEST',
capacity=50,
floor='1',
building_id=building.id,
is_active=True
)
db.session.add(classroom)
db.session.commit()
# Toggle aula
res = client.post(f'/api/v1/classrooms/{classroom.id}/toggle', headers=auth_headers)
assert res.status_code == 200
assert res.get_json()['is_active'] is False
def test_reservation_hard_delete(client, auth_headers):
# Crear edificio, aula, materia, comisión y reserva
building = Building(name='Sede Norte Test', code='SN-TEST', address='Av Norte 456')
db.session.add(building)
db.session.commit()
classroom = Classroom(
building=building.name,
code='LAB-1-TEST',
capacity=30,
floor='PB',
building_id=building.id,
is_active=True
)
db.session.add(classroom)
subject = Subject(name='Base de Datos Test', code='BD-TEST', is_active=True)
db.session.add(subject)
db.session.commit()
user = User.query.filter_by(email='admin_abm@unicaba.edu.ar').first()
commission = Commission(
subject_id=subject.id,
code='COM-101',
semester='2C',
year=2026,
teacher_id=user.id,
max_students=30,
active=True
)
db.session.add(commission)
db.session.commit()
now = datetime.now()
reservation = Reservation(
classroom_id=classroom.id,
commission_id=commission.id,
user_id=user.id,
purpose='Clase Regular de BD',
expected_attendees=25,
start_time=now,
end_time=now + timedelta(hours=2),
status='CONFIRMED'
)
db.session.add(reservation)
db.session.commit()
res_id = reservation.id
# Hard delete
res_del = client.delete(f'/api/v1/reservations/{res_id}?hard=true', headers=auth_headers)
assert res_del.status_code == 200
assert 'eliminada' in res_del.get_json()['message']
assert db.session.get(Reservation, res_id) is None