217 lines
8.5 KiB
Python
217 lines
8.5 KiB
Python
from app import db
|
|
from datetime import datetime
|
|
|
|
class Classroom(db.Model):
|
|
__tablename__ = 'classrooms'
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
campus_id = db.Column(db.Integer, nullable=True) # Maps to campus_id in DB
|
|
building_id = db.Column(db.Integer, db.ForeignKey('buildings.id'), nullable=True)
|
|
building = db.Column(db.String(100), nullable=False)
|
|
code = db.Column('room_number', db.String(50), nullable=False) # Maps to room_number column in DB
|
|
floor = db.Column(db.String(50), nullable=False, default='1')
|
|
capacity = db.Column(db.Integer, nullable=False)
|
|
description = db.Column(db.Text)
|
|
is_active = db.Column('active', db.Boolean, default=True, nullable=False) # Maps to active column in DB
|
|
created_at = db.Column(db.DateTime, default=datetime.utcnow)
|
|
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
|
|
|
|
# Relación con Building (mapeada vía backref 'building_entity' en Building.classrooms)
|
|
@property
|
|
def building_rel(self):
|
|
return self.building_entity
|
|
|
|
@property
|
|
def building_name(self):
|
|
"""Nombre del edificio desacoplado"""
|
|
if self.building_rel:
|
|
return self.building_rel.name
|
|
return self.building or 'Edificio Central'
|
|
|
|
@property
|
|
def floor_display(self):
|
|
"""Formato amigable para el piso: PB, Planta Baja, Piso X"""
|
|
f = str(self.floor).strip() if self.floor is not None else ''
|
|
if f in ['0', 'PB', 'pb', 'Planta Baja', 'planta baja']:
|
|
return 'Planta Baja'
|
|
if f.lower().startswith('piso') or '°' in f:
|
|
return f
|
|
return f"Piso {f}"
|
|
|
|
@property
|
|
def is_virtual(self):
|
|
"""Indica si el aula es virtual"""
|
|
return (self.code and 'VIRTUAL' in self.code.upper()) or (self.building and 'VIRTUAL' in self.building.upper())
|
|
|
|
@property
|
|
def location_display(self):
|
|
"""Ubicación completa y limpia: Edificio · Piso · Aula"""
|
|
if self.is_virtual:
|
|
return '🌐 Campus Virtual'
|
|
return f"{self.building_name} · {self.floor_display} · {self.code}"
|
|
|
|
# Virtual properties for compatibility
|
|
@property
|
|
def name(self):
|
|
"""Generate name from building and code"""
|
|
return f"{self.building_name}-{self.code}"
|
|
|
|
@property
|
|
def campus_location(self):
|
|
"""Placeholder for campus location"""
|
|
return self.building_rel.address if self.building_rel else None
|
|
|
|
# Virtual field for compatibility - combines building and code
|
|
@property
|
|
def room_number(self):
|
|
return self.code
|
|
|
|
@room_number.setter
|
|
def room_number(self, value):
|
|
self.code = value
|
|
|
|
# Override code property for consistency
|
|
@property
|
|
def code_display(self):
|
|
return f"{self.building_name} - {self.code}"
|
|
|
|
@property
|
|
def capacity_display(self):
|
|
"""Retorna '∞' para aulas virtuales o capacidad ilimitada, o el número entero."""
|
|
if self.capacity == 0 or self.is_virtual:
|
|
return '∞'
|
|
return str(self.capacity)
|
|
|
|
@property
|
|
def is_unlimited(self):
|
|
return self.capacity == 0 or self.is_virtual
|
|
|
|
def to_dict(self):
|
|
"""Convert classroom to dictionary"""
|
|
return {
|
|
'id': self.id,
|
|
'building_id': self.building_id,
|
|
'building': self.building_name,
|
|
'code': self.code,
|
|
'code_display': self.code_display,
|
|
'name': self.name,
|
|
'floor': self.floor,
|
|
'floor_display': self.floor_display,
|
|
'location_display': self.location_display,
|
|
'capacity': self.capacity,
|
|
'capacity_display': self.capacity_display,
|
|
'is_virtual': self.is_virtual,
|
|
'description': self.description,
|
|
'campus_location': self.campus_location,
|
|
'is_active': self.is_active,
|
|
'created_at': self.created_at.isoformat() if self.created_at else None,
|
|
'updated_at': self.updated_at.isoformat() if self.updated_at else None,
|
|
'resources': [resource.to_dict() for resource in self.resources] if hasattr(self, 'resources') else []
|
|
}
|
|
|
|
def get_full_location(self):
|
|
"""Get full classroom location"""
|
|
if self.is_virtual:
|
|
return 'Campus Virtual (Remoto)'
|
|
return f"{self.building_name} - {self.floor_display}"
|
|
|
|
@staticmethod
|
|
def find_best_classroom(max_students, start_time, end_time, exclude_reservation_id=None):
|
|
"""Find the best suitable classroom for a commission based on capacity and availability"""
|
|
from app.models.reservation import Reservation, ReservationStatus
|
|
|
|
# Get all active classrooms with sufficient capacity
|
|
suitable_classrooms = Classroom.query.filter(
|
|
Classroom.is_active == True,
|
|
Classroom.capacity >= max_students
|
|
).order_by(Classroom.capacity.asc()).all() # Start with smallest suitable
|
|
|
|
# Check availability for each classroom
|
|
available_classrooms = []
|
|
for classroom in suitable_classrooms:
|
|
# Check for conflicts
|
|
conflicts = Reservation.find_conflicts(
|
|
classroom.id, start_time, end_time, exclude_reservation_id
|
|
)
|
|
|
|
if not conflicts:
|
|
# Calculate efficiency score (how well the capacity matches)
|
|
efficiency = classroom.capacity / max_students if max_students > 0 else float('inf')
|
|
available_classrooms.append({
|
|
'classroom': classroom,
|
|
'efficiency': efficiency,
|
|
'wasted_capacity': classroom.capacity - max_students
|
|
})
|
|
|
|
# Sort by efficiency (closest capacity match first)
|
|
available_classrooms.sort(key=lambda x: x['efficiency'])
|
|
|
|
return available_classrooms
|
|
|
|
@staticmethod
|
|
def get_availability_status(start_time, end_time, exclude_reservation_id=None):
|
|
"""Get all classrooms classified as available or occupied for a time slot"""
|
|
from app.models.reservation import Reservation, ReservationStatus
|
|
|
|
all_classrooms = Classroom.query.filter_by(is_active=True).all()
|
|
available = []
|
|
occupied = []
|
|
|
|
for classroom in all_classrooms:
|
|
conflicts = Reservation.find_conflicts(
|
|
classroom.id, start_time, end_time, exclude_reservation_id
|
|
)
|
|
|
|
classroom_info = {
|
|
'classroom': classroom,
|
|
'conflicts': conflicts
|
|
}
|
|
|
|
if conflicts:
|
|
occupied.append(classroom_info)
|
|
else:
|
|
available.append(classroom_info)
|
|
|
|
return {
|
|
'available': available,
|
|
'occupied': occupied,
|
|
'total_available': len(available),
|
|
'total_occupied': len(occupied)
|
|
}
|
|
|
|
def __repr__(self):
|
|
return f'<Classroom {self.code_display}>'
|
|
|
|
class ClassroomResource(db.Model):
|
|
__tablename__ = 'classroom_resources'
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
classroom_id = db.Column(db.Integer, db.ForeignKey('classrooms.id'), nullable=False)
|
|
resource_type = db.Column(db.String(50), nullable=False) # PROJECTOR, WHITEBOARD, COMPUTER, etc.
|
|
brand = db.Column(db.String(100))
|
|
model = db.Column(db.String(100))
|
|
specifications = db.Column(db.Text)
|
|
functional = db.Column(db.Boolean, default=True)
|
|
last_maintenance_date = db.Column(db.DateTime)
|
|
created_at = db.Column(db.DateTime, default=datetime.utcnow)
|
|
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
|
|
|
|
# Relationships
|
|
classroom = db.relationship('Classroom', backref=db.backref('resources', lazy=True, cascade='all, delete-orphan'))
|
|
|
|
def to_dict(self):
|
|
"""Convert resource to dictionary"""
|
|
return {
|
|
'id': self.id,
|
|
'classroom_id': self.classroom_id,
|
|
'resource_type': self.resource_type,
|
|
'brand': self.brand,
|
|
'model': self.model,
|
|
'specifications': self.specifications,
|
|
'functional': self.functional,
|
|
'last_maintenance_date': self.last_maintenance_date.isoformat() if self.last_maintenance_date else None,
|
|
'created_at': self.created_at.isoformat() if self.created_at else None
|
|
}
|
|
|
|
def __repr__(self):
|
|
return f'<Resource {self.resource_type} for Classroom {self.classroom_id}>' |