Integrate the course assignment table according to researchers' preferences (#10)

Author: SamuelVch98

app.py

@@ -7,7 +7,8 @@
 from course import course_bp
 from config import config_bp
 from course_preference import course_preference_bp
-from db import db, Configuration, Organization, User, Course, Teacher, Researcher
+from assignment import assignment_bp
+from db import db, Year, Organization, User, Course, Teacher, Researcher
 from decorators import *
 from flask import Flask, render_template, session, request
 from enums import *
@@ -27,10 +28,11 @@
 app.register_blueprint(course_bp, url_prefix="/course")
 app.register_blueprint(config_bp, url_prefix="/config")
 app.register_blueprint(course_preference_bp, url_prefix="/course_preference")
+app.register_blueprint(assignment_bp, url_prefix="/assignment")
 
 
 def get_configurations():
-    return db.session.query(Configuration).order_by(Configuration.year.asc()).all()
+    return db.session.query(Year).order_by(Year.year.asc()).all()
 
 
 def get_organization():

assignment.py

@@ -0,0 +1,132 @@
+from decorators import login_required, check_access_level
+from db import db, User, Course, PreferenceAssignment, Teacher, Researcher, Organization, \
+    ResearcherSupervisor, Role, AssignmentDraft, AssignmentPublished
+from flask import Blueprint, render_template, flash, current_app, url_for, request, make_response, redirect, session, \
+    Flask, jsonify
+from util import get_current_year
+from enums import DEFAULT_MAX_LOAD
+
+assignment_bp = Blueprint('assignment', __name__)
+
+
+@assignment_bp.route('/assignments', methods=['GET'])
+@login_required
+def assignments():
+    return render_template('assignment.html')
+
+
+def serialize_model(model):
+    """Converts a SQLAlchemy model object into a dictionary."""
+    return {column.name: getattr(model, column.name) for column in model.__table__.columns}
+
+
+@assignment_bp.route('/load_data', methods=['GET'])
+@login_required
+@check_access_level(Role.ADMIN)
+def load_data():
+    current_year = get_current_year()
+
+    courses = [serialize_model(course) for course in
+               db.session.query(Course).filter_by(year=current_year).order_by(Course.quadri).all() or []]
+    supervisors = [serialize_model(supervisor) for supervisor in db.session.query(ResearcherSupervisor).all() or []]
+    teachers = {teacher.id: serialize_model(teacher) for teacher in
+                db.session.query(Teacher).filter_by(course_year=current_year).all() or []}
+    researchers = {researcher.id: serialize_model(researcher) for researcher in
+                   db.session.query(Researcher).all() or []}
+    preferences = {preference.id: serialize_model(preference) for preference in
+                   db.session.query(PreferenceAssignment).filter_by(course_year=current_year).all() or []}
+    organizations = {organization.id: serialize_model(organization) for organization in
+                     db.session.query(Organization).all() or []}
+
+    saved_data = [serialize_model(assignment) for assignment in
+                  db.session.query(AssignmentDraft).filter_by(course_year=current_year).all()]
+
+    # Retrieve active users or users associated with preferences.
+    # Join the 'Researcher' model to 'PreferenceAssignment' and check if the researcher has preferences.
+    users = {
+        user.id: serialize_model(user)
+        for user in db.session.query(User)
+        .filter(
+            (User.active == True) | (User.id.in_(
+                db.session.query(Researcher.user_id).join(PreferenceAssignment,
+                                                          Researcher.id == PreferenceAssignment.researcher_id)
+            ))
+        ).all()
+    }
+
+    data = {
+        'courses': courses,
+        'users': users,
+        'supervisors': supervisors,
+        'teachers': teachers,
+        'researchers': researchers,
+        'preferences': preferences,
+        'organizations': organizations,
+        'current_year': current_year,
+        'saved_data': saved_data,
+        'MAX_LOAD': DEFAULT_MAX_LOAD,
+    }
+
+    return jsonify(data)
+
+
+@assignment_bp.route('/publish_assignments', methods=['POST'])
+@login_required
+def publish_assignments():
+    data = request.get_json()
+    if not data:
+        return jsonify({"error": "No data provided"}), 400
+
+    current_year = get_current_year()
+    is_draft = data.get('isDraft')
+
+    try:
+        # Clear existing assignments for the current year
+        AssignmentDraft.query.filter_by(course_year=current_year).delete()
+        if not is_draft:
+            AssignmentPublished.query.filter_by(course_year=current_year).delete()
+        db.session.commit()
+
+        assignments_to_add = []
+
+        for index, item in enumerate(data.get('data', [])):
+            try:
+                user_data = item.get('userData')
+                course_data = item.get('courseData')
+
+                researcher_id = int(user_data.get('researcher_id'))
+                load_q1 = int(user_data.get('load_q1'))
+                load_q2 = int(user_data.get('load_q2'))
+
+                for course_id, properties in course_data.items():
+                    try:
+                        course_id = int(course_id)
+                        position = int(properties.get('position'))
+                        comment = properties.get('comment')
+                        if not isinstance(comment, (str, type(None))):
+                            raise ValueError("Invalid comment format")
+
+                        assignments_to_add.append(AssignmentDraft(
+                            course_id=course_id, course_year=current_year, researcher_id=researcher_id,
+                            load_q1=load_q1, load_q2=load_q2, position=position, comment=comment
+                        ))
+                        if not is_draft:
+                            assignments_to_add.append(AssignmentPublished(
+                                course_id=course_id, course_year=current_year, researcher_id=researcher_id,
+                                load_q1=load_q1, load_q2=load_q2, position=position, comment=comment
+                            ))
+                    except (ValueError, TypeError) as e:
+                        course = db.session.query(Course).filter_by(id=course_id, year=current_year).first()
+                        return jsonify({
+                            "error": f"Error for researcher_id {researcher_id}, course_name {course.code} - {course.title} : {e}"}), 400
+
+            except (ValueError, TypeError) as e:
+                return jsonify({"error": f"Invalid data : {str(e)}"}), 400
+
+        db.session.add_all(assignments_to_add)
+        db.session.commit()
+        return jsonify({"message": "Assignments published successfully"}), 200
+
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({"error": f"Failed to publish assignments: {str(e)}"}), 500

