Update app.py

app.py

@@ -1,4 +1,4 @@
-from fastapi import FastAPI, HTTPException, Header
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
@@ -8,27 +8,37 @@ import logging
 from datetime import datetime
 from fastapi.responses import HTMLResponse
 from simple_salesforce import Salesforce
-import json
+from dotenv import load_dotenv
 
-# Set up logging to capture errors and debug information
-logging.basicConfig(level=logging.INFO)
+# Load environment variables
+load_dotenv()
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
-# Salesforce credentials
-SF_USERNAME = os.getenv("SF_USERNAME", "[email protected]")
-SF_PASSWORD = os.getenv("SF_PASSWORD", "Internal@1")
-SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN", "NbUKcTx45azba5HEdntE9YAh")
+# Environment variables from .env
+SF_USERNAME = os.getenv("SF_USERNAME")
+SF_PASSWORD = os.getenv("SF_PASSWORD")
+SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
 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")
 
-# 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")
+# 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'}")
 
-# Connect to Salesforce
+# Salesforce connection
+sf = None
 try:
     sf = Salesforce(
         username=SF_USERNAME,
@@ -39,9 +49,9 @@ try:
     logger.info("Successfully connected to Salesforce")
 except Exception as e:
     logger.error(f"Failed to connect to Salesforce: {str(e)}")
-    raise
+    raise RuntimeError(f"Cannot connect to Salesforce: {str(e)}")
 
-# VendorLog model to match Salesforce data
+# VendorLog model
 class VendorLog(BaseModel):
     vendorLogId: str
     vendorId: str
@@ -55,61 +65,86 @@ class VendorLog(BaseModel):
     delayDays: int
     project: str
 
-# Store vendor logs for display
+# Store vendor logs
 vendor_logs = []
 
+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', 'Certification_URL__c'
+        ]
+        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']:
-            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)
+            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")
         return logs
     except Exception as e:
-        logger.error(f"Error fetching vendor logs from Salesforce: {str(e)}")
-        raise
+        logger.error(f"Error fetching vendor logs: {str(e)}")
+        return []
 
-def calculate_scores(log: VendorLog):
+def calculate_scores_local(log: VendorLog):
     try:
-        work_completion_percentage = float(log.workDetails)
-        quality_percentage = float(log.qualityReport)
+        work_completion_percentage = float(log.workDetails or 0.0)
+        quality_percentage = float(log.qualityReport or 0.0)
 
-        # 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),
@@ -117,8 +152,12 @@ def calculate_scores(log: VendorLog):
             'communicationScore': round(communication_score, 2)
         }
     except Exception as e:
-        logger.error(f"Error calculating scores: {str(e)}")
-        raise
+        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):
+    # Hugging Face disabled since API key is placeholder
+    return calculate_scores_local(log)
 
 def get_feedback(score: float, metric: str) -> str:
     try:
@@ -127,30 +166,15 @@ def get_feedback(score: float, metric: str) -> str:
         elif score >= 70:
             return "Good: Keep up the good work"
         elif score >= 50:
-            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"
+            return f"Needs Improvement: {'Maintain schedules' if metric == 'Timeliness' else 'Improve quality' if metric == 'Quality' else 'Enhance safety' if metric == 'Safety' else 'Better communication'}"
         else:
-            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
+            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"
 
 def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
     try:
-        filename = f'report_{vendor_id}.pdf'
+        filename = f'report_{vendor_id}_{datetime.now().strftime("%Y%m%d%H%M%S")}.pdf'
         c = canvas.Canvas(filename, pagesize=letter)
         c.setFont('Helvetica', 12)
         c.drawString(100, 750, 'Subcontractor Performance Report')
@@ -160,49 +184,42 @@ 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
+        raise HTTPException(status_code=500, detail="Failed to generate PDF")
 
 def determine_alert_flag(scores: dict, all_logs: list):
     try:
         if not all_logs:
             return False
-        # 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
+        avg_score = sum(scores.values()) / 4
         if avg_score < 50:
             return True
-        lowest_avg = min([(log['scores']['qualityScore'] + log['scores']['timelinessScore'] + log['scores']['safetyScore'] + log['scores']['communicationScore']) / 4 for log in all_logs])
+        lowest_avg = min([sum(log['scores'].values()) / 4 for log in all_logs], default=avg_score)
         return avg_score == lowest_avg
     except Exception as e:
         logger.error(f"Error determining alert flag: {str(e)}")
