Update app.py

app.py

@@ -10,8 +10,8 @@ import requests
 from datetime import datetime
 from simple_salesforce import Salesforce
 
-# Set up logging to capture errors and debug information
-logging.basicConfig(level=logging.INFO)
+# Set up logging with more detail
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 app = Flask(__name__)
@@ -35,6 +35,12 @@ try:
         domain=SF_DOMAIN
     )
     logger.info("Successfully connected to Salesforce")
+
+    # Debug: Describe the Subcontractor_Performance_Score__c object to log its fields
+    object_description = sf.Subcontractor_Performance_Score__c.describe()
+    logger.info("Fields on Subcontractor_Performance_Score__c:")
+    for field in object_description['fields']:
+        logger.info(f"Field Name: {field['name']}")
 except Exception as e:
     logger.error(f"Failed to connect to Salesforce: {str(e)}")
     raise ValueError("Failed to connect to Salesforce")
@@ -58,33 +64,41 @@ vendor_logs = []
 def fetch_vendor_logs_from_salesforce():
     """Fetch vendor logs from Salesforce to send to Hugging Face."""
     try:
+        # Validate Salesforce session
+        if not sf.session_id:
+            logger.error("Salesforce session is invalid")
+            raise ValueError("Salesforce session is invalid")
+
+        # Use a more flexible query
         query = """
-        SELECT Id, Vendor_Log_Id__c, Vendor_Id__c, Work_Details__c, Quality_Report__c, 
+        SELECT Id, Vendor_Log_Id__c, VendorId__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
+        WHERE CreatedDate >= 2025-05-01T00:00:00Z AND CreatedDate <= 2025-05-31T23:59:59Z
         """
         result = sf.query(query)
         logs = []
         for record in result['records']:
+            # Handle missing fields with defaults
             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']
+                vendorLogId=record.get('Vendor_Log_Id__c', 'Unknown'),
+                vendorId=record.get('VendorId__c', 'Unknown'),
+                workDetails=record.get('Work_Details__c', '0% completed'),
+                qualityReport=record.get('Quality_Report__c', '0% quality'),
+                incidentLog=record.get('Incident_Log__c', 'None'),
+                workCompletionDate=record.get('Work_Completion_Date__c', '2025-05-01'),
+                actualCompletionDate=record.get('Actual_Completion_Date__c', '2025-05-01'),
+                vendorLogName=record.get('Vendor_Log_Name__c', 'Unknown Vendor'),
+                delayDays=record.get('Delay_Days__c', 0),
+                project=record.get('Project__c', 'Unknown Project')
             )
             logs.append(log)
+        logger.info(f"Fetched {len(logs)} vendor logs from Salesforce")
         return logs
     except Exception as e:
         logger.error(f"Error fetching vendor logs from Salesforce: {str(e)}")
-        raise
+        return []
 
 def calculate_scores_with_hugging_face(log: VendorLog):
     """Send data to Hugging Face and get scores (mocked for now)."""
@@ -100,6 +114,9 @@ def calculate_scores_with_hugging_face(log: VendorLog):
         # 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)
+        # if response.status_code != 200:
+        #     logger.error(f"Hugging Face API error: {response.text}")
+        #     raise ValueError("Failed to get scores from Hugging Face")
         # scores = response.json()
 
         # Mocked response for now
@@ -107,8 +124,8 @@ def calculate_scores_with_hugging_face(log: VendorLog):
             '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
+            'communicationScore': 0.0,
+            'finalScore': 0.0
         }
         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
@@ -117,6 +134,7 @@ def calculate_scores_with_hugging_face(log: VendorLog):
         for key in scores:
             scores[key] = round(scores[key], 2)
 
+        logger.debug(f"Calculated scores for vendor {log.vendorId}: {scores}")
         return scores
     except Exception as e:
         logger.error(f"Error calculating scores with Hugging Face: {str(e)}")
@@ -148,11 +166,11 @@ def get_feedback(score: float, metric: str) -> str:
                 return "Poor: Communication issues detected"
     except Exception as e:
         logger.error(f"Error generating feedback: {str(e)}")
-        raise
+        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')
@@ -167,7 +185,13 @@ def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
 
         with open(filename, 'rb') as f:
             pdf_content = f.read()
-        os.remove(filename)
+        
+        # Clean up the file
+        try:
+            os.remove(filename)
+        except Exception as e:
+            logger.warning(f"Could not delete temporary PDF file {filename}: {str(e)}")
+
         return pdf_content
     except Exception as e:
         logger.error(f"Error generating PDF: {str(e)}")
@@ -183,7 +207,7 @@ def determine_alert_flag(final_score: float, all_logs: list):
         return final_score == lowest_score
     except Exception as e:
         logger.error(f"Error determining alert flag: {str(e)}")
-        raise
+        return False
 
 @app.route('/score', methods=['POST'])
 def score_vendor():
@@ -191,11 +215,13 @@ def score_vendor():
         # Validate the Authorization header
         authorization = request.headers.get('Authorization')
         if not authorization:
+            logger.warning("Authorization header missing in request")
             return jsonify({'error': 'Authorization header missing'}), 401
 
         # Parse the request data
         data = request.get_json()
         if not data:
