UUID pk

api/controllers/account/get_account.py

@@ -8,7 +8,7 @@
 from django.forms.models import model_to_dict
 from ...serializers import *
 
-def get_account(account_id:int):
+def get_account(account_id:str):
     try:
         account = Account.objects.get(account_id=account_id)
         serialize = AccountSerializer(account)

api/controllers/collection/create_collection.py

@@ -8,7 +8,7 @@
 from django.forms.models import model_to_dict
 from ...serializers import *
 
-def create_collection(account_id:int,request):
+def create_collection(account_id:str,request):
 
     request.data['creator'] = account_id
     serialize = CollectionSerializer(data=request.data)

api/controllers/collection/get_all_collections_by_account.py

@@ -8,19 +8,27 @@
 from django.forms.models import model_to_dict
 from ...serializers import *
 
-def get_all_collections_by_account(account_id:int):
-    collections = Collection.objects.filter(creator=account_id).order_by('-updated_date')
+def populated_problems(collections: Collection):
     problemCollections = CollectionProblem.objects.filter(collection__in=collections)
 
     populated_collections = []
     for collection in collections:
-        con_probs = problemCollections.filter(collection=collection)
-        serialize = CollectionSerializer(collection)
-        collection_data = serialize.data
-        collection_data['problems'] = CollectionProblemPopulateProblemSecureSerializer(con_probs,many=True).data
+        collection.problems = problemCollections.filter(collection=collection)
+        populated_collections.append(collection)
 
-        populated_collections.append(collection_data)
+    return populated_collections
+
+def get_all_collections_by_account(account:Account):
+
+    collections = Collection.objects.filter(creator=account).order_by('-updated_date')
+    collections = populated_problems(collections)
+    serialize = CollectionPopulateCollectionProblemsPopulateProblemSerializer(collections,many=True)
+
+    manageableCollections = Collection.objects.filter(collectiongrouppermission__permission_manage_collections=True,collectiongrouppermission__group__in=GroupMember.objects.filter(account=account).values_list("group",flat=True)).order_by('-updated_date')
+    manageableCollections = populated_problems(manageableCollections)
+    manageableSerialize = CollectionPopulateCollectionProblemsPopulateProblemSerializer(manageableCollections,many=True)
 
     return Response({
-        'collections': populated_collections
+        'collections': serialize.data,
+        'manageable_collections': manageableSerialize.data
     },status=status.HTTP_200_OK)

api/controllers/collection/get_collection.py

@@ -8,21 +8,16 @@
 from django.forms.models import model_to_dict
 from ...serializers import *
 
-def get_collection(collection_id:int):
+def get_collection(collection:Collection):
 
-    collection = Collection.objects.get(collection_id=collection_id)
-    # problems = Problem.objects.filter(collectionproblem__collection_id=collection_id)
-    collectionProblems = CollectionProblem.objects.filter(collection=collection).order_by('order')
+    collection.problems = CollectionProblem.objects.filter(collection=collection).order_by('order')
+    collection.group_permissions = CollectionGroupPermission.objects.filter(collection=collection)
+
+    for cp in collection.problems:
+        cp.problem.testcases = Testcase.objects.filter(problem=cp.problem,deprecated=False)
+        cp.problem.group_permissions = ProblemGroupPermission.objects.filter(problem=cp.problem)
+
+    serializer = CollectionPopulateCollectionProblemsPopulateProblemPopulateAccountAndTestcasesAndProblemGroupPermissionsPopulateGroupAndCollectionGroupPermissionsPopulateGroupSerializer(collection)
 
-    collection_ser = CollectionSerializer(collection)
-    collectionProblems_ser = CollectionProblemPopulateProblemSecureSerializer(collectionProblems,many=True)
-    # populated_problems = []
-    # for col_prob in collectionProblems:
-    #     col_prob_serialize = CollectionProblemPopulateProblemSecureSerializer(col_prob)
-    #     # prob_serialize = ProblemSerializer(col_prob.problem)
-    #     populated_problems.append(col_prob_serialize.data)
 
-    return Response({
-        **collection_ser.data,
-        'problems': collectionProblems_ser.data
-    } ,status=status.HTTP_200_OK)
+    return Response(serializer.data ,status=status.HTTP_200_OK)

api/controllers/collection/update_collection.py

