Update app.py

app.py

@@ -15,12 +15,12 @@ from dotenv import load_dotenv
 load_dotenv()
 
 # Set up logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
-# Environment variables for Salesforce
+# Environment variables
 SF_USERNAME = os.getenv("SF_USERNAME")
 SF_PASSWORD = os.getenv("SF_PASSWORD")
 SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
@@ -35,14 +35,12 @@ for var in required_env_vars:
         logger.error(f"Environment variable {var} is not set")
         raise ValueError(f"Environment variable {var} is not set")
 
-# Optional Hugging Face validation
-USE_HUGGINGFACE = HUGGINGFACE_API_KEY and HUGGINGFACE_API_URL
-if USE_HUGGINGFACE:
-    logger.info("Hugging Face integration enabled")
-else:
-    logger.info("Hugging Face integration disabled; using local scoring")
+# Hugging Face configuration
+USE_HUGGINGFACE = bool(HUGGINGFACE_API_KEY and HUGGINGFACE_API_URL)
+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,
@@ -53,9 +51,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
@@ -69,42 +67,38 @@ class VendorLog(BaseModel):
     delayDays: int
     project: str
 
-# Store vendor logs for display
+# Store vendor logs
 vendor_logs = []
 
 def validate_salesforce_fields():
-    """Verify required fields exist in Salesforce"""
+    """Validate required Salesforce fields"""
     try:
-        # Check Vendor_Log__c fields
-        vendor_log_desc = sf.Vendor_Log__c.describe()
+        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'
         ]
-        available_fields = [field['name'] for field in vendor_log_desc['fields']]
         for field in required_fields:
-            if field not in available_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")
 
-        # Check Subcontractor_Performance_Score__c fields
-        score_desc = sf.Subcontractor_Performance_Score__c.describe()
+        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'
         ]
-        available_score_fields = [field['name'] for field in score_desc['fields']]
         for field in required_score_fields:
-            if field not in available_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("All required Salesforce fields validated successfully")
+        logger.info("Salesforce fields validated successfully")
     except Exception as e:
         logger.error(f"Error validating Salesforce fields: {str(e)}")
         raise
 
-# Validate fields on startup
+# Validate schema on startup
 validate_salesforce_fields()
 
 def fetch_vendor_logs_from_salesforce():
@@ -119,42 +113,38 @@ def fetch_vendor_logs_from_salesforce():
         result = sf.query_all(query)
         logs = []
         for record in result['records']:
-            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)
-        logger.info(f"Fetched {len(logs)} vendor logs from Salesforce")
+            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 HTTPException(status_code=500, detail=f"Error fetching vendor logs: {str(e)}")
+        logger.error(f"Error fetching vendor logs: {str(e)}")
+        return []
 
 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)
 
         return {
@@ -165,39 +155,34 @@ def calculate_scores_local(log: VendorLog):
         }
     except Exception as e:
         logger.error(f"Error calculating local scores: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Error calculating scores: {str(e)}")
+        return {'qualityScore': 0.0, 'timelinessScore': 0.0, 'safetyScore': 0.0, 'communicationScore': 0.0}
 
 def calculate_scores_huggingface(log: VendorLog):
     try:
         payload = {
             'vendor_id': log.vendorId,
             'delay_days': log.delayDays,
-            '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),
             'incident_severity': log.incidentLog,
-            'communication_frequency': 5  # Placeholder; adjust as needed
+            'communication_frequency': 5
         }
-        headers = {
-            'Authorization': f'Bearer {HUGGINGFACE_API_KEY}',
-            'Content-Type': 'application/json'
-        }
-        response = requests.post(HUGGINGFACE_API_URL, json=payload, headers=headers, timeout=30)
+        headers = {'Authorization': f'Bearer {HUGGINGFACE_API_KEY}', 'Content-Type': 'application/json'}
+        response = requests.post(HUGGINGFACE_API_URL, json=payload, headers=headers, timeout=10)
         response.raise_for_status()
         result = response.json()
         return {
-            'qualityScore': round(result.get('quality_score', 0), 2),
-            'timelinessScore': round(result.get('timeliness_score', 0), 2),
-            'safetyScore': round(result.get('safety_score', 0), 2),
-            'communicationScore': round(result.get('communication_score', 0), 2)
+            'qualityScore': round(result.get('quality_score', 0.0), 2),
+            'timelinessScore': round(result.get('timeliness_score', 0.0), 2),
+            'safetyScore': round(result.get('safety_score', 0.0), 2),
+            'communicationScore': round(result.get('communication_score', 0.0), 2)
         }
     except Exception as e:
