added most features

app.py

@@ -15,6 +15,16 @@ from google import genai
 from typing import Optional,List
 from pydantic import BaseModel
 import re
+from bson.json_util import dumps
+import threading
+import concurrent.futures
+from gamification.pointLogic import get_all_simple_points_func,get_dream_job
+from pydantic import BaseModel
+from datetime import datetime
+from bson import ObjectId
+import os 
+
+
 
 load_dotenv()
 
@@ -410,3 +420,119 @@ def protected_route(authorization: str = Header(...)):
 
 
 
+
+class LeaderBoardRanking(BaseModel):
+    userId:str
+    firstName:str
+    lastName:str
+    totalpoints:float
+    lastUpdated:datetime
+    careerPath:str
+    class Config:
+        json_encoder ={
+        ObjectId:str
+        }
+    
+    
+def create_leaderboard_ranking( document: LeaderBoardRanking) -> bool:
+
+    collection = db['LeaderBoard']
+    # Insert the document
+    result= collection.find_one_and_replace(filter={"userId":document.userId},replacement=document.model_dump())
+    if result==None:
+        result = collection.insert_one(document.model_dump())
+        print("correctly inserted new document for",document.firstName)
+        return True
+
+    return False
+
+
+    
+def get_all_users(user_id =None) -> List:
+
+    client = MongoClient(MONGO_URI)
+    db = client.crayonics
+    collection = db['users']
+    # Insert the document
+    if user_id==None:
+        results= collection.find()
+    
+        if results:
+            result = [result for result in  results]
+            return result
+        
+        client.close()
+    else:
+        result = collection.find_one(filter={"_id":ObjectId(user_id)})
+        return result
+
+
+def get_user_id_from_docKey(dockId):
+    client = MongoClient(MONGO_URI)
+    db = client.crayonics
+    collection = db['Points']
+    # Insert the document 
+    result = collection.find_one(filter={"_id":ObjectId(dockId)})
+    client.close()
+    return result['userId']
+
+        
+    
+   
+   
+# MongoDB connection setup
+client = MongoClient(MONGO_URI)
+db = client.crayonics
+collection = db['Points']
+
+# A function to handle changes
+def handle_change(change):
+    # add everybodies points and add it to the leaderboard table
+    collections = db.list_collection_names()
+    if "LeaderBoard" not in collections:
+        print("Collection doesnt exists.")
+        # loop through points, get userId from points and total points from points table then we 
+        # loop through userId and get the firstName and LastName of each userId lastly
+        # loop throguh the questionarier using the userId and get the careerPath of each user
+        users = get_all_users()
+        for user in users:
+            points = get_all_simple_points_func(userId=str(user['_id']))
+            tempDreamJob =  get_dream_job(userId=str(user['_id'])) 
+            dreamJob = tempDreamJob if type(tempDreamJob)==str else "IncompleteProfile"
+            create_leaderboard_ranking(LeaderBoardRanking(userId=str(user['_id']),firstName=user['first_name'],lastName=user['last_name'],totalpoints=points.totalpoints,lastUpdated=datetime.now(),careerPath=dreamJob,))
+    else:
+        if change['operationType'] == 'insert':
+            # Extract the full document
+            full_document = change['fullDocument']
+            
+            # Extract the userId and numOfPoints
+            
+            user_id =full_document.get('userId')
+            leveleduser = get_all_users(userId=user_id)
+            points = get_all_simple_points_func(userId=user_id)
+            tempDreamJob =  get_dream_job(userId=user_id) 
+            dreamJob = tempDreamJob if type(tempDreamJob)==str else "IncompleteProfile"
+            create_leaderboard_ranking(LeaderBoardRanking(userId=user_id,firstName=leveleduser['first_name'],lastName=leveleduser['last_name'],totalpoints=points.totalpoints,lastUpdated=datetime.now(),careerPath=dreamJob,))
+        elif change['operationType'] == 'update':
+            dockey = str(change['documentKey']['_id'])
+            user_id = get_user_id_from_docKey(dockId=dockey)
+            leveleduser = get_all_users(user_id=user_id)
+            points = get_all_simple_points_func(userId=user_id)
+            tempDreamJob =  get_dream_job(userId=user_id)
+            dreamJob = tempDreamJob if type(tempDreamJob)==str else "IncompleteProfile"
+            create_leaderboard_ranking(LeaderBoardRanking(userId=user_id,firstName=leveleduser['first_name'],lastName=leveleduser['last_name'],totalpoints=points.totalpoints,lastUpdated=datetime.now(),careerPath=dreamJob,))
+            
+        
+    print(f"Change detected: {dumps(change)}")
+
+# Function to run the change stream in a separate thread (non-blocking)
+def watch_change_stream():
+    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:  # Limit to 10 threads, adjust as needed
+        with collection.watch() as stream:
+            for change in stream:
+                # Submit the handle_change task to the thread pool
+                executor.submit(handle_change, change)
+# Start a background thread to watch the change stream
+@app.on_event("startup")
+def start_change_stream():
+    threading.Thread(target=watch_change_stream, daemon=True).start()