auth.py

@@ -1,4 +1,4 @@
-from db import db, User, Configuration
+from db import db, User
 from flask import Blueprint, current_app, url_for, request, make_response, redirect, session
 from onelogin.saml2.auth import OneLogin_Saml2_Auth
 from onelogin.saml2.utils import OneLogin_Saml2_Utils

config.py

@@ -1,5 +1,5 @@
 from decorators import login_required, check_access_level
-from db import db, Configuration, Role
+from db import db, Year, Role
 from flask import Blueprint, render_template, flash, current_app, url_for, request, make_response, redirect, session, \
     Flask
 import logging
@@ -11,7 +11,7 @@
 @login_required
 @check_access_level(Role.ADMIN)
 def manage_years():
-    configurations = Configuration.query.order_by(Configuration.year.desc()).all()
+    configurations = Year.query.order_by(Year.year.desc()).all()
     return render_template('config.html', configurations=configurations)
 
 
@@ -20,17 +20,17 @@ def manage_years():
 @login_required
 @check_access_level(Role.ADMIN)
 def new_year():
-    last_year = Configuration.query.order_by(Configuration.year.desc()).first()
+    last_year = Year.query.order_by(Year.year.desc()).first()
     new_year = last_year.year + 1
 
     try:
         # Check whether the following year already exists in the database
-        existing_config = Configuration.query.filter_by(year=new_year).first()
+        existing_config = Year.query.filter_by(year=new_year).first()
         if existing_config is not None:
             flash("The year already exists", "error")
             return redirect(url_for("index"))
 
-        config = Configuration(year=new_year)
+        config = Year(year=new_year)
         db.session.add(config)
         db.session.commit()
         flash("Year created successfully", "success")
@@ -49,8 +49,8 @@ def new_year():
 @check_access_level(Role.ADMIN)
 def change_year(year):
     try:
-        new_current_year = Configuration.query.filter_by(year=year).first()
-        Configuration.update_current_year(new_current_year.id)
+        new_current_year = Year.query.filter_by(year=year).first()
+        Year.update_current_year(new_current_year.id)
 
     except Exception as e:
         db.session.rollback()

course.py

@@ -1,5 +1,5 @@
 from decorators import login_required, check_access_level
-from db import db, User, Course, Teacher, Organization, Evaluation, Configuration, Role
+from db import db, User, Course, Teacher, Organization, Evaluation, Year, Role
 from flask import Blueprint, render_template, flash, url_for, request, make_response, redirect, \
     Flask, jsonify, session
 from util import get_current_year
@@ -104,7 +104,7 @@ def add_course():
 
         db.session.add(new_course)
         db.session.commit()
-        return redirect(url_for("course.courses", current_year=year))
+        return redirect(url_for("course.courses", year=year))
     except Exception as e:
         db.session.rollback()
         raise e
@@ -125,8 +125,8 @@ def search_teachers():
     if not validate_string_pattern(search_term):
         return make_response("Invalid search term", 400)
 
