def shift_report(self, request, pk=None):
subject = get_object_or_404(Subject, id=pk)
user = get_user_from_request(request)
if not isinstance(user, Student):
raise exceptions.PermissionDenied()
course = user.course.all().last()
shifts = Shift.objects.filter(subject=subject)
return Response(
dict(
shifts=[
SummaryShiftSerializer(
shift,
context=dict(
course=course,
enrolled=user in shift.student.all(),
lesson_spec=LessonSpecification.objects.filter(
shift=shift),
student=user,
)).data for shift in shifts
],
subject_spec=SubjectSpecificationSerializer(
subject.subject_spec).data,
))
def my_timetable(self, request):
user = get_user_from_request(request)
if isinstance(user, Student):
return self.timetable_student(request, user)
elif isinstance(user, Professor):
return self.timetable_professor(request, user)
else:
raise exceptions.PermissionDenied()
def sign_up(self, request, pk=None):
shift = get_object_or_404(Shift, id=pk)
user = get_user_from_request(request)
if not isinstance(user, Student) or not self.is_eligible(shift, user):
raise exceptions.PermissionDenied()
shift.student.add(user)
shift.save()
return Response(status=200)
def request_exchange(self, request, pk=None):
shift = get_object_or_404(Shift, id=pk)
user = get_user_from_request(request)
if not isinstance(user, Student) or self.is_eligible(shift, user):
raise exceptions.PermissionDenied()
request = ShiftExchangeRequest(student=user, shift=shift)
request.save()
return Response(status=200)
def lectured_shifts(self, request):
user = get_user_from_request(request)
if not isinstance(user, Professor):
raise exceptions.PermissionDenied()
return Response(
LecturedShiftSerializer(
Shift.objects.filter(professor=user),
many=True,
).data)
def my_grades(self, request, pk=None):
subject = get_object_or_404(Subject, id=pk)
user = get_user_from_request(request)
if not isinstance(user, Student):
raise exceptions.PermissionDenied()
return Response(
GradeSerializer(
Grade.objects.filter(subject=subject, student=user),
many=True,
).data)
def my_requests(self, request):
user = get_user_from_request(request)
if not isinstance(user, Professor):
raise exceptions.PermissionDenied()
return Response(
ShiftExchangeRequestSerializer(
ShiftExchangeRequest.objects.filter(
shift__professor=user,
acceptance=None,
),
many=True,
).data)
def change_open_state(self, request, pk=None):
shift = get_object_or_404(Shift, id=pk)
user = get_user_from_request(request)
if not isinstance(user, Professor) and shift.professor != user:
raise exceptions.PermissionDenied()
is_open = request.query_params.get("is_open", None)
if is_open is not None:
shift.is_open = is_open == "true"
shift.student.clear()
shift.save()
return Response(status=200)
def my_subjects(self, request):
user = get_user_from_request(request)
if not isinstance(user, Student):
raise exceptions.PermissionDenied()
course = user.course.all().last()
course_subjects = CourseSubject.objects.filter(
subject__in=Subject.objects.filter(students=user),
course=course,
)
return Response(
self.serializer_class(
course_subjects,
many=True,
).data)
def my_curriculum(self, request):
user = get_user_from_request(request)
if not isinstance(user, Student):
raise exceptions.PermissionDenied()
course = user.course.last()
max_ects_per_semester = course.specification.department.faculty.max_ects_per_semester
course_subjects = CourseSubject.objects.filter(course=course)
subjects = []
first_semester_ects = 0
second_semester_ects = 0
for course_subject in course_subjects:
subject = dict()
is_enrolled = user in course_subject.subject.students.all()
if is_enrolled and course_subject.subject.semester == "1":
first_semester_ects += course_subject.subject.subject_spec.ects
elif is_enrolled and course_subject.subject.semester == "2":
second_semester_ects += course_subject.subject.subject_spec.ects
subject['course_subject'] = CourseSubjectSerializer(
course_subject).data
subject['subject'] = RestrictedSubjectSerializer(
course_subject.subject).data
subject['subject_spec'] = SubjectSpecificationSerializer(
course_subject.subject.subject_spec).data
subject['is_enrolled'] = is_enrolled
subjects.append(subject)
return Response(
dict(
max_ects_per_semester=max_ects_per_semester,
subjects=subjects,
first_semester_ects=first_semester_ects,
second_semester_ects=second_semester_ects,
current_semester="1" if course.f_semester_begin_date <=
date.today() <= course.f_semester_end_date else "2",
))
def sign_up(self, request, pk=None):
subject = get_object_or_404(Subject, id=pk)
user = get_user_from_request(request)
if not isinstance(user, Student):
raise exceptions.PermissionDenied()
course = user.course.last()
max_ects_per_semester = course.specification.department.faculty.max_ects_per_semester
current_semester = "1" if course.f_semester_begin_date <= date.today(
) <= course.f_semester_end_date else "2"
sign_up = request.query_params.get("sign_up", None)
if sign_up is None:
raise exceptions.PermissionDenied()
if current_semester == "2" and subject.semester == "1":
raise exceptions.PermissionDenied()
sign_up = sign_up == "true"
if sign_up and user in subject.students.all():
raise exceptions.PermissionDenied()
if sign_up:
current_semester_ects = self.check_current_ects(
user, course, current_semester)
if current_semester_ects + subject.subject_spec.ects <= max_ects_per_semester:
subject.students.add(user)
subject.save()
else:
raise exceptions.PermissionDenied()
else:
for shift in Shift.objects.filter(student=user):
shift.student.remove(user)
shift.save()
subject.students.remove(user)
subject.save()
return Response(status=200)
def grades(self, request, pk=None):
subject = get_object_or_404(Subject, id=pk)
user = get_user_from_request(request)
if not isinstance(user, Professor):
raise exceptions.PermissionDenied()
students = subject.students.all()
filters = dict()
for query_param in self.filter_queries:
query_value = request.query_params.get(query_param, None)
if query_value is not None:
filters[self.filter_queries[query_param]] = query_value
if filters:
students = students.filter(**filters)
return Response(
GradeSerializer(
Grade.objects.filter(subject=subject, student__in=students),
many=True,
).data)
def my_global_curriculum(self, request):
user = get_user_from_request(request)
if not isinstance(user, Student):
raise exceptions.PermissionDenied()
course_spec = user.course.last().specification
subjects = Subject.objects.filter(students=user)
subject_specs = list(set(map(lambda subj: subj.subject_spec,
subjects)))
curriculum = []
for subject_spec in subject_specs:
subject = {}
latest_subject = subjects.filter(
subject_spec=subject_spec).latest('lective_year')
course_subject = CourseSubject.objects.get(
subject=latest_subject, course__specification=course_spec)
subject['course_subject'] = CourseSubjectSerializer(
course_subject).data
subject['subject'] = RestrictedSubjectSerializer(
latest_subject).data
subject['subject_spec'] = SubjectSpecificationSerializer(
subject_spec).data
final_grade = FinalGrade.objects.filter(
student=user,
subject__subject_spec=subject_spec).order_by("-grade").first()
if final_grade is not None and final_grade.grade >= settings.PASSING_GRADE:
subject['grade'] = FinalGradeSerializer(final_grade).data
curriculum.append(subject)
return Response(curriculum)
def modify(self, request, pk=None):
xg_request = get_object_or_404(ShiftExchangeRequest, id=pk)
user = get_user_from_request(request)
if not isinstance(user,
Professor) or xg_request.shift.professor != user:
raise exceptions.PermissionDenied()
acceptance = request.query_params.get("acceptance", None)
if acceptance is not None:
acceptance = acceptance == "true"
xg_request.acceptance = acceptance
xg_request.save()
if acceptance:
enrolled_shifts = Shift.objects.filter(
subject=xg_request.shift.subject,
student=xg_request.student,
)
shift_ctype = LessonSpecification.objects.filter(
shift=xg_request.shift)[0].c_type
old_shift = None
for shift in enrolled_shifts:
_c_type = LessonSpecification.objects.filter(
shift=shift)[0].c_type
if _c_type == shift_ctype:
old_shift = shift
break
if old_shift is not None:
old_shift.student.remove(xg_request.student)
xg_request.shift.student.add(xg_request.student)
return Response(status=200)
def batch_grades(self, request, pk=None):
"""
Expects json data in the format of a list containing grades,
each grade is a dictionary with the following keys:
string: int -> 'student_number': number
string: string -> 'eecc': 'a'|'b'|'c'|'d'|'e'
string: float -> 'grade': 0.0 <= grade <= 20.0
"""
subject = get_object_or_404(Subject, id=pk)
user = get_user_from_request(request)
if not isinstance(user, Professor) or not Shift.objects.filter(
subject=subject, professor=user):
raise exceptions.PermissionDenied()
if request.content_type == "application/json" and request.data:
for grade in request.data['grades']:
student = Student.objects.get(number=grade['student_number'])
designation = grade['designation']
grade_score = grade['grade']
percentage = grade['percentage']
observations = grade['observations']
previous_grade = Grade.objects.filter(
subject=subject,
student=student,
designation=designation,
).first()
if previous_grade is not None:
previous_grade.grade = grade_score
previous_grade.percentage = percentage
previous_grade.observations = observations
previous_grade.save()
else:
new_grade = Grade(
subject=subject,
student=student,
designation=designation,
grade=grade_score,
percentage=percentage,
observations=observations,
)
new_grade.save()
if percentage == 100.0:
previous_final_grade = FinalGrade.objects.filter(
subject=subject, student=student).first()
if previous_final_grade is not None:
previous_final_grade.eecc = grade['eecc']
previous_final_grade.grade = grade_score
previous_final_grade.save()
else:
new_final_grade = FinalGrade(subject=subject,
student=student,
eecc=grade['eecc'],
grade=grade_score)
new_final_grade.save()
return Response(status=200)
def has_object_permission(self, request, view, obj):
return ProfessorPermission().has_object_permission(request, view, obj) or \
obj.student == get_user_from_request(request)
def has_permission(self, request, view):
if view.action in ["list", "shiftless_students", "batch_grades"]:
return IsAdminUser().has_permission(request, view) or \
isinstance(get_user_from_request(request), Professor)
return super().has_permission(request, view)
def has_permission(self, request, view):
if view.action in ["list", "create"]:
return IsAdminUser().has_permission(request, view) or \
isinstance(get_user_from_request(request), Professor)
return True
def my_attendances(self, request):
queryset = self.get_queryset().filter(
student=get_user_from_request(request))
return Response(AttendanceSerializer(queryset, many=True).data)
def has_object_permission(self, request, view, obj):
user = get_user_from_request(request)
return super().has_object_permission(request, view, obj) or \
obj.shift.professor == user
def has_object_permission(self, request, view, obj):
return obj == get_user_from_request(request) or request.user.is_superuser
