Update app.py

app.py

@@ -1,16 +1,15 @@
-from flask import Flask, request, Response, jsonify, render_template
+from flask import Flask, request, Response, jsonify, render_template, send_file
 from pydantic import BaseModel
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
 import base64
 import os
 import logging
-import traceback
-import requests
+import io
 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 +21,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(
@@ -36,16 +31,20 @@ try:
     )
     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']}")
+    # Debug: Describe objects for field verification
+    for obj in ['Subcontractor_Performance_Score__c', 'Vendor_Log__c']:
+        try:
+            description = getattr(sf, obj).describe()
+            logger.info(f"Fields on {obj}:")
+            for field in description['fields']:
+                logger.info(f"Field Name: {field['name']}")
+        except Exception as e:
+            logger.error(f"Error describing {obj}: {str(e)}")
 except Exception as e:
     logger.error(f"Failed to connect to Salesforce: {str(e)}")
-    raise ValueError("Failed to connect to Salesforce")
+    sf = None
 
-# VendorLog model to match Salesforce data
+# VendorLog model
 class VendorLog(BaseModel):
     vendorLogId: str
     vendorId: str
@@ -62,14 +61,12 @@ class VendorLog(BaseModel):
 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")
+    """Fetch vendor logs from Salesforce."""
+    if not sf:
+        logger.error("Salesforce connection not initialized")
+        return []
 
-        # Use a more flexible query
+    try:
         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, 
@@ -80,7 +77,6 @@ def fetch_vendor_logs_from_salesforce():
         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'),
@@ -97,29 +93,48 @@ def fetch_vendor_logs_from_salesforce():
         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)}")
+        logger.error(f"Error fetching vendor logs: {str(e)}")
+        return []
+
+def fetch_performance_scores():
+    """Fetch performance scores from Salesforce."""
+    if not sf:
+        logger.error("Salesforce connection not initialized")
         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
