Align with Staging

app/main.py

@@ -15,7 +15,7 @@ from openai import OpenAI
 import psycopg2
 from psycopg2 import sql
 import os
-from app.utils import add_to_cache, get_api_key, get_user_info, get_growth_guide_session, pop_cache, print_log, get_user, upload_mementos_to_db, get_user_summary, get_user_life_status, get_life_score
+from app.utils import add_to_cache, get_api_key, get_user_info, get_growth_guide_session, pop_cache, print_log, get_user, upload_mementos_to_db, get_user_summary, get_user_life_status, create_pre_gg_report, get_life_score
 from dotenv import load_dotenv
 import logging.config
 import time
@@ -40,6 +40,20 @@ else:
     for file in os.listdir(os.path.join('users', 'data')):
         os.remove(os.path.join('users', 'data', file))
 
+if not os.path.exists(os.path.join('bookings', 'data')):
+    os.makedirs(os.path.join('bookings', 'data'))
+else:
+    # Folder exists, we want to clear all current booking data
+    for file in os.listdir(os.path.join('bookings', 'data')):
+        os.remove(os.path.join('bookings', 'data', file))
+
+if not os.path.exists(os.path.join('bookings', 'to_upload')):
+    os.makedirs(os.path.join('bookings', 'to_upload'))
+else:
+    # Folder exists, we want to clear all current booking data
+    for file in os.listdir(os.path.join('bookings', 'to_upload')):
+        os.remove(os.path.join('bookings', 'to_upload', file))
+
 if not os.path.exists(os.path.join('users', 'to_upload')):
     os.makedirs(os.path.join('users', 'to_upload'))
 if not os.path.exists(os.path.join('mementos', 'to_upload')):
@@ -254,6 +268,10 @@ class ErrorResponse(BaseModel):
     message: str
     timestamp: datetime = datetime.now()
 
+class BookingItem(BaseModel):
+    booking_id: str
+
+
 @app.get("/ok")
 def ok_endpoint():
     print_log("INFO", "health check endpoint")
@@ -382,6 +400,7 @@ def migrate_user(request: CreateUserItem, api_key: str = Security(get_api_key)):
                 api_response['challenges'] = user.challenges
                 api_response['other_focusses'] = user.other_focusses
                 api_response['scores'] = f"Personal Growth: {user.personal_growth_score} || Career: {user.career_growth_score} || Health/Wellness: {user.health_and_wellness_score} || Relationships: {user.relationship_score} || Mental Health: {user.mental_well_being_score}"
+                api_response['recent_wins'] = user.recent_wins
 
                 add_to_cache(user)
                 pop_cache(user.user_id)
@@ -424,7 +443,7 @@ def get_user_by_id(user_id: str, api_key: str = Security(get_api_key)):
         api_response['other_focusses'] = user.other_focusses
         api_response['reminders'] = user.reminders
         api_response['scores'] = f"Personal Growth: {user.personal_growth_score} || Career: {user.career_growth_score} || Health/Wellness: {user.health_and_wellness_score} || Relationships: {user.relationship_score} || Mental Health: {user.mental_well_being_score}"
-
+        api_response['recent_wins'] = user.recent_wins
 
         return api_response
     except LookupError:
@@ -664,10 +683,12 @@ def chat(request: ChatItem, api_key: str = Security(get_api_key)):
             if recent_run:
                 user.cancel_run(recent_run)
                 response = user.send_message(user.get_recent_message())
-        
-        print_log("INFO",f"Assistant: {response['content']}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-        logger.info(f"Assistant: {response['content']}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-        return {"response": response}
+    
+        finally:
+            print_log("INFO",f"Assistant: {response['content']}", extra={"user_id": request.user_id, "endpoint": "/chat"})
+            logger.info(f"Assistant: {response['content']}", extra={"user_id": request.user_id, "endpoint": "/chat"})
+
+            return {"response": response}
     except LookupError:
         print_log("ERROR",f"User not found for chat: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/chat"})
         logger.error(f"User not found for chat: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/chat"})
