Create app.py

app.py

@@ -0,0 +1,459 @@
+from fastapi import FastAPI, HTTPException, Header
+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
+from fastapi.responses import HTMLResponse
+from simple_salesforce import Salesforce
+import json
+
+# Set up logging to capture errors and debug information
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+# Salesforce credentials
+SF_USERNAME = os.getenv("SF_USERNAME", "scores@app.com")
+SF_PASSWORD = os.getenv("SF_PASSWORD", "Internal@1")
+SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN", "NbUKcTx45azba5HEdntE9YAh")
+SF_DOMAIN = os.getenv("SF_DOMAIN", "login")
+
+# Verify API key is set
+API_KEY = os.getenv("HUGGINGFACE_API_KEY")
+if not API_KEY:
+    logger.error("HUGGINGFACE_API_KEY environment variable not set")
+    raise ValueError("HUGGINGFACE_API_KEY environment variable not set")
+
+# Connect to Salesforce
+try:
+    sf = Salesforce(
+        username=SF_USERNAME,
+        password=SF_PASSWORD,
+        security_token=SF_SECURITY_TOKEN,
+        domain=SF_DOMAIN
+    )
+    logger.info("Successfully connected to Salesforce")
+except Exception as e:
+    logger.error(f"Failed to connect to Salesforce: {str(e)}")
+    raise
+
+# VendorLog model to match Salesforce data
+class VendorLog(BaseModel):
+    vendorLogId: str
+    vendorId: str
+    vendorRecordId: str
+    workDetails: str
+    qualityReport: str
+    incidentLog: str
+    workCompletionDate: str
+    actualCompletionDate: str
+    vendorLogName: str
+    delayDays: int
+    project: str
+
+# Store vendor logs for display
+vendor_logs = []
+
+def fetch_vendor_logs_from_salesforce():
+    try:
+        query = """
+        SELECT Id, Name, Vendor__c, Work_Completion_Percentage__c, Quality_Percentage__c, Incident_Severity__c, 
+               Work_Completion_Date__c, Actual_Completion_Date__c, Delay_Days__c,Project__c
+               
+        FROM Vendor_Log__c
+        """
+        result = sf.query_all(query)
+        logs = []
+        for record in result['records']:
+            if not record['Vendor__c']:
+                logger.warning(f"Skipping Vendor_Log__c record with ID {record['Id']} due to missing Vendor__c")
+                continue
+            log = VendorLog(
+                vendorLogId=record['Id'] or "Unknown",
+                vendorId=record['Name'] or "Unknown",
+                vendorRecordId=record['Vendor__c'] or "Unknown",
+                workDetails=str(record['Work_Completion_Percentage__c'] or "0.0"),
+                qualityReport=str(record['Quality_Percentage__c'] or "0.0"),
+                incidentLog=record['Incident_Severity__c'] or "None",
+                workCompletionDate=record['Work_Completion_Date__c'] or "N/A",
+                actualCompletionDate=record['Actual_Completion_Date__c'] or "N/A",
+                vendorLogName=record['Name'] or "Unknown",
+                delayDays=int(record['Delay_Days__c'] or 0),
+                 project=record['Project__c'] or "Unknown"
+            )
+            logs.append(log)
+        return logs
+    except Exception as e:
+        logger.error(f"Error fetching vendor logs from Salesforce: {str(e)}")
+        raise
+
+def calculate_scores(log: VendorLog):
+    try:
+        work_completion_percentage = float(log.workDetails)
+        quality_percentage = float(log.qualityReport)
+
+        # 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
+
+        # 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)
+
+        # Communication Score: Weighted average of other scores
+        communication_score = (quality_score * 0.33 + timeliness_score * 0.33 + safety_score * 0.33)
+
+        # Removed finalScore calculation since Final_Score__c is a Formula field
+        return {
+            'qualityScore': round(quality_score, 2),
+            'timelinessScore': round(timeliness_score, 2),
+            'safetyScore': round(safety_score, 2),
+            'communicationScore': round(communication_score, 2)
+        }
+    except Exception as e:
+        logger.error(f"Error calculating scores: {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)}")
+        raise
+
+def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
+    try:
+        filename = f'report_{vendor_id}.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")})')
+        # Removed Final Score from PDF since it's a Formula field
+        c.save()
+
+        with open(filename, 'rb') as f:
+            pdf_content = f.read()
+        os.remove(filename)
+        return pdf_content
+    except Exception as e:
+        logger.error(f"Error generating PDF: {str(e)}")
+        raise
+
+def determine_alert_flag(scores: dict, all_logs: list):
+    try:
+        if not all_logs:
+            return False
+        # Since finalScore is a Formula field, we'll need to fetch it from Salesforce or adjust logic
+        # For now, we'll base the alert on the average of other scores
+        avg_score = (scores['qualityScore'] + scores['timelinessScore'] + scores['safetyScore'] + scores['communicationScore']) / 4
+        if avg_score < 50:
+            return True
+        lowest_avg = min([(log['scores']['qualityScore'] + log['scores']['timelinessScore'] + log['scores']['safetyScore'] + log['scores']['communicationScore']) / 4 for log in all_logs])
+        return avg_score == lowest_avg
+    except Exception as e:
+        logger.error(f"Error determining alert flag: {str(e)}")
+        raise
+
+def store_scores_in_salesforce(log: VendorLog, scores: dict, pdf_content: bytes, alert_flag: bool):
+    try:
+        # Step 1: Create the Subcontractor_Performance_Score__c record without Final_Score__c
+        score_record = sf.Subcontractor_Performance_Score__c.create({
+            'Vendor_Log__c': log.vendorLogId,
+            'Vendor__c': log.vendorRecordId,
+            'Quality_Score__c': scores['qualityScore'],
+            'Timeliness_Score__c': scores['timelinessScore'],
+            'Safety_Score__c': scores['safetyScore'],
+            'Communication_Score__c': scores['communicationScore'],
+            'Alert_Flag__c': alert_flag
+            # Removed Final_Score__c since it's a Formula field
+        })
+        score_record_id = score_record['id']
+        logger.info(f"Successfully created Subcontractor_Performance_Score__c record with ID: {score_record_id}")
+
+        # Step 2: Upload the PDF as a ContentVersion
+        pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
+        content_version = sf.ContentVersion.create({
+            'Title': f'Performance_Report_{log.vendorId}',
+            'PathOnClient': f'report_{log.vendorId}.pdf',
+            'VersionData': pdf_base64,
+            'FirstPublishLocationId': score_record_id
+        })
+        logger.info(f"Successfully uploaded PDF as ContentVersion for Vendor Log ID: {log.vendorLogId}")
+
+        # Step 3: Get the ContentDocumentId and construct a URL to the file
+        content_version_id = content_version['id']
+        content_version_record = sf.query(f"SELECT ContentDocumentId FROM ContentVersion WHERE Id = '{content_version_id}'")
+        content_document_id = content_version_record['records'][0]['ContentDocumentId']
+        
+        # Construct the URL to the file
+        pdf_url = f"https://{sf.sf_instance}/sfc/servlet.shepherd/document/download/{content_document_id}"
+
+        # Step 4: Update the Subcontractor_Performance_Score__c record with the PDF URL
+        sf.Subcontractor_Performance_Score__c.update(score_record_id, {
+            'PDF_Link__c': pdf_url
+        })
+        logger.info(f"Successfully updated Subcontractor_Performance_Score__c record with PDF URL: {pdf_url}")
+
+    except Exception as e:
+        logger.error(f"Error storing scores in Salesforce: {str(e)}")
+        raise
+
+@app.post('/score')
+async def score_vendor(log: VendorLog, authorization: str = Header(...)):
+    try:
+        logger.info(f"Received Vendor Log: {log}")
+        if authorization != f'Bearer {API_KEY}':
+            raise HTTPException(status_code=401, detail='Invalid API key')
+
+        scores = calculate_scores(log)
+        pdf_content = generate_pdf(log.vendorId, log.vendorLogName, scores)
+        pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
+        alert_flag = determine_alert_flag(scores, vendor_logs)
+        store_scores_in_salesforce(log, scores, pdf_content, alert_flag)
+
+        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
+        })
+
+        return {
+            'vendorLogId': log.vendorLogId,
+            'vendorId': log.vendorId,
+            'vendorLogName': log.vendorLogName,
+            'qualityScore': scores['qualityScore'],
+            'timelinessScore': scores['timelinessScore'],
+            'safetyScore': scores['safetyScore'],
+            'communicationScore': scores['communicationScore'],
+            'pdfContent': pdf_base64,
+            'alert': alert_flag
+        }
+    except Exception as e:
+        logger.error(f"Error in /score endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error processing vendor log: {str(e)}")
+
+@app.get('/', response_class=HTMLResponse)
+async def get_dashboard():
+    try:
+        global vendor_logs
+        fetched_logs = fetch_vendor_logs_from_salesforce()
+        for log in fetched_logs:
+            if not any(existing_log['vendorLogId'] == log.vendorLogId for existing_log in vendor_logs):
+                scores = calculate_scores(log)
+                pdf_content = generate_pdf(log.vendorId, log.vendorLogName, scores)
+                pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
+                alert_flag = determine_alert_flag(scores, vendor_logs)
+                store_scores_in_salesforce(log, scores, pdf_content, alert_flag)
+                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
+                })
+
+        html_content = """
+        <html>
+            <head>
+                <title>Subcontractor Performance Score App</title>
+                <style>
+                    body { font-family: Arial, sans-serif; margin: 20px; }
+                    table { width: 100%; border-collapse: collapse; margin-top: 20px; }
+                    th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+                    th { background-color: #f2f2f2; }
+                    h1, h2 { text-align: center; }
+                    .generate-btn { 
+                        display: block; 
+                        margin: 20px auto; 
+                        padding: 10px 20px; 
+                        background-color: #4CAF50; 
+                        color: white; 
+                        border: none; 
+                        border-radius: 5px; 
+                        cursor: pointer; 
+                        font-size: 16px; 
+                    }
+                    .generate-btn:hover { background-color: #45a049; }
+                </style>
+                <script>
+                    async function generateScores() {
+                        const response = await fetch('/generate', { method: 'POST' });
+                        if (response.ok) {
+                            window.location.reload();
+                        } else {
+                            alert('Error generating scores');
+                        }
+                    }
+                </script>
+            </head>
+            <body>
+                <h1>SUBCONTRACTOR PERFORMANCE SCORE APP GENERATOR</h1>
+                <h2>VENDOR LOGS SUBMISSION</h2>
+                <table>
+                    <tr>
+                        <th>Vendor ID</th>
+                        <th>Vendor Log Name</th>
+                        <th>Project</th>
+                        <th>Work Completion Percentage</th>
+                        <th>Quality Percentage</th>
+                        <th>Incident Severity</th>
+                        <th>Work Completion Date</th>
+                        <th>Actual Completion Date</th>
+                        <th>Delay Days</th>
+                    </tr>
+        """
+
+        if not vendor_logs:
+            html_content += """
+                    <tr>
+                        <td colspan="9" style="text-align: center;">No vendor logs available</td>
+                    </tr>
+            """
+        else:
+            for log in vendor_logs:
+                html_content += f"""
+                        <tr>
+                            <td>{log['vendorId']}</td>
+                            <td>{log['vendorLogName']}</td>
+                            <td>{log['project']}</td>
+                            <td>{log['workDetails']}</td>
+                            <td>{log['qualityReport']}</td>
+                            <td>{log['incidentLog']}</td>
+                            <td>{log['workCompletionDate']}</td>
+                            <td>{log['actualCompletionDate']}</td>
+                            <td>{log['delayDays']}</td>
+                        </tr>
+                """
+
+        html_content += """
+                </table>
+                <button class="generate-btn" onclick="generateScores()">Generate</button>
+                <h2>SUBCONTRACTOR PERFORMANCE SCORES</h2>
+                <table>
+                    <tr>
+                        <th>Vendor ID</th>
+                        <th>Vendor Log Name</th>
+                        <th>Project</th>
+                        <th>Quality Score</th>
+                        <th>Timeliness Score</th>
+                        <th>Safety Score</th>
+                        <th>Communication Score</th>
+                        <th>Alert Flag</th>
+                    </tr>
+        """
+
+        if not vendor_logs:
+            html_content += """
+                    <tr>
+                        <td colspan="8" style="text-align: center;">No scores available</td>
+                    </tr>
+            """
+        else:
+            for log in vendor_logs:
+                scores = log['scores']
+                alert_flag = determine_alert_flag(scores, vendor_logs)
+                html_content += f"""
+                        <tr>
+                            <td>{log['vendorId']}</td>
+                            <td>{log['vendorLogName']}</td>
+                            <td>{log['project']}</td>
+                            <td>{scores['qualityScore']}%</td>
+                            <td>{scores['timelinessScore']}%</td>
+                            <td>{scores['safetyScore']}%</td>
+                            <td>{scores['communicationScore']}%</td>
+                            <td>{'Checked' if alert_flag else 'Unchecked'}</td>
+                        </tr>
+                """
+
+        html_content += """
+                </table>
+            </body>
+        </html>
+        """
+        return HTMLResponse(content=html_content)
+    except Exception as e:
+        logger.error(f"Error in / endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error generating dashboard: {str(e)}")
+
+@app.post('/generate')
+async def generate_scores():
+    try:
+        global vendor_logs
+        fetched_logs = fetch_vendor_logs_from_salesforce()
+        vendor_logs = []
+        for log in fetched_logs:
+            scores = calculate_scores(log)
+            pdf_content = generate_pdf(log.vendorId, log.vendorLogName, scores)
+            pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
+            alert_flag = determine_alert_flag(scores, vendor_logs)
+            store_scores_in_salesforce(log, scores, pdf_content, alert_flag)
+            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
+            })
+        return {"status": "success"}
+    except Exception as e:
+        logger.error(f"Error in /generate endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error generating scores: {str(e)}")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)