Update app.py

app.py

@@ -1,4 +1,4 @@
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Header
 from pydantic import BaseModel
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
@@ -8,38 +8,27 @@ import logging
 from datetime import datetime
 from fastapi.responses import HTMLResponse
 from simple_salesforce import Salesforce
-from dotenv import load_dotenv
-from datasets import load_dataset  # Added for Hugging Face
+import json
 
-# Load environment variables
-load_dotenv()
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# Set up logging to capture errors and debug information
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
-# Environment variables from .env
-SF_USERNAME = os.getenv("SF_USERNAME")
-SF_PASSWORD = os.getenv("SF_PASSWORD")
-SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
+# Salesforce credentials
+SF_USERNAME = os.getenv("SF_USERNAME", "scores@app.com")
+SF_PASSWORD = os.getenv("SF_PASSWORD", "Internal@1")
+SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN", "NbUKcTx45azba5HEdntE9YAh")
 SF_DOMAIN = os.getenv("SF_DOMAIN", "login")
-HUGGINGFACE_API_KEY = os.getenv("HUGGINGFACE_API_KEY")
-
-# Validate environment variables
-required_env_vars = ["SF_USERNAME", "SF_PASSWORD", "SF_SECURITY_TOKEN"]
-for var in required_env_vars:
-    if not os.getenv(var):
-        logger.error(f"Environment variable {var} is not set")
-        raise ValueError(f"Environment variable {var} is not set")
 
-# Check Hugging Face configuration
-USE_HUGGINGFACE = bool(HUGGINGFACE_API_KEY and HUGGINGFACE_API_KEY != "your_huggingface_api_key_here")
-logger.info(f"Hugging Face integration {'enabled' if USE_HUGGINGFACE else 'disabled'}")
+# Verify API key is set
+API_KEY = os.getenv("HUGGINGFACE_API_KEY")
+if not API_KEY:
+    logger.error("HUGGINGFACE_API_KEY environment variable not set")
+    raise ValueError("HUGGINGFACE_API_KEY environment variable not set")
 
