Update app.py

app.py

@@ -1,396 +1,442 @@
+from flask import Flask, request, jsonify, session, redirect, url_for, render_template, send_file
+from simple_salesforce import Salesforce, SalesforceAuthenticationFailed, SalesforceError
 import os
-import logging
-import requests
 from datetime import datetime
-from flask import Flask, render_template, request, redirect, url_for, session, jsonify, send_file
-from simple_salesforce import Salesforce
 from dotenv import load_dotenv
+import logging
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
-from io import BytesIO
+import io
+import tempfile
 
 # Load environment variables
 load_dotenv()
 
 # Configure logging
 logging.basicConfig(
-    filename='app.log',
     level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('app.log'),
+        logging.StreamHandler()
+    ]
 )
+logger = logging.getLogger(__name__)
 
 app = Flask(__name__)
-app.secret_key = os.getenv('FLASK_SECRET_KEY', 'default-secret-key')
-
-# Salesforce connection
-sf = None
-try:
-    sf = Salesforce(
-        username=os.getenv('SALESFORCE_USERNAME'),
-        password=os.getenv('SALESFORCE_PASSWORD'),
-        security_token=os.getenv('SALESFORCE_SECURITY_TOKEN'),
-        domain=os.getenv('SALESFORCE_DOMAIN', 'login')
-    )
-    # Verify connection by querying Salesforce metadata
-    user_info = sf.query("SELECT Id, Name FROM User WHERE Username = '{}'".format(os.getenv('SALESFORCE_USERNAME')))
-    if user_info['totalSize'] > 0:
-        logging.info(f"Successfully connected to Salesforce org. User: {user_info['records'][0]['Name']}")
-    else:
-        logging.error("Salesforce connection established, but user not found in org")
-except Exception as e:
-    logging.error(f"Failed to connect to Salesforce: {str(e)}")
-    sf = None
-
-# Hugging Face API configuration
-HUGGING_FACE_API_TOKEN = os.getenv('HUGGING_FACE_API_TOKEN')
-HUGGING_FACE_API_URL = os.getenv('HUGGING_FACE_API_URL')
-HUGGING_FACE_HEADERS = {
-    'Authorization': f'Bearer {HUGGING_FACE_API_TOKEN}',
-    'Content-Type': 'application/json'
+app.secret_key = os.getenv('FLASK_SECRET_KEY', 'your-secret-key')
+
+# Salesforce mock data for guest users
+MOCK_DATA = {
+    "supervisor_name": "GUEST",
+    "project_id": "PROJ_001",
+    "daily_checklist": "Inspect safety equipment\nReview team assignments\nCheck project timeline",
+    "suggested_tips": "Prioritize safety checks\nCommunicate clearly with the team\nMonitor resource usage",
+    "reflection_log": "",
+    "engagement_score": 85,
+    "kpi_flag": False,
+    "download_link": "",
+    "last_login": str(datetime.now())
 }
 
-def generate_coaching_output_with_hf(data):
+def get_salesforce_connection():
+    """Establish a Salesforce connection with error handling."""
     try:
-        prompt = (
-            f"Generate a daily checklist and focus tips for a supervisor with the following details:\n"
-            f"Project ID: {data.get('project_id', 'N/A')}\n"
-            f"Engagement Score: {data.get('engagement_score', 0)}%\n"
-            f"KPI Flag: {'Active' if data.get('kpi_flag', False) else 'Inactive'}\n"
-            f"Reflection Log: {data.get('reflection_log', 'No reflections yet.')}\n\n"
-            "Provide a checklist (3 items) and focus tips (3 items) in a concise format."
+        sf = Salesforce(
+            username=os.getenv('SALESFORCE_USERNAME'),
+            password=os.getenv('SALESFORCE_PASSWORD'),
+            security_token=os.getenv('SALESFORCE_SECURITY_TOKEN'),
+            domain=os.getenv('SALESFORCE_DOMAIN', 'test')  # 'login' for production
         )
-        payload = {
-            "inputs": prompt,
-            "parameters": {"max_length": 150, "num_return_sequences": 1}
-        }
-        response = requests.post(HUGGING_FACE_API_URL, headers=HUGGING_FACE_HEADERS, json=payload)
-        response.raise_for_status()
-        result = response.json()
-        generated_text = result[0]['generated_text'].split('\n')
-
-        checklist = []
-        tips = []
-        is_checklist = True
-        for line in generated_text:
-            line = line.strip()
-            if not line:
-                continue
-            if "focus tips" in line.lower():
-                is_checklist = False
-                continue
-            if is_checklist and len(checklist) < 3:
-                checklist.append(line.replace('- ', '').strip())
-            elif not is_checklist and len(tips) < 3:
-                tips.append(line.replace('- ', '').strip())
-
-        # Fallback if model output is incomplete
-        while len(checklist) < 3:
-            checklist.append(f"Placeholder Task {len(checklist) + 1}")
-        while len(tips) < 3:
-            tips.append(f"Placeholder Tip {len(tips) + 1}")
-
-        return {'checklist': checklist, 'tips': tips}
+        logger.info("Successfully connected to Salesforce")
+        return sf
+    except SalesforceAuthenticationFailed as e:
+        logger.error(f"Salesforce authentication failed: {str(e)}")
+        raise Exception("Salesforce authentication failed. Check your credentials.")
     except Exception as e:
-        logging.error(f"Error generating coaching output with Hugging Face API: {str(e)}")
-        return {
-            'checklist': ['Review project milestones', 'Conduct team check-in', 'Update resource allocation'],
-            'tips': ['Set clear deadlines', 'Encourage team feedback', 'Monitor progress daily']
-        }
+        logger.error(f"Error connecting to Salesforce: {str(e)}")
+        raise Exception("Unable to connect to Salesforce. Please try again later.")
 
 @app.route('/')
-def home():
+def index():
     if 'supervisor_name' not in session:
-        logging.info("User not logged in, redirecting to login page")
-        return redirect(url_for('login'))
-    logging.info(f"User {session['supervisor_name']} accessed the dashboard")
+        logger.info("User not logged in, redirecting to login page")
+        return redirect(url_for('login_page'))
     return render_template('index.html')
 
-@app.route('/login', methods=['GET', 'POST'])
-def login():
-    if request.method == 'POST':
-        username = request.form['username']
-        password = request.form['password']
-        logging.info(f"Login attempt for username: {username}")
-
-        if username == 'GUEST':
-            session['supervisor_name'] = 'GUEST'
-            logging.info("Guest login successful")
-            return redirect(url_for('home'))
-
-        if not sf:
-            logging.error("Salesforce connection not available during login")
-            return render_template('login.html', error="Salesforce connection unavailable")
-
-        try:
-            query = f"SELECT Id, Name, Password__c FROM Supervisor_AI_Coaching__c WHERE Name = '{username}'"
-            result = sf.query(query)
-            logging.info(f"Queried Salesforce for user: {username}")
-
-            if result['totalSize'] == 0:
-                logging.warning(f"User {username} not found in Salesforce")
-                return render_template('login.html', error="Invalid username or password")
-
-            user = result['records'][0]
-            if user['Password__c'] == password:
-                session['supervisor_name'] = user['Name']
-                sf.Supervisor_AI_Coaching__c.update(user['Id'], {'Last_Login__c': datetime.utcnow().isoformat()})
-                logging.info(f"User {username} logged in successfully")
-                return redirect(url_for('home'))
-            else:
-                logging.warning(f"Invalid password for user {username}")
-                return render_template('login.html', error="Invalid username or password")
-        except Exception as e:
-            logging.error(f"Error during login for {username}: {str(e)}")
-            return render_template('login.html', error="An error occurred during login")
+@app.route('/login', methods=['GET'])
+def login_page():
     return render_template('login.html')
 
-@app.route('/signup', methods=['GET', 'POST'])
-def signup():
-    if request.method == 'POST':
-        username = request.form['username']
-        password = request.form['password']
-        project_id = request.form['project_id']
-        engagement_score = float(request.form['engagement_score'])
-        kpi_flag = request.form.get('kpi_flag') == 'on'
-        logging.info(f"Signup attempt for username: {username}")
-
-        if not sf:
-            logging.error("Salesforce connection not available during signup")
-            return render_template('signup.html', error="Salesforce connection unavailable")
-
-        try:
-            existing_user = sf.query(f"SELECT Id FROM Supervisor_AI_Coaching__c WHERE Name = '{username}'")
-            if existing_user['totalSize'] > 0:
-                logging.warning(f"Signup failed: Username {username} already exists")
-                return render_template('signup.html', error="Username already exists")
-
-            sf.Supervisor_AI_Coaching__c.create({
-                'Name': username,
-                'Password__c': password,
-                'Project_ID__c': project_id,
-                'Engagement_Score__c': engagement_score,
-                'KPI_Flag__c': kpi_flag
-            })
-            logging.info(f"User {username} signed up successfully")
-            return redirect(url_for('login'))
-        except Exception as e:
-            logging.error(f"Error during signup for {username}: {str(e)}")
-            return render_template('signup.html', error="An error occurred during signup")
+@app.route('/signup', methods=['GET'])
+def signup_page():
     return render_template('signup.html')
 
+@app.route('/login', methods=['POST'])
+def login():
+    data = request.get_json()
+    username = data.get('username')  # Now using Name field
+    password = data.get('password')
+
+    if username == 'GUEST':
+        session['supervisor_name'] = 'GUEST'
+        logger.info("Guest login successful")
+        return jsonify({"status": "success", "message": "Logged in as guest"})
+
+    try:
+        sf = get_salesforce_connection()
+        # Query Supervisor_AI_Coaching__c for Name and Password__c
+        query = f"SELECT Id, Name, Password__c FROM Supervisor_AI_Coaching__c WHERE Name = '{username}' LIMIT 1"
+        result = sf.query(query)
+        if not result['records']:
+            logger.warning(f"Invalid username: {username}")
+            return jsonify({"status": "error", "message": "Invalid username"}), 401
+
+        record = result['records'][0]
+        stored_password = record['Password__c']
+        if stored_password != password:
+            logger.warning(f"Invalid password for username: {username}")
+            return jsonify({"status": "error", "message": "Invalid password"}), 401
+
+        session['supervisor_name'] = username
+        logger.info(f"Login successful for {username}")
+        return jsonify({"status": "success", "message": "Login successful"})
+    except Exception as e:
+        logger.error(f"Login error: {str(e)}")
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+@app.route('/signup', methods=['POST'])
+def signup():
+    data = request.get_json()
+    username = data.get('username')  # Name field
+    password = data.get('password')  # Password__c field
+    project_id = data.get('project_id', 'PROJ_001')  # Project_ID__c
+    engagement_score = float(data.get('engagement_score', 85))  # Engagement_Score__c
+    kpi_flag = data.get('kpi_flag', False)  # KPI_Flag__c
+
+    if not username or not password:
+        logger.warning("Signup failed: Username and password are required")
+        return jsonify({"status": "error", "message": "Username and password are required"}), 400
+
+    try:
+        sf = get_salesforce_connection()
+        # Check if username already exists
+        query = f"SELECT Id FROM Supervisor_AI_Coaching__c WHERE Name = '{username}' LIMIT 1"
+        result = sf.query(query)
+        if result['records']:
+            logger.warning(f"Signup failed: Username {username} already exists")
+            return jsonify({"status": "error", "message": "Username already exists"}), 400
+
+        # Create new Supervisor_AI_Coaching__c record
+        new_record = {
+            'Name': username,
+            'Password__c': password,
+            'Project_ID__c': project_id,
+            'Engagement_Score__c': engagement_score,
+            'KPI_Flag__c': kpi_flag,
+            'Daily_Checklist__c': '',
+            'Suggested_Tips__c': '',
+            'Reflection_Log__c': '',
+            'Download_Link__c': ''
+        }
+        sf.Supervisor_AI_Coaching__c.create(new_record)
+        logger.info(f"Signup successful for {username}")
+
+        # Automatically log in the user after signup
+        session['supervisor_name'] = username
+        return jsonify({"status": "success", "message": "Signup successful, you are now logged in"})
+    except SalesforceError as e:
+        logger.error(f"Salesforce API error during signup: {str(e)}")
+        return jsonify({"status": "error", "message": "Salesforce API error. Please try again later."}), 500
+    except Exception as e:
+        logger.error(f"Signup error: {str(e)}")
+        return jsonify({"status": "error", "message": str(e)}), 500
+
 @app.route('/logout', methods=['POST'])
 def logout():
-    username = session.get('supervisor_name', 'Unknown')
+    supervisor_name = session.get('supervisor_name', 'Unknown')
     session.pop('supervisor_name', None)
-    logging.info(f"User {username} logged out")
-    return jsonify({'status': 'success', 'message': 'Logged out successfully'})
+    logger.info(f"User {supervisor_name} logged out")
+    return jsonify({"status": "success", "message": "Logged out successfully"})
 
 @app.route('/get_supervisor_data')
 def get_supervisor_data():
     supervisor_name = session.get('supervisor_name', 'GUEST')
-    logging.info(f"Fetching supervisor data for: {supervisor_name}")
-
     if supervisor_name == 'GUEST':
-        logging.info("Returning default data for GUEST user")
-        return jsonify({
-            'status': 'success',
-            'data': {
-                'supervisor_name': 'GUEST',
-                'daily_checklist': 'Sample Task 1\nSample Task 2',
-                'suggested_tips': 'Tip 1\nTip 2\nTip 3',
-                'reflection_log': '',
-                'engagement_score': 50,
-                'kpi_flag': False,
-                'download_link': ''
-            }
-        })
-
-    if not sf:
-        logging.error("Salesforce connection not available for get_supervisor_data")
-        return jsonify({'status': 'error', 'message': 'Salesforce connection unavailable'}), 500
+        logger.info("Returning mock data for guest user")
+        return jsonify({"status": "success", "data": MOCK_DATA})
 
     try:
+        sf = get_salesforce_connection()
         query = f"""
-            SELECT Name, Project_ID__c, Daily_Checklist__c, Suggested_Tips__c, 
-                   Reflection_Log__c, Engagement_Score__c, KPI_Flag__c, 
-                   Download_Link__c, Last_Login__c
-            FROM Supervisor_AI_Coaching__c 
+            SELECT Name, Project_ID__c, Daily_Checklist__c, Suggested_Tips__c,
+                   Reflection_Log__c, Engagement_Score__c, KPI_Flag__c, Download_Link__c
+            FROM Supervisor_AI_Coaching__c
             WHERE Name = '{supervisor_name}'
+            LIMIT 1
         """
         result = sf.query(query)
-        logging.info(f"Queried Salesforce for supervisor data: {supervisor_name}")
-
-        if result['totalSize'] == 0:
-            logging.warning(f"No data found for user {supervisor_name}")
-            return jsonify({'status': 'error', 'message': 'User not found'})
 
-        record = result['records'][0]
-        data = {
-            'supervisor_name': record['Name'],
-            'project_id': record['Project_ID__c'],
-            'daily_checklist': record['Daily_Checklist__c'] or '',
-            'suggested_tips': record['Suggested_Tips__c'] or '',
-            'reflection_log': record['Reflection_Log__c'] or '',
-            'engagement_score': record['Engagement_Score__c'] or 0,
-            'kpi_flag': record['KPI_Flag__c'] or False,
-            'download_link': record['Download_Link__c'] or '',
-            'last_login': record['Last_Login__c']
-        }
-        logging.info(f"Successfully fetched supervisor data for {supervisor_name}")
-        return jsonify({'status': 'success', 'data': data})
+        if result['records']:
+            record = result['records'][0]
+            data = {
+                "supervisor_name": record['Name'],
+                "project_id": record['Project_ID__c'],
+                "daily_checklist": record['Daily_Checklist__c'] or "",
+                "suggested_tips": record['Suggested_Tips__c'] or "",
+                "reflection_log": record['Reflection_Log__c'] or "",
+                "engagement_score": record['Engagement_Score__c'] or 0,
+                "kpi_flag": record['KPI_Flag__c'],
+                "download_link": record['Download_Link__c'] or "",
+                "last_login": str(datetime.now())
+            }
+            logger.info(f"Fetched data for supervisor {supervisor_name}")
+            return jsonify({"status": "success", "data": data})
+        else:
+            logger.warning(f"No data found for supervisor {supervisor_name}")
+            return jsonify({"status": "error", "message": "No data found for this supervisor"})
+    except SalesforceError as e:
+        logger.error(f"Salesforce API error while fetching data: {str(e)}")
+        return jsonify({"status": "error", "message": "Salesforce API error. Please try again later."}), 500
     except Exception as e:
-        logging.error(f"Error fetching supervisor data for {supervisor_name}: {str(e)}")
-        return jsonify({'status': 'error', 'message': 'Error fetching data'})
+        logger.error(f"Error fetching supervisor data: {str(e)}")
+        return jsonify({"status": "error", "message": str(e)}), 500
 
 @app.route('/submit_reflection', methods=['POST'])
 def submit_reflection():
     supervisor_name = session.get('supervisor_name', 'GUEST')
-    logging.info(f"Submitting reflection for user: {supervisor_name}")
-
     if supervisor_name == 'GUEST':
-        logging.warning("Reflection submission not allowed for GUEST user")
-        return jsonify({'status': 'error', 'message': 'Guest users cannot submit reflections'})
+        MOCK_DATA['reflection_log'] = request.get_json().get('reflection')
+        logger.info("Reflection submitted for guest user")
+        return jsonify({"status": "success", "message": "Reflection submitted successfully (guest mode)"})
 
-    if not sf:
-        logging.error("Salesforce connection not available for submit_reflection")
-        return jsonify({'status': 'error', 'message': 'Salesforce connection unavailable'}), 500
-
-    reflection = request.json.get('reflection')
-    if not reflection:
-        logging.warning(f"Empty reflection submitted by {supervisor_name}")
-        return jsonify({'status': 'error', 'message': 'Reflection cannot be empty'})
+    data = request.get_json()
+    reflection = data.get('reflection')
 
     try:
-        query = f"SELECT Id FROM Supervisor_AI_Coaching__c WHERE Name = '{supervisor_name}'"
+        sf = get_salesforce_connection()
+        query = f"SELECT Id FROM Supervisor_AI_Coaching__c WHERE Name = '{supervisor_name}' LIMIT 1"
         result = sf.query(query)
-        if result['totalSize'] == 0:
-            logging.warning(f"User {supervisor_name} not found for reflection submission")
-            return jsonify({'status': 'error', 'message': 'User not found'})
+        if not result['records']:
+            logger.warning(f"No record found for supervisor {supervisor_name}")
+            return jsonify({"status": "error", "message": "No record found for this supervisor"}), 404
 
         record_id = result['records'][0]['Id']
         sf.Supervisor_AI_Coaching__c.update(record_id, {'Reflection_Log__c': reflection})
-        logging.info(f"Reflection submitted successfully for {supervisor_name}")
-        return jsonify({'status': 'success', 'message': 'Reflection submitted successfully'})
+        logger.info(f"Reflection updated for supervisor {supervisor_name}")
+        return jsonify({"status": "success", "message": "Reflection submitted successfully"})
+    except SalesforceError as e:
+        logger.error(f"Salesforce API error while submitting reflection: {str(e)}")
+        return jsonify({"status": "error", "message": "Salesforce API error. Please try again later."}), 500
     except Exception as e:
-        logging.error(f"Error submitting reflection for {supervisor_name}: {str(e)}")
-        return jsonify({'status': 'error', 'message': 'Error submitting reflection'})
+        logger.error(f"Error submitting reflection: {str(e)}")
+        return jsonify({"status": "error", "message": str(e)}), 500
 
 @app.route('/generate', methods=['POST'])
-def generate_coaching():
+def generate():
     supervisor_name = session.get('supervisor_name', 'GUEST')
-    logging.info(f"Generating coaching output for user: {supervisor_name}")
+    data = request.get_json()
+
+    # Generate checklist and tips (simplified logic)
+    checklist = [
+        "Inspect safety equipment",
+        "Review team assignments",
+        "Check project timeline"
+    ]
+    tips = [
+        "Prioritize safety checks",
+        "Communicate clearly with the team",
+        "Monitor resource usage"
+    ]
 
-    if not sf:
-        logging.error("Salesforce connection not available for generate_coaching")
-        return jsonify({'status': 'error', 'message': 'Salesforce connection unavailable'}), 500
+    if supervisor_name == 'GUEST':
+        MOCK_DATA['daily_checklist'] = '\n'.join(checklist)
+        MOCK_DATA['suggested_tips'] = '\n'.join(tips)
+        logger.info("Generated coaching output for guest user")
+        return jsonify({
+            "status": "success",
+            "output": {
+                "checklist": checklist,
+                "tips": tips
+            }
+        })
 
     try:
-        # Fetch supervisor data to pass to Hugging Face API
-        data = request.json
-        output = generate_coaching_output_with_hf(data)
-
-        if supervisor_name != 'GUEST':
-            query = f"SELECT Id FROM Supervisor_AI_Coaching__c WHERE Name = '{supervisor_name}'"
-            result = sf.query(query)
-            if result['totalSize'] == 0:
-                logging.warning(f"User {supervisor_name} not found for coaching generation")
-                return jsonify({'status': 'error', 'message': 'User not found'})
-
-            record_id = result['records'][0]['Id']
-            sf.Supervisor_AI_Coaching__c.update(record_id, {
-                'Daily_Checklist__c': '\n'.join(output['checklist']),
-                'Suggested_Tips__c': '\n'.join(output['tips'])
-            })
-            logging.info(f"Coaching output updated in Salesforce for {supervisor_name}")
-
-        logging.info(f"Coaching output generated for {supervisor_name}")
-        return jsonify({'status': 'success', 'output': output})
+        sf = get_salesforce_connection()
+        query = f"SELECT Id FROM Supervisor_AI_Coaching__c WHERE Name = '{supervisor_name}' LIMIT 1"
+        result = sf.query(query)
+        if not result['records']:
+            logger.warning(f"No record found for supervisor {supervisor_name}")
+            return jsonify({"status": "error", "message": "No record found for this supervisor"}), 404
+
+        record_id = result['records'][0]['Id']
+        sf.Supervisor_AI_Coaching__c.update(record_id, {
+            'Daily_Checklist__c': '\n'.join(checklist),
+            'Suggested_Tips__c': '\n'.join(tips)
+        })
+        logger.info(f"Generated and updated coaching output for supervisor {supervisor_name}")
+        return jsonify({
+            "status": "success",
+            "output": {
+                "checklist": checklist,
+                "tips": tips
+            }
+        })
+    except SalesforceError as e:
+        logger.error(f"Salesforce API error while generating output: {str(e)}")
+        return jsonify({"status": "error", "message": "Salesforce API error. Please try again later."}), 500
     except Exception as e:
-        logging.error(f"Error generating coaching output for {supervisor_name}: {str(e)}")
-        return jsonify({'status': 'error', 'message': 'Error generating coaching output'})
+        logger.error(f"Error generating coaching output: {str(e)}")
+        return jsonify({"status": "error", "message": str(e)}), 500
 
-@app.route('/download_pdf')
+def generate_pdf_summary(data):
+    """Generate a PDF summary and return the file path."""
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf', dir='/tmp') as tmp_file:
+            pdf_path = tmp_file.name
+            c = canvas.Canvas(pdf_path, pagesize=letter)
+            width, height = letter
+
+            # Title
+            c.setFont("Helvetica-Bold", 16)
+            c.drawString(50, height - 50, "Supervisor AI Coaching Summary")
+
+            # Supervisor Data
+            c.setFont("Helvetica", 12)
+            y_position = height - 100
+            c.drawString(50, y_position, f"Supervisor Name: {data.get('supervisor_name', 'N/A')}")
+            y_position -= 20
+            c.drawString(50, y_position, f"Project ID: {data.get('project_id', 'N/A')}")
+            y_position -= 20
+            c.drawString(50, y_position, f"Last Login: {data.get('last_login', 'N/A')}")
+            y_position -= 40
+
+            # Daily Checklist
+            c.setFont("Helvetica-Bold", 14)
+            c.drawString(50, y_position, "Daily Checklist")
+            c.setFont("Helvetica", 12)
+            y_position -= 20
+            checklist = data.get('daily_checklist', '').split('\n')
+            for item in checklist:
+                if item.strip():
+                    c.drawString(70, y_position, f"- {item}")
+                    y_position -= 20
+                    if y_position < 50:
+                        c.showPage()
+                        y_position = height - 50
+
+            # Suggested Tips
+            y_position -= 20
+            c.setFont("Helvetica-Bold", 14)
+            c.drawString(50, y_position, "Suggested Tips")
+            c.setFont("Helvetica", 12)
+            y_position -= 20
+            tips = data.get('suggested_tips', '').split('\n')
+            for tip in tips:
+                if tip.strip():
+                    c.drawString(70, y_position, f"- {tip}")
+                    y_position -= 20
+                    if y_position < 50:
+                        c.showPage()
+                        y_position = height - 50
+
+            # Reflection Log
+            y_position -= 20
+            c.setFont("Helvetica-Bold", 14)
+            c.drawString(50, y_position, "Reflection Log")
+            c.setFont("Helvetica", 12)
+            y_position -= 20
+            reflection = data.get('reflection_log', 'No reflection available.')
+            lines = reflection.split('\n')
+            for line in lines:
+                c.drawString(70, y_position, line)
+                y_position -= 20
+                if y_position < 50:
+                    c.showPage()
+                    y_position = height - 50
+
+            # KPIs
+            y_position -= 20
+            c.setFont("Helvetica-Bold", 14)
+            c.drawString(50, y_position, "KPIs")
+            c.setFont("Helvetica", 12)
+            y_position -= 20
+            c.drawString(70, y_position, f"Engagement Score: {data.get('engagement_score', 0)}%")
+            y_position -= 20
+            c.drawString(70, y_position, f"KPI Flag: {'Active' if data.get('kpi_flag', False) else 'Inactive'}")
+            y_position -= 20
+
+            c.save()
+            logger.info(f"Generated PDF at {pdf_path}")
+            return pdf_path
+    except Exception as e:
+        logger.error(f"Error generating PDF: {str(e)}")
+        raise
+
+@app.route('/download_pdf', methods=['GET'])
 def download_pdf():
     supervisor_name = session.get('supervisor_name', 'GUEST')
-    logging.info(f"Generating PDF for user: {supervisor_name}")
-
-    if not sf:
-        logging.error("Salesforce connection not available for download_pdf")
-        return jsonify({'status': 'error', 'message': 'Salesforce connection unavailable'}), 500
+    if supervisor_name == 'GUEST':
+        logger.info("Download not available for guest user")
+        return jsonify({"status": "success", "message": "Download not available in guest mode"})
 
     try:
+        sf = get_salesforce_connection()
         query = f"""
-            SELECT Name, Project_ID__c, Daily_Checklist__c, Suggested_Tips__c, 
-                   Reflection_Log__c, Engagement_Score__c, KPI_Flag__c
-            FROM Supervisor_AI_Coaching__c 
+            SELECT Id, Name, Project_ID__c, Daily_Checklist__c, Suggested_Tips__c,
+                   Reflection_Log__c, Engagement_Score__c, KPI_Flag__c, Download_Link__c
+            FROM Supervisor_AI_Coaching__c
             WHERE Name = '{supervisor_name}'
+            LIMIT 1
         """
         result = sf.query(query)
-        if result['totalSize'] == 0:
-            logging.warning(f"User {supervisor_name} not found for PDF generation")
-            return jsonify({'status': 'error', 'message': 'User not found'})
+        if not result['records']:
+            logger.warning(f"No record found for supervisor {supervisor_name}")
+            return jsonify({"status": "error", "message": "No record found for this supervisor"}), 404
 
         record = result['records'][0]
+        record_id = record['Id']
+        data = {
+            "supervisor_name": record['Name'],
+            "project_id": record['Project_ID__c'],
+            "daily_checklist": record['Daily_Checklist__c'] or "",
+            "suggested_tips": record['Suggested_Tips__c'] or "",
+            "reflection_log": record['Reflection_Log__c'] or "",
+            "engagement_score": record['Engagement_Score__c'] or 0,
+            "kpi_flag": record['KPI_Flag__c'],
+            "download_link": record['Download_Link__c'] or "",
+            "last_login": str(datetime.now())
+        }
 
-        buffer = BytesIO()
-        c = canvas.Canvas(buffer, pagesize=letter)
-        c.setFont("Helvetica", 12)
-
-        y = 750
-        c.drawString(100, y, f"Supervisor Report for {record['Name']}")
-        y -= 30
-        c.drawString(100, y, f"Project ID: {record['Project_ID__c'] or 'N/A'}")
-        y -= 20
-        c.drawString(100, y, f"Engagement Score: {record['Engagement_Score__c'] or 0}%")
-        y -= 20
-        c.drawString(100, y, f"KPI Flag: {'Active' if record['KPI_Flag__c'] else 'Inactive'}")
-        y -= 30
-
-        c.drawString(100, y, "Daily Checklist:")
-        y -= 20
-        checklist = (record['Daily_Checklist__c'] or '').split('\n')
-        for item in checklist:
-            if item.strip():
-                c.drawString(120, y, f"- {item}")
-                y -= 15
-
-        y -= 20
-        c.drawString(100, y, "Suggested Tips:")
-        y -= 20
-        tips = (record['Suggested_Tips__c'] or '').split('\n')
-        for tip in tips:
-            if tip.strip():
-                c.drawString(120, y, f"- {tip}")
-                y -= 15
-
-        y -= 20
-        c.drawString(100, y, "Reflection Log:")
-        y -= 20
-        reflection = record['Reflection_Log__c'] or 'No reflections yet.'
-        c.drawString(120, y, reflection[:80])
-        y -= 15
-        if len(reflection) > 80:
-            c.drawString(120, y, reflection[80:160])
-            y -= 15
-
-        c.showPage()
-        c.save()
-        buffer.seek(0)
-
-        if supervisor_name != 'GUEST':
-            record_id = result['records'][0]['Id']
-            sf.Supervisor_AI_Coaching__c.update(record_id, {
-                'Download_Link__c': 'https://example.com/report.pdf'
-            })
-            logging.info(f"Updated Download_Link__c for {supervisor_name}")
-
-        logging.info(f"PDF generated successfully for {supervisor_name}")
-        return send_file(buffer, as_attachment=True, download_name=f'supervisor_report_{supervisor_name}.pdf', mimetype='application/pdf')
+        # Generate PDF
+        pdf_path = generate_pdf_summary(data)
+        
+        # Placeholder for Download_Link__c (requires actual storage solution in production)
+        download_link = "https://example.com/report.pdf"
+        sf.Supervisor_AI_Coaching__c.update(record_id, {'Download_Link__c': download_link})
+        logger.info(f"Updated Download_Link__c for supervisor {supervisor_name}")
+
+        # Serve the PDF file
+        return send_file(
+            pdf_path,
+            as_attachment=True,
+            download_name=f"supervisor_report_{supervisor_name}.pdf",
+            mimetype='application/pdf'
+        )
+    except SalesforceError as e:
+        logger.error(f"Salesforce API error while downloading PDF: {str(e)}")
+        return jsonify({"status": "error", "message": "Salesforce API error. Please try again later."}), 500
     except Exception as e:
-        logging.error(f"Error generating PDF for {supervisor_name}: {str(e)}")
-        return jsonify({'status': 'error', 'message': 'Error generating PDF'})
+        logger.error(f"Error downloading PDF: {str(e)}")
+        return jsonify({"status": "error", "message": str(e)}), 500
+    finally:
+        if 'pdf_path' in locals():
+            try:
+                os.remove(pdf_path)
+                logger.info(f"Cleaned up temporary PDF file: {pdf_path}")
+            except Exception as e:
+                logger.warning(f"Failed to clean up PDF file: {str(e)}")
 
 if __name__ == '__main__':
     port = int(os.getenv('PORT', 5000))
-    logging.info(f"Starting Flask app on port {port}")
     app.run(host='0.0.0.0', port=port, debug=True)