@@ -929,12 +950,44 @@ def get_life_status_by_id(user_id: str, api_key: str = Security(get_api_key)):
     
 @app.post("/add_booking_point")
 def add_booking_point_by_user(user_id: str, api_key: str = Security(get_api_key)):
-    user = get_user(user_id)
-    user.add_point_for_booking()
-    return {"response": "ok"}
+    try:    
+        user = get_user(user_id)
+        user.add_point_for_booking()
+        return {"response": "ok"}
+    except Exception as e:
+        print_log("ERROR",f"Error: {str(e)}", extra={"user_id": user_id, "endpoint": "/add_booking_point"}, exc_info=True)
+        logger.error(f"Error: {str(e)}", extra={"user_id": user_id, "endpoint": "/add_booking_point"}, exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        )
 
 @app.post("/add_session_completion_point")
 def add_session_completion_point_by_user(user_id: str, api_key: str = Security(get_api_key)):
-    user = get_user(user_id)
-    user.add_point_for_completing_session()
-    return {"response": "ok"}
+    try:
+        user = get_user(user_id)
+        user.add_point_for_completing_session()
+        return {"response": "ok"}
+
+
+
+    except Exception as e:
+        print_log("ERROR",f"Error: {str(e)}", extra={"user_id": user_id, "endpoint": "/add_session_completion_point"}, exc_info=True)
+        logger.error(f"Error: {str(e)}", extra={"user_id": user_id, "endpoint": "/add_session_completion_point"}, exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        )
+
+@app.post("/create_pre_gg_report")
+def create_pre_gg_by_booking(request: BookingItem, api_key: str = Security(get_api_key)):
+    try:
+        create_pre_gg_report(request.booking_id)
+        return {"response": "ok"}
+    except Exception as e:
+        print_log("ERROR",f"Error: {str(e)}", extra={"booking_id": request.booking_id, "endpoint": "/create_pre_gg_report"}, exc_info=True)
+        logger.error(f"Error: {str(e)}", extra={"booking_id": request.booking_id, "endpoint": "/create_pre_gg_report"}, exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        )

app/user.py

@@ -298,6 +298,7 @@ class User:
         self.mental_well_being_score = 0
         self.health_and_wellness_score = 0
         self.reminders = None
+        self.recent_wins = []
 
         # Read growth_plan.json and store it
         # growth_plan = {"growthPlan": [
@@ -392,6 +393,13 @@ class User:
         self.user_interaction_guidelines = self.generate_user_interaction_guidelines(user_info, client)
         self.conversations = ConversationManager(client, self, asst_id)
 
+    def add_recent_wins(self, wins):
+        if len(self.recent_wins)<5:
+            self.recent_wins.insert(0,wins)
+        else:
+            self.recent_wins.pop()
+            self.recent_wins.insert(0,wins)
+
     def add_life_score_point(self, variable, points_added, notes):
         if variable == 'Personal Growth':
             self.personal_growth_score += points_added
@@ -439,6 +447,7 @@ class User:
         if completed:
             self.update_goal(current_goal, "COMPLETED")
             self.add_life_score_point(variable = goal_area, points_added = 30, notes = "Completing a Goal")
+            self.add_recent_wins(wins = "You have completed your goal!")
 
         if current_goal is None:
             new_goal = UserDataItem(role="assistant", content=goal, area=goal_area, user_id=self.user_id, status="ONGOING", created_at=pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S"), updated_at=pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S"))
@@ -451,6 +460,7 @@ class User:
             new_goal = UserDataItem(role="assistant", content=goal, area=goal_area, user_id=self.user_id, status="ONGOING", created_at=pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S"), updated_at=pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S"))
             self.goal.append(new_goal)
             self.add_life_score_point(variable = goal_area, points_added = 10, notes = "Setting a Goal")
+            self.add_recent_wins(wins = "You have set your first goal!")
         else:
             self.update_goal(current_goal, "ONGOING", content=goal)
 
@@ -832,8 +842,10 @@ class User:
         ## ADD POINT FOR CHANGE DATE
         if self.growth_plan.current()['day'] == 7:
             self.add_life_score_point(variable = self.get_current_goal(full=True).area, points_added = 5, notes = "Reaching Day 7")