gamification/imports.py

@@ -0,0 +1,8 @@
+from bson import ObjectId
+from pymongo import MongoClient
+import os
+from typing import List
+from dotenv import load_dotenv
+from datetime import datetime,timedelta
+load_dotenv()
+MONGO_URI = os.getenv("MONGO_URI")

gamification/levelLogic.py

@@ -0,0 +1,111 @@
+# levels
+from gamification.imports import *
+
+from gamification.objects import UserLevel
+
+
+def create_level_func(document:UserLevel,)->bool:
+    """
+    Creates a UserLevel document in the MongoDB collection.
+    
+    :param UserLevel: Actually accepts an Instance of UserLevel and deserializes it here 
+    :param maxPoints: Maximum Amount of points for this level.
+    :param minPoints: Minimum Amount of points for this level.
+    :param levelNumber: Number for this level.
+    :param careerPath: Career Path Special for this level.
+    """
+    db_uri = MONGO_URI
+    db_name = "crayonics"
+    collection_name="Level"
+    client = MongoClient(db_uri)
+    db = client[db_name]
+    collection = db[collection_name]
+    should_proceed= (collection.find_one(document.model_dump()))
+    # Insert the document
+    if should_proceed==None:
+        if document!=None:
+            result = collection.insert_one(document.model_dump(exclude_none=True))
+            return True
+        else:
+            client.close()
+            return False
+    else:
+        # The exact document already exists so it can't be created again
+        return False
+
+
+
+
+def get_all_levels_func() -> List[UserLevel]:
+#    MongoDB URI and configuration
+    db_uri = MONGO_URI
+    db_name = "crayonics"
+    collection_name="Level"
+    client = MongoClient(db_uri)
+    db = client[db_name]
+    collection = db[collection_name]
+    
+    # Fetch all documents from the collection
+    levels_cursor = collection.find()  # This returns a cursor to the documents
+    
+    # Convert the cursor to a list of UserLevel objects
+    levels = [UserLevel(**level) for level in levels_cursor]
+    
+    return levels
+
+
+
+def delete_level_func(level_id,)->bool:
+    db_uri = MONGO_URI
+    db_name = "crayonics"
+    collection_name="Level"
+    client = MongoClient(db_uri)
+    db = client[db_name]
+    collection = db[collection_name]
+    if isinstance(level_id, str):
+        level_id = ObjectId(level_id)
+    result = collection.delete_one(filter={"_id":level_id})
+    if result.acknowledged==True:
+        if result.deleted_count ==0:
+            return False
+        else:
+            return True
+    else:
+        return False
+
+
+
+
+def edit_level_func(level_id, **kwargs):
+    """
+    Edit a UserLevel document in the MongoDB collection.
+    
+    :param level_id: The ObjectId or unique identifier of the UserLevel to edit.
+    :param maxPoints: Maximum Amount of points for this level.
+    :param minPoints: Minimum Amount of points for this level.
+    :param levelNumber: Number for this level.
+    :param careerPath: Career Path Special for this level.
+    """
+    db_uri = MONGO_URI
+    db_name = "crayonics"
+    collection_name="Level"
+    client = MongoClient(db_uri)
+    db = client[db_name]
+    collection = db[collection_name]
+    
+    
+    # Ensure that `level_id` is an ObjectId if using ObjectId as the identifier
+    if isinstance(level_id, str):
+        level_id = ObjectId(level_id)
+
+    # Prepare the update data
+    update_data = {key: value for key, value in kwargs.items() if value is not None}
+    
+    
+    # Perform the update operation in the collection
+    result = collection.update_one(
+        {"_id": level_id},  # Find the document by its unique identifier (ObjectId or other)
+        {"$set": update_data}  # Update the document with the new values
+    )
+    
+    return result.modified_count  

gamification/logic.py

@@ -1,12 +1,9 @@
 
-from gamification.objects import UserFeedback, UserLevel, UserPoints,CustomerInfo,Customer
-from bson import ObjectId
-from pymongo import MongoClient
-import os
-from typing import List
-from dotenv import load_dotenv
-from datetime import datetime,timedelta
-load_dotenv()
+from gamification.objects import PlatformEngagement, UserFeedback, UserLevel, UserPoints,CustomerInfo,Customer,IndividualUserLevel,Points,SimpleIndividualUserLevel
+from gamification.levelLogic import create_level_func,get_all_levels_func,edit_level_func,delete_level_func
+from gamification.imports import *
+from gamification.pointLogic import create_points_func,get_all_simple_points_func,get_all_points_func
+
 
 # Normal Math
 def caculate_rate_change_func(c0,c1,days_ago):
