584 lines
25 KiB
Python
584 lines
25 KiB
Python
from flask import Blueprint, render_template, request, redirect, url_for, flash, jsonify
|
|
from flask_login import login_required, current_user
|
|
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
|
|
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.utcnow().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(Commission.subject),
|
|
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 and floor_filter.isdigit():
|
|
query = query.filter(Classroom.floor == int(floor_filter))
|
|
|
|
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('/calendar')
|
|
@login_required
|
|
def calendar_view():
|
|
"""Show calendar view with classroom, subject, career, shift, floor and virtual filtering"""
|
|
from app.models.career import Career
|
|
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()
|
|
|
|
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,
|
|
available_floors=available_floors
|
|
)
|
|
|
|
@schedule_bp.route('/commissions')
|
|
def commissions_view():
|
|
subjects = Subject.query.all()
|
|
|
|
# Calculamos el total de capacidad sumando todas las comisiones de todas las materias
|
|
total_capacity = sum(c.max_students for s in subjects for c in s.commissions)
|
|
# Calculamos el total de comisiones
|
|
total_commissions = sum(len(s.commissions) for s in subjects)
|
|
|
|
return render_template('schedule/commissions.html',
|
|
subjects=subjects,
|
|
total_capacity=total_capacity,
|
|
total_commissions=total_commissions)
|
|
|
|
@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
|
|
|
|
form = ReservationForm()
|
|
|
|
# Get active classrooms for the dropdown
|
|
classrooms = Classroom.query.filter_by(is_active=True).all()
|
|
|
|
# Get active commissions for the dropdown
|
|
commissions = Commission.query.filter_by(active=True).all()
|
|
|
|
# Populate form choices
|
|
form.classroom_id.choices = [(c.id, f'{c.code_display} - {c.name} (Cap: {c.capacity})') 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)
|
|
|
|
# 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,
|
|
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()
|
|
current_app.logger.error(f"Error creating reservation: {str(e)}")
|
|
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)
|
|
|
|
@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()
|
|
search = request.args.get('search', '').strip()
|
|
|
|
query = Reservation.query.options(
|
|
joinedload(Reservation.classroom),
|
|
joinedload(Reservation.commission).joinedload(Commission.subject),
|
|
joinedload(Reservation.user)
|
|
).join(Reservation.classroom).outerjoin(Reservation.commission).outerjoin(Commission.subject)
|
|
|
|
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 and floor_filter.isdigit():
|
|
query = query.filter(Classroom.floor == int(floor_filter))
|
|
|
|
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}%'),
|
|
Classroom.code.ilike(f'%{search}%'),
|
|
Reservation.purpose.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]
|
|
|
|
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,
|
|
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 = {
|
|
'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:
|
|
from datetime import datetime
|
|
# 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).joinedload(Commission.subject).joinedload(Subject.career_obj)
|
|
).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))
|
|
|
|
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 and floor.isdigit():
|
|
query = query.filter(Classroom.floor == int(floor))
|
|
|
|
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 if reservation.classroom else None
|
|
is_virtual = bool(reservation.classroom and ('VIRTUAL' in (reservation.classroom.code or '').upper() or 'VIRTUAL' in (reservation.classroom.building or '').upper()))
|
|
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': reservation.classroom.building if reservation.classroom else '',
|
|
'floor': classroom_floor,
|
|
'is_virtual': is_virtual,
|
|
'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 ''
|
|
}
|
|
})
|
|
|
|
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).joinedload(Commission.subject).joinedload(Subject.career_obj)
|
|
).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 |