-        logger.error(f"Error calculating Hugging Face scores: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Error with Hugging Face API: {str(e)}")
+        logger.error(f"Hugging Face API error: {str(e)}")
+        return calculate_scores_local(log)  # Fallback to local scoring
 
 def calculate_scores(log: VendorLog):
-    if USE_HUGGINGFACE:
-        return calculate_scores_huggingface(log)
-    return calculate_scores_local(log)
+    return calculate_scores_huggingface(log) if USE_HUGGINGFACE else calculate_scores_local(log)
 
 def get_feedback(score: float, metric: str) -> str:
     try:
@@ -206,26 +191,11 @@ 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 HTTPException(status_code=500, detail=f"Error generating feedback: {str(e)}")
+            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:
@@ -240,34 +210,29 @@ def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
         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")})')
         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=f"Error generating PDF: {str(e)}")
+        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
-        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], default=avg_score)
+        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 HTTPException(status_code=500, detail=f"Error determining alert flag: {str(e)}")
+        return False
 
 def store_scores_in_salesforce(log: VendorLog, scores: dict, pdf_content: bytes, alert_flag: bool):
     try:
-        # Create Subcontractor_Performance_Score__c record
         score_record = sf.Subcontractor_Performance_Score__c.create({
             'Vendor__c': log.vendorRecordId,
             'Month__c': datetime.today().replace(day=1).strftime('%Y-%m-%d'),
@@ -278,9 +243,8 @@ def store_scores_in_salesforce(log: VendorLog, scores: dict, pdf_content: bytes,
             'Alert_Flag__c': alert_flag
         })
         score_record_id = score_record['id']
-        logger.info(f"Created Subcontractor_Performance_Score__c record with ID: {score_record_id}")
+        logger.info(f"Created score record: {score_record_id}")
 
-        # Upload PDF as ContentVersion
         pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
         content_version = sf.ContentVersion.create({
             'Title': f'Performance_Report_{log.vendorId}',
@@ -288,30 +252,23 @@ def store_scores_in_salesforce(log: VendorLog, scores: dict, pdf_content: bytes,
             'VersionData': pdf_base64,
             'FirstPublishLocationId': score_record_id
         })
-        logger.info(f"Uploaded PDF as ContentVersion for Vendor Log ID: {log.vendorLogId}")
-
-        # Get ContentDocumentId and construct URL
         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 found for ID: {content_version_id}")
-            raise HTTPException(status_code=500, detail="Failed to retrieve ContentDocumentId")
+            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']
         pdf_url = f"https://{sf.sf_instance}/sfc/servlet.shepherd/document/download/{content_document_id}"
 
-        # Update Subcontractor_Performance_Score__c with PDF URL
-        sf.Subcontractor_Performance_Score__c.update(score_record_id, {
-            'Certification_URL__c': pdf_url
-        })
-        logger.info(f"Updated Subcontractor_Performance_Score__c with Certification_URL__c: {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 HTTPException(status_code=500, detail=f"Error storing scores: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to store scores")
 
 @app.post('/score')
-async def score_vendor(log: VendorLog, authorization: str = Header(None)):
+async def score_vendor(log: VendorLog):
     try:
-        logger.info(f"Received Vendor Log: {log}")
         scores = calculate_scores(log)
         pdf_content = generate_pdf(log.vendorId, log.vendorLogName, scores)
         pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
@@ -347,7 +304,7 @@ async def score_vendor(log: VendorLog, authorization: str = Header(None)):
     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)
@@ -359,7 +316,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({
@@ -383,19 +339,16 @@ async def get_dashboard():
                 <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; margin: 20px; background-color: #f4f4f9; }
-                    .container { max-width: 1200px; }
-                    table { width: 100%; border-collapse: collapse; margin-top: 20px; }
-                    th, td { border: 1px solid #ddd; padding: 12px; text-align: left; }
-                    th { background-color: #007bff; color: white; }
+                    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; 
+                        border-radius: 5px; cursor: pointer; 
                     }
                     .generate-btn:hover { background-color: #45a049; }
-                    .table-striped tbody tr:nth-of-type(odd) { background-color: #f9f9f9; }
                 </style>
                 <script>
                     async function generateScores() {
@@ -407,15 +360,15 @@ async def get_dashboard():
                                 alert('Error generating scores');
                             }
                         } catch (error) {
-                            alert('Error generating scores: ' + error.message);
+                            alert('Error: ' + error.message);
                         }
                     }
                 </script>
             </head>
             <body>
                 <div class="container">
-                    <h1>SUBCONTRACTOR PERFORMANCE SCORE APP</h1>
-                    <h2>VENDOR LOGS SUBMISSION</h2>
+                    <h1>Subcontractor Performance Score App</h1>
+                    <h2>Vendor Logs</h2>
                     <table class="table table-striped">
                         <thead>
                             <tr>
@@ -431,35 +384,27 @@ async def get_dashboard():
                             </tr>
                         </thead>
                         <tbody>
-        """
-
-        if not vendor_logs:
-            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>
-                """
-
-        html_content += """
+                            {% if not vendor_logs %}
+                                <tr><td colspan="9" class="text-center">No vendor logs available</td></tr>
+                            {% else %}
+                                {% for log in vendor_logs %}
+                                    <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>
+                                {% endfor %}
+                            {% endif %}
                         </tbody>
                     </table>
                     <button class="generate-btn" onclick="generateScores()">Generate Scores</button>
-                    <h2>SUBCONTRACTOR PERFORMANCE SCORES</h2>
+                    <h2>Performance Scores</h2>
                     <table class="table table-striped">
                         <thead>
                             <tr>
@@ -474,44 +419,35 @@ async def get_dashboard():
                             </tr>
                         </thead>
                         <tbody>
-        """
-
-        if not vendor_logs:
-            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>
-                """
-
-        html_content += """
+                            {% if not vendor_logs %}
+                                <tr><td colspan="8" class="text-center">No scores available</td></tr>
+                            {% else %}
+                                {% for log in vendor_logs %}
+                                    <tr>
+                                        <td>{{ log['vendorId'] }}</td>
+                                        <td>{{ log['vendorLogName'] }}</td>
+                                        <td>{{ log['project'] }}</td>
+                                        <td>{{ log['scores']['qualityScore'] }}%</td>
+                                        <td>{{ log['scores']['timelinessScore'] }}%</td>
+                                        <td>{{ log['scores']['safetyScore'] }}%</td>
+                                        <td>{{ log['scores']['communicationScore'] }}%</td>
+                                        <td>{{ 'Checked' if determine_alert_flag(log['scores'], vendor_logs) else 'Unchecked' }}</td>
+                                    </tr>
+                                {% endfor %}
+                            {% endif %}
                         </tbody>
                     </table>
                 </div>
             </body>
         </html>
-        """
+        """.replace('{% if not vendor_logs %}', '' if not vendor_logs else '').replace(
+            '{% else %}', '').replace('{% for log in vendor_logs %}', '' if not vendor_logs else '\n'.join(
+                [html_content.split('{% for log in vendor_logs %}')[1].split('{% endfor %}')[0].format(**log) for log in vendor_logs]
+            )).replace('{% endif %}', '')
         return HTMLResponse(content=html_content)
-    except HTTPException as e:
-        raise e
     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():
@@ -522,7 +458,6 @@ async def generate_scores():
         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({
@@ -539,32 +474,28 @@ async def generate_scores():
                 'scores': scores,
                 'extracted': True
             })
-        logger.info(f"Generated scores for {len(vendor_logs)} vendor logs")
+        logger.info(f"Generated scores for {len(vendor_logs)} logs")
         return {"status": "success"}
-    except HTTPException as e:
-        raise e
     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('/health')
-async def health_check():
+@app.get('/debug')
+async def debug_info():
     try:
-        # Test Salesforce connection
-        result = sf.query("SELECT Id FROM Vendor_Log__c LIMIT 1")
+        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 {
-            "status": "healthy",
-            "salesforce_connection": "success",
-            "vendor_log_count": result['totalSize'],
+            "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"Health check failed: {str(e)}")
-        return {
-            "status": "unhealthy",
-            "salesforce_connection": f"failed: {str(e)}",
-            "huggingface_enabled": USE_HUGGINGFACE
-        }
+        logger.error(f"Debug error: {str(e)}")
+        return {"salesforce_connected": False, "error": str(e)}
 
 if __name__ == "__main__":
     import uvicorn