@@ -15,13 +12,13 @@ def caculate_rate_change_func(c0,c1,days_ago):
             # If there are customers now, but no customers initially (c0 is 0), 
             # we consider it as infinite growth or 100% growth
             print("here")
-            return {"daysAgo":days_ago,"totalCustomers": c1, "GrowthRate": 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999, "GrowthRateType": "positive"}
+            return {"daysAgo":days_ago,"totalCustomers": c1, "GrowthRate": 9999999999999999999999999999999999999999999999999999999, "GrowthRateType": "positive"}
         elif c1 == 0:
             # If both c0 and c1 are zero, there is no change
             return {"daysAgo":days_ago,"totalCustomers": c1, "GrowthRate": 0.0, "GrowthRateType": "neutral"}
         else:
             # This case is for when c1 < 0, but it's unlikely in a customer count scenario.
-            return {"daysAgo":days_ago,"totalCustomers": c1, "GrowthRate": -99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999, "GrowthRateType": "negative"}
+            return {"daysAgo":days_ago,"totalCustomers": c1, "GrowthRate": -999999999999999999999999999999999999999999999999999999, "GrowthRateType": "negative"}
     
     elif c1 > c0:
         # Positive growth rate: c1 > c0
@@ -45,117 +42,7 @@ def caculate_rate_change_func(c0,c1,days_ago):
 
 MONGO_URI = os.getenv("MONGO_URI")
 
-    
-# levels
-def create_level_func(document:UserLevel,)->bool:
-    """
-    Creates a UserLevel document in the MongoDB collection.
-    
-    :param UserLevel: Actually accepts an Instance of UserLevel and deserializes it here 
-    :param maxPoints: Maximum Amount of points for this level.
-    :param minPoints: Minimum Amount of points for this level.
-    :param levelNumber: Number for this level.
-    :param careerPath: Career Path Special for this level.
-    """
-    db_uri = MONGO_URI
-    db_name = "crayonics"
-    collection_name="Level"
-    client = MongoClient(db_uri)
-    db = client[db_name]
-    collection = db[collection_name]
-    should_proceed= (collection.find_one(document.model_dump()))
-    # Insert the document
-    if should_proceed==None:
-        if document!=None:
-            result = collection.insert_one(document.model_dump())
-            return True
-        else:
-            client.close()
-            return False
-    else:
-        # The exact document already exists so it can't be created again
-        return False
-
-
-
-
-def get_all_levels_func() -> List[UserLevel]:
-#    MongoDB URI and configuration
-    db_uri = MONGO_URI
-    db_name = "crayonics"
-    collection_name="Level"
-    client = MongoClient(db_uri)
-    db = client[db_name]
-    collection = db[collection_name]
-    
-    # Fetch all documents from the collection
-    levels_cursor = collection.find()  # This returns a cursor to the documents
-    
-    # Convert the cursor to a list of UserLevel objects
-    levels = [UserLevel(**level) for level in levels_cursor]
-    
-    return levels
-
-
-
-def delete_level_func(level_id,)->bool:
-    db_uri = MONGO_URI
-    db_name = "crayonics"
-    collection_name="Level"
-    client = MongoClient(db_uri)
-    db = client[db_name]
-    collection = db[collection_name]
-    if isinstance(level_id, str):
-        level_id = ObjectId(level_id)
-    result = collection.delete_one(filter={"_id":level_id})
-    if result.acknowledged==True:
-        if result.deleted_count ==0:
-            return False
-        else:
-            return True
-    else:
-        return False
-
-
-
-
-def edit_level_func(level_id, **kwargs):
-    """
-    Edit a UserLevel document in the MongoDB collection.
-    
-    :param level_id: The ObjectId or unique identifier of the UserLevel to edit.
-    :param maxPoints: Maximum Amount of points for this level.
-    :param minPoints: Minimum Amount of points for this level.
-    :param levelNumber: Number for this level.
-    :param careerPath: Career Path Special for this level.
-    """
-    db_uri = MONGO_URI
-    db_name = "crayonics"
-    collection_name="Level"
-    client = MongoClient(db_uri)
-    db = client[db_name]
-    collection = db[collection_name]
-    
-    
-    # Ensure that `level_id` is an ObjectId if using ObjectId as the identifier
-    if isinstance(level_id, str):
-        level_id = ObjectId(level_id)
-
-    # Prepare the update data
-    update_data = {key: value for key, value in kwargs.items() if value is not None}
-    
-    
-    # Perform the update operation in the collection
-    result = collection.update_one(
-        {"_id": level_id},  # Find the document by its unique identifier (ObjectId or other)
-        {"$set": update_data}  # Update the document with the new values
-    )
-    
-    return result.modified_count  
-
-
-
-
+# Levels
 
 
 