-        raise
+        return False
 
 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"Successfully created Subcontractor_Performance_Score__c record with ID: {score_record_id}")
+        logger.info(f"Created score record: {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}',
@@ -210,33 +227,23 @@ 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}"
 
-        # 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}")
-
+        sf.Subcontractor_Performance_Score__c.update(score_record_id, {'Certification_URL__c': pdf_url})
+        logger.info(f"Updated score record with PDF URL: {pdf_url}")
     except Exception as e:
         logger.error(f"Error storing scores in Salesforce: {str(e)}")
-        raise
+        raise HTTPException(status_code=500, detail="Failed to store scores")
 
 @app.post('/score')
-async def score_vendor(log: VendorLog, authorization: str = Header(...)):
+async def score_vendor(log: VendorLog):
     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')
@@ -269,8 +276,10 @@ async def score_vendor(log: VendorLog, authorization: str = Header(...)):
             'pdfContent': pdf_base64,
             'alert': alert_flag
         }
+    except HTTPException as e:
+        raise e
     except Exception as e:
-        logger.error(f"Error in /score endpoint: {str(e)}")
+        logger.error(f"Error in /score: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error processing vendor log: {str(e)}")
 
 @app.get('/', response_class=HTMLResponse)
@@ -282,7 +291,6 @@ 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({
@@ -304,135 +312,132 @@ async def get_dashboard():
         <html>
             <head>
                 <title>Subcontractor Performance Score App</title>
+                <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css">
                 <style>
-                    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; }
+                    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; }
                     .generate-btn { 
-                        display: block; 
-                        margin: 20px auto; 
-                        padding: 10px 20px; 
-                        background-color: #4CAF50; 
-                        color: white; 
-                        border: none; 
-                        border-radius: 5px; 
-                        cursor: pointer; 
-                        font-size: 16px; 
+                        display: block; margin: 20px auto; padding: 10px 20px; 
+                        background-color: #4CAF50; color: white; border: none; 
+                        border-radius: 5px; cursor: pointer; 
                     }
                     .generate-btn:hover { background-color: #45a049; }
                 </style>
                 <script>
                     async function generateScores() {
-                        const response = await fetch('/generate', { method: 'POST' });
-                        if (response.ok) {
-                            window.location.reload();
-                        } else {
-                            alert('Error generating scores');
+                        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);
                         }
                     }
                 </script>
             </head>
             <body>
-                <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>
+                <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>
         """
-
         if not vendor_logs:
-            html_content += """
-                    <tr>
-                        <td colspan="9" style="text-align: center;">No vendor logs available</td>
-                    </tr>
-            """
+            html_content += '<tr><td colspan="9" class="text-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 += """
-                </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>
+                        </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>
         """
-
         if not vendor_logs:
-            html_content += """
-                    <tr>
-                        <td colspan="8" style="text-align: center;">No scores available</td>
-                    </tr>
-            """
+            html_content += '<tr><td colspan="8" class="text-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 += """
-                </table>
+                        </tbody>
+                    </table>
+                </div>
             </body>
         </html>
         """
         return HTMLResponse(content=html_content)
     except Exception as e:
-        logger.error(f"Error in / endpoint: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Error generating dashboard: {str(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)
 
 @app.post('/generate')
 async def generate_scores():
     try:
         global vendor_logs
-        fetched_logs = fetch_vendor_logs_from_salesforce()
         vendor_logs = []
+        fetched_logs = fetch_vendor_logs_from_salesforce()
         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({
@@ -449,10 +454,28 @@ 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 endpoint: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Error generating scores: {str(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']]
+        return {
+            "salesforce_connected": True,
+            "vendor_log_count": log_count,
+            "vendor_log_fields": fields,
+            "score_fields": score_fields,
+            "huggingface_enabled": USE_HUGGINGFACE
+        }
+    except Exception as e:
+        logger.error(f"Debug error: {str(e)}")
+        return {"salesforce_connected": False, "error": str(e)}
 
 if __name__ == "__main__":
     import uvicorn