+            logger.warning("Invalid or missing JSON data in request")
             return jsonify({'error': 'Invalid request data'}), 400
 
         # Validate and create VendorLog instance
@@ -204,6 +230,7 @@ def score_vendor():
 
         # Validate Salesforce session
         if not sf.session_id:
+            logger.error("Salesforce session invalid")
             return jsonify({'error': 'Salesforce session invalid'}), 401
 
         # Calculate scores using Hugging Face
@@ -232,17 +259,17 @@ def score_vendor():
             'extracted': True
         })
 
-        # Save scores and PDF to Salesforce (Subcontractor_Performance_Score__c object)
+        # Save scores and PDF to Salesforce
         try:
             sf.Subcontractor_Performance_Score__c.create({
-                'Vendor_ID__c': log.vendorId,
+                'VendorId__c': log.vendorId,  # Updated field name
                 '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'],  # 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)
+                'Final_Score__c': scores['finalScore'],
+                'Certification_URL__c': pdf_base64,
                 'Alert_Flag__c': alert_flag
             })
             logger.info(f"Successfully saved scores to Salesforce for Vendor Log: {log.vendorLogId}")
@@ -270,27 +297,35 @@ def score_vendor():
 @app.route('/', methods=['GET'])
 def get_dashboard():
     try:
-        # Fetch data from Salesforce (Subcontractor_Performance_Score__c)
+        # Fetch data from Salesforce with updated field name
         query = """
-        SELECT Vendor_ID__c, Month__c, Quality_Score__c, Timeliness_Score__c, 
+        SELECT VendorId__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
+        try:
+            result = sf.query(query)
+        except Exception as e:
+            logger.error(f"Error querying Salesforce: {str(e)}")
+            # Fallback to empty data to render the dashboard
+            result = {'records': []}
+
+        vendor_logs.clear()
         for record in result['records']:
+            # Handle missing or null scores
+            scores = {
+                'qualityScore': record.get('Quality_Score__c', 0.0) or 0.0,
+                'timelinessScore': record.get('Timeliness_Score__c', 0.0) or 0.0,
+                'safetyScore': record.get('Safety_Score__c', 0.0) or 0.0,
+                'communicationScore': record.get('Communication_Score__c', 0.0) or 0.0,
+                'finalScore': record.get('Final_Score__c', 0.0) or 0.0
+            }
             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']
-                },
+                'vendorId': record.get('VendorId__c', 'Unknown'),
+                'vendorLogName': f"Vendor {record.get('VendorId__c', 'Unknown')}",
+                'scores': scores,
                 'extracted': True
             })
 
@@ -325,25 +360,44 @@ def get_dashboard():
                 'status_text': status_text
             })
 
-        # Render the template with the data
-        return render_template('dashboard.html',
-            total_vendors=total_vendors,
-            performance_alerts=performance_alerts,
-            percent_alerts=round(performance_alerts/total_vendors*100, 1) if total_vendors else 0,
-            top_performers=top_performers,
-            percent_top=round(top_performers/total_vendors*100, 1) if total_vendors else 0,
-            improving_vendors=improving_vendors,
-            percent_improving=round(improving_vendors/total_vendors*100, 1) if total_vendors else 0,
-            top_logs=top_logs,
-            alert_logs=alert_logs,
-            top_performing_logs=top_performing_logs,
-            vendor_logs=vendor_logs,
-            sorted_logs=sorted_logs
-        )
+        # Ensure all variables are defined for the template
+        template_data = {
+            'total_vendors': total_vendors,
+            'performance_alerts': performance_alerts,
+            'percent_alerts': round(performance_alerts/total_vendors*100, 1) if total_vendors else 0,
+            'top_performers': top_performers,
+            'percent_top': round(top_performers/total_vendors*100, 1) if total_vendors else 0,
+            'improving_vendors': improving_vendors,
+            'percent_improving': round(improving_vendors/total_vendors*100, 1) if total_vendors else 0,
+            'top_logs': top_logs,
+            'alert_logs': alert_logs,
+            'top_performing_logs': top_performing_logs,
+            'vendor_logs': vendor_logs,
+            'sorted_logs': sorted_logs
+        }
+
+        logger.info(f"Rendering dashboard with data: {template_data}")
+        return render_template('dashboard.html', **template_data)
     except Exception as e:
         error_trace = traceback.format_exc()
         logger.error(f"Error in / endpoint: {str(e)}\nStack trace:\n{error_trace}")
-        return jsonify({'error': f"Error generating dashboard: {str(e)}"}), 500
+        # Fallback to render the dashboard with empty data
+        template_data = {
+            'total_vendors': 0,
+            'performance_alerts': 0,
+            'percent_alerts': 0,
+            'top_performers': 0,
+            'percent_top': 0,
+            'improving_vendors': 0,
+            'percent_improving': 0,
+            'top_logs': [],
+            'alert_logs': [],
+            'top_performing_logs': [],
+            'vendor_logs': [],
+            'sorted_logs': []
+        }
+        logger.info("Rendering dashboard with fallback data due to error")
+        return render_template('dashboard.html', **template_data)
 
 @app.route('/document', methods=['GET'])
 def get_document():