Update app.py

app.py

@@ -1,233 +1,334 @@
-
-import gradio as gr
-from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+from flask import Flask, request, jsonify, session, redirect, url_for, render_template
+from simple_salesforce import Salesforce, SalesforceAuthenticationFailed, SalesforceError
 import os
-from fastapi import FastAPI
-from pydantic import BaseModel
-from simple_salesforce import Salesforce
 from dotenv import load_dotenv
+import logging
+import requests
+import json
+from datetime import datetime
+from urllib.parse import quote
 
 # Load environment variables
 load_dotenv()
 
-# Salesforce connection
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    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', 'tTPLQduw8wDpxdKOMJ3d9dM3o')
+
+# Salesforce credentials from .env
+SALESFORCE_USERNAME = os.getenv('SALESFORCE_USERNAME')
+SALESFORCE_PASSWORD = os.getenv('SALESFORCE_PASSWORD')
+SALESFORCE_SECURITY_TOKEN = os.getenv('SALESFORCE_SECURITY_TOKEN')
+SALESFORCE_DOMAIN = os.getenv('SALESFORCE_DOMAIN', 'login')
+HUGGING_FACE_API_TOKEN = os.getenv('HUGGING_FACE_API_TOKEN')
+HUGGING_FACE_API_URL = os.getenv('HUGGING_FACE_API_URL', 'https://api-inference.huggingface.co/models/facebook/bart-large')
+
 def get_salesforce_connection():
+    """Establish a Salesforce connection with detailed error handling."""
     try:
-        # Load credentials from environment variables
-        username = os.getenv("SF_USERNAME")
-        password = os.getenv("SF_PASSWORD")
-        security_token = os.getenv("SF_SECURITY_TOKEN")
-        domain = os.getenv("SF_DOMAIN", "login")  # Default to production (login.salesforce.com)
-
-        # Validate credentials
-        if not all([username, password, security_token, domain]):
-            missing = []
-            if not username:
-                missing.append("onteddugeetha104@gmail.com")
-            if not password:
-                missing.append("9032590825g@")
-            if not security_token:
-                missing.append("tTPLQduw8wDpxdKOMJ3d9dM3o")
-            if not domain:
-                missing.append("SF_DOMAIN")
-            raise ValueError(f"Missing environment variables: {', '.join(missing)}. Set them in .env or Space environment variables.")
-
-        # Ensure all are strings
-        if not all(isinstance(x, str) for x in [username, password, security_token, domain]):
-            raise ValueError("All Salesforce credentials (SF_USERNAME, SF_PASSWORD, SF_SECURITY_TOKEN, SF_DOMAIN) must be strings.")
-
         sf = Salesforce(
-            username=username,
-            password=password,
-            security_token=security_token,
-            domain=domain
+            username=SALESFORCE_USERNAME,
+            password=SALESFORCE_PASSWORD,
+            security_token=SALESFORCE_SECURITY_TOKEN,
+            domain=SALESFORCE_DOMAIN,
+            version='60.0'
         )
-
-        # Test connection by fetching user info
-        sf.User.get(sf.user_id)
+        logger.info("Successfully connected to Salesforce")
+        sf.query("SELECT Id FROM Supervisor_AI_Coaching__c LIMIT 1")
+        logger.debug("Salesforce connection test query successful")
         return sf
+    except SalesforceAuthenticationFailed as e:
+        logger.error(f"Salesforce authentication failed: {str(e)}")
+        raise Exception(f"Salesforce authentication failed: {str(e)}")
+    except SalesforceError as e:
+        logger.error(f"Salesforce error during connection: {str(e)}")
+        raise Exception(f"Salesforce error: {str(e)}")
     except Exception as e:
