145 lines
5.0 KiB
Python
145 lines
5.0 KiB
Python
from flask import abort, current_app
|
|
from apiflask import APIBlueprint
|
|
from flask_sqlalchemy import get_debug_queries
|
|
|
|
from ...students.models import Group, Student, YearGroup, ProjectGradeSheet
|
|
from ...project_supervisor.models import ProjectSupervisor, YearGroupProjectSupervisors
|
|
from ..schemas import GroupEditSchema, GroupsPaginationSchema, GroupCreateSchema, MessageSchema, GroupQuerySchema, \
|
|
DetailGroupSchema
|
|
from ...dependencies import db
|
|
from ...base.utils import paginate_models
|
|
from ..utils import load_weight_for_project_grade_sheet, calculate_points_for_one_term
|
|
|
|
bp = APIBlueprint("groups", __name__, url_prefix="/groups")
|
|
|
|
|
|
@bp.get("/<int:year_group_id>/")
|
|
@bp.input(GroupQuerySchema, location='query')
|
|
@bp.output(GroupsPaginationSchema)
|
|
def list_groups(year_group_id: int, query: dict) -> dict:
|
|
search_name = query.get('name')
|
|
page = query.get('page')
|
|
per_page = query.get('per_page')
|
|
|
|
weights = load_weight_for_project_grade_sheet()
|
|
|
|
groups_query = Group.search_by_name(year_group_id, search_name)
|
|
data = paginate_models(page, groups_query, per_page)
|
|
|
|
items = data['items']
|
|
pgs = []
|
|
for g in items:
|
|
if len(g.project_grade_sheet) == 0:
|
|
pgs.append(None)
|
|
else:
|
|
pgs.append(g.project_grade_sheet[0])
|
|
calculated_points = calculate_points_for_one_term(weights, pgs)
|
|
|
|
for group, points in zip(items, calculated_points):
|
|
group.points_for_first_term = points[0]
|
|
group.points_for_second_term = points[1]
|
|
|
|
return {
|
|
"groups": items,
|
|
"max_pages": data['max_pages']
|
|
}
|
|
|
|
|
|
@bp.post("/<int:year_group_id>/")
|
|
@bp.input(GroupCreateSchema)
|
|
@bp.output(MessageSchema, status_code=201)
|
|
def create_group(year_group_id: int, data: dict) -> dict:
|
|
name = data['name']
|
|
students_indexes = data['students']
|
|
project_supervisor_id = data['project_supervisor_id']
|
|
|
|
yg = YearGroup.query.filter(YearGroup.id == year_group_id).first()
|
|
if yg is None:
|
|
abort(404, "YearGroup doesn't exist!")
|
|
|
|
project_supervisor = ProjectSupervisor.query.filter_by(id=project_supervisor_id).first()
|
|
|
|
limit_student_per_group = current_app.config.get('LIMIT_STUDENTS_PER_GROUP')
|
|
if project_supervisor is None:
|
|
abort(400, f"Project Supervisor with id {project_supervisor_id} doesnt exist")
|
|
elif limit_student_per_group is not None and limit_student_per_group < len(students_indexes):
|
|
abort(400, f"Too much students you want add to group, "
|
|
f"The group can have only {limit_student_per_group} students")
|
|
|
|
limit = db.session.query(db.func.count(ProjectSupervisor.id)). \
|
|
join(Group).filter(ProjectSupervisor.id == project_supervisor_id).group_by(ProjectSupervisor.id).scalar()
|
|
|
|
ygps = YearGroupProjectSupervisors.query. \
|
|
filter(YearGroupProjectSupervisors.year_group_id == year_group_id,
|
|
YearGroupProjectSupervisors.project_supervisor_id == project_supervisor_id).first()
|
|
if limit is not None and ygps is not None and limit >= ygps.limit_group:
|
|
abort(400, "Can't create new group, project supervisor achieved a limit of groups")
|
|
|
|
group = Group(name=name, project_supervisor_id=project_supervisor_id, year_group_id=year_group_id)
|
|
|
|
students_without_groups = db.session.query(Student, Group). \
|
|
join(Group, Student.groups). \
|
|
filter(Group.year_group_id == year_group_id). \
|
|
filter(db.or_(*[Student.index == idx for idx in students_indexes])).all()
|
|
if len(students_without_groups) > 0:
|
|
abort(400, "One or more students have already belonged to group!")
|
|
|
|
db.session.add(group)
|
|
db.session.commit()
|
|
|
|
students = db.session.query(Student).filter(Student.index.in_(students_indexes)).all()
|
|
for student in students:
|
|
group.students.append(student)
|
|
|
|
db.session.commit()
|
|
|
|
pgs = ProjectGradeSheet(group_id=group.id)
|
|
db.session.add(pgs)
|
|
db.session.commit()
|
|
|
|
return {"message": "Group was created!"}
|
|
|
|
|
|
@bp.get("/<int:id>/detail/")
|
|
@bp.output(DetailGroupSchema)
|
|
def detail_group(id: int) -> Group:
|
|
group = Group.query.filter_by(id=id).first()
|
|
if group is None:
|
|
abort(404, f"Not found group!")
|
|
return group
|
|
|
|
|
|
@bp.delete("/<int:id>/")
|
|
@bp.output(MessageSchema, status_code=202)
|
|
def delete_group(id: int) -> dict:
|
|
group = Group.query.filter_by(id=id).first()
|
|
if group is None:
|
|
abort(404, f"Not found group!")
|
|
|
|
group.students = []
|
|
db.session.delete(group)
|
|
db.session.commit()
|
|
return {"message": "Group was deleted!"}
|
|
|
|
|
|
@bp.put("/<int:id>/")
|
|
@bp.input(GroupEditSchema)
|
|
@bp.output(MessageSchema)
|
|
def edit_group(id: int, data: dict) -> dict:
|
|
if not data:
|
|
abort(400, 'You have passed empty data!')
|
|
|
|
group_query = Group.query.filter_by(id=id)
|
|
group = group_query.first()
|
|
|
|
if group is None:
|
|
abort(404, f"Not found group!")
|
|
|
|
students = db.session.query(Student).filter(Student.index.in_(data['students'])).all()
|
|
group.students = students
|
|
group.name = data['name']
|
|
group.project_supervisor_id = data['project_supervisor_id']
|
|
|
|
db.session.commit()
|
|
return {"message": "Group was updated!"}
|