Request substitution confirmation pop-up

django/university/routes/MarketplaceExchangeView.py

@@ -122,9 +122,10 @@ def submit_marketplace_exchange_request(self, request):
         exchanges = request.POST.getlist('exchangeChoices[]')
         exchanges = list(map(lambda exchange : json.loads(exchange), exchanges))
 
-        # If user sent a message explaining why their request should be directly handled by the comission instead of having to be
+        # If user sent a message explaining why their request should be directly handled by the commission instead of having to be
         # accepted by students in the marketplace
-        urgentMessage = request.POST.get('urgentMessage')
+        urgent_message = request.POST.get('urgentMessage')
+        is_urgent = urgent_message is not None and urgent_message != ""
 
         curr_student = request.user.username
         sigarra_res = SigarraController().get_student_schedule(curr_student)
@@ -143,27 +144,26 @@ def submit_marketplace_exchange_request(self, request):
         if status == ExchangeStatus.STUDENTS_NOT_ENROLLED:
             return JsonResponse({"error": incorrect_class_error()}, status=400, safe=False)
 
-        if not urgentMessage or urgentMessage == "":
+        if not is_urgent:
             if ExchangeController.exchange_overlap(student_schedules, curr_student):
                 return JsonResponse({"error": "classes-overlap"}, status=400, safe=False)
 
+        replace = request.POST.get('replace', 'false') == 'true'
         exchange_hash = ExchangeHasher.hash(exchanges, username=curr_student)
 
-        if MarketplaceExchange.objects.filter(hash=exchange_hash, canceled=False).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)
+        if is_urgent:
+            return self.add_urgent_exchange(request, exchanges, urgent_message, exchange_hash, replace)
         else:
-            return self.add_normal_marketplace_exchange(request, exchanges, exchange_hash)
-
-
-    def add_urgent_exchange(self, request, exchanges, message: str, exchange_hash):
+            return self.add_normal_marketplace_exchange(request, exchanges, exchange_hash, replace)
 
+    def add_urgent_exchange(self, request, exchanges, message: str, exchange_hash, replace_existing=False):
         with transaction.atomic():
+            if replace_existing:
+                self.reject_old_urgent_requests(request.user, exchange_hash)
+            elif ExchangeUrgentRequests.objects.filter(hash=exchange_hash, admin_state="untreated").exists():
+                # Replace not set to true and an untreated exchange with the same hash already exists => return error
+                return JsonResponse({"error": "duplicate-request"}, status=400, safe=False)
+
             urgent_request = ExchangeUrgentRequests.objects.create(
                 issuer_name=request.user.first_name + " " + request.user.last_name,
                 issuer_nmec=request.user.username,
@@ -187,30 +187,57 @@ def add_urgent_exchange(self, request, exchanges, message: str, exchange_hash):
 
         return JsonResponse({"success": True}, safe=False)
 
-    def add_normal_marketplace_exchange(self, request, exchanges, exchange_hash):
-        self.insert_marketplace_exchange(exchanges, request.user, exchange_hash)
-
-        return JsonResponse({"success": True}, safe=False)
+    def reject_old_urgent_requests(self, user, exchange_hash):
+        with transaction.atomic():
+            old_requests = ExchangeUrgentRequests.objects.filter(
+                issuer_nmec=user.username,
+                hash=exchange_hash,
+                admin_state="untreated"
+            )
+            for old_request in old_requests:
+                old_request.admin_state = "rejected"
+                old_request.save()
 
-    def insert_marketplace_exchange(self, exchanges, user, exchange_hash):
+    def add_normal_marketplace_exchange(self, request, exchanges, exchange_hash, replace_existing=False):
+        user = request.user
         issuer_name = f"{user.first_name} {user.last_name.split(' ')[-1]}"
 
-        marketplace_exchange = MarketplaceExchange.objects.create(
-            issuer_name=issuer_name,
-            issuer_nmec=user.username,
-            accepted=False,
-            hash=exchange_hash,
-            canceled=False,
-            date=timezone.now()
-        )
-        for exchange in exchanges:
-            course_unit_id = int(exchange["courseUnitId"])
-            course_unit = CourseUnit.objects.get(pk=course_unit_id)
-            MarketplaceExchangeClass.objects.create(
-                marketplace_exchange=marketplace_exchange,
-                course_unit_acronym=course_unit.acronym,
-                course_unit_id=course_unit_id,
-                course_unit_name=course_unit.name,
-                class_issuer_goes_from=exchange["classNameRequesterGoesFrom"],
-                class_issuer_goes_to=exchange["classNameRequesterGoesTo"]
+        with transaction.atomic():
+            if replace_existing:
+                self.cancel_old_marketplace_exchanges(user, exchange_hash)
+            elif MarketplaceExchange.objects.filter(hash=exchange_hash, canceled=False).exists():
+                # Replace not set to true and a non-canceled exchange with the same hash already exists => return error
+                return JsonResponse({"error": "duplicate-request"}, status=400, safe=False)
+
+            marketplace_exchange = MarketplaceExchange.objects.create(
+                issuer_name=issuer_name,
+                issuer_nmec=user.username,
+                accepted=False,
+                hash=exchange_hash,
+                canceled=False,
+                date=timezone.now()
+            )
+            for exchange in exchanges:
+                course_unit_id = int(exchange["courseUnitId"])
+                course_unit = CourseUnit.objects.get(pk=course_unit_id)
+                MarketplaceExchangeClass.objects.create(
+                    marketplace_exchange=marketplace_exchange,
+                    course_unit_acronym=course_unit.acronym,
+                    course_unit_id=course_unit_id,
+                    course_unit_name=course_unit.name,
+                    class_issuer_goes_from=exchange["classNameRequesterGoesFrom"],
+                    class_issuer_goes_to=exchange["classNameRequesterGoesTo"]
+                )
+
+        return JsonResponse({"success": True}, safe=False)
+
+    def cancel_old_marketplace_exchanges(self, user, exchange_hash):
+        with transaction.atomic():
+            old_exchanges = MarketplaceExchange.objects.filter(
+                issuer_nmec=user.username,
+                hash=exchange_hash,
+                canceled=False
             )
+            for old_exchange in old_exchanges:
+                old_exchange.canceled = True
+                old_exchange.save()

django/university/routes/exchange/DirectExchangeView.py

@@ -124,11 +124,20 @@ def post(self, request):
 
         # Restricts repeated exchange requests
         exchange_hash = ExchangeHasher.hash(exchanges, username)
-
-        if DirectExchange.objects.filter(hash=exchange_hash, canceled=False).exists():
-            return JsonResponse({"error": "duplicate-request"}, status=400, safe=False)
+        # Allow exchange overwrite with replace=true
+        replace = request.POST.get('replace', 'false') == 'true'
 
         with transaction.atomic():
+            if replace:
+                # Cancel previous exchanges with same hash
+                previous_exchanges = DirectExchange.objects.filter(hash=exchange_hash, canceled=False)
+                for previous_exchange in previous_exchanges:
+                    ExchangeValidationController().cancel_exchange(previous_exchange)
+
+            elif DirectExchange.objects.filter(hash=exchange_hash, canceled=False).exists():
+                # Replace not set to true and a non-canceled exchange with the same hash already exists => return error
+                return JsonResponse({"error": "duplicate-request"}, status=400, safe=False)
+
             exchange_model = DirectExchange(
                 accepted=False,
                 issuer_name=f"{request.user.first_name} {request.user.last_name}",