@@ -8,8 +8,7 @@
 from django.forms.models import model_to_dict
 from ...serializers import *
 
-def update_collection(collection_id:int,request):
-    collection = Collection.objects.get(collection_id=collection_id)
+def update_collection(collection:Collection,request):
 
     collection.name = request.data.get('name',collection.name)
     collection.description = request.data.get('description',collection.description)

api/controllers/collection/update_group_permissions_collection.py

@@ -0,0 +1,32 @@
+from api.utility import passwordEncryption
+from rest_framework.response import Response
+from rest_framework.decorators import api_view
+from api.sandbox.grader import PythonGrader
+from ...constant import GET,POST,PUT,DELETE
+from ...models import *
+from rest_framework import status
+from django.forms.models import model_to_dict
+from ...serializers import *
+
+def update_group_permissions_collection(collection:Collection,request):
+
+    CollectionGroupPermission.objects.filter(collection=collection).delete()
+
+    print(request.data['groups'])
+
+    collection_group_permissions = []
+    for collection_request in request.data['groups']:
+        group = Group.objects.get(group_id=collection_request['group_id'])
+        collection_group_permissions.append(
+            CollectionGroupPermission(
+                collection=collection,
+                group=group,
+                **collection_request
+        ))
+
+    CollectionGroupPermission.objects.bulk_create(collection_group_permissions)
+
+    collection.group_permissions = collection_group_permissions
+    serialize = CollectionPopulateCollectionGroupPermissionsPopulateGroupSerializer(collection)
+
+    return Response(serialize.data,status=status.HTTP_202_ACCEPTED)

api/controllers/group/create_group.py

@@ -9,6 +9,8 @@
 from ...serializers import *
 
 def create_group(account:Account,request):
