Main

django/tts_be/asgi.py

@@ -10,11 +10,9 @@
 import os
 from django.core.asgi import get_asgi_application
 
-import socketio
-from university.socket.views import sessions_server
+# import socketio
+# from university.socket.views import sessions_server
 
 os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'tts_be.settings')
 
-django_app = get_asgi_application()
-
-application = socketio.ASGIApp(sessions_server.sio, django_app)
+application = get_asgi_application()

django/tts_be/settings.py

@@ -74,7 +74,7 @@
 INSTALLED_APPS = [ 
     'corsheaders',
     'anymail',
-    'daphne',
+    # 'daphne',
     'django.contrib.admin',
     'django.contrib.auth',
     'django.contrib.contenttypes',
@@ -84,7 +84,7 @@
     'django.contrib.staticfiles',
     'mozilla_django_oidc',
     'university',
-    'channels',
+    # 'channels',
 ]
 
 EMAIL_HOST = os.getenv("EMAIL_HOST", "tts-mailpit")
@@ -169,8 +169,6 @@
 
 OIDC_RENEW_ID_TOKEN_EXPIRY_SECONDS = 3600 * 60
 
-ASGI_APPLICATION = 'tts_be.asgi.application'
-
 # Database
 # https://docs.djangoproject.com/en/4.0/ref/settings/#databases
 

django/university/controllers/CourseUnitController.py

@@ -1,14 +1,22 @@
 from university.models import CourseMetadata
 
 class CourseUnitController:
+    available_courses = [22862, 22841]
+
     @staticmethod
     def course_unit_curricular_year(course_unit_id):
-        course_metadata = CourseMetadata.objects.filter(course_unit_id=course_unit_id).get()
+        course_metadata = CourseMetadata.objects.filter(
+            course_unit_id=course_unit_id,
+            course_id__in=CourseUnitController.available_courses
+        ).first()
+
 
         return course_metadata.course_unit_year
 
     @staticmethod
     def course_unit_major(course_unit_id):
-        course_metadata = CourseMetadata.objects.filter(course_unit_id=course_unit_id).get()
+        course_metadata = CourseMetadata.objects.filter(
+            course_id__in=CourseUnitController.available_courses,
+            course_unit_id=course_unit_id).first()
 
         return course_metadata.course.id

django/university/controllers/ExchangeController.py

@@ -9,7 +9,7 @@
 from django.utils import timezone
 from enum import Enum
 
-from university.models import UserCourseUnits
+from university.models import UserCourseUnits, Class
 
 from university.serializers.DirectExchangeParticipantsSerializer import DirectExchangeParticipantsSerializer
 from university.serializers.MarketplaceExchangeClassSerializer import MarketplaceExchangeClassSerializer
@@ -51,7 +51,7 @@ class ExchangeController:
     @staticmethod
     def eligible_course_units(nmec):
         course_units = UserCourseUnits.objects.filter(user_nmec=nmec).values_list("course_unit_id", flat=True)
