Update app.py

app.py

@@ -6,6 +6,7 @@ import base64
 import os
 import logging
 import traceback
+import requests
 from datetime import datetime
 from simple_salesforce import Salesforce
 
@@ -21,6 +22,10 @@ SF_PASSWORD = "Internal@1"
 SF_SECURITY_TOKEN = "NbUKcTx45azba5HEdntE9YAh"
 SF_DOMAIN = "login"
 
+# Hugging Face API details (mocked for now)
+HUGGING_FACE_API_URL = "https://api-inference.huggingface.co/models/your-model-name"
+HUGGING_FACE_API_TOKEN = "your-hugging-face-api-token"
+
 # Initialize Salesforce connection
 try:
     sf = Salesforce(
@@ -50,37 +55,71 @@ class VendorLog(BaseModel):
 # Store vendor logs for display
 vendor_logs = []
 
-def calculate_scores(log: VendorLog):
+def fetch_vendor_logs_from_salesforce():
+    """Fetch vendor logs from Salesforce to send to Hugging Face."""
     try:
-        # Extract percentages from the string fields
-        work_completion_percentage = float(log.workDetails.replace('% completed', ''))
-        quality_percentage = float(log.qualityReport.replace('% quality', ''))
-
-        # 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
+        query = """
+        SELECT Id, Vendor_Log_Id__c, Vendor_Id__c, Work_Details__c, Quality_Report__c, 
+        Incident_Log__c, Work_Completion_Date__c, Actual_Completion_Date__c, 
+        Vendor_Log_Name__c, Delay_Days__c, Project__c 
+        FROM Vendor_Log__c 
+        WHERE CreatedDate = THIS_MONTH
+        """
+        result = sf.query(query)
+        logs = []
+        for record in result['records']:
+            log = VendorLog(
+                vendorLogId=record['Vendor_Log_Id__c'],
+                vendorId=record['Vendor_Id__c'],
+                workDetails=record['Work_Details__c'],
+                qualityReport=record['Quality_Report__c'],
+                incidentLog=record['Incident_Log__c'],
+                workCompletionDate=record['Work_Completion_Date__c'],
+                actualCompletionDate=record['Actual_Completion_Date__c'],
+                vendorLogName=record['Vendor_Log_Name__c'],
+                delayDays=record['Delay_Days__c'],
+                project=record['Project__c']
+            )
+            logs.append(log)
+        return logs
+    except Exception as e:
+        logger.error(f"Error fetching vendor logs from Salesforce: {str(e)}")
+        raise
 
-        # 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)
+def calculate_scores_with_hugging_face(log: VendorLog):
+    """Send data to Hugging Face and get scores (mocked for now)."""
+    try:
+        # Prepare data for Hugging Face
+        payload = {
+            "workDetails": log.workDetails,
+            "qualityReport": log.qualityReport,
+            "incidentLog": log.incidentLog,
+            "delayDays": log.delayDays
+        }
+        
+        # Mocked Hugging Face API call (replace with actual API call)
+        # headers = {"Authorization": f"Bearer {HUGGING_FACE_API_TOKEN}"}
+        # response = requests.post(HUGGING_FACE_API_URL, json=payload, headers=headers)
+        # scores = response.json()
 
-        # Communication Score: Weighted average of other scores
-        communication_score = (quality_score * 0.33 + timeliness_score * 0.33 + safety_score * 0.33)
+        # Mocked response for now
+        scores = {
+            'qualityScore': float(log.qualityReport.replace('% quality', '')),
+            'timelinessScore': 100.0 if log.delayDays <= 0 else 80.0 if log.delayDays <= 3 else 60.0 if log.delayDays <= 7 else 40.0,
+            'safetyScore': {'None': 100.0, 'Low': 80.0, 'Minor': 80.0, 'Medium': 50.0, 'High': 20.0}.get(log.incidentLog, 100.0),
+            'communicationScore': 0.0,  # Will be calculated below
+            'finalScore': 0.0  # Will be calculated below
+        }
+        scores['communicationScore'] = (scores['qualityScore'] * 0.33 + scores['timelinessScore'] * 0.33 + scores['safetyScore'] * 0.33)
+        scores['finalScore'] = (scores['qualityScore'] + scores['timelinessScore'] + scores['safetyScore'] + scores['communicationScore']) / 4
 
-        # Final Score: Average of all scores
-        final_score = (quality_score + timeliness_score + safety_score + communication_score) / 4
+        # Round scores
+        for key in scores:
+            scores[key] = round(scores[key], 2)
 
-        return {
-            'qualityScore': round(quality_score, 2),
-            'timelinessScore': round(timeliness_score, 2),
-            'safetyScore': round(safety_score, 2),
-            'communicationScore': round(communication_score, 2),
-            'finalScore': round(final_score, 2)
-        }
+        return scores
     except Exception as e:
-        logger.error(f"Error calculating scores: {str(e)}")
+        logger.error(f"Error calculating scores with Hugging Face: {str(e)}")
         raise
 
 def get_feedback(score: float, metric: str) -> str:
@@ -167,8 +206,8 @@ def score_vendor():
         if not sf.session_id:
             return jsonify({'error': 'Salesforce session invalid'}), 401
 
-        # Calculate scores
-        scores = calculate_scores(log)
+        # Calculate scores using Hugging Face
+        scores = calculate_scores_with_hugging_face(log)
         
         # Generate PDF
         pdf_content = generate_pdf(log.vendorId, log.vendorLogName, scores)
@@ -177,7 +216,7 @@ def score_vendor():
         # Determine alert flag
         alert_flag = determine_alert_flag(scores['finalScore'], vendor_logs)
 
-        # Store the log and scores
+        # Store the log and scores in memory
         vendor_logs.append({
             'vendorLogId': log.vendorLogId,
             'vendorId': log.vendorId,
@@ -193,19 +232,18 @@ def score_vendor():
             'extracted': True
         })
 
-        # Optionally, save scores back to Salesforce
+        # Save scores and PDF to Salesforce (Subcontractor_Performance_Score__c object)
         try:
-            sf.Vendor_Log__c.create({
-                'Vendor_Log_Id__c': log.vendorLogId,
-                'Vendor_Id__c': log.vendorId,
-                'Vendor_Log_Name__c': log.vendorLogName,
+            sf.Subcontractor_Performance_Score__c.create({
+                'Vendor_ID__c': log.vendorId,
+                'Month__c': datetime.now().strftime('%Y-%m-%d'),
                 'Quality_Score__c': scores['qualityScore'],
                 'Timeliness_Score__c': scores['timelinessScore'],
                 'Safety_Score__c': scores['safetyScore'],
                 'Communication_Score__c': scores['communicationScore'],
-                'Final_Score__c': scores['finalScore'],
-                'Alert_Flag__c': alert_flag,
-                'PDF_Content__c': pdf_base64
+                'Final_Score__c': scores['finalScore'],  # Note: This may be a formula field in Salesforce
+                'Certification_URL__c': pdf_base64,  # Store base64 PDF (or upload to Salesforce Files and store URL)
+                'Alert_Flag__c': alert_flag
             })
             logger.info(f"Successfully saved scores to Salesforce for Vendor Log: {log.vendorLogId}")
         except Exception as e:
@@ -232,6 +270,30 @@ def score_vendor():
 @app.route('/', methods=['GET'])
 def get_dashboard():
     try:
+        # Fetch data from Salesforce (Subcontractor_Performance_Score__c)
+        query = """
+        SELECT Vendor_ID__c, Month__c, Quality_Score__c, Timeliness_Score__c, 
+        Safety_Score__c, Communication_Score__c, Final_Score__c, Certification_URL__c, 
+        Alert_Flag__c 
+        FROM Subcontractor_Performance_Score__c 
+        WHERE Month__c = '2025-05-01'
+        """
+        result = sf.query(query)
+        vendor_logs.clear()  # Clear existing logs and repopulate from Salesforce
+        for record in result['records']:
+            vendor_logs.append({
+                'vendorId': record['Vendor_ID__c'],
+                'vendorLogName': f"Vendor {record['Vendor_ID__c']}",  # Placeholder; fetch actual name if needed
+                'scores': {
+                    'qualityScore': record['Quality_Score__c'],
+                    'timelinessScore': record['Timeliness_Score__c'],
+                    'safetyScore': record['Safety_Score__c'],
+                    'communicationScore': record['Communication_Score__c'],
+                    'finalScore': record['Final_Score__c']
+                },
+                'extracted': True
+            })
+
         # Calculate summary metrics
         total_vendors = len(vendor_logs)
         performance_alerts = sum(1 for log in vendor_logs if determine_alert_flag(log['scores']['finalScore'], vendor_logs))
@@ -283,5 +345,14 @@ def get_dashboard():
         logger.error(f"Error in / endpoint: {str(e)}\nStack trace:\n{error_trace}")
         return jsonify({'error': f"Error generating dashboard: {str(e)}"}), 500
 
+@app.route('/document', methods=['GET'])
+def get_document():
+    try:
+        return render_template('document.html')
+    except Exception as e:
+        error_trace = traceback.format_exc()
+        logger.error(f"Error in /document endpoint: {str(e)}\nStack trace:\n{error_trace}")
+        return jsonify({'error': f"Error generating document: {str(e)}"}), 500
+
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860, debug=True)