@@ -163,51 +50,6 @@ def edit_level_func(level_id, **kwargs):
 
 # points
 
-def create_points_func(document:UserPoints)->bool:
-
-    db_uri = MONGO_URI
-    db_name = "crayonics"
-    collection_name="Points"
-    client = MongoClient(db_uri)
-    db = client[db_name]
-    collection = db[collection_name]
-    # Insert the document
-    
-    if document!=None:
-        result = collection.insert_one(document.model_dump())
-        return True
-    else:
-        client.close()
-        return False
-
-
-
-def get_all_points_func() -> List[UserFeedback]:
-    # MongoDB URI and configuration
-    db_uri = MONGO_URI
-    db_name = "crayonics"
-    collection_name="Points"
-    client = MongoClient(db_uri)
-    db = client[db_name]
-    collection = db[collection_name]
-    
-    # Fetch all documents from the collection
-    point_cursor = collection.find()  # This returns a cursor to the documents
-    
-    # Convert the cursor to a list of UserLevel objects
-    points = [UserFeedback(**point) for point in point_cursor]
-    
-    return points
-
-
-
-
-
-
-
-
-
-
 
 # feedback
 def create_feedback_func(document:UserFeedback)->bool:
@@ -219,6 +61,8 @@ def create_feedback_func(document:UserFeedback)->bool:
     collection = db[collection_name]
     # Insert the document
     if document!=None:
+        feedbackPoints= Points(userId=document.userId,platformEngagement=PlatformEngagement(providing_feedback=15))
+        create_points_func(document=feedbackPoints)
         result = collection.insert_one(document.model_dump())
         return True
     else:
@@ -248,7 +92,6 @@ def get_all_feedback_func() -> List[UserFeedback]:
 
 def get_all_customer_info()->List[CustomerInfo]:
     db_uri=MONGO_URI
-    # db_uri = "mongodb+srv://groupcresearchseminar:[email protected]/?retryWrites=true&w=majority&appName=Cluster0"
     db_name = "crayonics"
     collection_name = "users"
     client = MongoClient(db_uri)
@@ -283,3 +126,23 @@ def get_all_customer_info()->List[CustomerInfo]:
     for rate in list_of_rates:
         customer_info.append(CustomerInfo(**rate))
     return customer_info
+
+
+
+
+
+# Leaderboard Logic
+def get_top_30():
+    db_uri=MONGO_URI
+    db_name = "crayonics"
+    collection_name = "LeaderBoard"
+    client = MongoClient(db_uri)
+    db = client[db_name]
+    collection = db[collection_name]
+    sorted_documents = collection.find().sort([("totalpoints", -1), ("lastName", 1)]).limit(30)
+    rankers = [
+        {**r, 'rank': i + 1}  # Add 'rank' to the document with i+1 (1-based index)
+        for i, r in enumerate(sorted_documents)
+    ]
+
+    return rankers

gamification/objects.py

@@ -1,35 +1,217 @@
 from datetime import datetime
-from pydantic import BaseModel
+from pydantic import model_validator, BaseModel
+from typing import List, Optional, Union
 from bson import ObjectId
+
 class UserLevel(BaseModel):
-    maxPoints:int
-    minPoints:int
-    levelName:str
-    careerPath:str
-    levelNumber:int
-        # To convert MongoDB ObjectId to string, if needed
+    _id: Optional[ObjectId]=None  # Make sure _id can be Optional
+    id:Optional[str]=None
+    maxPoints: int
+    minPoints: int
+    levelName: str
+    careerPath: str
+    levelNumber: int
+
+    # To convert MongoDB ObjectId to string
     class Config:
         json_encoders = {
             ObjectId: str
         }
 
+    # Custom validator to handle the ObjectId conversion if needed
+    @model_validator(mode='before')
+    def handle_objectid(cls, values):
+        if '_id' in values and isinstance(values['_id'], ObjectId):
+            values['id'] = str(values['_id'])  # Convert ObjectId to string
+        return values
+    
+
+
 class UserPoints(BaseModel):
-    points:int
-    reason:str
+    pointsId:str
     userId:str
     class Config:
         json_encoders = {
             ObjectId: str
         }