-    teachers = db.session.query(User).join(Teacher).filter(
-        User.active == True,
+    teachers = db.session.query(User).filter(
+        User.is_teacher == True,
         User.name.ilike(f'%{search_term}%')
     ).all()
     results = [{'id': teacher.id, 'text': f'{teacher.name} {teacher.first_name}'} for teacher in teachers]
@@ -172,7 +172,7 @@ def update_course_info():
     organisation_code = request.form.getlist('organization_code[]')
     if not len(organisation_code):
         flash("Please select at least one organization", "danger")
-        return redirect(url_for('course.course_info', course_id=course_id))
+        return redirect(url_for('course.course_info', course_id=course_id, year=year))
 
     course = db.session.query(Course).filter(Course.id == course_id, Course.year == year).first()
     if not course:

course_preference.py

@@ -9,12 +9,11 @@
 course_preference_bp = Blueprint('course_preference', __name__)
 
 
-def delete_old_preferences(researcher_id, course_ids, current_year):
+def delete_old_preferences(researcher_id, current_year):
     try:
         db.session.query(PreferenceAssignment).filter(
             PreferenceAssignment.researcher_id == researcher_id,
             PreferenceAssignment.course_year == current_year,
-            PreferenceAssignment.course_id.in_(course_ids)
         ).delete()
         db.session.commit()
     except Exception as e:
@@ -41,14 +40,15 @@ def save_preference():
     if researcher is None:
         return make_response("User is not a researcher", 500)
 
-    new_course_ids = {preference['course_id'] for preference in preferences}
-    delete_old_preferences(researcher.id, new_course_ids, current_year)
+    delete_old_preferences(researcher.id, current_year)
 
+    rank = 0
     for preference in preferences:
         try:
+            rank += 1
             course_id = preference['course_id']
             course_year = preference['course_year']
-            new_preference = PreferenceAssignment(course_id=course_id, course_year=course_year,
+            new_preference = PreferenceAssignment(rank=rank, course_id=course_id, course_year=course_year,
                                                   researcher_id=researcher.id)
             db.session.add(new_preference)
             db.session.commit()

create_db.py

@@ -1,7 +1,7 @@
 import argparse
 from app import app, db
 from datetime import datetime
-from db import User, Configuration, Organization
+from db import User, Year, Organization
 
 
 def create_database(name, first_name, email):
@@ -27,10 +27,10 @@ def add_first_admin(name, first_name, email):
 # Add the first year corresponding to the current year
 def initialize_configuration():
     current_year = datetime.now().year
-    existing_year = Configuration.query.filter_by(year=current_year).first()
+    existing_year = Year.query.filter_by(year=current_year).first()
 
     if existing_year is None:
-        config = Configuration(year=current_year, is_current_year=True)
+        config = Year(year=current_year, is_current_year=True)
         db.session.add(config)
         db.session.commit()
 

db.py

@@ -110,6 +110,7 @@ class Teacher(db.Model):
 class PreferenceAssignment(db.Model):
     __tablename__ = 'preference_assignment'
     id = db.Column(db.Integer, primary_key=True)
+    rank = db.Column(db.Integer, nullable=False)
     course_id = db.Column(db.Integer, nullable=False)
     course_year = db.Column(db.Integer, nullable=False)
     researcher_id = db.Column(db.Integer, db.ForeignKey('researcher.id'), nullable=False)
@@ -127,18 +128,18 @@ class PreferenceAssignment(db.Model):
     researcher = db.relationship('Researcher', backref=db.backref('researcher_preference_assignment', lazy=True))
 
 
-class Configuration(db.Model):
-    __tablename__ = 'configuration'
+class Year(db.Model):
+    __tablename__ = 'year'
     id = db.Column(db.Integer, primary_key=True)
     year = db.Column(db.Integer, nullable=False)
     is_current_year = db.Column(db.Boolean, default=False)
 
     @classmethod
-    def update_current_year(cls, config_id):
+    def update_current_year(cls, year_id):
         # Update all years to set is_current_year to False
         cls.query.update({cls.is_current_year: False})
 
-        selected_config = cls.query.get(config_id)
+        selected_config = cls.query.get(year_id)
         if selected_config:
             selected_config.is_current_year = True
             db.session.commit()
@@ -172,6 +173,44 @@ class CourseOrganization(db.Model):
     )
 
 
+class AssignmentDraft(db.Model):
+    __tablename__ = 'assignment_draft'
+    id = db.Column(db.Integer, primary_key=True)
+    course_id = db.Column(db.Integer, nullable=False)
+    course_year = db.Column(db.Integer, nullable=False)
+    researcher_id = db.Column(db.Integer, db.ForeignKey('researcher.id'))
+    load_q1 = db.Column(db.Integer)
+    load_q2 = db.Column(db.Integer)
+    position = db.Column(db.Integer)
+    comment = db.Column(db.String(500))
+
+    __table_args__ = (
+        db.ForeignKeyConstraint(
+            ['course_id', 'course_year'],
+            ['course.id', 'course.year']
+        ),
+    )
+
+
+class AssignmentPublished(db.Model):
+    __tablename__ = 'assignment_published'
+    id = db.Column(db.Integer, primary_key=True)
+    course_id = db.Column(db.Integer, nullable=False)
+    course_year = db.Column(db.Integer, nullable=False)
+    researcher_id = db.Column(db.Integer, db.ForeignKey('researcher.id'))
+    load_q1 = db.Column(db.Integer)
+    load_q2 = db.Column(db.Integer)
+    position = db.Column(db.Integer)
+    comment = db.Column(db.String(500))
+
+    __table_args__ = (
+        db.ForeignKeyConstraint(
+            ['course_id', 'course_year'],
+            ['course.id', 'course.year']
+        ),
+    )
+
+
 class Evaluation(db.Model):
     __tablename__ = 'evaluation'