Merge pull request #29 from IEEECS-VIT/aryan

jainaryan04 · web-flow · commit 30daf2c5340a · 2025-02-06T20:50:19.000+05:30
roundwise answer submission and dashboard
diff --git a/config.py b/config.py
@@ -12,6 +12,20 @@ def initialize():
         aws_access_key_id=os.getenv("AWS_ACCESS_KEY"),
         aws_secret_access_key=os.getenv("AWS_SECRET_KEY")
     )
+
+    domain_tables = {
+        "ai": dynamodb.Table("domain-ai"),
+        "app": dynamodb.Table("domain-app"),
+        "events": dynamodb.Table("domain-events"),
+        "graphic": dynamodb.Table("domain-graphic"),
+        "iot": dynamodb.Table("domain-iot"),
+        "pnm": dynamodb.Table("domain-pnm"),
+        "rnd": dynamodb.Table("domain-rnd"),
+        "ui": dynamodb.Table("domain-ui"),
+        "video": dynamodb.Table("domain-video"),
+        "web": dynamodb.Table("domain-web")
+    }
+
     user_table = dynamodb.Table("enrollments-site-users")
     quiz_table = dynamodb.Table("enrollments-site-quiz")
     interview_table = dynamodb.Table("enrollments-site-interview")
@@ -26,15 +40,14 @@ def initialize():
         'firebase_app': firebase_app,
         'user_table': user_table,
         'quiz_table': quiz_table,
-        'interview_table': interview_table
+        'interview_table': interview_table,
+        'domain_tables': domain_tables
     }
 
-resources = initialize()
-
-firebase_app = resources['firebase_app']
-user_table = resources['user_table']
-quiz_table = resources['quiz_table']
-interview_table = resources['interview_table']
+resources = None
 
 def get_resources():
+    global resources
+    if resources is None:
+        resources = initialize()
     return resources
diff --git a/main.py b/main.py
@@ -4,7 +4,7 @@
 from routes.user import user
 from routes.answer import ans_app
 from routes.slots import slot_app
-from routes.quiz_progress import quiz_app
+#from routes.quiz_progress import quiz_app
 from routes.quiz_status import quiz_status
 from config import initialize
 
@@ -34,7 +34,7 @@
 app.mount("/domain", domain_app)
 app.mount("/answer", ans_app)
 app.mount("/slots", slot_app)
-app.mount("/quiz", quiz_app)
+#app.mount("/quiz", quiz_app)
 app.mount("/quiz-status", quiz_status)
 @app.get("/ping")
 async def ping():
diff --git a/routes/answer.py b/routes/answer.py
@@ -4,6 +4,7 @@
 from middleware.verifyToken import get_access_token
 from firebase_admin import auth
 from config import initialize
+from fastapi.responses import JSONResponse
 from botocore.exceptions import ClientError
 
 ans_app = FastAPI()
@@ -14,63 +15,103 @@
 
 
 class AnswerStruct(BaseModel):
-    domain: str = Field(..., title="Domain for the answers")
-    questions: List[str] = Field(..., title="List of questions")
-    answers: List[str] = Field(..., title="List of answers")
-    score: Optional[int] = Field(None, title="Score for the domain, not compulsory")
+    domain: str = Field(...)
+    questions: List[str] = Field(...)
+    answers: List[str] = Field(...)
+    score: Optional[int] = Field(None)
     round: int
 
+domain_mapping = {
+    "UI/UX": "ui",
+    "Graphic Design": "graphic",
+    "Video Editing": "video",
+    'Events':'events', 
+    'PnM':'pnm',
+    'WEB':'web', 
+    'IOT':'iot', 
+    'APP':'app',
+    'AI/ML':'ai',
+    'RND':'rnd'
+}
+
 @ans_app.post("/submit")
 async def post_answers(answerReq: AnswerStruct, idToken: str = Depends(get_access_token)):
     try:
         decoded_token = auth.verify_id_token(idToken, app=resources["firebase_app"])
         email = decoded_token.get("email")
 
         if not email:
-            raise HTTPException(status_code=401, detail="Invalid or missing email in token.")
+            return JSONResponse(status_code=401, content="Invalid or missing email in token.")
 
         response = user_table.get_item(Key={"uid": email})
         user = response.get("Item")
 
         if not user:
-            raise HTTPException(status_code=404, detail="User not found.")
+            return JSONResponse(status_code=404, content="User not found.")
 
-        if len(answerReq.questions) != len(answerReq.answers):
-            raise HTTPException(
-                status_code=400,
-                detail="Questions and answers lists must have the same length."
-            )
+        if answerReq.domain not in user.get('domains', []):
+            return JSONResponse(status_code=408, content="Domain was not selected")
+        mapped_domain = domain_mapping.get(answerReq.domain)
+        domain_tables = resources['domain_tables']
+        domain_table = domain_tables.get(mapped_domain)
 
-        existing_round = user.get(f"round {answerReq.round}", {})
+        if not domain_table:
+            raise HTTPException(status_code=400, detail=f"Domain '{answerReq.domain}' not recognized.")
 
-        if answerReq.domain in existing_round:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Answers for domain '{answerReq.domain}' have already been submitted for round {answerReq.round}."
-            )
+        if len(answerReq.questions) != len(answerReq.answers):
+            raise HTTPException(status_code=400, detail="Questions and answers lists must have the same length.")
 