+        
+
+class LearningProgress(BaseModel):
+        course_completion: Optional[int] = None  # Points for course completion
+        module_completion: Optional[int] = None  # Points for module completion
+        daily_learning_streak: Optional[int] = None  # Points for daily learning streak
+        quiz_assessment_completion: Optional[int] = None# Points for quiz/assessment completion
+        passing_score: Optional[int] = None # Points for passing assessments
+        class Config:
+            json_encoders = {
+                ObjectId: str
+            }
+class SkillDevelopment(BaseModel):
+        skill_milestone_achievements: Optional[int] = None # Points for achieving milestones
+        cross_discipline_learning: Optional[int] = None # Points for completing courses in different tech categories
+        practical_project_submission: Optional[int] = None  # Points for submitting a practical project
+        project_peer_review: Optional[int] = None  # Points for reviewing a project
+        class Config:
+            json_encoders = {
+                ObjectId: str
+            }
+class PlatformEngagement(BaseModel):
+        profile_completion: Optional[int] = None  # Points for completing profile
+        connecting_learning_accounts: Optional[int] = None  # Points for connecting learning accounts
+        daily_check_in: Optional[int] = None  # Points for daily check-in
+        community_participation: Optional[int] = None  # Points for community participation
+        providing_feedback: Optional[int] = None # Points for providing feedback
+        class Config:
+            json_encoders = {
+                ObjectId: str
+            }
+            
+            
+class PointMultipliersWeekendWarrior(BaseModel):
+    weekendWarrior: float = 1.5
+    class Config:
+        json_encoders = {
+            ObjectId: str
+        }
+
+class PointMultipliersFocusMode(BaseModel):
+    focusMode: float = 2
+    class Config:
+        json_encoders = {
+            ObjectId: str
+        }
+
+class PointMultipliersSkillGapTargeting(BaseModel):
+    skillGapTargeting: float = 2
+    class Config:
+        json_encoders = {
+            ObjectId: str
+        }
+
+class PointMultipliersTrendingTech(BaseModel):
+    trendingTech: float = 1.5
+
+    class Config:
+        json_encoders = {
+            ObjectId: str
+        }
+
+
+
+
+class Points(BaseModel):
+    userId: str
+    numOfPoints: Optional[float] = None  # Initially set to None
+    learningProgress: Optional[LearningProgress] = None
+    skillDevelopment: Optional[SkillDevelopment] = None
+    platformEngagement: Optional[PlatformEngagement] = None
+    weekendWarrior: Optional[PointMultipliersWeekendWarrior] = None
+    trendingTech: Optional[PointMultipliersTrendingTech]=None
+    skillGapTargeting:Optional[PointMultipliersSkillGapTargeting]=None
+    focusMode:Optional[PointMultipliersFocusMode]=None
+    earnedAt:Optional[datetime]=datetime.now()    
+
+    @model_validator(mode='before')
+    def calculate_num_of_points(cls, values):
+        total_points = 0
+
+        # Add points from LearningProgress
+        learning_progress = values.get('learningProgress')
+        
+        if learning_progress:
+            total_points += sum(filter(None, [
+                learning_progress.course_completion,
+                learning_progress.module_completion,
+                learning_progress.daily_learning_streak,
+                learning_progress.quiz_assessment_completion,
+                learning_progress.passing_score
+            ]))
+
+        # Add points from SkillDevelopment
+        skill_development = values.get('skillDevelopment')
+        if skill_development:
+            total_points += sum(filter(None, [
+                skill_development.skill_milestone_achievements,
+                skill_development.cross_discipline_learning,
+                skill_development.practical_project_submission,
+                skill_development.project_peer_review
+            ]))
+
+        # Add points from PlatformEngagement
+        platform_engagement = values.get('platformEngagement')
+        if platform_engagement:
+            total_points += sum(filter(None, [
+                platform_engagement.profile_completion,
+                platform_engagement.connecting_learning_accounts,
+                platform_engagement.daily_check_in,
+                platform_engagement.community_participation,
+                platform_engagement.providing_feedback
+            ]))
+
+        # Apply multipliers if present
+        PointMultipliersWeekendWarrior = values.get('weekendWarrior')
+        if PointMultipliersWeekendWarrior:
+            total_points *= sum([
+                PointMultipliersWeekendWarrior.weekendWarrior
+            
+            ])   
+        
+        PointMultipliersTrendingTech = values.get('trendingTech')
+        if PointMultipliersTrendingTech:
+            total_points *= sum([
+                PointMultipliersTrendingTech.trendingTech
+            ]) 
+            
+            
+        PointMultipliersSkillGapTargeting = values.get('skillGapTargeting')
+        if PointMultipliersSkillGapTargeting:
+            total_points *= sum([
+                PointMultipliersSkillGapTargeting.skillGapTargeting
+            ]) 
+        
+        
+        
+        PointMultipliersFocusMode = values.get('focusMode')
+        if PointMultipliersFocusMode:
+            total_points *= sum([
+                PointMultipliersFocusMode.focusMode,
+            ]) 
+        
+
+        values['numOfPoints'] = total_points  # Store calculated points
+
+        return values
+
+    class Config:
+        json_encoders = {
+            ObjectId: str
+        }
+
+
+
+
 class UserFeedback(BaseModel):
     userId:str
     feedback:str
     rating:int
