Update app.py

app.py

@@ -11,15 +11,15 @@ from simple_salesforce import Salesforce
 from dotenv import load_dotenv
 from datasets import load_dataset
 
-# Load environment variables
-load_dotenv()
-
-# Set up logging
+# Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
+# Load environment variables
+load_dotenv()
+
 # Environment variables
 SF_USERNAME = os.getenv("SF_USERNAME")
 SF_PASSWORD = os.getenv("SF_PASSWORD")
@@ -66,7 +66,7 @@ class VendorLog(BaseModel):
 vendor_logs = []
 
 def validate_salesforce_fields():
-    """Validate required Salesforce fields"""
+    """Validate required Salesforce fields, log warnings if optional fields are missing."""
     try:
         vendor_log_fields = [f['name'] for f in sf.Vendor_Log__c.describe()['fields']]
         required_vendor_fields = [
@@ -82,19 +82,24 @@ def validate_salesforce_fields():
         score_fields = [f['name'] for f in sf.Subcontractor_Performance_Score__c.describe()['fields']]
         required_score_fields = [
             'Vendor_Log__c', 'Vendor__c', 'Quality_Score__c', 'Timeliness_Score__c',
-            'Safety_Score__c', 'Communication_Score__c', 'Alert_Flag__c', 'PDF_Link__c'
+            'Safety_Score__c', 'Communication_Score__c', 'Alert_Flag__c'
         ]
+        optional_score_fields = ['PDF_Link__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")
+        for field in optional_score_fields:
+            if field not in score_fields:
+                logger.warning(f"Optional field {field} not found in Subcontractor_Performance_Score__c, skipping related functionality")
         logger.info("Salesforce fields validated successfully")
+        return 'PDF_Link__c' in score_fields
     except Exception as e:
         logger.error(f"Error validating Salesforce fields: {str(e)}")
         raise
 
-# Validate fields on startup
-validate_salesforce_fields()
+# Check if PDF_Link__c exists
+has_pdf_link = validate_salesforce_fields()
 
 def fetch_huggingface_records(dataset_name: str = "imdb"):
     """Fetch records from a Hugging Face dataset."""
@@ -109,7 +114,7 @@ def fetch_huggingface_records(dataset_name: str = "imdb"):
         return []
 
 def fetch_vendor_logs_from_salesforce():
-    """Fetch vendor logs from Salesforce with null handling."""
+    """Fetch vendor logs from Salesforce with comprehensive null handling."""
     try:
         query = """
         SELECT Id, Name, Vendor__c, Work_Completion_Percentage__c, Quality_Percentage__c, 
@@ -120,41 +125,62 @@ def fetch_vendor_logs_from_salesforce():
         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")
+            # Skip records with missing critical fields
+            if not record['Vendor__c'] or not record['Id']:
+                logger.warning(f"Skipping Vendor_Log__c record with ID {record.get('Id', 'Unknown')} due to missing Vendor__c or Id")
                 continue
             # Handle null values for all fields
             delay_days = record.get('Delay_Days__c', 0)
             if delay_days is None:
-                logger.warning(f"Delay_Days__c is null for record ID {record['Id']}, defaulting to 0")
+                logger.info(f"Delay_Days__c is null for record ID {record['Id']}, defaulting to 0")
                 delay_days = 0
             work_completion = record.get('Work_Completion_Percentage__c', 0.0)
             if work_completion is None:
-                logger.warning(f"Work_Completion_Percentage__c is null for record ID {record['Id']}, defaulting to 0.0")
+                logger.info(f"Work_Completion_Percentage__c is null for record ID {record['Id']}, defaulting to 0.0")
                 work_completion = 0.0
             quality_percentage = record.get('Quality_Percentage__c', 0.0)
             if quality_percentage is None:
-                logger.warning(f"Quality_Percentage__c is null for record ID {record['Id']}, defaulting to 0.0")
+                logger.info(f"Quality_Percentage__c is null for record ID {record['Id']}, defaulting to 0.0")
                 quality_percentage = 0.0
+            incident_severity = record.get('Incident_Severity__c', 'None')
+            if incident_severity is None:
+                logger.info(f"Incident_Severity__c is null for record ID {record['Id']}, defaulting to 'None'")
+                incident_severity = 'None'
+            work_completion_date = record.get('Work_Completion_Date__c', 'N/A')
+            if work_completion_date is None:
+                logger.info(f"Work_Completion_Date__c is null for record ID {record['Id']}, defaulting to 'N/A'")
+                work_completion_date = 'N/A'
+            actual_completion_date = record.get('Actual_Completion_Date__c', 'N/A')
+            if actual_completion_date is None:
+                logger.info(f"Actual_Completion_Date__c is null for record ID {record['Id']}, defaulting to 'N/A'")
+                actual_completion_date = 'N/A'
+            project = record.get('Project__c', 'Unknown')
+            if project is None:
+                logger.info(f"Project__c is null for record ID {record['Id']}, defaulting to 'Unknown'")
+                project = 'Unknown'
+            name = record.get('Name', 'Unknown')
+            if name is None:
+                logger.info(f"Name is null for record ID {record['Id']}, defaulting to 'Unknown'")
+                name = 'Unknown'
             log = VendorLog(
-                vendorLogId=record.get('Id', 'Unknown'),
-                vendorId=record.get('Name', 'Unknown'),
-                vendorRecordId=record.get('Vendor__c', 'Unknown'),
+                vendorLogId=record['Id'],
+                vendorId=name,
+                vendorRecordId=record['Vendor__c'],
                 workDetails=str(work_completion),
                 qualityReport=str(quality_percentage),
-                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'),
+                incidentLog=incident_severity,
+                workCompletionDate=work_completion_date,
+                actualCompletionDate=actual_completion_date,
+                vendorLogName=name,
                 delayDays=int(delay_days),
-                project=record.get('Project__c', 'Unknown')
+                project=project
             )
             logs.append(log)
         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)}")
+        return []  # Return empty list to prevent dashboard crash
 
 def calculate_scores(log: VendorLog):
     """Calculate vendor performance scores."""
@@ -175,8 +201,13 @@ def calculate_scores(log: VendorLog):
             'communicationScore': round(communication_score, 2)
         }
     except Exception as e:
-        logger.error(f"Error calculating scores: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Error calculating scores: {str(e)}")
+        logger.error(f"Error calculating scores for log {log.vendorLogId}: {str(e)}")
+        return {
+            'qualityScore': 0.0,
+            'timelinessScore': 0.0,
+            'safetyScore': 0.0,
+            'communicationScore': 0.0
+        }
 
 def get_feedback(score: float, metric: str) -> str:
     """Generate feedback based on score and metric."""
@@ -227,7 +258,7 @@ def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
         os.remove(filename)
         return pdf_content
     except Exception as e:
-        logger.error(f"Error generating PDF: {str(e)}")
+        logger.error(f"Error generating PDF for vendor {vendor_id}: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error generating PDF: {str(e)}")
 
 def determine_alert_flag(scores: dict, all_logs: list):
@@ -273,11 +304,14 @@ def store_scores_in_salesforce(log: VendorLog, scores: dict, pdf_content: bytes,
             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}"
-        sf.Subcontractor_Performance_Score__c.update(score_record_id, {'PDF_Link__c': pdf_url})
-        logger.info(f"Updated Subcontractor_Performance_Score__c record with PDF URL: {pdf_url}")
+        if has_pdf_link:
+            pdf_url = f"https://{sf.sf_instance}/sfc/servlet.shepherd/document/download/{content_document_id}"
+            sf.Subcontractor_Performance_Score__c.update(score_record_id, {'PDF_Link__c': pdf_url})
+            logger.info(f"Updated Subcontractor_Performance_Score__c record with PDF URL: {pdf_url}")
+        else:
+            logger.info(f"Skipping PDF_Link__c update as field is not available")
     except Exception as e:
-        logger.error(f"Error storing scores in Salesforce: {str(e)}")
+        logger.error(f"Error storing scores in Salesforce for log {log.vendorLogId}: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error storing scores: {str(e)}")
 
 @app.post('/score')
@@ -336,7 +370,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({
@@ -360,4 +393,201 @@ async def get_dashboard():
                 <title>Subcontractor Performance Score App</title>
                 <style>
                     body { font-family: Arial, sans-serif; margin: 20px; }
-                    table { width: 100%; border-collapse: collapse; margin-top: 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; 
+                        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);
+                        }
+                    }
+                </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>
+        """
+
+        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 += """
+                </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" 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 += """
+                </table>
+            </body>
+        </html>
+        """
+        return HTMLResponse(content=html_content)
+    except Exception as e:
+        logger.error(f"Error in / endpoint: {str(e)}")
+        html_content = """
+        <html>
+            <head><title>Error</title></head>
+            <body>
+                <h1>Error Loading Dashboard</h1>
+                <p>An error occurred while loading the dashboard. Please check the server logs.</p>
+            </body>
+        </html>
+        """
+        return HTMLResponse(content=html_content)
+
+@app.post('/generate')
+async def generate_scores():
+    """Generate scores for all vendor logs."""
+    try:
+        global 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)
+            alert_flag = determine_alert_flag(scores, vendor_logs)
+            store_scores_in_salesforce(log, scores, pdf_content, alert_flag)
+            vendor_logs.append({
+                'vendorLogId': log.vendorLogId,
+                'vendorId': log.vendorId,
+                'vendorLogName': log.vendorLogName,
+                'workDetails': log.workDetails,
+                'qualityReport': log.qualityReport,
+                'incidentLog': log.incidentLog,
+                'workCompletionDate': log.workCompletionDate,
+                'actualCompletionDate': log.actualCompletionDate,
+                'delayDays': log.delayDays,
+                'project': log.project,
+                '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)}")
+        return {"status": "error", "message": str(e)}
+
+@app.get('/huggingface-records')
+async def get_huggingface_records():
+    """Fetch and return Hugging Face dataset records."""
+    try:
+        records = fetch_huggingface_records()
+        if not records:
+            logger.warning("No records fetched from Hugging Face")
+            return {"records": [], "message": "No records available"}
+        logger.info(f"Fetched {len(records)} Hugging Face records")
+        return {"records": records}
+    except Exception as e:
+        logger.error(f"Error fetching Hugging Face records: {str(e)}")
+        return {"records": [], "message": f"Failed to fetch Hugging Face records: {str(e)}"}
+
+@app.get('/debug')
+async def debug_info():
+    """Return debug information about Salesforce and Hugging Face."""
+    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']]
+        hf_records = fetch_huggingface_records()
+        return {
+            "salesforce_connected": True,
+            "vendor_log_count": log_count,
+            "vendor_log_fields": fields,
+            "score_fields": score_fields,
+            "huggingface_records_sample": hf_records[:2]  # Limit to 2 for brevity
+        }
+    except Exception as e:
+        logger.error(f"Debug error: {str(e)}")
+        return {"salesforce_connected": False, "error": str(e)}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)