+
+    # print(request.headers["Authorization"])
 
     serialize = GroupSerializer(data={
         'creator':account.account_id,

api/controllers/group/get_all_groups_by_account.py

@@ -10,6 +10,11 @@
 
 def get_all_groups_by_account(account:Account,request):
 
+    print("GET ALL")
+
+    # Get request headers
+    headers = request.headers
+
     groups = Group.objects.filter(creator=account).order_by('-updated_date')
 
     populate_members = request.GET.get('populate_members',False)

api/controllers/problem/create_problem.py

@@ -8,7 +8,7 @@
 from django.forms.models import model_to_dict
 from ...serializers import *
 
-def create_problem(account_id:int,request):
+def create_problem(account_id:str,request):
     account = Account.objects.get(account_id=account_id)
 
     running_result = PythonGrader(request.data['solution'],request.data['testcases'],1,1.5).generate_output()
@@ -22,7 +22,8 @@ def create_problem(account_id:int,request):
         title = request.data['title'],
         description = request.data['description'],
         solution = request.data['solution'],
-        time_limit = request.data['time_limit']
+        time_limit = request.data['time_limit'],
+        allowed_languages = request.data['allowed_languages'],
     )
     problem.save()
 

api/controllers/problem/delete_problem.py

@@ -8,11 +8,11 @@
 from django.forms.models import model_to_dict
 from ...serializers import *
 
-def delete_problem(problem_id:int):
-    try:
-        problem = Problem.objects.get(problem_id=problem_id)
-    except Problem.DoesNotExist:
-        return Response({'detail': "Problem doesn't exist!"},status=status.HTTP_404_NOT_FOUND)
+def delete_problem(problem:Problem):
+    # try:
+    #     problem = Problem.objects.get(problem_id=problem_id)
+    # except Problem.DoesNotExist:
+    #     return Response({'detail': "Problem doesn't exist!"},status=status.HTTP_404_NOT_FOUND)
     testcases = Testcase.objects.filter(problem_id=problem_id)
 
     problem.delete()

api/controllers/problem/get_all_problem_with_best_submission.py

@@ -8,7 +8,7 @@
 from django.forms.models import model_to_dict
 from ...serializers import *
 
-def get_all_problem_with_best_submission(account_id:int):
+def get_all_problem_with_best_submission(account_id:str):
 
     problems = Problem.objects.all().order_by('-updated_date')
 

api/controllers/problem/get_all_problems.py

@@ -13,13 +13,13 @@ def get_all_problems(request):
 
     get_private = int(request.query_params.get("private",0))
     get_deactive = int(request.query_params.get("deactive",0))
-    account_id = int(request.query_params.get("account_id",0))
+    account_id = str(request.query_params.get("account_id",""))
 
     if not get_private:
         problem = problem.filter(is_private=False)
     if not get_deactive:
         problem = problem.filter(is_active=True)
-    if account_id != 0:
+    if account_id != "":
         problem = problem.filter(creator_id=account_id)
 
     problem = problem.order_by('-problem_id')

api/controllers/problem/get_all_problems_by_account.py

@@ -8,11 +8,17 @@
 from django.forms.models import model_to_dict
 from ...serializers import *
 
-def get_all_problems_by_account(account_id:int):
-    problems = Problem.objects.filter(creator=account_id).order_by('-updated_date')
+def get_all_problems_by_account(account:Account):
+    personalProblems = Problem.objects.filter(creator=account).order_by('-updated_date')
+    for problem in personalProblems:
+        problem.testcases = Testcase.objects.filter(problem=problem,deprecated=False)
 
-    for problem in problems:
+    manageableProblems = Problem.objects.filter(problemgrouppermission__permission_manage_problems=True,problemgrouppermission__group__in=GroupMember.objects.filter(account=account).values_list("group",flat=True)).order_by('-updated_date')
+    for problem in manageableProblems:
         problem.testcases = Testcase.objects.filter(problem=problem,deprecated=False)
 
-    problem_ser = ProblemPopulateTestcaseSerializer(problems,many=True)
-    return Response({"problems":problem_ser.data},status=status.HTTP_200_OK)
+    # problem_ser = ProblemPopulateTestcaseSerializer(problems,many=True)
+    personalSerialize = ProblemPopulateTestcaseSerializer(personalProblems,many=True)
+    manageableSerialize = ProblemPopulateTestcaseSerializer(manageableProblems,many=True)
+
+    return Response({"problems":personalSerialize.data,"manageable_problems":manageableSerialize.data},status=status.HTTP_200_OK)

api/controllers/problem/get_problem.py

@@ -8,13 +8,20 @@
 from django.forms.models import model_to_dict
 from ...serializers import *
 
-def get_problem(problem_id:int):
-    try:
-        problem = Problem.objects.get(problem_id=problem_id)
-    except Problem.DoesNotExist:
-        return Response({'detail': "Problem doesn't exist!"},status=status.HTTP_404_NOT_FOUND)
-    testcases = Testcase.objects.filter(problem_id=problem_id,deprecated=False)
-    problem_serialize = ProblemPopulateAccountSerializer(problem)
-    testcases_serialize = TestcaseSerializer(testcases,many=True)
-    return Response({**problem_serialize.data,'testcases': testcases_serialize.data},status=status.HTTP_200_OK)
+def get_problem(problem:Problem):
+    # try:
+    #     problem = Problem.objects.get(problem_id=problem_id)
+    # except Problem.DoesNotExist:
+    #     return Response({'detail': "Problem doesn't exist!"},status=status.HTTP_404_NOT_FOUND)
+    # testcases = Testcase.objects.filter(problem_id=problem_id,deprecated=False)
+    # problem_serialize = ProblemPopulateAccountSerializer(problem)
+    # testcases_serialize = TestcaseSerializer(testcases,many=True)
+
+    problem.testcases = Testcase.objects.filter(problem=problem,deprecated=False)
+    problem.group_permissions = ProblemGroupPermission.objects.filter(problem=problem)
+
+    serialize = ProblemPopulateAccountAndTestcasesAndProblemGroupPermissionsPopulateGroupSerializer(problem)
+
+
+    return Response(serialize.data,status=status.HTTP_200_OK)
 

api/controllers/problem/get_problem_in_topic_with_best_submission.py

@@ -8,7 +8,7 @@
 from django.forms.models import model_to_dict
 from ...serializers import *
 
-def get_problem_in_topic_with_best_submission(account_id:int,topic_id:int,problem:int):
+def get_problem_in_topic_with_best_submission(account_id:str,topic_id:str,problem:int):
 
     account = Account.objects.get(account_id=account_id)
     problem = Problem.objects.get(problem_id=problem)

api/controllers/problem/get_problem_public.py

@@ -0,0 +1,14 @@
+from api.utility import passwordEncryption
+from rest_framework.response import Response
+from rest_framework.decorators import api_view
+from api.sandbox.grader import PythonGrader
+from ...constant import GET,POST,PUT,DELETE
+from ...models import *
+from rest_framework import status
+from django.forms.models import model_to_dict
+from ...serializers import *
+
+def get_problem_public(problem:Problem):
+    serialize = ProblemPopulateAccountSecureSerializer(problem)
+    return Response(serialize.data,status=status.HTTP_200_OK)
+

api/controllers/problem/update_group_permission_to_problem.py

@@ -0,0 +1,30 @@
+from api.utility import passwordEncryption
+from rest_framework.response import Response
+from rest_framework.decorators import api_view
+from api.sandbox.grader import PythonGrader
+from ...constant import GET,POST,PUT,DELETE
+from ...models import *
+from rest_framework import status
+from django.forms.models import model_to_dict
+from ...serializers import *
+
+def update_group_permission_to_problem(problem:Problem,request):
+    ProblemGroupPermission.objects.filter(problem=problem).delete()
+
+    problem_group_permissions = []
+    for group_request in request.data['groups']:
+        group = Group.objects.get(group_id=group_request['group_id'])
+        problem_group_permissions.append(
+            ProblemGroupPermission(
+                problem=problem,
+                group=group,
+                **group_request
+        ))
+
+    ProblemGroupPermission.objects.bulk_create(problem_group_permissions)
+
+    problem.group_permissions = problem_group_permissions
+    problem.testcases = Testcase.objects.filter(problem=problem)
+
+    serialize = ProblemPopulateAccountAndTestcasesAndProblemGroupPermissionsPopulateGroupSerializer(problem)
+    return Response(serialize.data,status=status.HTTP_202_ACCEPTED)

api/controllers/problem/update_problem.py

@@ -9,19 +9,20 @@
 from ...serializers import *
 from django.utils import timezone
 
-def update_problem(problem_id:int,request):
-    try:
-        problem = Problem.objects.get(problem_id=problem_id)
-    except Problem.DoesNotExist:
-        return Response({'detail': "Problem doesn't exist!"},status=status.HTTP_404_NOT_FOUND)
-    testcases = Testcase.objects.filter(problem_id=problem_id,deprecated=False)
+def update_problem(problem:Problem,request):
+    # try:
+    #     problem = Problem.objects.get(problem_id=problem_id)
+    # except Problem.DoesNotExist:
+    #     return Response({'detail': "Problem doesn't exist!"},status=status.HTTP_404_NOT_FOUND)
+    testcases = Testcase.objects.filter(problem=problem,deprecated=False)
 
     problem.title = request.data.get("title",problem.title)
     problem.language = request.data.get("language",problem.language)
     problem.description = request.data.get("description",problem.description)
     problem.solution = request.data.get("solution",problem.solution)
     problem.time_limit = request.data.get("time_limit",problem.time_limit)  
     problem.is_private = request.data.get("is_private",problem.is_private)
+    problem.allowed_languages = request.data.get("allowed_languages",problem.allowed_languages)
 
     problem.updated_date = timezone.now()
 
@@ -30,29 +31,27 @@ def update_problem(problem_id:int,request):
 
         # if not running_result.runnable:
         #     return Response({'detail': 'Error during editing. Your code may has an error/timeout!'},status=status.HTTP_406_NOT_ACCEPTABLE)
-
         for testcase in testcases:
             testcase.deprecated = True
             testcase.save()
-
         testcase_result = []
         for unit in running_result.data:
-            testcase = Testcase(
+            testcase2 = Testcase(
                 problem = problem,
                 input = unit.input,
                 output = unit.output,
                 runtime_status = unit.runtime_status
             )
-            testcase.save()
-            testcase_result.append(testcase)
+            testcase2.save()
+            testcase_result.append(testcase2)
         problem.save()
-
         problem_serialize = ProblemSerializer(problem)
         testcases_serialize = TestcaseSerializer(testcase_result,many=True)
 
         return Response({**problem_serialize.data,'testcases': testcases_serialize.data},status=status.HTTP_201_CREATED)
 
-    elif 'solution' in request.data:
+    if 'solution' in request.data:
+        testcases = Testcase.objects.filter(problem=problem,deprecated=False)
         program_input = [i.input for i in testcases]
         running_result = PythonGrader(problem.solution,program_input,1,1.5).generate_output()