added jwt auth

app.py

@@ -1,14 +1,18 @@
 from io import BytesIO
 from dotenv import load_dotenv
 import os
-from utils import google_search,split_text_into_chunks,insert_embeddings_into_pinecone_database,query_vector_database,generate_embedding_for_user_resume,delete_vector_namespace,create_user,login_user,create_questionaire
-from fastapi import FastAPI, File, UploadFile
+from utils import *
+from fastapi import FastAPI, File, HTTPException, Header, UploadFile,status
+from tokenManagement import *
+from jwtcoding import *
 from fastapi.responses import JSONResponse
 import docx
 import fitz
 from scraper import scrapeCourse
 import asyncio
 from google import genai 
+from fastapi.security import OAuth2PasswordBearer
+from typing import Optional
 from pydantic import BaseModel
 load_dotenv()
 
@@ -22,28 +26,32 @@ app = FastAPI()
 import re
 
 class UserBody(BaseModel):
-    Email:str
-    Password:str
+    firstName: Optional[str] = None
+    lastName: Optional[str] = None
+    email:str
+    password:str
     
 class AiAnalysis(BaseModel):
-    UserId:str
-    Query:str
+    query:str
+    
+class Token(BaseModel):
+    refreshToken:str
+
 
 class UserCourse(BaseModel):
-    EmploymentStatus:str
-    InterimRole:str
-    DesiredRole:str
-    Motivation:str
-    LearningPreference:str
-    HoursSpentLearning:str
-    Challenges:str
-    TimeframeToAchieveDreamRole:str
-    userId:str
+    employmentStatus:str
+    interimRole:str
+    desiredRole:str
+    motivation:str
+    learningPreference:str
+    hoursSpentLearning:str
+    challenges:str
+    timeframeToAchieveDreamRole:str
 
 
 class CourseRecommendation(BaseModel):
-    CourseName: str
-    CompletionTime: str
+    courseName: str
+    completionTime: str
 
 def extract_course_info(text: str) -> CourseRecommendation:
     # Example regex patterns – adjust these as needed based on the response format.
@@ -56,12 +64,12 @@ def extract_course_info(text: str) -> CourseRecommendation:
     coursename = course_match.group(1).strip() if course_match else "Unknown"
     completiontime = time_match.group(0).strip() if time_match else "Unknown"
 
-    return CourseRecommendation(CourseName=coursename, CompletionTime=completiontime)
+    return CourseRecommendation(courseName=coursename, completionTime=completiontime)
 
 
 
 
-@app.get("/get/course")
+@app.get("/get/course",tags=["Scrape"])
 def get_course(query):
 # Example search query
     results = google_search(query, API_KEY, CX)
@@ -74,10 +82,10 @@ def get_course(query):
             snippet = item.get('snippet')
             content_structure={}
             
-            content_structure["Course_Title"]=title
-            content_structure["Course_Link"]=link
-            content_structure["Course_Snippet"]= snippet
-            content_structure["Scraped_Course_Details"]= scrapeCourse(url=link)
+            content_structure["courseTitle"]=title
+            content_structure["courseLink"]=link
+            content_structure["courseSnippet"]= snippet
+            content_structure["scrapedCourseDetails"]= scrapeCourse(url=link)
             content.append(content_structure)
         
     
@@ -97,10 +105,10 @@ def get_course_func(query):
             link = item.get('link')
             snippet = item.get('snippet')
             content_structure={}
-            content_structure["Course_Title"]=title
-            content_structure["Course_Link"]=link
-            content_structure["Course_Snippet"]= snippet
-            content_structure["Scraped_Course_Details"]= scrapeCourse(url=link)
+            content_structure["courseTitle"]=title
+            content_structure["courseLink"]=link
+            content_structure["courseSnippet"]= snippet
+            content_structure["scrapedCourseDetails"]= scrapeCourse(url=link)
             content.append(content_structure)
         
     
@@ -112,42 +120,60 @@ def get_course_func(query):
 
 
 
-@app.post("/upload")
-async def upload_file(user_id,file: UploadFile = File(...)):
-    content = await file.read()  # Read the file content (this will return bytes)
-    sentences=[]
-
-    print(f"File name: {file.filename}")
-    print(f"File content type: {file.content_type}")
-    print(f"File size: {file.size} bytes")
+@app.post("/upload",tags=["AI"])
+async def upload_file(file: UploadFile = File(...),authorization: str = Header(...)):
+     # Extract the token from the Authorization header (Bearer token)
+    token = authorization.split("Bearer ")[-1]
     
