def get_user_schedule(user_id=None):
if g.user_role == 'administrator':
id_to_check = int(user_id or g.user_id)
else:
id_to_check = g.user_id
# Get current maximum run ID from database, should be a subquery
current_run_id = db_session.query(OptimizationRun.id).order_by(
desc(OptimizationRun.created_at)).limit(1).scalar()
course_schedule = []
for c in StudentAssignment.query.filter(StudentAssignment.run_id == current_run_id)\
.filter(StudentAssignment.student_id == id_to_check).all():
course_schedule.append({
'course':
c.course,
'semester':
c.semester,
'instructors':
db_session.query(User).join(
InstructorAssignment,
User.id == InstructorAssignment.instructor_id).
filter(InstructorAssignment.course_id == c.course.id).filter(
InstructorAssignment.semester_id == c.semester.id).all()
})
return jsonify(
courses=ScheduleSchema().dump(course_schedule, many=True).data)
def get_user_schedule(user_id=None):
if g.user_role == 'administrator':
id_to_check = int(user_id or g.user_id)
else:
id_to_check = g.user_id
# Get current maximum run ID from database, should be a subquery
current_run_id = db_session.query(OptimizationRun.id).order_by(
desc(OptimizationRun.created_at)).limit(1).scalar()
semester_contents = {}
for c in StudentAssignment.query.filter(StudentAssignment.run_id == current_run_id)\
.filter(StudentAssignment.student_id == id_to_check).all():
if c.semester.id not in semester_contents.keys():
semester_contents[c.semester.id] = (c.semester, [c.course])
else:
semester_contents[c.semester.id][1].append(c.course)
semester_array = []
for s in semester_contents.keys():
semester_data = SemesterSchema().dump(semester_contents[s][0]).data
semester_data['courses'] = CourseSchema().dump(semester_contents[s][1],
many=True).data
semester_array.append(semester_data)
return jsonify(
schedule=list(sorted(semester_array, key=lambda s: s['id'])))
def get_aggregate_demand():
course_demand = []
aggregate_sub = db_session.query(StudentDemand.course_id, StudentDemand.semester_id, func.count(StudentDemand.id)
.label('student_count')).filter(StudentDemand.is_current == True).group_by(StudentDemand.course_id)\
.group_by(StudentDemand.semester_id).subquery()
merged_query = db_session.query(Course, Semester, aggregate_sub.c.student_count).select_from(aggregate_sub)\
.join(Course, Course.id == aggregate_sub.c.course_id).join(Semester, Semester.id == aggregate_sub.c.semester_id)\
.all()
for (course, semester, count) in merged_query:
course_demand.append({
'course': course,
'semester': semester,
'demand': count
})
return jsonify(demand=AggregateDemandSchema().dump(course_demand, many=True).data)
def get_solver_context():
# Students
students = {}
for (student,
record) in db_session.query(User,
StudentRecord).join(StudentRecord).all():
students[student.id] = {
'seniority': record.seniority if record else 0,
'current_gpa': record.current_gpa if record else 0
}
# Semesters (should figure out better course timing approach)
semesters = {}
for semester in db_session.query(Semester).all():
semesters[semester.id] = {'semester_name': semester.name}
# Courses
courses = {}
for course in db_session.query(Course).all():
courses[course.id] = {
'is_fall': course.is_fall,
'is_spring': course.is_spring,
'is_summer': course.is_summer
}
# Prerequisites
course_dependencies = []
for cd in db_session.query(CourseDependency).all():
course_dependencies.append({
'first_course': cd.first_course,
'second_course': cd.second_course
})
# Student demand
student_demand = []
for sd in db_session.query(StudentDemand).all():
student_demand.append({
'student_id': sd.student_id,
'course_id': sd.course_id,
'semester_id': sd.semester_id
})
# Instructor availability
instructor_availability = []
for ia in db_session.query(InstructorPool).all():
instructor_availability.append({
'instructor_id': ia.user_id,
'course_id': ia.course_id,
'semester_id': ia.semester_id,
'instructor_role': ia.instructor_role
})
return {
'students': students,
'courses': courses,
'semesters': semesters,
'course_dependencies': course_dependencies,
'student_demand': student_demand,
'instructor_pool': instructor_availability
}
def get_solver_context():
# Students
students = {}
for (student, record) in db_session.query(User, StudentRecord).join(StudentRecord).all():
students[student.id] = {
'seniority': record.seniority if record else 0,
'current_gpa': record.current_gpa if record else 0
}
# Semesters (should figure out better course timing approach)
semesters = {}
for semester in db_session.query(Semester).all():
semesters[semester.id] = {
'semester_name': semester.name
}
# Courses
courses = {}
for course in db_session.query(Course).all():
courses[course.id] = {
'is_fall': course.is_fall,
'is_spring': course.is_spring,
'is_summer': course.is_summer
}
# Prerequisites
course_dependencies = []
for cd in db_session.query(CourseDependency).all():
course_dependencies.append({
'first_course': cd.first_course,
'second_course': cd.second_course
})
# Student demand
student_demand = []
for sd in db_session.query(StudentDemand).filter(StudentDemand.is_current == True).all():
student_demand.append({
'student_id': sd.student_id,
'course_id': sd.course_id,
'semester_id': sd.semester_id
})
# Instructor availability
instructor_availability = []
for ia in db_session.query(InstructorPool).all():
instructor_availability.append({
'instructor_id': ia.user_id,
'course_id': ia.course_id,
'semester_id': ia.semester_id,
'instructor_role': ia.instructor_role
})
return {
'students': students,
'courses': courses,
'semesters': semesters,
'course_dependencies': course_dependencies,
'student_demand': student_demand,
'instructor_pool': instructor_availability
}
def get_user_schedule(user_id=None):
if g.user_role == 'administrator':
id_to_check = int(user_id or g.user_id)
else:
id_to_check = g.user_id
# Get current maximum run ID from database, should be a subquery
current_run_id = db_session.query(OptimizationRun.id).order_by(desc(OptimizationRun.created_at)).limit(1).scalar()
course_schedule = []
for c in StudentAssignment.query.filter(StudentAssignment.run_id == current_run_id)\
.filter(StudentAssignment.student_id == id_to_check).all():
course_schedule.append({
'course': c.course,
'semester': c.semester,
'instructors': db_session.query(User).join(InstructorAssignment, User.id == InstructorAssignment.instructor_id)
.filter(InstructorAssignment.course_id == c.course.id)
.filter(InstructorAssignment.semester_id == c.semester.id).all()
})
return jsonify(courses=ScheduleSchema().dump(course_schedule, many=True).data)
import json
from api.models import db_session, engine, BaseModel, User, Semester, Course, CourseDependency, InstructorPool, StudentDemand, StudentRecord
user_roles = {
'5': 'student',
'1': 'TA',
'3': 'professor',
'4': 'administrator'
}
# Students
students = {}
for (student, record) in db_session.query(User, StudentRecord).join(StudentRecord).all():
students[student.id] = {
'seniority': record.seniority if record else 0,
'current_gpa': record.current_gpa if record else 0
}
# Semesters (should figure out better course timing approach)
semesters = {}
for semester in db_session.query(Semester).all():
semesters[semester.id] = {
'semester_name': semester.name
}
# Courses
courses = {}
for course in db_session.query(Course).all():
courses[course.id] = {
'is_fall': course.is_fall,
'is_spring': course.is_spring,
import json
from api.models import db_session, engine, BaseModel, User, Semester, Course, CourseDependency, InstructorPool, StudentDemand, StudentRecord
user_roles = {
'5': 'student',
'1': 'TA',
'3': 'professor',
'4': 'administrator'
}
# Students
students = {}
for (student,
record) in db_session.query(User,
StudentRecord).join(StudentRecord).all():
students[student.id] = {
'seniority': record.seniority if record else 0,
'current_gpa': record.current_gpa if record else 0
}
# Semesters (should figure out better course timing approach)
semesters = {}
for semester in db_session.query(Semester).all():
semesters[semester.id] = {'semester_name': semester.name}
# Courses
courses = {}
for course in db_session.query(Course).all():
courses[course.id] = {
'is_fall': course.is_fall,
'is_spring': course.is_spring,