+    respondedAt:datetime
     
     class Config:
         json_encoders = {
             ObjectId: str
         }
+      
+
+  
+class Feedback(BaseModel):
+    feedback:str
+    rating:int
+    
+    class Config:
+        json_encoders = {
+            ObjectId: str
+        }
+        
         
 class Customer(BaseModel):
     email:str
@@ -40,6 +222,7 @@ class Customer(BaseModel):
         json_encoders = {
             ObjectId: str
         }
+
         
         
         
@@ -54,12 +237,61 @@ class CustomerInfo(BaseModel):
         }
     
     
+class individualPoints(BaseModel):
+    numOfPoints:int
+    earnedAt:datetime
+    platformEngagement:Optional[dict]=None
+    learningProgress:Optional[dict]=None
+    skillDevelopment:Optional[dict]=None
+    weekendWarrior:Optional[dict]=None
+    trendingTech:Optional[dict]=None
+    skillGapTargeting:Optional[dict]=None
+    focusMode:Optional[dict]=None
+    class Config:
+        json_encoders={
+            ObjectId:str
+        }
+        
+        
 class IndividualUserLevel(BaseModel):
     totalpoints:int
-    userId:str
-    levelId:str
+    levelName:str
+    maxPoints:float
+    minPoints:float
+    individualPoints:List[individualPoints]
+
     class Config:
         json_encoders = {
             ObjectId: str
         }
-    
+    
+    
+class SimpleIndividualUserLevel(BaseModel):
+    totalpoints:int
+    levelName:str
+    maxPoints:float
+    minPoints:float
+
+    class Config:
+        json_encoders = {
+            ObjectId: str
+        }
+    
+    
+class Ranker(BaseModel):
+    firstName:str
+    lastName:str
+    rank:int
+    
+    totalPoints:Optional[float]=None
+    dreamJob:Optional[str]=None
+    class Config:
+        json_encoders = {
+            ObjectId:str
+        }
+    @model_validator(mode='before')
+    def changeValueNames(cls,values):
+        values['totalPoints']= values.get("totalpoints")
+        values['dreamJob']=values.get("careerPath")
+        return values
+        

gamification/pointLogic.py

