Progression 60

.gitignore

@@ -1,13 +1,15 @@
 .dist/
 __pycache__
 
-api/sandbox/testcases/*.txt
+api/sandbox/section*/testcases/*.txt
+api/sandbox/section*/runner*
 runner.py
+@/*
 
 env/
 .env
 
-[0-9]*.txt
+# [0-9]*.txt
 
 media/testfile
 media/topic
@@ -20,5 +22,4 @@ media/resource
 tempCodeRunnerFile.py
 
 *.sqlite3
-*.exe
-
+*.exe

Backend/settings.py

@@ -40,10 +40,14 @@
 
 CORS_ALLOWED_ORIGINS = [
     "http://localhost:3000",
+    "http://localhost:4000",
+    "http://localhost:5173",
+    "http://localhost:5174",
     "http://localhost:3001",
     "http://192.168.216.250:3000",
     "http://192.168.0.2:3000",
     "http://192.168.0.5:3000",
+    "http://192.168.0.11:5173",
     FRONEND_URL
 ]
 

api/admin.py

@@ -16,8 +16,8 @@ class ProblemAdmin(admin.ModelAdmin):
     list_filter = ['language']
 
 class AccountAdmin(admin.ModelAdmin):
-    list_display = ['account_id','username','email','is_admin','is_active']
-    list_filter = ['is_admin','is_active']
+    list_display = ['account_id','username','email','is_active']
+    list_filter = ['is_active']
 
 admin.site.register(Problem,ProblemAdmin)
 admin.site.register(Account,AccountAdmin)

api/controllers/account/create_account.py

@@ -0,0 +1,18 @@
+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 create_account(request):
+    request.data['password'] = passwordEncryption(request.data['password'])
+    try:
+        account = Account.objects.create(**request.data)
+    except Exception as e:
+        return Response({'message':str(e)},status=status.HTTP_400_BAD_REQUEST)
+    serialize = AccountSerializer(account)
+    return Response(serialize.data,status=status.HTTP_201_CREATED)

api/controllers/account/get_account.py

@@ -0,0 +1,17 @@
+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_account(account_id:str):
+    try:
+        account = Account.objects.get(account_id=account_id)
+        serialize = AccountSerializer(account)
+        return Response(serialize.data,status=status.HTTP_200_OK)
+    except:
+        return Response({'message':'Account not found!'},status=status.HTTP_404_NOT_FOUND)

api/controllers/account/get_all_accounts.py

@@ -0,0 +1,16 @@
+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_all_accounts():
+    accounts = Account.objects.all()
+    serialize = AccountSecureSerializer(accounts,many=True)
+    return Response({
+        "accounts": serialize.data
+    },status=status.HTTP_200_OK)

api/controllers/auth/authorization.py

@@ -0,0 +1,21 @@
+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 *
+from time import time
+
+def authorization(request):
+    try:
+        account = Account.objects.get(account_id=request.data['account_id'])
+        account_dict = model_to_dict(account)
+        if account_dict['token_expire'] >= time() and account_dict['token'] == request.data['token']:
+            return Response({'result':True},status=status.HTTP_200_OK)
+        return Response({'result':False},status=status.HTTP_200_OK)
+    except Account.DoesNotExist:
+        return Response({'result':False},status=status.HTTP_200_OK)
+        # return Response({'message':"User doesn't exists!"},status=status.HTTP_404_NOT_FOUND)

api/controllers/auth/login.py

@@ -0,0 +1,29 @@
+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 *
+from decouple import config
+from uuid import uuid4
+from time import time
+
+TOKEN_LIFETIME = int(config('TOKEN_LIFETIME_SECOND')) # (Second)
+
+def login(request):
+    try:
+        account = Account.objects.get(username=request.data['username'])
+        account_dict = model_to_dict(account)
+
+        if passwordEncryption(request.data['password']) == account_dict['password']:
+            account.token = uuid4().hex
+            account.token_expire = int(time()+TOKEN_LIFETIME)
+            account.save()
+            return Response(model_to_dict(account),status=status.HTTP_202_ACCEPTED)
+        else:
+            return Response({'message':"Incorrect password!"},status=status.HTTP_406_NOT_ACCEPTABLE)
+    except Account.DoesNotExist:
+        return Response({'message':"User doesn't exists!"},status=status.HTTP_404_NOT_FOUND)

api/controllers/auth/logout.py

@@ -0,0 +1,24 @@
+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 *
+from decouple import config
+from uuid import uuid4
+from time import time
+
+def logout(request):
+    try:
+        account = Account.objects.get(account_id=request.data['account_id'])
+        if account.token == request.data['token']:
+            account.token = None
+            account.save()
+            return Response(model_to_dict(account),status=status.HTTP_200_OK)
+        else:
+            return Response({'message':"Invalid token!"},status=status.HTTP_200_OK)
+    except Account.DoesNotExist:
+        return Response({'message':"User doesn't exists!"},status=status.HTTP_404_NOT_FOUND)

api/controllers/collection/add_problems_to_collection.py

@@ -0,0 +1,38 @@
+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 add_problems_to_collection(collection:Collection,request):
+    populated_problems = []
+
+    index = 0
+    for problem_id in request.data['problem_ids']:
+
+        problem = Problem.objects.get(problem_id=problem_id)
+
+        alreadyExist = CollectionProblem.objects.filter(problem=problem,collection=collection)
+        if alreadyExist:
+            alreadyExist.delete()
+
+        collection_problem = CollectionProblem(
+            problem=problem,
+            collection=collection,
+            order=index
+        )
+        collection_problem.save()
+        index += 1
+        populated_problems.append(collection_problem)
+    collection.updated_date = timezone.now()
+    problem_serialize = CollectionProblemPopulateProblemSecureSerializer(populated_problems,many=True)
+    collection_serialize = CollectionSerializer(collection)
+
+    return Response({
+        **collection_serialize.data,
+        'problems': problem_serialize.data
+    },status=status.HTTP_201_CREATED)

api/controllers/collection/create_collection.py

@@ -0,0 +1,20 @@
+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 create_collection(account_id:str,request):
+
+    request.data['creator'] = account_id
+    serialize = CollectionSerializer(data=request.data)
+
+    if serialize.is_valid():
+        serialize.save()
+        return Response(serialize.data,status=status.HTTP_201_CREATED)
+    else:
+        return Response(serialize.errors,status=status.HTTP_400_BAD_REQUEST)

api/controllers/collection/delete_collection.py

@@ -0,0 +1,13 @@
+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 delete_collection(collection:Collection):
+    collection.delete()
+    return Response(status=status.HTTP_204_NO_CONTENT)

api/controllers/collection/get_all_collections.py

@@ -0,0 +1,37 @@
+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_all_collections(request):
+    collections = Collection.objects.all()
+
+    account_id = request.query_params.get('account_id',0)
+
+    if account_id:
+        collections = collections.filter(creator_id=account_id)
+
+    populated_collections = []
+    for collection in collections:
+        con_probs = CollectionProblem.objects.filter(collection=collection)
+
+        populated_cp = []
+        for cp in con_probs:
+            prob_serialize = ProblemSerializer(cp.problem)
+            cp_serialize = CollectionProblemSerializer(cp)
+            populated_cp.append({**cp_serialize.data,**prob_serialize.data})
+
+        serialize = CollectionSerializer(collection)
+        collection_data = serialize.data
+        collection_data['problems'] = populated_cp
+
+        populated_collections.append(collection_data)
+
+    return Response({
+        'collections': populated_collections
+    },status=status.HTTP_200_OK)

api/controllers/collection/get_all_collections_by_account.py

@@ -0,0 +1,34 @@
+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 populated_problems(collections: Collection):
+    problemCollections = CollectionProblem.objects.filter(collection__in=collections)
+
+    populated_collections = []
+    for collection in collections:
+        collection.problems = problemCollections.filter(collection=collection)
+        populated_collections.append(collection)
+
+    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': serialize.data,
+        'manageable_collections': manageableSerialize.data
+    },status=status.HTTP_200_OK)

api/controllers/collection/get_collection.py

@@ -0,0 +1,23 @@
+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_collection(collection:Collection):
+
+    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)
+
+
+    return Response(serializer.data ,status=status.HTTP_200_OK)

api/controllers/collection/remove_problems_from_collection.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 remove_problems_from_collection(collection:Collection,request):
+    CollectionProblem.objects.filter(collection=collection,problem_id__in=request.data['problem_ids']).delete()
+    collection.updated_date = timezone.now()
+    return Response(status=status.HTTP_204_NO_CONTENT)

api/controllers/collection/update_collection.py

@@ -0,0 +1,22 @@
+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_collection(collection:Collection,request):
+
+    collection.name = request.data.get('name',collection.name)
+    collection.description = request.data.get('description',collection.description)
+    collection.is_private = request.data.get('is_private',collection.is_private)
+    collection.is_active = request.data.get('is_active',collection.is_active)
+    collection.updated_date = timezone.now()
+
+    collection.save()
+    collection_ser = CollectionSerializer(collection)
+
+    return Response(collection_ser.data,status=status.HTTP_200_OK)