+    # Here, you would validate the token (e.g., check with a JWT library)
+    decoded_user_id,decoded_access_token = decode_jwt(token) 
+    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:
     
-    if "pdf" == file.filename.split('.')[1]:
-        pdf_document = fitz.open(stream=BytesIO(content), filetype="pdf")
-        extracted_text = ""
-        for page_num in range(pdf_document.page_count):
-            page = pdf_document.load_page(page_num)
-            extracted_text += page.get_text()
-            
-    elif "docx" == file.filename.split('.')[1]:
-        docx_file = BytesIO(content)
-        doc = docx.Document(docx_file)
-        extracted_text = ""
-        for para in doc.paragraphs:
-            extracted_text += para.text + "\n"
-            
-    sentences = split_text_into_chunks(extracted_text,chunk_size=200)
-    docs = generate_embedding_for_user_resume(data=sentences,user_id=file.filename)
-    response= insert_embeddings_into_pinecone_database(doc=docs,api_key=PINECONE_API_KEY,name_space=user_id)
-    
-    return {"filename": file.filename,"response":str(response) }    
+        content = await file.read()  # Read the file content (this will return bytes)
+        sentences=[]
 
+        print(f"File name: {file.filename}")
+        print(f"File content type: {file.content_type}")
+        print(f"File size: {file.size} bytes")
+        
+        
+        if "pdf" == file.filename.split('.')[1]:
+            pdf_document = fitz.open(stream=BytesIO(content), filetype="pdf")
+            extracted_text = ""
+            for page_num in range(pdf_document.page_count):
+                page = pdf_document.load_page(page_num)
+                extracted_text += page.get_text()
+                
+        elif "docx" == file.filename.split('.')[1]:
+            docx_file = BytesIO(content)
+            doc = docx.Document(docx_file)
+            extracted_text = ""
+            for para in doc.paragraphs:
+                extracted_text += para.text + "\n"
+                
+        sentences = split_text_into_chunks(extracted_text,chunk_size=200)
+        docs = generate_embedding_for_user_resume(data=sentences,user_id=file.filename)
+        response= insert_embeddings_into_pinecone_database(doc=docs,api_key=PINECONE_API_KEY,name_space=decoded_user_id)
+        
+        return {"   name": file.filename,"response":str(response) }    
 
 
-@app.post("/ask")
-def ask_ai_about_resume(req:AiAnalysis):
+
+@app.post("/ask",tags=["AI"])
+def ask_ai_about_resume(req:AiAnalysis,authorization: str = Header(...)):
     # Retrieve context from your vector database
-    context = query_vector_database(query=req.Query, api_key=PINECONE_API_KEY, name_space=req.UserId)
+    token = authorization.split("Bearer ")[-1]
+    
+    # Here, you would validate the token (e.g., check with a JWT library)
+    decoded_user_id,decoded_access_token = decode_jwt(token) 
+    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")
+    
+    context = query_vector_database(query=req.Query, api_key=PINECONE_API_KEY, name_space=decoded_user_id)
     
     # Ensure that an event loop is present in this thread.
     try:
@@ -170,8 +196,8 @@ def ask_ai_about_resume(req:AiAnalysis):
     
     return {"Ai_Response":response.text}
 
-@app.post("/recommend/courses")
-def ask_ai_about_resume(request:UserCourse):
+@app.post("/recommend/courses",tags=["AI"])
+def ask_ai_about_resume(request:UserCourse,authorization:str=Header(...)):
     """
 User Profile Information for Career Development
 
@@ -203,13 +229,18 @@ Parameters:
     timeframe_to_achieve_dream_role (str): 
         The ideal timeframe the user has in mind for achieving their dream role (e.g., "6-12 months").
     
-    user_id (str): 
-        A unique identifier for the user; used to query personalized data from a vector database or other services.
 
     """
     
 
-    # Retrieve context from your vector database
+    # Extract the token from the Authorization header (Bearer token)
+    token = authorization.split("Bearer ")[-1]
+    
+    # Here, you would validate the token (e.g., check with a JWT library)
+    decoded_user_id,decoded_access_token = decode_jwt(token) 
+    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")
     
     # Ensure that an event loop is present in this thread.
     try:
@@ -229,35 +260,84 @@ Parameters:
         - "completiontime": an estimate of how long it would take to complete the course.
         Do not include any extra text.
         Recommend a course using this information below :
