added auth and get routes (#14)

- #update (7ea3d3f1c8cdc94568081cb243236ff6ca0de69c)

Ars/ai_functions.py

@@ -3,15 +3,15 @@ from io import BytesIO
 from Ars.objects import ai,ResumeData,AutomationRiskResult,AutomationRiskInput,RealWorldQuestion,SkillDepthResult,SkillDepthInput,BreakDownByDomainUpdate,FlaggedRiskAreasUpdate,BoostSuggestionsUpdate,AICollabReadinessInput
 from Ars.embedDoc import search_pinecone_text
 from fastapi import UploadFile
-
 def extract_text_from_bytes(pdf_bytes: bytes) -> str:
     output_string = BytesIO()
     with BytesIO(pdf_bytes) as input_stream:
         extract_text_to_fp(input_stream, output_string)
     return output_string.getvalue().decode()
 
+
             
-async def resume_analysis(upload_file:UploadFile) -> ResumeData:
+async def resume_analysis(upload_file:UploadFile) -> dict[str, str | ResumeData]:
     contents = await upload_file.read()
     resume = extract_text_from_bytes(pdf_bytes=contents)
     if resume:

Ars/controllers.py

@@ -1,19 +1,35 @@
 from Ars.core import r
-from Ars.repositories import create_boost_suggestions,create_breakdown_by_domain,create_flagged_risk_areas,create_user_resilience
+from Ars.repositories import get_document_by_hashed_doc,create_new_hashed_doc_entry,create_boost_suggestions,create_breakdown_by_domain,create_flagged_risk_areas,create_user_resilience
 from fastapi import UploadFile
 from Ars.ai_functions import resume_analysis,calculate_automation_risk,calculate_Ai_collab_readiness,calculate_skill_depth,generate_boost_suggestion,generate_domain_breakdown,generate_flagged_risk_areas
 from Ars.objects import AICollabReadiness,SkillDepthResult,AutomationRiskResult 
-async def resilience_analysis(file:UploadFile):
-    resume= await resume_analysis(file)
-    risk = calculate_automation_risk(resume)
-    risk = AutomationRiskResult(**risk.model_dump())
-    skill_depth =  calculate_skill_depth(resume)
-    skill_depth= SkillDepthResult(**skill_depth.model_dump())
-    ai_readiness = calculate_Ai_collab_readiness(resume)
-    ai_readiness = AICollabReadiness(**ai_readiness.model_dump())
-    ResilienceScore = ((1-(risk.result/100))*0.5+(skill_depth.result/100)*0.3+(ai_readiness.result/100)*0.2)
-    flagged_risk =generate_flagged_risk_areas(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
-    boost_suggestion = generate_boost_suggestion(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
-    domain_breakdown = generate_domain_breakdown(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
+import hashlib
 
-    return {"overall score": ResilienceScore,"flagged Risk": flagged_risk,"boost suggestion":boost_suggestion,"domain breakdown":domain_breakdown,"resume":resume,"skil_depth":skill_depth,"risk":risk,"ai_readiness":ai_readiness}
+def get_document_hash(document_content: str) -> str:
+    # Ensure consistent encoding (e.g., UTF-8) before hashing
+    document_bytes = document_content.encode('utf-8')
+    hasher = hashlib.sha256()
+    hasher.update(document_bytes)
+    return hasher.hexdigest()
+
+async def resilience_analysis(file:UploadFile,userId:str):
+    hashed_doc = get_document_hash(resume)
+    
+    check = get_document_by_hashed_doc(hashed_doc=hashed_doc)
+    if check==None:
+        resume= await resume_analysis(file)
+        risk = calculate_automation_risk(resume)
+        risk = AutomationRiskResult(**risk.model_dump())
+        skill_depth =  calculate_skill_depth(resume)
+        skill_depth= SkillDepthResult(**skill_depth.model_dump())
+        ai_readiness = calculate_Ai_collab_readiness(resume)
+        ai_readiness = AICollabReadiness(**ai_readiness.model_dump())
+        ResilienceScore = ((1-(risk.result/100))*0.5+(skill_depth.result/100)*0.3+(ai_readiness.result/100)*0.2)
+        flagged_risk =generate_flagged_risk_areas(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
+        boost_suggestion = generate_boost_suggestion(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
+        domain_breakdown = generate_domain_breakdown(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
+        final_analysis_response ={"overall score": ResilienceScore,"flagged Risk": flagged_risk,"boost suggestion":boost_suggestion,"domain breakdown":domain_breakdown,"resume":resume,"skil_depth":skill_depth,"risk":risk,"ai_readiness":ai_readiness}
+        await create_new_hashed_doc_entry(data={"hashed_doc":hashed_doc,"resume":final_analysis_response,"userId":userId})
+        return final_analysis_response
+    else:
+        return check

Ars/repositories.py

@@ -4,8 +4,54 @@ from fastapi import HTTPException
 from typing import Optional, List
 from motor.motor_asyncio import AsyncIOMotorDatabase
 from Ars.objects import UserResilienceScoreCreate, UserResilienceScoreOut,BreakDownByDomainCreate,BreakDownByDomainOut,FlaggedRiskAreasCreate,FlaggedRiskAreasOut,BoostSuggestionsCreate,BoostSuggestionsOut,BoostSuggestionsUpdate,UserResilienceScoreUpdate,FlaggedRiskAreasUpdate,BreakDownByDomainUpdate
-
-
+import pymongo
+
+async def create_new_hashed_doc_entry(data: dict):
+    # Ensure the 'hashed_doc' field is present in the input data
+    if "hashed_doc" not in data:
+        return {"error": "Missing 'hashed_doc' field in the data"}
+
+    try:
+        # Attempt to insert the document, ensuring hashed_doc is unique due to the index
+        result = await db.resume_resilience_analysis.insert_one(data)
+        return {"inserted_id": result.inserted_id}  # Return the inserted ID
+    except pymongo.errors.DuplicateKeyError:
+        # Handle the case where a document with the same 'hashed_doc' already exists
+        return {"error": "Document with this 'hashed_doc' already exists"}
+    except Exception as e:
+        # Catch other exceptions (e.g., database connection issues)
+        return {"error": str(e)}
+    
+async def get_document_by_hashed_doc(hashed_doc: str):
+    try:
+        # Find the document using the hashed_doc field
+        document = await db.resume_resilience_analysis.find_one({"hashed_doc": hashed_doc})
+        
+        if document:
+            return document['resume']
+        else:
+            return None
+    
+    except Exception as e:
+        # Handle any other errors, like database issues
+        return {"error": str(e)}
+
+
+async def get_document_by_userId(userId: str):
+    try:
+        # Find the document using the hashed_doc field
+        document = await db.resume_resilience_analysis.find_one({"userId": userId})
+        
+        if document:
+            return document['resume']
+        else:
+            return None
+    
+    except Exception as e:
+        # Handle any other errors, like database issues
+        return {"error": str(e)}
+    
+    
 async def create_user_resilience(  data: UserResilienceScoreCreate) -> UserResilienceScoreOut:
     """
     Create a new UserResilienceScore in the database.

Ars/routes.py

@@ -1,15 +1,31 @@
 import base64
-from fastapi import FastAPI, File, UploadFile,HTTPException
+from fastapi import FastAPI, File, UploadFile,HTTPException,Depends
 from Ars.controllers import resilience_analysis
+from Ars.repositories import get_document_by_userId
+from security.authDependency import verifyAccessToken
 from Ars.embedDoc import upsert_text_with_chunks,search_pinecone_text
+import hashlib
+
+
 ARS = FastAPI()
 
+
+
+
+
 @ARS.post("/risk-analysis")
-async def perform_risk_analysis(file: UploadFile = File(...)):
+async def perform_risk_analysis(user =Depends(verifyAccessToken) ,file: UploadFile = File(...), ):
     if file.content_type != "application/pdf":
         return HTTPException(status_code=400, detail={"error": "File must be a PDF."})
-    ResilienceScore = await resilience_analysis(file=file)
+    
+    ResilienceScore = await resilience_analysis(file=file,userId=user['userId'])
     return ResilienceScore
 
 
     
+@ARS.get("/risk-analysis")
+async def perform_risk_analysis(user=Depends(verifyAccessToken) ):
+    ResilienceScore = await get_document_by_userId(userId=user['userId'])
+    
+    return ResilienceScore
+

security/authDependency.py

@@ -0,0 +1,14 @@
+from fastapi.security import HTTPBearer
+from fastapi import Depends
+from controller.imports import *
+
+token_auth_scheme = HTTPBearer()
+
+def verifyAccessToken(token:str =Depends(token_auth_scheme)):
+    credentials = token.credentials
+    decoded_user_id,decoded_access_token = decode_jwt(credentials) 
+    is_valid = verify_access_token(db_uri=MONGO_URI, user_id=decoded_user_id, access_token=decoded_access_token)
+    if is_valid != True:  # Example check
+        raise HTTPException(status_code=401, detail="Invalid token")
+    else:
+        return {"userId":decoded_user_id}