+            self.add_recent_wins(wins = "You have reached Day 7 of your growth journey!")
         elif self.growth_plan.current()['day'] == 14:
             self.add_life_score_point(variable = self.get_current_goal(full=True).area, points_added = 10, notes = "Reaching Day 14")
+            self.add_recent_wins(wins = "You have finished your growth journey!")
 
         logger.info(f"Today's action is {action}", extra={"user_id": self.user_id, "endpoint": "user_change_date"})
 
@@ -1073,17 +1085,21 @@ class User:
 
             if (num_of_micro_actions_completed in (1,3,5)) or (num_of_micro_actions_completed % 10 == 0 and num_of_micro_actions_completed != 0):
                 self.add_life_score_point(variable = self.get_current_goal(full=True).area, points_added = 10, notes = f"Completing the {num_of_micro_actions_completed}-th micro-action")
-    
+                self.add_recent_wins(wins = "You have completed a micro action!")
+
     def trigger_deep_reflection_point(self, area_of_deep_reflection):
         if len(area_of_deep_reflection)>0:
             for area in area_of_deep_reflection:
                 self.add_life_score_point(variable = area, points_added = 5, notes = f"Doing a deep reflection about {area}")
+                self.add_recent_wins(wins = f"You have done a deep reflection about your {area}!")
 
     def add_point_for_booking(self):
         self.add_life_score_point(variable = self.get_current_goal(full=True).area, points_added = 5, notes = "Booking a GG session")
+        self.add_recent_wins(wins = "You have booked a Growth Guide session!")
     
     def add_point_for_completing_session(self):
         self.add_life_score_point(variable = self.get_current_goal(full=True).area, points_added = 20, notes = "Completing a GG session")
+        self.add_recent_wins(wins = "You have completed a Growth Guide session!")
         
     def build_ourcoach_report(self, overview, action_plan, gg_session_notes):
         logger.info(f"Building ourcoach report", extra={"user_id": self.user_id, "endpoint": "build_ourcoach_report"})

app/utils.py

@@ -22,8 +22,11 @@ from cachetools import TTLCache
 import threading
 import time
 import uuid
-
 from app.cache import CustomTTLCache, upload_file_to_s3
+import pdfkit
+import PyPDF2
+import secrets
+import string
 
 load_dotenv()
 
@@ -96,31 +99,8 @@ def get_user(user_id):
                 raise ReferenceError(f"User {user_id} pickle still being created")
             raise LookupError(f"User [{user_id}] has not onboarded yet")
 