-        Which of the following best describes you?: {request.EmploymentStatus}
+        Which of the following best describes you?: {request.employmentStatus}
         Would you like to prepare for an interim role to gain experience and income while pursuing your dream job?: {request.InterimRole}
-        What is your desired role?: {request.DesiredRole}
-        Why do you want to achieve this desired role?: {request.Motivation}
-        How do you prefer to learn new skills?: {request.LearningPreference}
-        How many hours per day can you dedicate to learning?: {request.HoursSpentLearning}
-        What are the biggest challenges or obstacles you face in reaching your dream role?: {request.Challenges}
-        What is your ideal timeframe for achieving your dream role?: {request.TimeframeToAchieveDreamRole}
+        What is your desired role?: {request.desiredRole}
+        Why do you want to achieve this desired role?: {request.motivation}
+        How do you prefer to learn new skills?: {request.learningPreference}
+        How many hours per day can you dedicate to learning?: {request.hoursSpentLearning}
+        What are the biggest challenges or obstacles you face in reaching your dream role?: {request.challenges}
+        What is your ideal timeframe for achieving your dream role?: {request.timeframeToAchieveDreamRole}
         
     
         """
     )
     questions=request.model_dump()
+    questions['userId']=decoded_user_id
     create_questionaire(db_uri=MONGO_URI,db_name="crayonics",collection_name="questionaire",document=questions)
     course_info = extract_course_info(response.text)
-    courses = get_course_func(query=course_info.CourseName)
-    return {"CourseInfo":course_info,"Courses":courses}
+    courses = get_course_func(query=course_info.courseName)
+    return {"courseInfo":course_info,"courses":courses}
 
 
 
-@app.post("/login")
+@app.post("/login",tags=["Authentication"])
 def login(user:UserBody):
-    user ={"email":user.Email,"password":user.Password}
+    user ={"email":user.email,"password":user.password,"firstName":user.firstName,"lastName":user.lastName}
     user_id= login_user(db_uri=MONGO_URI,db_name="crayonics",collection_name="users",document=user)
-    return {"user_id":user_id}
+    
+    if user_id != False:
+        refreshToken=create_refreshToken(db_uri=MONGO_URI,user_id=user_id)
+        accessToken = create_accessToken(db_uri=MONGO_URI,user_id=user_id,refresh_token=refreshToken)
+        result = update_refreshTokenWithPreviouslyUsedAccessToken(db_uri=MONGO_URI,refresh_token=refreshToken,access_token=accessToken)
+        print(result)
+        access_token = encode_jwt(user_id=user_id,access_token=accessToken)
+        return {"userId":user_id,"refreshToken":refreshToken,"accessToken":access_token}
+    return JSONResponse(status_code=401,content="Invalid login details")
 
 
-@app.post("/signup")
+@app.post("/signup",tags=["Authentication"])
 def signUp(user:UserBody):
-    user ={"email":user.Email,"password":user.Password}
+    user ={"email":user.email,"password":user.password}
     user_id= create_user(db_uri=MONGO_URI,db_name="crayonics",collection_name="users",document=user)
-    return {"user_id":user_id}
+    if user_id != False:
+        refreshToken=create_refreshToken(db_uri=MONGO_URI,user_id=user_id)
+        accessToken = create_accessToken(db_uri=MONGO_URI,user_id=user_id,refresh_token=refreshToken)
+        result = update_refreshTokenWithPreviouslyUsedAccessToken(db_uri=MONGO_URI,refresh_token=refreshToken,access_token=accessToken)
+        print(result)
+        access_token = encode_jwt(user_id=user_id,access_token=accessToken)
+        return {"userId":user_id,"refreshToken":refreshToken,"accessToken":access_token}
+    return JSONResponse(status_code=401,content="Invalid Sign Up details")
+
+
+@app.post("/accessToken",tags=["Authentication"])
+def refresh_access_token(refresh_token:Token, authorization: str = Header(...)):
+    
+    token = authorization.split("Bearer ")[-1]
+    
+    # Here, you would validate the token (e.g., check with a JWT library)
+    decoded_user_id,decoded_access_token = decode_jwt(token) 
+    is_valid = verify_access_token(db_uri=MONGO_URI, user_id=decoded_user_id, access_token=decoded_access_token)
+    print(decoded_user_id,decoded_access_token)
+    if is_valid != True:  # Example check
+        raise HTTPException(status_code=401, detail="Invalid token")
+    new_access_token = create_accessToken(db_uri=MONGO_URI,user_id=decoded_user_id,refresh_token=refresh_token.refreshToken)
+    newly_encoded_access_token = encode_jwt(user_id=decoded_user_id,access_token=new_access_token) 
+    return {"accessToken":newly_encoded_access_token}
+
+
+
+
+@app.get("/protected-route")
+def protected_route(authorization: str = Header(...)):
+    # Extract the token from the Authorization header (Bearer token)
+    token = authorization.split("Bearer ")[-1]
+    
+    # Here, you would validate the token (e.g., check with a JWT library)
+    decoded_user_id,decoded_access_token = decode_jwt(token) 
+    is_valid = verify_access_token(db_uri=MONGO_URI, user_id=decoded_user_id, access_token=decoded_access_token)
+    print(decoded_user_id,decoded_access_token)
+    if is_valid != True:  # Example check
+        raise HTTPException(status_code=401, detail="Invalid token")
+    
+    return {"message": "Access granted", "verification": "verified"}

jwtcoding.py

@@ -0,0 +1,25 @@
+from jose import jwt
+import os
+from dotenv import load_dotenv
+from datetime import datetime, timedelta
+load_dotenv()
+SECRET_KEY = os.getenv("SECRET_KEY")
+ALGORITHM = os.getenv("ALGORITHM")
+
+def encode_jwt(user_id: str, access_token: str, expires_delta: timedelta = timedelta(minutes=130)) -> str:
+    """Encode user_id and access_token into a JWT."""
+    payload = {
+        "user_id": user_id,
+        "access_token": access_token,
+        "exp": datetime.now() + expires_delta  # Expiration time
+    }
+    return jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)
+
+def decode_jwt(encoded: str) -> tuple[str, str]:
+    """Decode the JWT back into user_id and access_token."""
+    try:
+        payload = jwt.decode(encoded, SECRET_KEY, algorithms=[ALGORITHM])
+        return payload["user_id"], payload["access_token"]
+    except jwt.JWTError as e:
+        raise ValueError(f"Invalid or expired token: {str(e)}")
+

password.py

@@ -0,0 +1,36 @@
+import bcrypt
+
+def hash_password(password):
+    """
+    Hash a password using bcrypt.
+    
+    Args:
+        password (str): The plain text password to hash
+        
+    Returns:
+        bytes: The hashed password
+    """
+    # Convert string to bytes and generate a salt
+    salt = bcrypt.gensalt()
+    # Hash the password with the salt
+    hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
+    return hashed
+
+def check_password(password, hashed_password):
+    """
+    Check if a provided password matches the hashed password.
+    
+    Args:
+        password (str): The plain text password to check
+        hashed_password (bytes): The previously hashed password
+        
+    Returns:
+        bool: True if password matches, False otherwise
+    """
+    try:
+        # Check if the password matches the hash
+        return bcrypt.checkpw(password.encode('utf-8'), hashed_password)
+    except Exception:
+        # Return False if there's any error (e.g., invalid hash)
+        return False
+

requirements.txt

@@ -8,4 +8,8 @@ einops
 google-genai
 python-docx
 beautifulsoup4
-pymongo
+pymongo
+bcrypt
+python-jose[cryptography] 
+passlib[bcrypt] 
+uvicorn

tokenManagement.py

@@ -0,0 +1,136 @@
+
+
+import datetime
+from bson import ObjectId
+
+
+def is_current_date_greater_than_previous(previous_date):
+    # Get the current date and time
+    current_date =datetime.datetime.now()
+
+    # Convert the previous date (which is a string) to a datetime object
+
+
+    # Compare the two dates
+    if current_date > previous_date:
+        return True
+    else:
+        return False
+
+
+
+def create_accessToken(db_uri: str, user_id: str, refresh_token: str) -> str:
+    from pymongo import MongoClient
+    current_time = datetime.datetime.now()
+    expire_at = current_time + datetime.timedelta(minutes=130)
+    """
+    Inserts a new document into the specified MongoDB collection.
+
+    Parameters:
+        db_uri (str): MongoDB connection URI.
+        db_name (str): Name of the database.
+        collection_name (str): Name of the collection.
+        document (dict): The document to insert.
+
+    Returns:
+        str: The ID of the inserted document.
+    """
+    # Connect to MongoDB
+    client = MongoClient(db_uri)
+    db = client["crayonics"]
+    collection = db["AccessToken"]
+    collection.find_one_and_delete({"refresh_token":refresh_token})
+    # Insert the document
+    result = collection.insert_one({"user_id":user_id,"refresh_token":refresh_token,"current_time":current_time,"expire_at":expire_at})
+    client.close()
+    return str(result.inserted_id)
+
+    
+    # Close the connection
+    
+    
+    
+def create_refreshToken(db_uri: str, user_id: str) -> str:
+    from pymongo import MongoClient
+    current_time = datetime.datetime.now()
+    expire_at = current_time + datetime.timedelta(days=30)
+
+    """
+    Inserts a new document into the specified MongoDB collection.
+
+    Parameters:
+        db_uri (str): MongoDB connection URI.
+        user_id (str): id of user .
+
+
+    Returns:
+        str: The ID of the inserted document.
+    """
+
+    # Connect to MongoDB
+    client = MongoClient(db_uri)
+    db = client["crayonics"]
+    collection = db["RefreshToken"]
+    # Insert the document
+    result = collection.insert_one({"user_id":user_id,"current_time":current_time,"expire_at":expire_at,"previous_access_token":"None"})
+    client.close()
+    return str(result.inserted_id)
+    
+    # Close the connection
+    
+    
+    
+    
+def update_refreshTokenWithPreviouslyUsedAccessToken(db_uri: str, refresh_token: str,access_token:str) -> bool:
+    from pymongo import MongoClient
+
+    """
+
+    """
+    # Connect to MongoDB
+    client = MongoClient(db_uri)
+    db = client["crayonics"]
+    collection = db["RefreshToken"]
+    
+    # Insert the document
+    try:
+        collection.update_one(
+        {"_id":ObjectId(oid=refresh_token) },  # Filter (find the document by user_id)
+        {"$set": {"previous_access_token": access_token}}  # Add or update the field
+    )
+        client.close()
+        return True
+    except:
+        return False
+
+
+
+def verify_access_token(db_uri: str, user_id: str, access_token: str) -> bool:
+    from pymongo import MongoClient
+    current_time = datetime.datetime.now()
+    expire_at = current_time + datetime.timedelta(minutes=15)
+    """
+
+    """
+    # Connect to MongoDB
+    client = MongoClient(db_uri)
+    db = client["crayonics"]
+    collection = db["AccessToken"]
+    doc = collection.find_one({"user_id":user_id})
+
+    
+    if doc==None:
+        return False
+    else:
+        if str(doc['_id']) == access_token:
+            if is_current_date_greater_than_previous(doc['expire_at']):
+                return False
+            else:
+                return True
+        else:
+            print("doc exists",str(doc['_id']),access_token,str(doc['_id']) == access_token )
+            return False
+    
+
+
+

utils.py

@@ -1,5 +1,6 @@
 import requests
 from pymongo import MongoClient
+from password import *
 
 def google_search(query, api_key, cx):
     url = f"https://www.googleapis.com/customsearch/v1?q={query}&key={api_key}&cx={cx}"
@@ -78,7 +79,7 @@ def query_vector_database(query,api_key,name_space):
     response = index.query(
         namespace=name_space,
         vector=query_embedding.tolist(),
-        top_k=3,
+        top_k=5,
         include_metadata=True
         )
 
@@ -131,14 +132,16 @@ def create_user(db_uri: str, db_name: str, collection_name: str, document: dict)
     collection = db[collection_name]
     
     # Insert the document
-    s = collection.find_one(document)
+    s = collection.find_one({"email":document.get('email')})
+    password = hash_password(document.get('password'))
+    document['password']= password
     if s==None:
         result = collection.insert_one(document)
         client.close()
         return str(result.inserted_id)
     else:
         client.close()
-        return str(s['_id'])
+        return "User Already Exists"
     
     # Close the connection
     
@@ -193,15 +196,18 @@ def login_user(db_uri: str, db_name: str, collection_name: str, document: dict)
     collection = db[collection_name]
     
     # Insert the document
-    s = collection.find_one(document)
+    s = collection.find_one({"email":document.get("email")})
+    print(s)
+    print(document.get('email'))
     if s==None:
-        return False
+        return "User Doesn;t exist"
     else:
-        if document['password']==s['password']:
+
+        if check_password(password=document['password'],hashed_password=s['password']):
             client.close()
             return str(s['_id'])
         else:
-            return True
+            return "Wrong Password"
     # Close the connection