@@ -0,0 +1,112 @@
+
+from gamification.objects import UserPoints ,SimpleIndividualUserLevel,IndividualUserLevel,UserLevel
+from gamification.imports import *
+from gamification.levelLogic import get_all_levels_func
+
+# utils 
+def get_particular_level(totalPoints,dreamJob)->UserLevel:
+    # query db and get the results of all the level probably re use a function 
+    levels = get_all_levels_func()
+    particularLevel= [level for level in levels if (level.maxPoints >= totalPoints) and (level.minPoints<=totalPoints)and (level.careerPath==dreamJob)]
+    defaulLevel= [level for level in levels if level.levelName=="default" ]
+    if len(particularLevel)>0:
+        return particularLevel
+    return defaulLevel
+
+
+def get_dream_job(userId):
+    db_uri=MONGO_URI
+    db_name = "crayonics"
+    collection_name = "Questionaire"
+    client = MongoClient(db_uri)
+    db = client[db_name]
+    collection = db[collection_name]
+    questionaire_doc = collection.find_one({"userId": userId})
+    if questionaire_doc:
+        return questionaire_doc['dreamRole']
+    else: return False
+
+
+def create_points_func(document:UserPoints)->bool:
+
+    db_uri = MONGO_URI
+    db_name = "crayonics"
+    collection_name="Points"
+    client = MongoClient(db_uri)
+    db = client[db_name]
+    collection = db[collection_name]
+    # Insert the document
+    
+    if document!=None:
+        doc = document.model_dump()
+        doc['earnedAt']=datetime.now()
+        result = collection.insert_one(doc)
+        return True
+    else:
+        client.close()
+        return False
+
+
+
+def get_all_points_func(userId) -> IndividualUserLevel:
+    # MongoDB URI and configuration
+    db_uri = MONGO_URI
+    db_name = "crayonics"
+    collection_name = "Points"
+    client = MongoClient(db_uri)
+    db = client[db_name]
+    collection = db[collection_name]
+    dreamJob = get_dream_job(userId=userId)
+    
+    # Fetch all documents from the collection
+    point_cursor = collection.find({"userId": userId})  # This returns a cursor to the documents
+    
+    # Convert the cursor to a list so we can reuse it
+    points_list = list(point_cursor)
+    
+    # Calculate the total points
+    totalPoints = sum([point['numOfPoints'] for point in points_list])
+    particularLevelInfo = get_particular_level(dreamJob=dreamJob,totalPoints=totalPoints)
+    # Create the individual points list
+    individualPoints = [indpoint for indpoint in points_list]
+    
+    print([pointss for pointss in individualPoints if all(val is not None for val in pointss.values())])
+
+    
+    # Create the IndividualUserLevel object with totalPoints and individualPoints
+    points = IndividualUserLevel(totalpoints=totalPoints,levelName=particularLevelInfo[0].levelName,minPoints=particularLevelInfo[0].minPoints,maxPoints=particularLevelInfo[0].maxPoints, individualPoints=individualPoints)
+    
+    return points
+
+
+
+
+
+def get_all_simple_points_func(userId) -> SimpleIndividualUserLevel:
+    # MongoDB URI and configuration
+    db_uri = MONGO_URI
+    db_name = "crayonics"
+    collection_name = "Points"
+    client = MongoClient(db_uri)
+    db = client[db_name]
+    collection = db[collection_name]
+    dreamJob = get_dream_job(userId=userId)
+    
+    # Fetch all documents from the collection
+    point_cursor = collection.find({"userId": userId})  # This returns a cursor to the documents
+    
+    # Convert the cursor to a list so we can reuse it
+    points_list = list(point_cursor)
+    
+    # Calculate the total points
+    totalPoints = sum([point['numOfPoints'] for point in points_list])
+    particularLevelInfo = get_particular_level(dreamJob=dreamJob,totalPoints=totalPoints)
+    # Create the individual points list
+
+    # Create the IndividualUserLevel object with totalPoints and individualPoints
+    points = SimpleIndividualUserLevel(totalpoints=totalPoints,levelName=particularLevelInfo[0].levelName,minPoints=particularLevelInfo[0].minPoints,maxPoints=particularLevelInfo[0].maxPoints)
+    
+    return points
+
+
+

gamification/routes.py

@@ -1,9 +1,8 @@
-from fastapi import FastAPI,HTTPException
+from fastapi import FastAPI,HTTPException, Header
 from gamification.objects import *
 from gamification.logic import *
-from pydantic import BaseModel
-from typing import Optional
-from bson import ObjectId
+from jwtcoding import decode_jwt
+from tokenManagement import verify_access_token
 
 class EditableUserLevel(BaseModel):
     levelId : str
@@ -25,17 +24,64 @@ gamification = FastAPI()
 
 
 @gamification.post("/create-feedback",tags=["user"])
-def create_feedback(user_feedback:UserFeedback)->bool:
+def create_feedback(feedback:Feedback,authorization: str = Header(...))->bool:
+    
+    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")
+    
     try:
+        user_feedback = UserFeedback(userId=decoded_user_id,respondedAt=datetime.now(), feedback=feedback.feedback,rating=feedback.rating)
         result = create_feedback_func(user_feedback)
-        return {"message":result}
+        return result
     except Exception as e:
         raise HTTPException(status_code=500,detail=f"{e}")
     
+
 @gamification.post("/get-leaderboard",tags=["user"])
 def get_leaderboard_details():
     pass
 
+@gamification.get("/get-advanced-user-points",tags=["user"])
+def get_points(authorization: str = Header(...))->IndividualUserLevel:
+ # 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")
+    
+    # do thing u want here
+    points = get_all_points_func(userId=decoded_user_id)
+    return points.model_dump(exclude_none=True)
+
+
+
+@gamification.get("/get-simple-user-points",tags=["user"])
+def get_points(authorization: str = Header(...))->SimpleIndividualUserLevel:
+ # 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")
+    
+    # do thing u want here
+    points = get_all_simple_points_func(userId=decoded_user_id)
+    return points.model_dump(exclude_none=True)
+
+
+
 @gamification.get("/get-customer-info",tags=["admin"])
 def get_customer_information():
     try:
@@ -55,7 +101,7 @@ def get_feedback()->List[UserFeedback]:
 @gamification.post("/create-level",tags=["admin"])
 def create_level(level_obj:UserLevel)->bool:
     result = create_level_func(document=level_obj)
-    return {"message":result}
+    return result
 
 
 
@@ -79,5 +125,17 @@ def delete_level(levelId)->bool:
     try:
         result = delete_level_func(level_id=levelId)
         return {"message":result}