+        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'
+        """
+        result = sf.query(query)
+        scores = []
+        for record in result['records']:
+            scores.append({
+                'vendorId': record.get('VendorId__c', 'Unknown'),
+                'vendorLogName': f"Vendor {record.get('VendorId__c', 'Unknown')}",
+                '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
+                },
+                'certification_url': record.get('Certification_URL__c', ''),
+                'alert_flag': record.get('Alert_Flag__c', False)
+            })
+        logger.info(f"Fetched {len(scores)} performance scores from Salesforce")
+        return scores
+    except Exception as e:
+        logger.error(f"Error fetching performance scores: {str(e)}")
+        return []
+
+def calculate_scores(log: VendorLog):
+    """Calculate scores for a vendor log."""
+    try:
         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,
@@ -130,15 +145,18 @@ def calculate_scores_with_hugging_face(log: VendorLog):
         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 with Hugging Face: {str(e)}")
-        raise
+        logger.error(f"Error calculating scores: {str(e)}")
+        return {
+            'qualityScore': 0.0,
+            'timelinessScore': 0.0,
+            'safetyScore': 0.0,
+            'communicationScore': 0.0,
+            'finalScore': 0.0
+        }
 
 def get_feedback(score: float, metric: str) -> str:
     try:
@@ -147,31 +165,18 @@ def get_feedback(score: float, metric: str) -> str:
         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"
+            return f"Needs Improvement: Enhance {metric.lower()} performance"
         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"
+            return f"Poor: Critical issues in {metric.lower()}"
     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):
+    """Generate a PDF report for a vendor."""
     try:
-        filename = f'report_{vendor_id}_{datetime.now().strftime("%Y%m%d_%H%M%S")}.pdf'
-        c = canvas.Canvas(filename, pagesize=letter)
+        buffer = io.BytesIO()
+        c = canvas.Canvas(buffer, pagesize=letter)
         c.setFont('Helvetica', 12)
         c.drawString(100, 750, 'Subcontractor Performance Report')
         c.drawString(100, 730, f'Vendor ID: {vendor_id}')
@@ -181,23 +186,16 @@ def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
         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, 590, f'Generated On: May 15, 2025, 12:01 PM IST')
         c.save()
-
-        with open(filename, 'rb') as f:
-            pdf_content = f.read()
-        
-        # 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
+        buffer.seek(0)
+        return buffer
     except Exception as e:
         logger.error(f"Error generating PDF: {str(e)}")
         raise
 
 def determine_alert_flag(final_score: float, all_logs: list):
+    """Determine if an alert flag should be set."""
     try:
         if not all_logs:
             return False
@@ -211,58 +209,32 @@ def determine_alert_flag(final_score: float, all_logs: list):
 
 @app.route('/score', methods=['POST'])
 def score_vendor():
+    """Score a vendor and save to Salesforce."""
     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)
+        scores = calculate_scores(log)
         
-        # Generate PDF
-        pdf_content = generate_pdf(log.vendorId, log.vendorLogName, scores)
+        pdf_buffer = generate_pdf(log.vendorId, log.vendorLogName, scores)
+        pdf_content = pdf_buffer.getvalue()
         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:
+        if sf:
             sf.Subcontractor_Performance_Score__c.create({
-                'VendorId__c': log.vendorId,  # Updated field name
+                'VendorId__c': log.vendorId,
                 'Month__c': datetime.now().strftime('%Y-%m-%d'),
                 'Quality_Score__c': scores['qualityScore'],
                 'Timeliness_Score__c': scores['timelinessScore'],
@@ -272,76 +244,84 @@ def score_vendor():
                 '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
+            logger.info(f"Saved scores to Salesforce for Vendor Log: {log.vendorLogId}")
 
-        # 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'],
+            'scores': scores,
             '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
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/generate_report', methods=['POST'])
+def generate_report():
+    """Generate a report for a selected vendor."""
+    try:
+        data = request.form
+        vendor_name = data.get('vendor_name')
+        report_month = data.get('report_month', 'May, 2025')
+
+        # Fetch the vendor's performance score
+        performance_scores = fetch_performance_scores()
+        vendor_data = next((v for v in performance_scores if v['vendorLogName'] == vendor_name), None)
+
+        if not vendor_data:
+            return jsonify({'error': 'Vendor not found'}), 404
+
+        # Generate PDF
+        pdf_buffer = generate_pdf(vendor_data['vendorId'], vendor_name, vendor_data['scores'])
+        
+        # Save to Salesforce
+        pdf_content = pdf_buffer.getvalue()
+        pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
+        if sf:
+            sf.Subcontractor_Performance_Score__c.update(vendor_data['vendorId'], {
+                'Certification_URL__c': pdf_base64
+            })
+
+        return send_file(
+            pdf_buffer,
+            attachment_filename=f'report_{vendor_data["vendorId"]}_{datetime.now().strftime("%Y%m%d_%H%M%S")}.pdf',
+            as_attachment=True
+        )
+    except Exception as e:
+        logger.error(f"Error in /generate_report endpoint: {str(e)}")
+        return jsonify({'error': str(e)}), 500
 
 @app.route('/', methods=['GET'])
 def get_dashboard():
+    """Render the dashboard with Salesforce data."""
     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': []}
+        # Fetch data from Salesforce
+        performance_scores = fetch_performance_scores()
+        vendor_logs_list = fetch_vendor_logs_from_salesforce()
 
+        # Prepare data for dashboard
         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
-            }
+        for score in performance_scores:
             vendor_logs.append({
-                'vendorId': record.get('VendorId__c', 'Unknown'),
-                'vendorLogName': f"Vendor {record.get('VendorId__c', 'Unknown')}",
-                'scores': scores,
+                'vendorLogId': score['vendorId'],
+                'vendorId': score['vendorId'],
+                'vendorLogName': score['vendorLogName'],
+                'scores': score['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
+        top_logs_data = sorted_logs[:5]
+        top_performing_logs = sorted_logs[:4]
         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']
@@ -360,7 +340,6 @@ def get_dashboard():
                 'status_text': status_text
             })
 
-        # Ensure all variables are defined for the template
         template_data = {
             'total_vendors': total_vendors,
             'performance_alerts': performance_alerts,
@@ -373,15 +352,14 @@ def get_dashboard():
             'alert_logs': alert_logs,
             'top_performing_logs': top_performing_logs,
             'vendor_logs': vendor_logs,
-            'sorted_logs': sorted_logs
+            'sorted_logs': sorted_logs,
+            'vendor_names': [log.vendorLogName for log in vendor_logs_list],
+            'report_month': 'May, 2025'
         }
 
-        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}")
-        # Fallback to render the dashboard with empty data
+        logger.error(f"Error in / endpoint: {str(e)}")
         template_data = {
             'total_vendors': 0,
             'performance_alerts': 0,
@@ -394,19 +372,20 @@ def get_dashboard():
             'alert_logs': [],
             'top_performing_logs': [],
             'vendor_logs': [],
-            'sorted_logs': []
+            'sorted_logs': [],
+            'vendor_names': [],
+            'report_month': 'May, 2025'
         }
-        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():
+    """Render the document page."""
     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
+        logger.error(f"Error in /document endpoint: {str(e)}")
+        return jsonify({'error': str(e)}), 500
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860, debug=True)