-# Salesforce connection
-sf = None
+# Connect to Salesforce
 try:
     sf = Salesforce(
         username=SF_USERNAME,
@@ -50,9 +39,9 @@ try:
     logger.info("Successfully connected to Salesforce")
 except Exception as e:
     logger.error(f"Failed to connect to Salesforce: {str(e)}")
-    raise RuntimeError(f"Cannot connect to Salesforce: {str(e)}")
+    raise
 
-# VendorLog model
+# VendorLog model to match Salesforce data
 class VendorLog(BaseModel):
     vendorLogId: str
     vendorId: str
@@ -66,105 +55,61 @@ class VendorLog(BaseModel):
     delayDays: int
     project: str
 
-# Store vendor logs
+# Store vendor logs for display
 vendor_logs = []
 
-# New function to fetch records from Hugging Face
-def fetch_huggingface_records(dataset_name: str = "imdb"):
-    """Fetch a dataset from Hugging Face and return its records."""
-    if not USE_HUGGINGFACE:
-        logger.warning("Hugging Face integration is disabled. Cannot fetch records.")
-        return []
-    try:
-        # Set Hugging Face token for authentication
-        os.environ["HUGGINGFACE_TOKEN"] = HUGGINGFACE_API_KEY
-        dataset = load_dataset(dataset_name)
-        logger.info(f"Successfully fetched dataset: {dataset_name}")
-        # Example: Convert dataset to a list of records (adjust based on dataset structure)
-        records = [record for record in dataset['train']]  # Assuming 'train' split
-        return records[:10]  # Limit to 10 records for demonstration
-    except Exception as e:
-        logger.error(f"Error fetching Hugging Face dataset {dataset_name}: {str(e)}")
-        return []
-
-def validate_salesforce_fields():
-    """Validate required Salesforce fields"""
-    try:
-        vendor_log_fields = [f['name'] for f in sf.Vendor_Log__c.describe()['fields']]
-        required_fields = [
-            'Vendor__c', 'Work_Completion_Percentage__c', 'Quality_Percentage__c',
-            'Incident_Severity__c', 'Work_Completion_Date__c', 'Actual_Completion_Date__c',
-            'Delay_Days__c', 'Project__c'
-        ]
-        for field in required_fields:
-            if field not in vendor_log_fields:
-                logger.error(f"Field {field} not found in Vendor_Log__c")
-                raise ValueError(f"Field {field} not found in Vendor_Log__c")
-
-        score_fields = [f['name'] for f in sf.Subcontractor_Performance_Score__c.describe()['fields']]
-        required_score_fields = [
-            'Vendor__c', 'Month__c', 'Quality_Score__c', 'Timeliness_Score__c',
-            'Safety_Score__c', 'Communication_Score__c', 'Alert_Flag__c'
-            # Removed 'Certification_URL__c' to avoid error
-        ]
-        for field in required_score_fields:
-            if field not in score_fields:
-                logger.error(f"Field {field} not found in Subcontractor_Performance_Score__c")
-                raise ValueError(f"Field {field} not found in Subcontractor_Performance_Score__c")
-        logger.info("Salesforce fields validated successfully")
-    except Exception as e:
-        logger.error(f"Error validating Salesforce fields: {str(e)}")
-        raise
-
-# Validate schema on startup
-validate_salesforce_fields()
-
 def fetch_vendor_logs_from_salesforce():
     try:
         query = """
-        SELECT Id, Name, Vendor__c, Work_Completion_Percentage__c, Quality_Percentage__c, 
-               Incident_Severity__c, Work_Completion_Date__c, Actual_Completion_Date__c, 
-               Delay_Days__c, Project__c
+        SELECT Id, Name, Vendor__c, Work_Completion_Percentage__c, Quality_Percentage__c, Incident_Severity__c, 
+               Work_Completion_Date__c, Actual_Completion_Date__c, Delay_Days__c,Project__c
+               
         FROM Vendor_Log__c
-        WHERE Vendor__c != null
         """
         result = sf.query_all(query)
         logs = []
         for record in result['records']:
-            try:
-                log = VendorLog(
-                    vendorLogId=record.get('Id', 'Unknown'),
-                    vendorId=record.get('Name', 'Unknown'),
-                    vendorRecordId=record.get('Vendor__c', 'Unknown'),
-                    workDetails=str(record.get('Work_Completion_Percentage__c', 0.0)),
-                    qualityReport=str(record.get('Quality_Percentage__c', 0.0)),
-                    incidentLog=record.get('Incident_Severity__c', 'None'),
-                    workCompletionDate=record.get('Work_Completion_Date__c', 'N/A'),
-                    actualCompletionDate=record.get('Actual_Completion_Date__c', 'N/A'),
-                    vendorLogName=record.get('Name', 'Unknown'),
-                    delayDays=int(record.get('Delay_Days__c', 0)),
-                    project=record.get('Project__c', 'Unknown')
-                )
-                logs.append(log)
-            except Exception as e:
-                logger.warning(f"Skipping invalid Vendor_Log__c record {record.get('Id')}: {str(e)}")
-        logger.info(f"Fetched {len(logs)} vendor logs")
+            if not record['Vendor__c']:
+                logger.warning(f"Skipping Vendor_Log__c record with ID {record['Id']} due to missing Vendor__c")
+                continue
+            log = VendorLog(
+                vendorLogId=record['Id'] or "Unknown",
+                vendorId=record['Name'] or "Unknown",
+                vendorRecordId=record['Vendor__c'] or "Unknown",
+                workDetails=str(record['Work_Completion_Percentage__c'] or "0.0"),
+                qualityReport=str(record['Quality_Percentage__c'] or "0.0"),
+                incidentLog=record['Incident_Severity__c'] or "None",
+                workCompletionDate=record['Work_Completion_Date__c'] or "N/A",
+                actualCompletionDate=record['Actual_Completion_Date__c'] or "N/A",
+                vendorLogName=record['Name'] or "Unknown",
+                delayDays=int(record['Delay_Days__c'] or 0),
+                 project=record['Project__c'] or "Unknown"
+            )
+            logs.append(log)
         return logs
     except Exception as e:
-        logger.error(f"Error fetching vendor logs: {str(e)}")
-        return []
+        logger.error(f"Error fetching vendor logs from Salesforce: {str(e)}")
+        raise
 
-def calculate_scores_local(log: VendorLog):
+def calculate_scores(log: VendorLog):
     try:
-        work_completion_percentage = float(log.workDetails or 0.0)
-        quality_percentage = float(log.qualityReport or 0.0)
+        work_completion_percentage = float(log.workDetails)
+        quality_percentage = float(log.qualityReport)
 
+        # Quality Score: Directly use the quality percentage
         quality_score = quality_percentage
+
+        # Timeliness Score: Based on delay days
         timeliness_score = 100.0 if log.delayDays <= 0 else 80.0 if log.delayDays <= 3 else 60.0 if log.delayDays <= 7 else 40.0
+
+        # Safety Score: Based on incident severity
         severity_map = {'None': 100.0, 'Low': 80.0, 'Minor': 80.0, 'Medium': 50.0, 'High': 20.0}
         safety_score = severity_map.get(log.incidentLog, 100.0)
+
+        # Communication Score: Weighted average of other scores
         communication_score = (quality_score * 0.33 + timeliness_score * 0.33 + safety_score * 0.33)
 
+        # Removed finalScore calculation since Final_Score__c is a Formula field
         return {
             'qualityScore': round(quality_score, 2),
             'timelinessScore': round(timeliness_score, 2),
@@ -172,16 +117,8 @@ def calculate_scores_local(log: VendorLog):
             'communicationScore': round(communication_score, 2)
         }
     except Exception as e:
-        logger.error(f"Error calculating local scores: {str(e)}")
-        return {'qualityScore': 0.0, 'timelinessScore': 0.0, 'safetyScore': 0.0, 'communicationScore': 0.0}
-
-def calculate_scores(log: VendorLog):
-    if USE_HUGGINGFACE:
-        # Example: Use Hugging Face model for score enhancement (placeholder)
-        logger.info("Using Hugging Face for score calculation (placeholder)")
-        return calculate_scores_local(log)  # Replace with actual Hugging Face logic if needed
-    else:
-        return calculate_scores_local(log)
+        logger.error(f"Error calculating scores: {str(e)}")
+        raise
 
 def get_feedback(score: float, metric: str) -> str:
     try:
@@ -190,15 +127,30 @@ def get_feedback(score: float, metric: str) -> str:
         elif score >= 70:
             return "Good: Keep up the good work"
         elif score >= 50:
-            return f"Needs Improvement: {'Maintain schedules' if metric == 'Timeliness' else 'Improve quality' if metric == 'Quality' else 'Enhance safety' if metric == 'Safety' else 'Better communication'}"
+            if metric == 'Timeliness':
+                return "Needs Improvement: Maintain schedules to complete tasks on time"
+            elif metric == 'Safety':
+                return "Needs Improvement: Implement stricter safety protocols"
+            elif metric == 'Quality':
+                return "Needs Improvement: Focus on improving work quality"
+            else:
+                return "Needs Improvement: Enhance coordination with project teams"
         else:
-            return f"Poor: {'Significant delays' if metric == 'Timeliness' else 'Quality issues' if metric == 'Quality' else 'Safety issues' if metric == 'Safety' else 'Communication issues'}"
-    except Exception:
-        return "Feedback unavailable"
+            if metric == 'Timeliness':
+                return "Poor: Significant delays detected"
+            elif metric == 'Safety':
+                return "Poor: Critical safety issues identified"
+            elif metric == 'Quality':
+                return "Poor: Quality standards not met"
+            else:
+                return "Poor: Communication issues detected"
+    except Exception as e:
+        logger.error(f"Error generating feedback: {str(e)}")
+        raise
 
 def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
     try:
-        filename = f'report_{vendor_id}_{datetime.now().strftime("%Y%m%d%H%M%S")}.pdf'
+        filename = f'report_{vendor_id}.pdf'
         c = canvas.Canvas(filename, pagesize=letter)
         c.setFont('Helvetica', 12)
         c.drawString(100, 750, 'Subcontractor Performance Report')
@@ -208,42 +160,49 @@ def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
         c.drawString(100, 670, f'Timeliness Score: {scores["timelinessScore"]}% ({get_feedback(scores["timelinessScore"], "Timeliness")})')
         c.drawString(100, 650, f'Safety Score: {scores["safetyScore"]}% ({get_feedback(scores["safetyScore"], "Safety")})')
         c.drawString(100, 630, f'Communication Score: {scores["communicationScore"]}% ({get_feedback(scores["communicationScore"], "Communication")})')
+        # Removed Final Score from PDF since it's a Formula field
         c.save()
+
         with open(filename, 'rb') as f:
             pdf_content = f.read()
         os.remove(filename)
         return pdf_content
     except Exception as e:
         logger.error(f"Error generating PDF: {str(e)}")
-        raise HTTPException(status_code=500, detail="Failed to generate PDF")
+        raise
 
 def determine_alert_flag(scores: dict, all_logs: list):
     try:
         if not all_logs:
             return False
-        avg_score = sum(scores.values()) / 4
+        # Since finalScore is a Formula field, we'll need to fetch it from Salesforce or adjust logic
+        # For now, we'll base the alert on the average of other scores
+        avg_score = (scores['qualityScore'] + scores['timelinessScore'] + scores['safetyScore'] + scores['communicationScore']) / 4
         if avg_score < 50:
             return True
-        lowest_avg = min([sum(log['scores'].values()) / 4 for log in all_logs], default=avg_score)
+        lowest_avg = min([(log['scores']['qualityScore'] + log['scores']['timelinessScore'] + log['scores']['safetyScore'] + log['scores']['communicationScore']) / 4 for log in all_logs])
         return avg_score == lowest_avg
     except Exception as e:
         logger.error(f"Error determining alert flag: {str(e)}")
-        return False
+        raise
 
 def store_scores_in_salesforce(log: VendorLog, scores: dict, pdf_content: bytes, alert_flag: bool):
     try:
+        # Step 1: Create the Subcontractor_Performance_Score__c record without Final_Score__c
         score_record = sf.Subcontractor_Performance_Score__c.create({
+            'Vendor_Log__c': log.vendorLogId,
             'Vendor__c': log.vendorRecordId,
-            'Month__c': datetime.today().replace(day=1).strftime('%Y-%m-%d'),
             'Quality_Score__c': scores['qualityScore'],
             'Timeliness_Score__c': scores['timelinessScore'],
             'Safety_Score__c': scores['safetyScore'],
             'Communication_Score__c': scores['communicationScore'],
             'Alert_Flag__c': alert_flag
+            # Removed Final_Score__c since it's a Formula field
         })
         score_record_id = score_record['id']
-        logger.info(f"Created score record: {score_record_id}")
+        logger.info(f"Successfully created Subcontractor_Performance_Score__c record with ID: {score_record_id}")
 
+        # Step 2: Upload the PDF as a ContentVersion
         pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
         content_version = sf.ContentVersion.create({
             'Title': f'Performance_Report_{log.vendorId}',
@@ -251,24 +210,33 @@ def store_scores_in_salesforce(log: VendorLog, scores: dict, pdf_content: bytes,
             'VersionData': pdf_base64,
             'FirstPublishLocationId': score_record_id
         })
+        logger.info(f"Successfully uploaded PDF as ContentVersion for Vendor Log ID: {log.vendorLogId}")
+
+        # Step 3: Get the ContentDocumentId and construct a URL to the file
         content_version_id = content_version['id']
         content_version_record = sf.query(f"SELECT ContentDocumentId FROM ContentVersion WHERE Id = '{content_version_id}'")
-        if content_version_record['totalSize'] == 0:
-            logger.error(f"No ContentVersion for ID: {content_version_id}")
-            raise ValueError("Failed to retrieve ContentDocumentId")
         content_document_id = content_version_record['records'][0]['ContentDocumentId']
+        
+        # Construct the URL to the file
         pdf_url = f"https://{sf.sf_instance}/sfc/servlet.shepherd/document/download/{content_document_id}"
 
-        # Comment out Certification_URL__c update to avoid error
-        # sf.Subcontractor_Performance_Score__c.update(score_record_id, {'Certification_URL__c': pdf_url})
-        logger.info(f"Updated score record with PDF (URL not stored due to missing field)")
+        # Step 4: Update the Subcontractor_Performance_Score__c record with the PDF URL
+        sf.Subcontractor_Performance_Score__c.update(score_record_id, {
+            'PDF_Link__c': pdf_url
+        })
+        logger.info(f"Successfully updated Subcontractor_Performance_Score__c record with PDF URL: {pdf_url}")
+
     except Exception as e:
         logger.error(f"Error storing scores in Salesforce: {str(e)}")
-        raise HTTPException(status_code=500, detail="Failed to store scores")
+        raise
 
 @app.post('/score')
-async def score_vendor(log: VendorLog):
+async def score_vendor(log: VendorLog, authorization: str = Header(...)):
     try:
+        logger.info(f"Received Vendor Log: {log}")
+        if authorization != f'Bearer {API_KEY}':
+            raise HTTPException(status_code=401, detail='Invalid API key')
+
         scores = calculate_scores(log)
         pdf_content = generate_pdf(log.vendorId, log.vendorLogName, scores)
         pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
@@ -301,10 +269,8 @@ async def score_vendor(log: VendorLog):
             'pdfContent': pdf_base64,
             'alert': alert_flag
         }
-    except HTTPException as e:
-        raise e
     except Exception as e:
-        logger.error(f"Error in /score: {str(e)}")
+        logger.error(f"Error in /score endpoint: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error processing vendor log: {str(e)}")
 
 @app.get('/', response_class=HTMLResponse)
@@ -316,6 +282,7 @@ async def get_dashboard():
             if not any(existing_log['vendorLogId'] == log.vendorLogId for existing_log in vendor_logs):
                 scores = calculate_scores(log)
                 pdf_content = generate_pdf(log.vendorId, log.vendorLogName, scores)
+                pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
                 alert_flag = determine_alert_flag(scores, vendor_logs)
                 store_scores_in_salesforce(log, scores, pdf_content, alert_flag)
                 vendor_logs.append({
@@ -337,132 +304,135 @@ async def get_dashboard():
         <html>
             <head>
                 <title>Subcontractor Performance Score App</title>
-                <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css">
                 <style>
-                    body { font-family: Arial, sans-serif; background-color: #f4f4f9; }
-                    .container { max-width: 1200px; margin: 20px auto; }
-                    h1, h2 { text-align: center; color: #333; }
-                    .table { margin-top: 20px; }
+                    body { font-family: Arial, sans-serif; margin: 20px; }
+                    table { width: 100%; border-collapse: collapse; margin-top: 20px; }
+                    th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+                    th { background-color: #f2f2f2; }
+                    h1, h2 { text-align: center; }
                     .generate-btn { 
-                        display: block; margin: 20px auto; padding: 10px 20px; 
-                        background-color: #4CAF50; color: white; border: none; 
-                        border-radius: 5px; cursor: pointer; 
+                        display: block; 
+                        margin: 20px auto; 
+                        padding: 10px 20px; 
+                        background-color: #4CAF50; 
+                        color: white; 
+                        border: none; 
+                        border-radius: 5px; 
+                        cursor: pointer; 
+                        font-size: 16px; 
                     }
                     .generate-btn:hover { background-color: #45a049; }
                 </style>
                 <script>
                     async function generateScores() {
-                        try {
-                            const response = await fetch('/generate', { method: 'POST' });
-                            if (response.ok) {
-                                window.location.reload();
-                            } else {
-                                alert('Error generating scores');
-                            }
-                        } catch (error) {
-                            alert('Error: ' + error.message);
+                        const response = await fetch('/generate', { method: 'POST' });
+                        if (response.ok) {
+                            window.location.reload();
+                        } else {
+                            alert('Error generating scores');
                         }
                     }
                 </script>
             </head>
             <body>
-                <div class="container">
-                    <h1>Subcontractor Performance Score App</h1>
-                    <h2>Vendor Logs</h2>
-                    <table class="table table-striped">
-                        <thead>
-                            <tr>
-                                <th>Vendor ID</th>
-                                <th>Vendor Log Name</th>
-                                <th>Project</th>
-                                <th>Work Completion %</th>
-                                <th>Quality %</th>
-                                <th>Incident Severity</th>
-                                <th>Work Completion Date</th>
-                                <th>Actual Completion Date</th>
-                                <th>Delay Days</th>
-                            </tr>
-                        </thead>
-                        <tbody>
+                <h1>SUBCONTRACTOR PERFORMANCE SCORE APP GENERATOR</h1>
+                <h2>VENDOR LOGS SUBMISSION</h2>
+                <table>
+                    <tr>
+                        <th>Vendor ID</th>
+                        <th>Vendor Log Name</th>
+                        <th>Project</th>
+                        <th>Work Completion Percentage</th>
+                        <th>Quality Percentage</th>
+                        <th>Incident Severity</th>
+                        <th>Work Completion Date</th>
+                        <th>Actual Completion Date</th>
+                        <th>Delay Days</th>
+                    </tr>
         """
+
         if not vendor_logs:
-            html_content += '<tr><td colspan="9" class="text-center">No vendor logs available</td></tr>'
+            html_content += """
+                    <tr>
+                        <td colspan="9" style="text-align: center;">No vendor logs available</td>
+                    </tr>
+            """
         else:
             for log in vendor_logs:
                 html_content += f"""
-                    <tr>
-                        <td>{log['vendorId']}</td>
-                        <td>{log['vendorLogName']}</td>
-                        <td>{log['project']}</td>
-                        <td>{log['workDetails']}</td>
-                        <td>{log['qualityReport']}</td>
-                        <td>{log['incidentLog']}</td>
-                        <td>{log['workCompletionDate']}</td>
-                        <td>{log['actualCompletionDate']}</td>
-                        <td>{log['delayDays']}</td>
-                    </tr>
+                        <tr>
+                            <td>{log['vendorId']}</td>
+                            <td>{log['vendorLogName']}</td>
+                            <td>{log['project']}</td>
+                            <td>{log['workDetails']}</td>
+                            <td>{log['qualityReport']}</td>
+                            <td>{log['incidentLog']}</td>
+                            <td>{log['workCompletionDate']}</td>
+                            <td>{log['actualCompletionDate']}</td>
+                            <td>{log['delayDays']}</td>
+                        </tr>
                 """
 
         html_content += """
-                        </tbody>
-                    </table>
-                    <button class="generate-btn" onclick="generateScores()">Generate Scores</button>
-                    <h2>Performance Scores</h2>
-                    <table class="table table-striped">
-                        <thead>
-                            <tr>
-                                <th>Vendor ID</th>
-                                <th>Vendor Log Name</th>
-                                <th>Project</th>
-                                <th>Quality Score</th>
-                                <th>Timeliness Score</th>
-                                <th>Safety Score</th>
-                                <th>Communication Score</th>
-                                <th>Alert Flag</th>
-                            </tr>
-                        </thead>
-                        <tbody>
+                </table>
+                <button class="generate-btn" onclick="generateScores()">Generate</button>
+                <h2>SUBCONTRACTOR PERFORMANCE SCORES</h2>
+                <table>
+                    <tr>
+                        <th>Vendor ID</th>
+                        <th>Vendor Log Name</th>
+                        <th>Project</th>
+                        <th>Quality Score</th>
+                        <th>Timeliness Score</th>
+                        <th>Safety Score</th>
+                        <th>Communication Score</th>
+                        <th>Alert Flag</th>
+                    </tr>
         """
+
         if not vendor_logs:
-            html_content += '<tr><td colspan="8" class="text-center">No scores available</td></tr>'
+            html_content += """
+                    <tr>
+                        <td colspan="8" style="text-align: center;">No scores available</td>
+                    </tr>
+            """
         else:
             for log in vendor_logs:
                 scores = log['scores']
                 alert_flag = determine_alert_flag(scores, vendor_logs)
                 html_content += f"""
-                    <tr>
-                        <td>{log['vendorId']}</td>
-                        <td>{log['vendorLogName']}</td>
-                        <td>{log['project']}</td>
-                        <td>{scores['qualityScore']}%</td>
-                        <td>{scores['timelinessScore']}%</td>
-                        <td>{scores['safetyScore']}%</td>
-                        <td>{scores['communicationScore']}%</td>
-                        <td>{'Checked' if alert_flag else 'Unchecked'}</td>
-                    </tr>
+                        <tr>
+                            <td>{log['vendorId']}</td>
+                            <td>{log['vendorLogName']}</td>
+                            <td>{log['project']}</td>
+                            <td>{scores['qualityScore']}%</td>
+                            <td>{scores['timelinessScore']}%</td>
+                            <td>{scores['safetyScore']}%</td>
+                            <td>{scores['communicationScore']}%</td>
+                            <td>{'Checked' if alert_flag else 'Unchecked'}</td>
+                        </tr>
                 """
 
         html_content += """
-                        </tbody>
-                    </table>
-                </div>
+                </table>
             </body>
         </html>
         """
         return HTMLResponse(content=html_content)
     except Exception as e:
-        logger.error(f"Error in /: {str(e)}")
-        return HTMLResponse(content="<h1>Error</h1><p>Failed to load dashboard. Check logs for details.</p>", status_code=500)
+        logger.error(f"Error in / endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error generating dashboard: {str(e)}")
 
 @app.post('/generate')
 async def generate_scores():
     try:
         global vendor_logs
-        vendor_logs = []
         fetched_logs = fetch_vendor_logs_from_salesforce()
+        vendor_logs = []
         for log in fetched_logs:
             scores = calculate_scores(log)
             pdf_content = generate_pdf(log.vendorId, log.vendorLogName, scores)
+            pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
             alert_flag = determine_alert_flag(scores, vendor_logs)
             store_scores_in_salesforce(log, scores, pdf_content, alert_flag)
             vendor_logs.append({
@@ -479,44 +449,11 @@ async def generate_scores():
                 'scores': scores,
                 'extracted': True
             })
-        logger.info(f"Generated scores for {len(vendor_logs)} logs")
         return {"status": "success"}
     except Exception as e:
-        logger.error(f"Error in /generate: {str(e)}")
-        raise HTTPException(status_code=500, detail="Failed to generate scores")
-
-@app.get('/debug')
-async def debug_info():
-    try:
-        log_count = sf.query("SELECT COUNT() FROM Vendor_Log__c")['totalSize']
-        fields = [f['name'] for f in sf.Vendor_Log__c.describe()['fields']]
-        score_fields = [f['name'] for f in sf.Subcontractor_Performance_Score__c.describe()['fields']]
-        # Fetch sample Hugging Face records for debugging
-        hf_records = fetch_huggingface_records() if USE_HUGGINGFACE else []
-        return {
-            "salesforce_connected": True,
-            "vendor_log_count": log_count,
-            "vendor_log_fields": fields,
-            "score_fields": score_fields,
-            "huggingface_enabled": USE_HUGGINGFACE,
-            "huggingface_records_sample": hf_records
-        }
-    except Exception as e:
-        logger.error(f"Debug error: {str(e)}")
-        return {"salesforce_connected": False, "error": str(e)}
-
-@app.get('/huggingface-records')
-async def get_huggingface_records():
-    """New endpoint to fetch and return Hugging Face records."""
-    try:
-        records = fetch_huggingface_records()
-        if not records:
-            raise HTTPException(status_code=404, detail="No records fetched from Hugging Face")
-        return {"records": records}
-    except Exception as e:
-        logger.error(f"Error fetching Hugging Face records: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Failed to fetch Hugging Face records: {str(e)}")
+        logger.error(f"Error in /generate endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error generating scores: {str(e)}")
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860)