Update app.py

app.py

@@ -1,16 +1,14 @@
-from flask import Flask, request, Response, jsonify, render_template
-from pydantic import BaseModel
+from flask import Flask, render_template
+from simple_salesforce import Salesforce
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
 import base64
 import os
 import logging
-import traceback
+from datetime import datetime, date
 import requests
-from datetime import datetime
-from simple_salesforce import Salesforce
 
-# Set up logging with more detail
+# Set up logging
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
@@ -22,10 +20,6 @@ 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(
@@ -35,378 +29,154 @@ 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")
 
-# 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
+# Store processed logs and scores
 vendor_logs = []
+subcontractor_scores = []
 
-def fetch_vendor_logs_from_salesforce():
-    """Fetch vendor logs from Salesforce to send to Hugging Face."""
+def calculate_scores(vendor_log):
+    """Calculate scores based on Vendor Log data."""
     try:
-        # Validate Salesforce session
-        if not sf.session_id:
-            logger.error("Salesforce session is invalid")
-            raise ValueError("Salesforce session is invalid")
+        # Timeliness Score: Based on Delay Days
+        delay_days = vendor_log['Delay_Days__c']
+        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'])
+
+        # Safety Score: Based on Incident Severity
+        incident_severity = vendor_log['Incident_Severity__c']
+        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']
+        communication_score = min(100.0, comm_count * 10.0)  # 10 communications = 100%
 
-        # 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
+        # Round scores
         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,
-            'finalScore': 0.0
+            'qualityScore': round(quality_score, 2),
+            'timelinessScore': round(timeliness_score, 2),
+            'safetyScore': round(safety_score, 2),
+            'communicationScore': round(communication_score, 2)
         }
-        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}")
+        # Final Score is calculated in Salesforce via Formula field
         return scores
     except Exception as e:
-        logger.error(f"Error calculating scores with Hugging Face: {str(e)}")
+        logger.error(f"Error calculating scores for Vendor Log {vendor_log['Vendor_Log_ID__c']}: {str(e)}")
         raise
 
-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):
+def generate_pdf(vendor_log, scores):
+    """Generate a PDF report for the vendor."""
     try:
+        vendor_id = vendor_log['Vendor__r']['Name']
+        vendor_name = vendor_log['Vendor__r']['Vendor_Name__c']
         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 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.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.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_content
+        return pdf_base64
     except Exception as e:
-        logger.error(f"Error generating PDF: {str(e)}")
+        logger.error(f"Error generating PDF for Vendor Log {vendor_log['Vendor_Log_ID__c']}: {str(e)}")
         raise
 
-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
+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
 
-@app.route('/score', methods=['POST'])
-def score_vendor():
     try:
-        # 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'),
+        # Fetch Vendor Logs for the current month
+        current_month = f"{today.month}-{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 Created_Month__c = :current_month
+        """
+        result = sf.query(query.replace(':current_month', f"'{current_month}'"))
+        vendor_logs = result['records']
+
+        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'),
                 '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'],
-                '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
+                'PDF_Link__c': pdf_link,
+                'Previous_Month_Score__c': previous_score
             }
-            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'],
+            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'],
                 'scores': scores,
-                'trend': trend,
-                'trend_symbol': trend_symbol,
-                'status_class': status_class,
-                'status_text': status_text
+                'pdf_link': pdf_link
             })
-
-        # 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)
+        logger.info(f"Processed {len(vendor_logs)} vendor logs.")
     except Exception as e:
-        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)
+        logger.error(f"Error processing vendor logs: {str(e)}")
+        raise
 
-@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
+@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)
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860, debug=True)