-        raise Exception(f"Failed to connect to Salesforce: {str(e)}")
-
-# Load Hugging Face token
-HF_TOKEN = os.getenv("HF_TOKEN")
-
-# Model configuration
-MODEL_PATH = "facebook/bart-large"  # Public model
-# MODEL_PATH = "your_actual_username/fine_tuned_bart_construction"  # Uncomment after uploading
-
-try:
-    model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_PATH, use_auth_token=HF_TOKEN if HF_TOKEN else None)
-    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, use_auth_token=HF_TOKEN if HF_TOKEN else None)
-except Exception as e:
-    raise Exception(f"Failed to load model: {str(e)}")
-
-# Define input model for FastAPI
-class ChecklistInput(BaseModel):
-    role: str = "Supervisor"
-    project_id: str = "Unknown"
-    project_name: str = "Unknown Project"
-    milestones: str = "No milestones provided"
-    record_id: str = None
-    supervisor_id: str = None
-    project_id_sf: str = None
-    reflection_log: str = None
-    download_link: str = None
-
-# Initialize FastAPI
-app = FastAPI()
-
-@app.post("/generate")
-async def generate_checklist(data: ChecklistInput):
+        logger.error(f"Unexpected error connecting to Salesforce: {str(e)}")
+        raise Exception(f"Unable to connect to Salesforce: {str(e)}")
+
+@app.route('/')
+def index():
+    if 'supervisor_id' not in session:
+        logger.info("User not logged in, redirecting to login page")
+        return redirect(url_for('login_page'))
+    return redirect(url_for('dashboard'))
+
+@app.route('/login', methods=['GET'])
+def login_page():
+    return render_template('login.html')
+
+@app.route('/signup', methods=['GET'])
+def signup_page():
+    return render_template('signup.html')
+
+@app.route('/login', methods=['POST'])
+def login():
+    data = request.get_json()
+    supervisor_id = data.get('supervisor_id')
+
+    if not supervisor_id:
+        logger.warning("Login failed: Supervisor ID is required")
+        return jsonify({"status": "error", "message": "Supervisor ID is required"}), 400
+
     try:
-        inputs = f"Role: {data.role} Project: {data.project_id} ({data.project_name}) Milestones: {data.milestones}"
-        input_ids = tokenizer(inputs, return_tensors="pt", max_length=128, truncation=True).input_ids
-        outputs = model.generate(input_ids, max_length=128, num_beams=4, early_stopping=True)
-        checklist = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        tips = "1. Prioritize safety checks\n2. Review milestones\n3. Log progress"
-        kpi_flag = "delay" in data.milestones.lower() or "behind" in data.milestones.lower()
-
-        if data.record_id:
-            sf = get_salesforce_connection()
-            existing_record = sf.Supervisor_AI_Coaching__c.get(data.record_id, default={
-                'Name': '',
-                'Supervisor_ID__c': None,
-                'Project_ID__c': None,
-                'Reflection_Log__c': '',
-                'Download_Link__c': '',
-                'Engagement_Score__c': 0,
-                'KPI_Flag__c': False,
-                'Daily_Checklist__c': '',
-                'Suggested_Tips__c': ''
-            })
-            update_data = {
-                'Daily_Checklist__c': checklist,
-                'Suggested_Tips__c': tips,
-                'Engagement_Score__c': existing_record.get('Engagement_Score__c', 0) + 10,
-                'KPI_Flag__c': kpi_flag,
-                'Supervisor_ID__c': data.supervisor_id if data.supervisor_id else existing_record.get('Supervisor_ID__c'),
-                'Project_ID__c': data.project_id_sf if data.project_id_sf else existing_record.get('Project_ID__c'),
-                'Reflection_Log__c': data.reflection_log if data.reflection_log else existing_record.get('Reflection_Log__c', ''),
-                'Download_Link__c': data.download_link if data.download_link else existing_record.get('Download_Link__c', '')
-            }
-            sf.Supervisor_AI_Coaching__c.update(data.record_id, update_data)
+        sf = get_salesforce_connection()
+        logger.debug(f"Querying Salesforce for Supervisor_AI_Coaching_Name__c: {supervisor_id}")
+        supervisor_id_escaped = quote(supervisor_id, safe='')
+        query = f"SELECT Id, Supervisor_AI_Coaching_Name__c, Project_ID__c FROM Supervisor_AI_Coaching__c WHERE Supervisor_AI_Coaching_Name__c = '{supervisor_id_escaped}' LIMIT 1"
+        result = sf.query(query)
+        logger.debug(f"Salesforce query result: {result}")
+
+        if not result['records']:
+            logger.warning(f"Invalid Supervisor ID: {supervisor_id}")
+            return jsonify({"status": "error", "message": "Invalid Supervisor ID"}), 401
+
+        session['supervisor_id'] = supervisor_id
+        logger.info(f"Login successful for {supervisor_id}")
+        return jsonify({"status": "success", "message": "Login successful", "redirect": "/dashboard"})
 