-def get_life_score(user_id):
-    function_name = get_life_score.__name__
-    logger.info(f"Generating user life score for user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
-
-    # Step 1: Call get_user to get user's info
-    try:
-        user = get_user(user_id)
-        # user_info = user.user_info
-        # user_messages = user.get_messages()
-        ## all the life scores here
-    
-        life_score = {
-        "personal_growth_score": user.personal_growth_score,
-        "career_growth_score": user.career_growth_score,
-        "relationship_score": user.relationship_score,
-        "mental_well_being_score": user.mental_well_being_score,
-        "health_and_wellness_score": user.health_and_wellness_score
-        }
-    except LookupError as e:
-        logger.error(f"Error fetching user data: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-        raise e
-    
-    return life_score
-
-def generate_html(json_data, coach_name='Growth Guide'):
+def generate_html(json_data, coach_name='Growth Guide', booking_id = None):
+    function_name = generate_html.__name__
     data = json_data["pre_growth_guide_session_report"]
     user_overview = data["user_overview"]
     personality_insights = data["personality_insights"]
@@ -290,7 +270,69 @@ def generate_html(json_data, coach_name='Growth Guide'):
     </body>
     </html>
     '''
-    return html_content
+
+    file_path = os.path.join("bookings", "data",f"{booking_id}.html")
+    path_to_upload = os.path.join("bookings", "to_upload",f"{booking_id}.pdf")
+    password = "Ourcoach2024!"
+
+    ## SAVING HTML FILE
+    try:
+        # Open the file in write mode
+        with open(file_path, 'w', encoding='utf-8') as html_file:
+            html_file.write(html_content)
+        logger.info(f"File '{booking_id}.html' has been created successfully.", extra={'booking_id': booking_id, 'endpoint': function_name})
+
+        # Saving as PDF File
+        pdfkit.from_file(file_path, path_to_upload, options={'encoding': 'UTF-8'})
+        logger.info(f"File '{booking_id}.pdf' has been created successfully.", extra={'booking_id': booking_id, 'endpoint': function_name})
+
+        ## ENCRYPTING PDF
+        logger.info(f"Encrypting '{booking_id}.pdf'...", extra={'booking_id': booking_id, 'endpoint': function_name})
+        with open(path_to_upload, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            pdf_writer = PyPDF2.PdfWriter()
+
+            # Add all pages to the writer
+            for page_num in range(len(pdf_reader.pages)):
+                pdf_writer.add_page(pdf_reader.pages[page_num])
+
+            # Encrypt the PDF with the given password
+            pdf_writer.encrypt(password)
+
+            with open(path_to_upload, 'wb') as encrypted_file:
+                pdf_writer.write(encrypted_file)
+        
+        logger.info(f"Succesfully encrypted '{booking_id}.pdf'", extra={'booking_id': booking_id, 'endpoint': function_name})
+        
+    except Exception as e:
+        logger.error(f"An error occurred: {e}", extra={'booking_id': booking_id, 'endpoint': function_name})
+        raise
+    
+    filename = booking_id
+    
+    logger.info(f"Uploading file {filename} to S3", extra={'booking_id': booking_id, 'endpoint': function_name})
+    bucket = 'core-ai-assets'
+    try:
+        if (AWS_ACCESS_KEY and AWS_SECRET_KEY):
+            session = boto3.session.Session(aws_access_key_id=AWS_ACCESS_KEY, aws_secret_access_key=AWS_SECRET_KEY, region_name=REGION)
+        else:
+            session = boto3.session.Session()
+        s3_client = session.client('s3')
+        with open(path_to_upload, "rb") as f:
+            ## Upload to Production Folder
+            s3_client.upload_fileobj(f, bucket, f'staging/pre_gg_reports/{filename}.pdf')
+        logger.info(f"File {filename} uploaded successfully to S3", extra={'booking_id': booking_id, 'endpoint': function_name})
+        
+        # Removing files
+        for file in os.listdir(os.path.join('bookings', 'data')):
+            os.remove(os.path.join('bookings', 'data', file))
+        for file in os.listdir(os.path.join('bookings', 'to_upload')):
+            os.remove(os.path.join('bookings', 'to_upload', file))
+
+        # force_file_move(os.path.join('users', 'to_upload', filename), os.path.join('users', 'data', filename))
+    except (FileNotFoundError, NoCredentialsError, PartialCredentialsError) as e:
+        logger.error(f"S3 upload failed for {filename}: {e}", extra={'booking_id': booking_id, 'endpoint': function_name})
+        raise
 
 def get_user_summary(user_id):
     function_name = get_user_summary.__name__
@@ -769,6 +811,53 @@ def get_user_summary(user_id):
     logger.info(f"User summary generated successfully for user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
     return reports
 
+def create_pre_gg_report(booking_id):
+    function_name = create_pre_gg_report.__name__
+
+    # Get user_id from booking_id
+    try:
+        logger.info(f"Retrieving booking details for {booking_id}", extra={'booking_id': booking_id, 'endpoint': function_name})
+        db_params = {
+            'dbname': 'ourcoach',
+            'user': 'ourcoach',
+            'password': 'hvcTL3kN3pOG5KteT17T',
+            'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
+            'port': '5432'
+        }
+        try:
+            with psycopg2.connect(**db_params) as conn:
+                with conn.cursor() as cursor:
+                    query = sql.SQL("""
+                    select user_id
+                    from {table}
+                    where id = %s
+                    """
+                    ).format(table=sql.Identifier('public', 'booking'))
+                    cursor.execute(query, (booking_id,))
+                    row = cursor.fetchone()
+                    if (row):
+                        colnames = [desc[0] for desc in cursor.description]
+                        booking_data = dict(zip(colnames, row))
+                        ### MODIFY THE FORMAT OF USER DATA
+                        user_id = booking_data['user_id']
+                        logger.info(f"User info retrieved successfully for {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
+                    else:
+                        logger.warning(f"No user info found for {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
+        except psycopg2.Error as e:
+            logger.error(f"Database error while retrieving user info for {user_id}: {e}", extra={'user_id': user_id, 'endpoint': function_name})
+            raise
+        
+        # Run get_user_summary
+        user_report = get_user_summary(user_id)
+
+        # Run generate_html
+        generate_html(user_report, booking_id=booking_id)
+        
+        return True
+    except Exception as e:
+        logger.error(f"An error occured: {e}", extra={'booking_id': booking_id, 'endpoint': function_name})
+        raise
+
 def get_user_life_status(user_id):
     function_name = get_user_life_status.__name__
     logger.info(f"Generating user life status for user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
@@ -787,72 +876,30 @@ def get_user_life_status(user_id):
         [f"{message['role'].capitalize()}: {message['content']}" for message in user_messages]
     )
 
+    logger.info(f"Fetched user data for: {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
     # Build the system prompt according to the provided instructions
     system_prompt = """
     You are an AI assistant that generates a personalized life status report for users based on their profile and chat history. Your task is to analyze the provided user data and produce a JSON output following the specified schema.
 
     **Instructions:**
 
-    1. **Life Score:**
-    - Calculate numerical scores for each of the following areas based on the user's profile and chat history, especially their responses to quantitative questions (e.g., "on a scale of 1 to 5, how do you feel about ..."):
-        - `personal_growth`
-        - `career_growth`
-        - `mental_well_being`
-        - `health_and_wellness`
-        - `relationship`
-    - Each score should be a float between 0 and 1. If an area hasn't been covered in the chat history, assign it a score of 0.
-    - Compute the `overall` score as the average of the non-zero area scores.
-
-    2. **Mantra of the Week:**
+    1. **Mantra of the Week:**
     - Create a very short encouragement quote that encapsulates the user's journey toward achieving their goals.
     - The mantra **MUST** be a single sentence with fewer than 5 words.
 
-    3. **This Week's Focus:**
-    - Identify the top three most important areas for the user from the five key areas:
-        - `personal_growth`
-        - `career_growth`
-        - `mental_well_being`
-        - `health_and_wellness`
-        - `relationship`
-    - For each selected area, provide a concise statement outlining the user's focus in that area.
-
-    4. **Suggested Action Items:**
-    - For the same three areas identified above, suggest concrete and actionable items that the user can undertake to make progress.
-
     **Output Format:**
 
     Produce your response in JSON format adhering to the following schema:
 
     ```json
     {
-        "life_score": {
-            "overall": float,
-            "personal_growth": float,
-            "health_and_wellness": float,
-            "mental_well_being": float,
-            "career_growth": float,
-            "relationship": float
-        },
-        "mantra_of_the_week": str,
-        "this_week_focus": [
-            {"area": str, "focus": str},
-            {"area": str, "focus": str},
-            {"area": str, "focus": str}
-        ],
-        "action_items": [
-            {"area": str, "focus": str},
-            {"area": str, "focus": str},
-            {"area": str, "focus": str}
-        ]
+        "mantra_of_the_week": str
     }
     ```
 
     **Guidelines:**
 
-    - Ensure all numerical values are floats (e.g., 3.0 instead of 3).
     - The `mantra_of_the_week` should be personalized, positive, and encouraging. It **MUST** be a single sentence with fewer than 5 words.
-    - Focus statements and action items should be clear, specific, and tailored to the user's context.
-    - Do not include any additional text or commentary outside of the JSON structure.
     """
 
     # Combine user information and chat history for context
@@ -899,93 +946,13 @@ def get_user_life_status(user_id):
                     "schema": {
                         "type": "object",
                         "properties": {
-                            "life_score": {
-                                "type": "object",
-                                "description": "Numerical life scores across different areas.",
-                                "properties": {
-                                    "overall": {
-                                        "type": "number",
-                                        "description": "Overall life score, average of all area scores."
-                                    },
-                                    "personal_growth": {
-                                        "type": "number",
-                                        "description": "Life score for personal growth."
-                                    },
-                                    "health_and_wellness": {
-                                        "type": "number",
-                                        "description": "Life score for health and wellness."
-                                    },
-                                    "mental_well_being": {
-                                        "type": "number",
-                                        "description": "Life score for mental well-being."
-                                    },
-                                    "career_growth": {
-                                        "type": "number",
-                                        "description": "Life score for career growth."
-                                    },
-                                    "relationship": {
-                                        "type": "number",
-                                        "description": "Life score for relationships."
-                                    }
-                                },
-                                "required": [
-                                    "overall",
-                                    "personal_growth",
-                                    "health_and_wellness",
-                                    "mental_well_being",
-                                    "career_growth",
-                                    "relationship"
-                                ],
-                                "additionalProperties": False
-                            },
                             "mantra_of_the_week": {
                                 "type": "string",
                                 "description": "A very short encouragement quote that encapsulates the user's journey to achieve their goals."
-                            },
-                            "this_week_focus": {
-                                "type": "array",
-                                "description": "List of the user's top 3 most important areas with focus.",
-                                "items": {
-                                    "type": "object",
-                                    "properties": {
-                                        "area": {
-                                            "type": "string",
-                                            "description": "The area of focus (e.g., 'personal_growth')."
-                                        },
-                                        "focus": {
-                                            "type": "string",
-                                            "description": "The focus within that area."
-                                        }
-                                    },
-                                    "required": ["area", "focus"],
-                                    "additionalProperties": False
-                                }
-                            },
-                            "action_items": {
-                                "type": "array",
-                                "description": "List of suggested concrete action items for the user.",
-                                "items": {
-                                    "type": "object",
-                                    "properties": {
-                                        "area": {
-                                            "type": "string",
-                                            "description": "The area of action (e.g., 'personal_growth')."
-                                        },
-                                        "focus": {
-                                            "type": "string",
-                                            "description": "Concrete action items in that area."
-                                        }
-                                    },
-                                    "required": ["area", "focus"],
-                                    "additionalProperties": False
-                                }
                             }
                         },
                         "required": [
-                            "life_score",
-                            "mantra_of_the_week",
-                            "this_week_focus",
-                            "action_items"
+                            "mantra_of_the_week"
                         ],
                         "additionalProperties": False
                     }
@@ -1000,12 +967,34 @@ def get_user_life_status(user_id):
         )
 
         # Get response and convert into dictionary
-        reports = json.loads(response.choices[0].message.content)
+        mantra = json.loads(response.choices[0].message.content)["mantra_of_the_week"]
 
     except Exception as e:
         logger.error(f"OpenAI API call failed: {e}", extra={'user_id': user_id, 'endpoint': function_name})
         raise e
 
+    # Get current life score
+    life_score = {
+        "overall": user.personal_growth_score + user.career_growth_score + user.relationship_score + user.mental_well_being_score + user.health_and_wellness_score,
+        "personal_growth": user.personal_growth_score,
+        "health_and_wellness": user.health_and_wellness_score,
+        "mental_well_being": user.mental_well_being_score,
+        "career_growth": user.career_growth_score,
+        "relationship": user.relationship_score
+    }
+    # Get current goal
+    current_goal = user.goal if not user.goal else user.goal[-1].content
+    # Get life score achievements in list
+    recent_wins = user.recent_wins
+    # Combine everything
+
+    reports = {
+        "life_score": life_score,
+        "mantra_of_the_week": mantra,
+        "goal": current_goal,
+        "recent_wins": recent_wins
+    }
+
     # Step 4: Return the JSON reports
     logger.info(f"User life status generated successfully for user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
     return reports