Integrate the course assignment table according to researchers' preferences

app.py

@@ -7,6 +7,7 @@
 from course import course_bp
 from config import config_bp
 from course_preference import course_preference_bp
+from assignment import assignment_bp
 from db import db, Configuration, Organization, User, Course, Teacher, Researcher
 from decorators import *
 from flask import Flask, render_template, session, request
@@ -27,6 +28,7 @@
 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():

assignment.py

@@ -0,0 +1,74 @@
+from decorators import login_required
+from db import db, User, Course, PreferenceAssignment, Teacher, Researcher, Organization, PublishAssignment, \
+ ResearcherSupervisor
+from flask import Blueprint, render_template, flash, current_app, url_for, request, make_response, redirect, session, \
+ Flask, jsonify
+from util import get_current_year
+
+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
+def load_data():
+ current_year = get_current_year()
+ courses = (db.session.query(Course).filter_by(year=current_year).order_by(Course.quadri).all())
+ users = db.session.query(User).filter_by(active=True).all()
+ supervisors = db.session.query(ResearcherSupervisor).all()
+ teachers = db.session.query(Teacher).filter_by(course_year=current_year).all()
+ researchers = db.session.query(Researcher).all()
+ preferences = db.session.query(PreferenceAssignment).filter_by(course_year=current_year).all()
+ organizations = db.session.query(Organization).all()
+
+ data = {
+ 'courses': [serialize_model(course) for course in courses],
+ 'users': {user.id: serialize_model(user) for user in users},
+ 'supervisors': [serialize_model(supervisor) for supervisor in supervisors],
+ 'teachers': {teacher.id: serialize_model(teacher) for teacher in teachers},
+ 'researchers': {researcher.id: serialize_model(researcher) for researcher in researchers},
+ 'preferences': {preference.id: serialize_model(preference) for preference in preferences},
+ 'organizations': {organization.id: serialize_model(organization) for organization in organizations},
+ 'current_year': current_year
+ }
+
+ 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()
+
+ for item in data:
+ user_data = item.get('userData')
+ course_data = item.get('courseData')
+
+ if course_data and user_data:
+ for id, pos in course_data.items():
+ try:
+ assignment = PublishAssignment(course_id=id, course_year=current_year,
+ user_id=user_data.get('user_id'),
+ load_q1=user_data.get('load_q1'), load_q2=user_data.get('load_q2'),
+ position=pos)
+ db.session.add(assignment)
+ except Exception as e:
+ return jsonify({"error": str(e)}), 400
+
+ db.session.commit()
+
+ return jsonify({"message": "Assignments published successfully"}), 200

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()

db.py

@@ -109,6 +109,7 @@ class Teacher(db.Model):
 
 class PreferenceAssignment(db.Model):
  __tablename__ = 'preference_assignment'
+ rank = db.Column(db.Integer, nullable=False)
  id = db.Column(db.Integer, primary_key=True)
  course_id = db.Column(db.Integer, nullable=False)
  course_year = db.Column(db.Integer, nullable=False)
@@ -172,6 +173,23 @@ class CourseOrganization(db.Model):
  )
 
 
+class PublishAssignment(db.Model):
+ __tablename__ = 'publish_assignment'
+ course_id = db.Column(db.Integer, primary_key=True)
+ course_year = db.Column(db.Integer, primary_key=True)
+ user_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
+ load_q1 = db.Column(db.Integer)
+ load_q2 = db.Column(db.Integer)
+ position = db.Column(db.Integer)
+
+ __table_args__ = (
+ db.ForeignKeyConstraint(
+ ['course_id', 'course_year'],
+ ['course.id', 'course.year']
+ ),
+ )
+
+
 class Evaluation(db.Model):
  __tablename__ = 'evaluation'