-
+        
         exchange_expirations = ExchangeExpirations.objects.filter(
             course_unit_id__in=course_units, 
             active_date__lte=timezone.now(),
@@ -140,7 +140,7 @@ def create_direct_exchange_participants(student_schedules, exchanges, inserted_e
         return (ExchangeStatus.SUCCESS, None)
 
     """
-        Checks if schedule for a user with a given username has overlpas
+        Checks if schedule for a user with a given username has overlaps
     """
     @staticmethod
     def exchange_overlap(student_schedules, username) -> bool:
@@ -153,9 +153,28 @@ def exchange_overlap(student_schedules, username) -> bool:
                 (class_schedule_day, class_schedule_start, class_schedule_end, class_schedule_type) = (class_schedule["dia"], class_schedule["hora_inicio"] / 3600, class_schedule["aula_duracao"] + class_schedule["hora_inicio"] / 3600, class_schedule['tipo'])
                 (overlap_param_day, overlap_param_start, overlap_param_end, overlap_param_type) = (other_class_schedule["dia"], other_class_schedule["hora_inicio"] / 3600, other_class_schedule["aula_duracao"] + other_class_schedule["hora_inicio"] / 3600, other_class_schedule['tipo'])
 
+                class_changed = False
+                other_class_changed = False
+
+                # Obtain ids of classes before change in the new schedule
+                original_class = UserCourseUnits.objects.filter(user_nmec=username, course_unit__id=int(class_schedule["ocorrencia_id"])).first()
+                if original_class is not None:
+                    original_class = original_class.class_field.id
+                    new_class_id = Class.objects.filter(name=class_schedule["turma_sigla"].split("+")[0], course_unit_id=int(class_schedule["ocorrencia_id"])).first().id
+                    class_changed = new_class_id != original_class    
+
+                original_other_class = UserCourseUnits.objects.filter(user_nmec=username, course_unit__id=int(other_class_schedule["ocorrencia_id"])).first()
+                if original_other_class is not None:   
+                    original_other_class = original_other_class.class_field.id
+                    # Need to check if the classes are the same as the previous ]ones or not 
+                    new_other_class_id = Class.objects.filter(name=other_class_schedule["turma_sigla"].split("+")[0], course_unit_id=int(other_class_schedule["ocorrencia_id"])).first().id
+
+                    other_class_changed = new_other_class_id != original_other_class
+
                 if (check_class_mandatory(class_schedule_type) and check_class_mandatory(overlap_param_type)
                     and check_class_schedule_overlap(class_schedule_day, class_schedule_start, class_schedule_end, overlap_param_day, overlap_param_start, overlap_param_end)):
-                    return True
+                    if class_changed or other_class_changed:
+                        return True
 
         return False
 

django/university/controllers/ExchangeValidationController.py

@@ -25,6 +25,9 @@ class ExchangeValidationController:
         All of the exchanges that include classes that were changed by the accepted exchange need to be revalidated or even canceled.
     """
     def cancel_conflicting_exchanges(self, accepted_exchange_id: int):
+        if(DirectExchange.objects.filter(id=accepted_exchange_id).first().canceled):
+            return 
+
         conflicting_exchanges = []
 
         with transaction.atomic():
@@ -33,7 +36,8 @@ def cancel_conflicting_exchanges(self, accepted_exchange_id: int):
                 # 1. Are there any exchanges that include classes that a participant changed from?
                 conflicting = DirectExchangeParticipants.objects.exclude(direct_exchange__id=accepted_exchange_id).filter(
                     participant_nmec=participant.participant_nmec, 
-                    class_participant_goes_from=participant.class_participant_goes_from
+                    class_participant_goes_from=participant.class_participant_goes_from,
+                    direct_exchange__accepted=True
                 )
                 conflicting_exchanges.extend(list(map(lambda conflicting_exchange: conflicting_exchange.direct_exchange, conflicting)))
 
@@ -72,17 +76,17 @@ def validate_direct_exchange(self, exchange_id: int) -> ExchangeValidationRespon
         schedule = {}
         for participant in exchange_participants:
             if participant.participant_nmec not in schedule.keys():
-                schedule[participant.participant_nmec] = build_student_schedule_dict(SigarraController().get_student_schedule(int(participant.participant_nmec)).data)
-
-            # Get new schedule from accepted changes
-            ExchangeController.update_schedule_accepted_exchanges(participant.participant_nmec, list(schedule[participant.participant_nmec].values()))
+                new_schedule = SigarraController().get_student_schedule(int(participant.participant_nmec)).data
+                ExchangeController.update_schedule_accepted_exchanges(participant.participant_nmec, new_schedule)
+                schedule[participant.participant_nmec] = build_student_schedule_dict(new_schedule)
 
         # 2. Check if users are inside classes they will exchange from with
         for username in schedule.keys():
             participant_entries = list(exchange_participants.filter(participant_nmec=username))
 
             for entry in participant_entries:
                 if (entry.class_participant_goes_from, int(entry.course_unit_id)) not in list(schedule[username].keys()):
+
                     return ExchangeValidationResponse(False, ExchangeStatus.STUDENTS_NOT_ENROLLED)
 
                 # 3. Alter the schedule of the users according to the exchange metadata 

django/university/controllers/StudentController.py

@@ -31,11 +31,12 @@ def populate_user_course_unit_data(nmec: int, erase_previous: bool = False):
 
         for item in course_units:
             (course_unit_id, class_acronym) = item
-            corresponding_class = Class.objects.filter(course_unit__id=course_unit_id, name=class_acronym).first()
+
+            corresponding_class = Class.objects.filter(course_unit__id=course_unit_id, name=class_acronym.split("+")[0]).first()
 
             if not corresponding_class:
                 continue
-
+            
             user_course_unit = UserCourseUnits(
                 user_nmec=nmec,
                 course_unit_id=course_unit_id, 

django/university/controllers/StudentScheduleController.py

@@ -14,9 +14,15 @@ def retrieveCourseUnitClasses(sigarra_controller, username):
 
         ExchangeController.update_schedule_accepted_exchanges(username, schedule_data)
 
+        ids = set()
         course_unit_classes = set()
         for scheduleItem in schedule_data:
-            course_unit_classes.add((scheduleItem["ocorrencia_id"], scheduleItem["turma_sigla"]))
+            if scheduleItem["tipo"] != "T" and scheduleItem["tipo"] != 'O':
+                if int(scheduleItem["ocorrencia_id"]) in ids:
+                    continue
+                else:
+                    course_unit_classes.add((scheduleItem["ocorrencia_id"], scheduleItem["turma_sigla"]))
+                    ids.add(int(scheduleItem["ocorrencia_id"]))
 
         return course_unit_classes
 

django/university/exchange/utils.py

@@ -108,7 +108,7 @@ def build_student_schedule_dicts(student_schedules, exchanges):
 
 def build_student_schedule_dict(schedule: list):
     return {
-        (class_schedule["turma_sigla"], class_schedule["ocorrencia_id"]): class_schedule for class_schedule in schedule if (class_schedule["tipo"] == "TP" or class_schedule["tipo"] == "PL")
+        (class_schedule["turma_sigla"].split("+")[0], class_schedule["ocorrencia_id"]): class_schedule for class_schedule in schedule if (class_schedule["tipo"] == "TP" or class_schedule["tipo"] == "PL")
     }
 
 def check_class_schedule_overlap(day_1: int, start_1: int, end_1: int, day_2: int, start_2: int, end_2: int) -> bool:

django/university/routes/MarketplaceExchangeView.py

@@ -79,8 +79,9 @@ def remove_invalid_dest_class_exchanges(self, marketplace_exchanges, nmec):
             for option in exchange.options:
                 course_unit_id = option.course_unit_id
                 class_issuer_goes_to = option.class_issuer_goes_to
-                if Class.objects.filter(course_unit_id=course_unit_id, name=class_issuer_goes_to).get().id == user_ucs_map[int(course_unit_id)].class_field.id:
-                    add_to_result = True
+                if int(course_unit_id) in user_ucs_map.keys():
+                    if Class.objects.filter(course_unit_id=course_unit_id, name=class_issuer_goes_to).get().id == user_ucs_map[int(course_unit_id)].class_field.id:
+                        add_to_result = True
 
             if add_to_result:
                 exchanges_with_valid_dest_class.append(exchange)
@@ -133,22 +134,23 @@ def submit_marketplace_exchange_request(self, request):
         student_schedule = list(student_schedules[curr_student].values())
         ExchangeController.update_schedule_accepted_exchanges(curr_student, student_schedule)
         student_schedules[curr_student] = build_student_schedule_dict(student_schedule)
-
+        
         (status, new_marketplace_schedule) = build_marketplace_submission_schedule(student_schedules, exchanges, curr_student)
         if status == ExchangeStatus.STUDENTS_NOT_ENROLLED:
             return JsonResponse({"error": incorrect_class_error()}, status=400, safe=False)
 
-        if exchange_overlap(student_schedules, curr_student):
-            return JsonResponse({"error": "classes-overlap"}, status=400, safe=False)
+        if not urgentMessage or urgentMessage == "":
+            if ExchangeController.exchange_overlap(student_schedules, curr_student):
+                return JsonResponse({"error": "classes-overlap"}, status=400, safe=False)
 
         exchange_data_str = json.dumps(exchanges, sort_keys=True)
         exchange_hash = hashlib.sha256(exchange_data_str.encode('utf-8')).hexdigest()
 
-        if MarketplaceExchange.objects.filter(hash=exchange_hash).exists():
-            return JsonResponse({"error": "duplicate-request"}, status=400, safe=False)
+        # if MarketplaceExchange.objects.filter(hash=exchange_hash).exists():
+        #     return JsonResponse({"error": "duplicate-request"}, status=400, safe=False)
 
-        if ExchangeUrgentRequests.objects.filter(hash=exchange_hash).exists():
-            return JsonResponse({"error": "duplicate-request"}, status=400, safe=False)
+        # if ExchangeUrgentRequests.objects.filter(hash=exchange_hash).exists():
+        #     return JsonResponse({"error": "duplicate-request"}, status=400, safe=False)
 
         if urgentMessage:
             return self.add_urgent_exchange(request, exchanges, urgentMessage, exchange_hash)

django/university/routes/course_unit/CourseUnitEnrollmentView.py

@@ -46,7 +46,7 @@ def filter_active_state(self, exchanges, state):
         states = state.split(",")
         return list(
             filter(
-                lambda exchange: exchange.get("admin_state") in states,
+                lambda exchange: exchange.admin_state in states,
                 exchanges
             )
         )
@@ -56,16 +56,18 @@ def get(self, request):
         if not(is_admin):
             return HttpResponse(status=403) 
 
-        enrollments = list(map(lambda enrollment: CourseUnitEnrollmentsSerializer(enrollment).data, CourseUnitEnrollments.objects.all().order_by('date')))
-
-        paginator = Paginator(enrollments, 48)
-        page_number = request.GET.get("page")
-        enrollments = [x for x in paginator.get_page(page_number if page_number != None else 1)]
+        enrollments = CourseUnitEnrollments.objects.all().order_by('date')
 
         for filter in AdminRequestFiltersController.filter_values():
             if request.GET.get(filter):
                 enrollments = self.filter_actions[filter](enrollments, request.GET.get(filter))
 
+        paginator = Paginator(enrollments, 10)
+        page_number = request.GET.get("page")
+        enrollments = [x for x in paginator.get_page(page_number if page_number != None else 1)]
+
+        enrollments = CourseUnitEnrollmentsSerializer(enrollments, many=True).data
+
         return JsonResponse({
             "enrollments": enrollments,
             "total_pages": paginator.num_pages
@@ -74,22 +76,27 @@ def get(self, request):
     def post(self, request):
         enrollments = request.POST.getlist("enrollCourses[]")
 
+        if(len(enrollments) == 0):
+            return JsonResponse({"error": "Pedido vazio"}, status=400)
+
         student_course_units = list(UserCourseUnits.objects.filter(user_nmec=request.user.username).all())
 
         with transaction.atomic():
-            course_unit_enrollment = CourseUnitEnrollments.objects.create(
+            course_unit_enrollment = CourseUnitEnrollments(
                 user_nmec=request.user.username,
                 accepted=False,
                 admin_state="untreated",
                 date=timezone.now()
             )
-            course_unit_enrollment.save()
 
             models_to_save = []
             for enrollment in enrollments:
                 enrollment_metadata = json.loads(enrollment) 
 
-                if enrollment_metadata["enrolling"] and len(list(filter(lambda x: x.course_unit_id == enrollment_metadata["course_unit_id"], student_course_units))) > 0:
+                if len(list(CourseUnitEnrollmentOptions.objects.filter(course_unit__id=int(enrollment_metadata["course_unit_id"]), course_unit_enrollment__user_nmec=request.user.username, enrolling=enrollment_metadata["enrolling"]))) > 0:
+                    return JsonResponse({"error": "Não podes fazer pedidos com disciplinas em que já pediste noutros!"}, status=400)
+
+                if enrollment_metadata["enrolling"] and len(list(filter(lambda x: int(x.course_unit_id) == int(enrollment_metadata["course_unit_id"]), student_course_units))) > 0:
                     return JsonResponse({"error": "Não te podes inscrever a disciplinas em que já tens uma inscrição!"}, status=400)
 
                 db_enrollment = CourseUnitEnrollmentOptions(
@@ -100,6 +107,8 @@ def post(self, request):
                 )
                 models_to_save.append(db_enrollment)
 
+
+            course_unit_enrollment.save()
             CourseUnitEnrollmentOptions.objects.bulk_create(models_to_save)
 
         return HttpResponse(status=200)