-        answers_dict = [
-            {"question": q, "answer": a}
-            for q, a in zip(answerReq.questions, answerReq.answers)
-        ]
+        answers_dict = [{"question": q, "answer": a} for q, a in zip(answerReq.questions, answerReq.answers)]
+        response = domain_table.get_item(Key={'email': email})
 
-        domain_data = {"answers": answers_dict}
-        if answerReq.score is not None:
-            domain_data["score"] = answerReq.score
 
-        existing_round[answerReq.domain] = domain_data
 
-        user_table.update_item(
-            Key={"uid": email},
-            UpdateExpression="SET #round = :updated_round",
-            ExpressionAttributeNames={"#round": f"round {answerReq.round}"},
-            ExpressionAttributeValues={":updated_round": existing_round},
-            ReturnValues="UPDATED_NEW",
-        )
+        if answerReq.round == 1:
+            if 'Item' in response:
+                return JSONResponse(status_code=409, content="Answers already submitted")
+            
+            domain_table.put_item(
+                Item={
+                    "email": email,
+                    f"round{answerReq.round}": answers_dict,
+                    f"score{answerReq.round}": answerReq.score
+                }
+            )
+        else:
+            result = domain_table.get_item(Key={"email": email})
+            domain_response = result.get('Item')
+            if not domain_response or not domain_response.get(f"round{answerReq.round - 1}"):
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"User '{email}' has not completed round {answerReq.round - 1} in domain '{answerReq.domain}'."
+                )
+            domain_table.update_item(Key={"email": email},
+                UpdateExpression="""
+                SET #new_answers = if_not_exists(#new_answers, :new_answers),
+                #new_score = if_not_exists(#new_score, :new_score)
+                """,
+            ExpressionAttributeNames={
+                "#new_answers": f"round{answerReq.round}",
+                "#new_score": f"score{answerReq.round}"
+            },
+            ExpressionAttributeValues={
+                ":new_answers": answers_dict,
+                ":new_score": answerReq.score
+            },
+            ReturnValues="UPDATED_NEW"
+            )
 
+        user_table.update_item(
+                Key={'uid': email},
+                UpdateExpression=f"SET round{answerReq.round} = list_append(if_not_exists(round{answerReq.round}, :empty_list), :new_value)",
+                ExpressionAttributeValues={
+                ':new_value': [answerReq.domain], 
+                ':empty_list': []           
+                },
+            )
         return {"message": f"Answers for domain '{answerReq.domain}' submitted successfully for round {answerReq.round}."}
 
     except ClientError as e:
         raise HTTPException(status_code=500, detail=f"DynamoDB error: {str(e)}")
     except Exception as e:
-        raise HTTPException(status_code=400, detail=f"Error posting answers: {str(e)}")
+        raise HTTPException(status_code=400, detail=f"Error posting answers: {str(e)}")
diff --git a/routes/domain.py b/routes/domain.py
@@ -30,7 +30,11 @@ async def post_domain(domain: Dict[str, List[str]], id_token: str = Depends(get_
             if len(domain_list) > 2:
                 raise HTTPException(status_code=400, content=f"Domain array for key {key} cannot have more than 2 entries")
 
-        user['domain'] = domain
+        all_domains = []
+        for domain_list in domain.values():
+            all_domains.extend(domain_list)
+
+        user['domain'] = all_domains
         user_table.put_item(Item=user)
         
         return JSONResponse(status_code=200, content=domain)
@@ -48,7 +52,6 @@ async def get_qs(domain: str, round: str):
 
         round_data = field.get(round)
         if not round_data:
-            print('no')
             return JSONResponse(status_code=401, content=f"Round {round} Questions not found")
         formatted_questions = []
 
diff --git a/routes/quiz_status.py b/routes/quiz_status.py
@@ -1,6 +1,5 @@
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-import boto3
 from firebase_admin import auth
 
 from config import initialize
diff --git a/routes/user.py b/routes/user.py
@@ -1,4 +1,4 @@
-from fastapi import FastAPI, HTTPException, Depends
+from fastapi import FastAPI, HTTPException, Depends, Query
 from fastapi.responses import JSONResponse
 from firebase_admin import auth
 from pydantic import BaseModel
@@ -109,3 +109,36 @@ async def submit_username(
         raise e
     except Exception as e:
         return JSONResponse(status_code=500, content= f"Internal Server Error: {str(e)}")
+    
+@user.get("/dashboard")
+async def get_dashboard(round: int = Query(..., description="Round number"), authorization: str = Depends(get_access_token), resources: dict = Depends(get_resources)):
+    try:
+        if not authorization:
+            raise HTTPException(status_code=400, detail="Authorization token missing")
+
+        try:
+            decoded_token = auth.verify_id_token(authorization)
+        except Exception as token_error:
+            raise HTTPException(status_code=401, detail=f"Invalid token: {str(token_error)}")
+
+        email = decoded_token.get('email')
+        if not email:
+            raise HTTPException(status_code=400, detail="Email not found in ID token")
+
+        try:
+            user_table = resources.get("user_table")
+            response = user_table.get_item(Key={'uid': email})
+            user = response.get('Item')
+
+        except Exception as db_error:
+            raise HTTPException(status_code=500, detail=f"Database lookup failed: {str(db_error)}")
+
+        pending = list(
+            set(map(str.lower, user.get('domains', []))) - 
+            set(map(str.lower, user.get(f'round{round}', [])))
+        )
+        return JSONResponse(status_code=200, content=pending)
+    
+    except Exception as unexpected_error:
+        raise HTTPException(status_code=500, detail=f"Unexpected server error: {str(unexpected_error)}")
+