-        return {
-            "checklist": checklist,
-            "tips": tips,
-            "kpi_flag": kpi_flag
-        }
     except Exception as e:
-        return {"error": str(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()
+    supervisor_id = data.get('supervisor_id')
+
+    if not supervisor_id:
+        logger.warning("Signup failed: Supervisor ID is required")
+        return jsonify({"status": "error", "message": "Supervisor ID is required"}), 400
 
-# Login and display records
-def login_and_display(project_id_sf):
     try:
         sf = get_salesforce_connection()
-        query = f"SELECT Id, Name, Supervisor_ID__c, 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 Project_ID__c = '{project_id_sf}'"
-        records = sf.query(query)["records"]
-        if not records:
-            return "No records found for Project ID.", "", False
-
-        output = "Supervisor_AI_Coaching__c Records:\n"
-        for record in records:
-            output += (
-                f"Record ID: {record['Id']}\n"
-                f"Name: {record['Name']}\n"
-                f"Supervisor ID: {record['Supervisor_ID__c']}\n"
-                f"Project ID: {record['Project_ID__c']}\n"
-                f"Daily Checklist: {record['Daily_Checklist__c'] or 'N/A'}\n"
-                f"Suggested Tips: {record['Suggested_Tips__c'] or 'N/A'}\n"
-                f"Reflection Log: {record['Reflection_Log__c'] or 'N/A'}\n"
-                f"Engagement Score: {record['Engagement_Score__c'] or 0}%\n"
-                f"KPI Flag: {record['KPI_Flag__c']}\n"
-                f"Download Link: {record['Download_Link__c'] or 'N/A'}\n"
-                f"{'-'*50}\n"
-            )
-        return output, "", False
+        logger.debug(f"Checking if Supervisor_AI_Coaching_Name__c {supervisor_id} already exists")
+        supervisor_id_escaped = quote(supervisor_id, safe='')
+        query = f"SELECT Id FROM Supervisor_AI_Coaching__c WHERE Supervisor_AI_Coaching_Name__c = '{supervisor_id_escaped}' LIMIT 1"
+        result = sf.query(query)
+        if result['records']:
+            logger.warning(f"Signup failed: Supervisor ID {supervisor_id} already exists")
+            return jsonify({"status": "error", "message": "Supervisor ID already exists"}), 400
+
+        logger.debug(f"Creating new Supervisor_AI_Coaching__c record for {supervisor_id}")
+        new_record = {
+            'Supervisor_AI_Coaching_Name__c': supervisor_id
+        }
+        response = sf.Supervisor_AI_Coaching__c.create(new_record)
+        logger.debug(f"Salesforce create response: {response}")
+
+        if not response.get('success'):
+            logger.error(f"Failed to create Supervisor record: {response.get('errors')}")
+            return jsonify({"status": "error", "message": f"Failed to create record in Salesforce: {response.get('errors')}"}), 500
+
+        session['supervisor_id'] = supervisor_id
+        logger.info(f"Signup successful for {supervisor_id}")
+        return jsonify({"status": "success", "message": "Signup successful, you are now logged in", "redirect": "/dashboard"})
     except Exception as e:
-        return f"Error querying Salesforce: {str(e)}", "", False
+        logger.error(f"Signup error: {str(e)}")
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+@app.route('/dashboard', methods=['GET'])
+def dashboard():
+    return render_template('dashboard.html')
+
+@app.route('/home')
+def home():
+    return render_template('home.html')
+
+def generate_coaching_output(data):
+    """Generate daily checklist and tips using Hugging Face LLM."""
+    logger.info("Generating coaching output for supervisor %s", data['supervisor_id'])
+    milestones_json = json.dumps(data['milestones'], indent=2)
+    prompt = f"""
+You are an AI Coach for construction site supervisors. Based on the following data, generate a daily checklist, three focus tips, and a motivational quote. Ensure outputs are concise, actionable, and tailored to the supervisor's role, project status, and reflection log.
+Supervisor ID: {data['supervisor_id']}
+Project Milestones: {milestones_json}
+Reflection Log: {data['reflection_log']}
+Weather: {data['weather']}
+Format the response as JSON:
+{{
+    "checklist": ["item1", "item2", ...],
+    "tips": ["tip1", "tip2", "tip3"],
+    "quote": "motivational quote"
+}}
+"""
+    headers = {
+        "Authorization": f"Bearer {HUGGING_FACE_API_TOKEN}",
+        "Content-Type": "application/json"
+    }
+    payload = {
+        "inputs": prompt,
+        "parameters": {
+            "max_length": 200,
+            "temperature": 0.7,
+            "top_p": 0.9
+        }
+    }
+
+    try:
+        response = requests.post(HUGGING_FACE_API_URL, headers=headers, json=payload, timeout=5)
+        response.raise_for_status()
+        result = response.json()
+        generated_text = result[0]["generated_text"] if isinstance(result, list) else result["generated_text"]
+
+        start_idx = generated_text.find('{')
+        end_idx = generated_text.rfind('}') + 1
+        if start_idx == -1 or end_idx == 0:
+            logger.error("No valid JSON found in LLM output")
+            raise ValueError("No valid JSON found in LLM output")
+        
+        json_str = generated_text[start_idx:end_idx]
+        output = json.loads(json_str)
+        logger.info("Successfully generated coaching output")
+        return output
+
+    except requests.exceptions.HTTPError as e:
+        logger.error("Hugging Face API HTTP error: %s", e)
+        return None
+    except (json.JSONDecodeError, ValueError) as e:
+        logger.error("Error parsing LLM output: %s", e)
+        return None
+    except Exception as e:
+        logger.error("Unexpected error in Hugging Face API call: %s", e)
+        return None
+
+def save_to_salesforce(output, supervisor_id, project_id):
+    """Save coaching output to Salesforce Supervisor_AI_Coaching__c object."""
+    if not output:
+        logger.error("No coaching output to save")
+        return False
 
-# Generate checklist from record
-def gradio_generate_checklist(record_id, role="Supervisor", project_id="Unknown", project_name="Unknown Project", milestones="No milestones provided", supervisor_id="", project_id_sf="", reflection_log="", download_link=""):
     try:
         sf = get_salesforce_connection()
-        existing_record = sf.Supervisor_AI_Coaching__c.get(record_id, default={
-            'Name': '',
-            'Supervisor_ID__c': None,
-            'Project_ID__c': None,
-            'Reflection_Log__c': '',
-            'Download_Link__c': '',
-            'Engagement_Score__c': 0,
-            'KPI_Flag__c': False,
-            'Daily_Checklist__c': '',
-            'Suggested_Tips__c': ''
-        })
-        inputs = f"Role: {role} Project: {project_id} ({project_name}) Milestones: {milestones}"
-        input_ids = tokenizer(inputs, return_tensors="pt", max_length=128, truncation=True).input_ids
-        outputs = model.generate(input_ids, max_length=128, num_beams=4, early_stopping=True)
-        checklist = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        tips = "1. Prioritize safety checks\n2. Review milestones\n3. Log progress"
-        kpi_flag = "delay" in milestones.lower() or "behind" in milestones.lower()
-
-        update_data = {
-            'Daily_Checklist__c': checklist,
-            'Suggested_Tips__c': tips,
-            'Engagement_Score__c': existing_record.get('Engagement_Score__c', 0) + 10,
-            'KPI_Flag__c': kpi_flag,
-            'Supervisor_ID__c': supervisor_id if supervisor_id else existing_record.get('Supervisor_ID__c'),
-            'Project_ID__c': project_id_sf if project_id_sf else existing_record.get('Project_ID__c'),
-            'Reflection_Log__c': reflection_log if reflection_log else existing_record.get('Reflection_Log__c', ''),
-            'Download_Link__c': download_link if download_link else existing_record.get('Download_Link__c', '')
+        logger.info("Connected to Salesforce")
+
+        coaching_record = {
+            "Supervisor_AI_Coaching_Name__c": supervisor_id,
+            "Project_ID__c": project_id,
+            "Daily_Checklist__c": "\n".join(output["checklist"]),
+            "Suggested_Tips__c": "\n".join(output["tips"]),
+            "Quote__c": output["quote"],
+            "Generated_Date__c": datetime.now().strftime("%Y-%m-%d")
         }
-        sf.Supervisor_AI_Coaching__c.update(record_id, update_data)
-        status = f"Updated Salesforce record {record_id}"
 
-        return checklist, tips, kpi_flag, status
+        external_id = f"{supervisor_id}_{datetime.now().strftime('%Y-%m-%d')}"
+        sf.Supervisor_AI_Coaching__c.upsert(f"Supervisor_AI_Coaching_Name__c/{external_id}", coaching_record)
+        logger.info("Successfully saved coaching record to Salesforce for supervisor %s", supervisor_id)
+        return True
+
     except Exception as e:
-        return f"Error: {str(e)}", "", False, ""
-
-# Define Gradio interface
-with gr.Blocks() as iface:
-    gr.Markdown("# AI Coach for Site Supervisors")
-    gr.Markdown("Enter a Project ID to view Supervisor_AI_Coaching__c records and generate checklists.")
-
-    with gr.Tab("Login"):
-        project_id_input = gr.Textbox(label="Project ID (Salesforce Project__c ID)", placeholder="Enter Project ID")
-        login_button = gr.Button("Submit")
-        records_output = gr.Textbox(label="Records", lines=10)
-        login_button.click(
-            fn=login_and_display,
-            inputs=project_id_input,
-            outputs=[records_output, gr.Textbox(visible=False), gr.Checkbox(visible=False)]
-        )
+        logger.error("Salesforce error: %s", e)
+        return False
 
-    with gr.Tab("Generate Checklist"):
-        record_id = gr.Textbox(label="Record ID", placeholder="Enter Record ID from above")
-        role = gr.Textbox(label="Role", value="Supervisor")
-        project_id = gr.Textbox(label="Project ID", value="P001")
-        project_name = gr.Textbox(label="Project Name", value="Building A")
-        milestones = gr.Textbox(label="Milestones", value="Complete foundation by 5/15")
-        supervisor_id = gr.Textbox(label="Supervisor ID (Salesforce User ID, optional)", value="")
-        project_id_sf = gr.Textbox(label="Project ID (Salesforce Project__c ID, optional)", value="")
-        reflection_log = gr.Textbox(label="Reflection Log (optional)", value="")
-        download_link = gr.Textbox(label="Download Link (optional)", value="")
-        generate_button = gr.Button("Generate and Update")
-        checklist_output = gr.Textbox(label="Checklist")
-        tips_output = gr.Textbox(label="Tips")
-        kpi_flag_output = gr.Checkbox(label="KPI Flag")
-        status_output = gr.Textbox(label="Salesforce Status")
-        generate_button.click(
-            fn=gradio_generate_checklist,
-            inputs=[record_id, role, project_id, project_name, milestones, supervisor_id, project_id_sf, reflection_log, download_link],
-            outputs=[checklist_output, tips_output, kpi_flag_output, status_output]
-        )
+@app.route('/generate', methods=['POST'])
+def generate_endpoint():
+    """Endpoint to generate coaching output based on supervisor data."""
+    try:
+        data = request.get_json()
+        required_keys = ['supervisor_id', 'project_id', 'milestones', 'reflection_log', 'weather']
+        if not data or not all(key in data for key in required_keys):
+            return jsonify({"status": "error", "message": "Invalid or missing supervisor data"}), 400
 
-# Mount FastAPI
-iface.app = app
+        coaching_output = generate_coaching_output(data)
+        if coaching_output:
+            success = save_to_salesforce(coaching_output, data["supervisor_id"], data["project_id"])
+            if success:
+                return jsonify({"status": "success", "output": coaching_output}), 200
+            else:
+                return jsonify({"status": "error", "message": "Failed to save to Salesforce"}), 500
+        else:
+            return jsonify({"status": "error", "message": "Failed to generate coaching output"}), 500
+    except Exception as e:
+        logger.error("Error in generate endpoint: %s", e)
+        return jsonify({"status": "error", "message": str(e)}), 500
 
-if __name__ == "__main__":
+@app.route('/submit_reflection', methods=['POST'])
+def submit_reflection():
+    """Endpoint to submit a reflection and update Salesforce."""
     try:
-        iface.launch(server_name="0.0.0.0", server_port=7860, share=False)
+        data = request.get_json()
+        reflection = data.get('reflection')
+        supervisor_id = session.get('supervisor_id')
+
+        if not reflection or not supervisor_id:
+            return jsonify({"status": "error", "message": "Reflection and supervisor ID are required"}), 400
+
+        sf = get_salesforce_connection()
+        query = f"SELECT Id FROM Supervisor_AI_Coaching__c WHERE Supervisor_AI_Coaching_Name__c = '{quote(supervisor_id, safe='')}' LIMIT 1"
+        result = sf.query(query)
+
+        if not result['records']:
+            return jsonify({"status": "error", "message": "Supervisor not found"}), 404
+
+        record_id = result['records'][0]['Id']
+        sf.Supervisor_AI_Coaching__c.update(record_id, {"Reflection_Log__c": reflection})
+        logger.info(f"Reflection saved for supervisor {supervisor_id}")
+        return jsonify({"status": "success", "message": "Reflection submitted successfully"})
+
     except Exception as e:
-        print(f"Failed to launch Gradio: {str(e)}")
+        logger.error(f"Error submitting reflection: {str(e)}")
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+@app.route('/get_supervisor_data', methods=['GET'])
+def get_supervisor_data():
+    supervisor_id = session.get('supervisor_id')
+    if not supervisor_id:
+        logger.warning("No supervisor ID in session")
+        return jsonify({"status": "error", "message": "User not logged in"}), 401
+
+    try:
+        sf = get_salesforce_connection()
+        supervisor_id_escaped = quote(supervisor_id, safe='')
+        query = f"""
+            SELECT Supervisor_AI_Coaching_Name__c, Project_ID__c, Daily_Checklist__c, Suggested_Tips__c, 
+                   Reflection_Log__c, Engagement_Score__c, KPI_Flag__c, Quote__c
+            FROM Supervisor_AI_Coaching__c
+            WHERE Supervisor_AI_Coaching_Name__c = '{supervisor_id_escaped}'
+            LIMIT 1
+        """
+        result = sf.query(query)
+
+        if result['records']:
+            record = result['records'][0]
+            data = {
+                "supervisor_id": record['Supervisor_AI_Coaching_Name__c'],
+                "project_id": record['Project_ID__c'],
+                "daily_checklist": record['Daily_Checklist__c'],
+                "suggested_tips": record['Suggested_Tips__c'],
+                "reflection_log": record['Reflection_Log__c'],
+                "engagement_score": record['Engagement_Score__c'] or 0,
+                "kpi_flag": record['KPI_Flag__c'] or False,
+                "quote": record['Quote__c'],
+                "last_login": str(datetime.now())
+            }
+            logger.info(f"Fetched data for supervisor {supervisor_id}")
+            return jsonify({"status": "success", "data": data})
+        else:
+            logger.warning(f"No data found for supervisor {supervisor_id}")
+            return jsonify({"status": "error", "message": "No data found for this supervisor"}), 404
+    except Exception as e:
+        logger.error(f"Error fetching supervisor data: {str(e)}")
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+@app.route('/logout', methods=['POST'])
+def logout():
+    supervisor_id = session.get('supervisor_id', 'Unknown')
+    session.pop('supervisor_id', None)
+    logger.info(f"User {supervisor_id} logged out")
+    return jsonify({"status": "success", "message": "Logged out successfully"})
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    return jsonify({"status": "healthy", "message": "Application is running"}), 200
+
+if __name__ == '__main__':
+    port = int(os.getenv('PORT', 5000))
+    app.run(host='0.0.0.0', port=port, debug=True)