+    except Exception as e:
+        raise HTTPException(status_code=500,detail=f"{e}")
+    
+    
+@gamification.get("/get-top-30",tags=["user","admin"])
+def get_leaderboard()->List[Ranker]:
+    try:
+        list_of_rankers = []
+        result = get_top_30()
+        list_of_rankers = [Ranker(**ranker) for ranker in result]
+        
+        return list_of_rankers
     except Exception as e:
         raise HTTPException(status_code=500,detail=f"{e}")

streaksManagement.py

@@ -1,6 +1,9 @@
 from pymongo import MongoClient
 from datetime import datetime, timedelta
 from typing import Dict, List, Union
+from gamification.objects import Points,PointMultipliersWeekendWarrior,PlatformEngagement
+from gamification.logic import create_points_func 
+
 
 def get_current_date() -> str:
     # Get the current date and return it in YYYY-MM-DD format
@@ -37,12 +40,19 @@ def save_in_streaks_history(db_uri,document):
         print("added new streak reset record")
         document["streaks_records"] = [{"date_of_streak_reset":current_date,"streak_dates":document["streak_dates"]}]
         document.pop("streak_dates")
+        streakPoints= Points(userId=document['user_id'],platformEngagement=PlatformEngagement(daily_check_in=5))
+        create_points_func(document=streakPoints)
         collection.insert_one(document)
         return True
     else:
         print("added another streak reset record")
         current_record={"date_of_streaks_reset":current_date,"streak_dates":document["streak_dates"]}
-        
+        today = datetime.date(datetime.now())
+        if (today.weekday()>=5):
+            streakPoints= Points(userId=document['user_id'],platformEngagement=PlatformEngagement(daily_check_in=5),weekendWarrior=PointMultipliersWeekendWarrior())
+        else:
+            streakPoints= Points(userId=document['user_id'],platformEngagement=PlatformEngagement(daily_check_in=5))
+        wasCreated= create_points_func(document=streakPoints)
         dates = found_user["streaks_records"] + [current_record]
         collection.update_one(
                 {"user_id": document.get("user_id")},
@@ -57,8 +67,6 @@ def save_in_streaks_history(db_uri,document):
     # finally:
     #     client.close()
     
-   
-
 def streaks_manager(db_uri: str, document: Dict) -> Union[bool, str]:
     """
     Manage user streaks in MongoDB.
@@ -93,9 +101,17 @@ def streaks_manager(db_uri: str, document: Dict) -> Union[bool, str]:
             if is_a_streak:
                 print("its a streak guys")
                 # Extend existing streak
-                if not (current_date== found_user["streak_dates"][-1]):
+                if not ((current_date)== (found_user["streak_dates"][-1])):
                     dates = found_user["streak_dates"] + [current_date]
+                    print("an actual streak")
+                    today = datetime.date(datetime.now())
+                    if (today.weekday()>=5):
+                        streakPoints= Points(userId=document['user_id'],platformEngagement=PlatformEngagement(daily_check_in=5),weekendWarrior=PointMultipliersWeekendWarrior())
+                    else:
+                        streakPoints= Points(userId=document['user_id'],platformEngagement=PlatformEngagement(daily_check_in=5))
+                        create_points_func(document=streakPoints)
                 else:
+
                     dates=found_user["streak_dates"]
                 collection.update_one(
                     {"user_id": document.get("user_id")},

utils.py

@@ -1,8 +1,13 @@
 from bson import ObjectId
-import json
+
+from pymongo import MongoClient
+from typing import Dict, Optional
+
 from datetime import datetime
 import requests
 from pymongo import MongoClient
+from gamification.logic import create_points_func
+from gamification.objects import PlatformEngagement, Points
 from password import *
 from streaksManagement import streaks_manager
 
@@ -176,6 +181,9 @@ def create_questionaire(db_uri: str, db_name: str, collection_name: str, documen
     result= collection.find_one_and_replace(filter={"userId":document.get("userId")},replacement=document)
     print(result)
     if result==None:
+        # give points for the completness of a profile
+        completProfilePoints= Points(userId=document.get('userId'),platformEngagement=PlatformEngagement(profile_completion=50))
+        wasCreated= create_points_func(document=completProfilePoints)
         result = collection.insert_one(document)
         print(result)
         return str(result.inserted_id)
@@ -230,10 +238,6 @@ def login_user(db_uri: str, db_name: str, collection_name: str, document: dict)
     
     
 
-from pymongo import MongoClient
-from bson.objectid import ObjectId
-from typing import Dict, Optional
-
 def user_details_func(db_uri: str, document: Dict) -> Optional[Dict]:
     """
     Retrieve and process user details from MongoDB collections.