Update app.py

app.py

@@ -1,14 +1,16 @@
-from flask import Flask, render_template
-from simple_salesforce import Salesforce
+from flask import Flask, request, Response, jsonify, render_template
+from pydantic import BaseModel
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
 import base64
 import os
 import logging
-from datetime import datetime, date
+import traceback
 import requests
+from datetime import datetime
+from simple_salesforce import Salesforce
 
-# Set up logging
+# Set up logging with more detail
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
@@ -20,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(
@@ -29,156 +35,378 @@ 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")
 
-# Store processed logs and scores
+# VendorLog model to match Salesforce data
+class VendorLog(BaseModel):
+    vendorLogId: str
+    vendorId: str
+    workDetails: str
+    qualityReport: str
+    incidentLog: str
+    workCompletionDate: str
+    actualCompletionDate: str
+    vendorLogName: str
+    delayDays: int
+    project: str
+
+# Store vendor logs for display
 vendor_logs = []
-subcontractor_scores = []
 
-def calculate_scores(vendor_log):
-    """Calculate scores based on Vendor Log data."""
+def fetch_vendor_logs_from_salesforce():
+    """Fetch vendor logs from Salesforce to send to Hugging Face."""
     try:
-        # Timeliness Score: Based on Delay Days
-        delay_days = vendor_log['Delay_Days__c'] if vendor_log['Delay_Days__c'] is not None else 0
-        timeliness_score = 100.0 if delay_days <= 0 else 80.0 if delay_days <= 3 else 60.0 if delay_days <= 7 else 40.0
-
-        # Quality Score: Direct mapping from Quality Percentage
-        quality_score = float(vendor_log['Quality_Percentage__c']) if vendor_log['Quality_Percentage__c'] is not None else 0.0
-
-        # Safety Score: Based on Incident Severity
-        incident_severity = vendor_log['Incident_Severity__c'] if vendor_log['Incident_Severity__c'] is not None else 'None'
-        safety_score = {
-            'None': 100.0,
-            'Low': 80.0,
-            'Minor': 80.0,
-            'Medium': 50.0,
-            'High': 20.0
-        }.get(incident_severity, 100.0)
-
-        # Communication Score: Based on Communication Count (scale 0-100)
-        comm_count = vendor_log['Communication_Count__c'] if vendor_log['Communication_Count__c'] is not None else 0
-        communication_score = min(100.0, comm_count * 10.0)  # 10 communications = 100%
+        # Validate Salesforce session
+        if not sf.session_id:
+            logger.error("Salesforce session is invalid")
+            raise ValueError("Salesforce session is invalid")
 
-        # Round scores
+        # Use a more flexible query
+        query = """
+        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 >= 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.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)}")
+        return []
+
+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)
+        # 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
         scores = {
-            'qualityScore': round(quality_score, 2),
-            'timelinessScore': round(timeliness_score, 2),
-            'safetyScore': round(safety_score, 2),
-            'communicationScore': round(communication_score, 2)
+            '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,
+            '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
+
+        # Round scores
+        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 for Vendor Log {vendor_log.get('Vendor_Log_ID__c', 'Unknown')}: {str(e)}")
+        logger.error(f"Error calculating scores with Hugging Face: {str(e)}")
         raise
 
-def generate_pdf(vendor_log, scores):
-    """Generate a PDF report for the vendor."""
+def get_feedback(score: float, metric: str) -> str:
+    try:
+        if score >= 90:
+            return "Excellent: Maintain this standard"
+        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"
+        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)}")
+        return "Feedback unavailable"
+
+def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
     try:
-        vendor_id = vendor_log['Vendor__r']['Name'] if vendor_log['Vendor__r'] and vendor_log['Vendor__r']['Name'] else 'Unknown'
-        vendor_name = vendor_log['Vendor__r']['Vendor_Name__c'] if vendor_log['Vendor__r'] and vendor_log['Vendor__r']['Vendor_Name__c'] else 'Unknown'
         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')
         c.drawString(100, 730, f'Vendor ID: {vendor_id}')
-        c.drawString(100, 710, f'Vendor Name: {vendor_name}')
-        c.drawString(100, 690, f'Quality Score: {scores["qualityScore"]}%')
-        c.drawString(100, 670, f'Timeliness Score: {scores["timelinessScore"]}%')
-        c.drawString(100, 650, f'Safety Score: {scores["safetyScore"]}%')
-        c.drawString(100, 630, f'Communication Score: {scores["communicationScore"]}%')
-        c.drawString(100, 610, 'Final Score: Calculated in Salesforce')
+        c.drawString(100, 710, f'Vendor Log Name: {vendor_log_name}')
+        c.drawString(100, 690, f'Quality Score: {scores["qualityScore"]}% ({get_feedback(scores["qualityScore"], "Quality")})')
+        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")})')
+        c.drawString(100, 610, f'Final Score: {scores["finalScore"]}%')
         c.save()
 
         with open(filename, 'rb') as f:
             pdf_content = f.read()
-        pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
         
+        # 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_base64
+        return pdf_content
     except Exception as e:
-        logger.error(f"Error generating PDF for Vendor Log {vendor_log.get('Vendor_Log_ID__c', 'Unknown')}: {str(e)}")
+        logger.error(f"Error generating PDF: {str(e)}")
         raise
 
-def fetch_and_process_logs():
-    """Fetch Vendor Logs and calculate scores on the 15th of each month."""
-    global vendor_logs, subcontractor_scores
-    today = date.today()
-    if today.day != 15:  # Only process on the 15th
-        logger.info("Today is not the 15th. Skipping processing.")
-        return
+def determine_alert_flag(final_score: float, all_logs: list):
+    try:
+        if not all_logs:
+            return False
+        if final_score < 50:
+            return True
+        lowest_score = min([log['scores']['finalScore'] for log in all_logs])
+        return final_score == lowest_score
+    except Exception as e:
+        logger.error(f"Error determining alert flag: {str(e)}")
+        return False
 
+@app.route('/score', methods=['POST'])
+def score_vendor():
     try:
-        # Fetch Vendor Logs for the current month using CreatedDate
-        current_month = today.month
-        current_year = today.year
-        query = """
-        SELECT Id, Vendor_Log_ID__c, Vendor__c, Vendor__r.Name, Vendor__r.Vendor_Name__c, Vendor__r.Contact_Email__c,
-        Project__c, Work_Completion_Date__c, Actual_Completion_Date__c, Delay_Days__c,
-        Quality_Percentage__c, Incident_Severity__c, Communication_Count__c, Work_Completion_Percentage__c
-        FROM Vendor_Log__c
-        WHERE CALENDAR_MONTH(CreatedDate) = :currentMonth AND CALENDAR_YEAR(CreatedDate) = :currentYear
-        """
-        query = query.replace(':currentMonth', str(current_month)).replace(':currentYear', str(current_year))
-        result = sf.query(query)
-        vendor_logs = result['records']
-        logger.info(f"Fetched {len(vendor_logs)} Vendor Log records for {current_month}-{current_year}")
-
-        subcontractor_scores = []
-        for log in vendor_logs:
-            # Calculate scores
-            scores = calculate_scores(log)
-            # Generate PDF
-            pdf_base64 = generate_pdf(log, scores)
-            pdf_link = f"data:application/pdf;base64,{pdf_base64}"
-
-            # Fetch previous month's score for trend calculation
-            previous_month = today.month - 1 if today.month > 1 else 12
-            previous_year = today.year if today.month > 1 else today.year - 1
-            prev_query = """
-            SELECT Final_Score__c
-            FROM Subcontractor_Performance_Score__c
-            WHERE Vendor__c = :vendorId AND CALENDAR_MONTH(Month__c) = :prevMonth AND CALENDAR_YEAR(Month__c) = :prevYear
-            """
-            prev_result = sf.query(prev_query.replace(':vendorId', f"'{log['Vendor__c']}'")
-                                    .replace(':prevMonth', str(previous_month))
-                                    .replace(':prevYear', str(previous_year)))
-            previous_score = prev_result['records'][0]['Final_Score__c'] if prev_result['records'] else 0.0
-
-            # Save to Subcontractor Performance Score
-            score_record = {
-                'Vendor__c': log['Vendor__c'],
-                'Vendor_Log__c': log['Id'],
-                'Month__c': today.strftime('%Y-%m-%d'),
+        # 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
+        log = VendorLog(**data)
+        logger.info(f"Received Vendor Log: {log}")
+
+        # 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
+        scores = calculate_scores_with_hugging_face(log)
+        
+        # Generate PDF
+        pdf_content = generate_pdf(log.vendorId, log.vendorLogName, scores)
+        pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
+
+        # Determine alert flag
+        alert_flag = determine_alert_flag(scores['finalScore'], vendor_logs)
+
+        # Store the log and scores in memory
+        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
+        })
+
+        # Save scores and PDF to Salesforce
+        try:
+            sf.Subcontractor_Performance_Score__c.create({
+                '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'],
-                'PDF_Link__c': pdf_link,
-                'Previous_Month_Score__c': previous_score
+                '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}")
+        except Exception as e:
+            logger.error(f"Error saving to Salesforce: {str(e)}")
+            # Continue even if Salesforce save fails
+
+        # Return the response
+        return jsonify({
+            'vendorLogId': log.vendorLogId,
+            'vendorId': log.vendorId,
+            'vendorLogName': log.vendorLogName,
+            'qualityScore': scores['qualityScore'],
+            'timelinessScore': scores['timelinessScore'],
+            'safetyScore': scores['safetyScore'],
+            'communicationScore': scores['communicationScore'],
+            'finalScore': scores['finalScore'],
+            'pdfContent': pdf_base64,
+            'alert': alert_flag
+        }), 200
+    except Exception as e:
+        logger.error(f"Error in /score endpoint: {str(e)}")
+        return jsonify({'error': f"Error processing vendor log: {str(e)}"}), 500
+
+@app.route('/', methods=['GET'])
+def get_dashboard():
+    try:
+        # Fetch data from Salesforce with updated field name
+        query = """
+        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'
+        """
+        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
             }
-            sf.Subcontractor_Performance_Score__c.create(score_record)
-            subcontractor_scores.append({
-                'Vendor_Log_ID__c': log['Vendor_Log_ID__c'],
-                'Vendor_Name__c': log['Vendor__r']['Vendor_Name__c'],
+            vendor_logs.append({
+                'vendorId': record.get('VendorId__c', 'Unknown'),
+                'vendorLogName': f"Vendor {record.get('VendorId__c', 'Unknown')}",
+                'scores': scores,
+                '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))
+        top_performers = sum(1 for log in vendor_logs if log['scores']['finalScore'] >= 90)
+        improving_vendors = sum(1 for log in vendor_logs if log['scores']['finalScore'] >= 70)
+
+        # Sort vendor logs by final score for leaderboard
+        sorted_logs = sorted(vendor_logs, key=lambda x: x['scores']['finalScore'], reverse=True)
+        top_logs_data = sorted_logs[:5]  # Top 5 for leaderboard
+        top_performing_logs = sorted_logs[:4]  # Top 4 for "Top Performing Vendors" section
+        alert_logs = [log for log in vendor_logs if determine_alert_flag(log['scores']['finalScore'], vendor_logs)][:3]
+
+        # Prepare data for the leaderboard
+        top_logs = []
+        for idx, log in enumerate(top_logs_data, 1):
+            scores = log['scores']
+            alert_flag = determine_alert_flag(scores['finalScore'], vendor_logs)
+            trend = "trend-up" if scores['finalScore'] >= 90 else "trend-down" if scores['finalScore'] < 70 else "trend-flat"
+            trend_symbol = "↗" if trend == "trend-up" else "↘" if trend == "trend-down" else "—"
+            status_class = "status-good" if not alert_flag else "status-alert"
+            status_text = "Good" if not alert_flag else "Alert"
+            top_logs.append({
+                'idx': idx,
+                'vendorLogName': log['vendorLogName'],
                 'scores': scores,
-                'pdf_link': pdf_link
+                'trend': trend,
+                'trend_symbol': trend_symbol,
+                'status_class': status_class,
+                'status_text': status_text
             })
-        logger.info(f"Processed {len(vendor_logs)} vendor logs and created {len(subcontractor_scores)} score records.")
+
+        # 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:
-        logger.error(f"Error processing vendor logs: {str(e)}")
-        raise
+        error_trace = traceback.format_exc()
+        logger.error(f"Error in / endpoint: {str(e)}\nStack trace:\n{error_trace}")
+        # 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('/')
-def index():
-    # Process logs if today is the 15th
-    fetch_and_process_logs()
-    return render_template('index.html', vendor_logs=vendor_logs, subcontractor_scores=subcontractor_scores)
+@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)