Update app.py

app.py

@@ -10,23 +10,24 @@ from fastapi.responses import HTMLResponse
 from simple_salesforce import Salesforce
 import json
 
-# Set up logging to capture errors and debug information
+# Set up logging
 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")
+# Environment variables for Salesforce
+SF_USERNAME = os.getenv("SF_USERNAME")
+SF_PASSWORD = os.getenv("SF_PASSWORD")
+SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
 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")
+# Validate environment variables
+required_env_vars = ["SF_USERNAME", "SF_PASSWORD", "SF_SECURITY_TOKEN"]
+for var in required_env_vars:
+    if not os.getenv(var):
+        logger.error(f"Environment variable {var} is not set")
+        raise ValueError(f"Environment variable {var} is not set")
 
 # Connect to Salesforce
 try:
@@ -61,9 +62,9 @@ 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
-               
+        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)
@@ -83,13 +84,14 @@ def fetch_vendor_logs_from_salesforce():
                 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"
+                project=record['Project__c'] or "Unknown"
             )
             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
+        raise HTTPException(status_code=500, detail=f"Error fetching vendor logs: {str(e)}")
 
 def calculate_scores(log: VendorLog):
     try:
@@ -109,7 +111,6 @@ def calculate_scores(log: VendorLog):
         # 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),
@@ -118,7 +119,7 @@ def calculate_scores(log: VendorLog):
         }
     except Exception as e:
         logger.error(f"Error calculating scores: {str(e)}")
-        raise
+        raise HTTPException(status_code=500, detail=f"Error calculating scores: {str(e)}")
 
 def get_feedback(score: float, metric: str) -> str:
     try:
@@ -146,7 +147,7 @@ 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
+        raise HTTPException(status_code=500, detail=f"Error generating feedback: {str(e)}")
 
 def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
     try:
@@ -160,7 +161,6 @@ def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
         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:
@@ -169,40 +169,40 @@ def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
         return pdf_content
     except Exception as e:
         logger.error(f"Error generating PDF: {str(e)}")
-        raise
+        raise HTTPException(status_code=500, detail=f"Error generating PDF: {str(e)}")
 
 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
+        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])
+        lowest_avg = min([(log['scores']['qualityScore'] + log['scores']['timelinessScore'] + 
+                           log['scores']['safetyScore'] + log['scores']['communicationScore']) / 4 
+                          for log in all_logs], default=avg_score)
         return avg_score == lowest_avg
     except Exception as e:
         logger.error(f"Error determining alert flag: {str(e)}")
-        raise
+        raise HTTPException(status_code=500, detail=f"Error determining alert flag: {str(e)}")
 
 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
+        # Create Subcontractor_Performance_Score__c record
         score_record = sf.Subcontractor_Performance_Score__c.create({
-            'Vendor_Log__c': log.vendorLogId,
             'Vendor__c': log.vendorRecordId,
+            'Month__c': datetime.today().replace(day=1).strftime('%Y-%m-%d'),
             '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}")
+        logger.info(f"Created Subcontractor_Performance_Score__c record with ID: {score_record_id}")
 
-        # Step 2: Upload the PDF as a ContentVersion
+        # Upload PDF as ContentVersion
         pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
         content_version = sf.ContentVersion.create({
             'Title': f'Performance_Report_{log.vendorId}',
@@ -210,32 +210,34 @@ def store_scores_in_salesforce(log: VendorLog, scores: dict, pdf_content: bytes,
             'VersionData': pdf_base64,
             'FirstPublishLocationId': score_record_id
         })
-        logger.info(f"Successfully uploaded PDF as ContentVersion for Vendor Log ID: {log.vendorLogId}")
+        logger.info(f"Uploaded PDF as ContentVersion for Vendor Log ID: {log.vendorLogId}")
 
-        # Step 3: Get the ContentDocumentId and construct a URL to the file
+        # Get ContentDocumentId and construct URL
         content_version_id = content_version['id']
         content_version_record = sf.query(f"SELECT ContentDocumentId FROM ContentVersion WHERE Id = '{content_version_id}'")
+        if content_version_record['totalSize'] == 0:
+            logger.error(f"No ContentVersion found for ID: {content_version_id}")
+            raise HTTPException(status_code=500, detail="Failed to retrieve ContentDocumentId")
         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
+        # Update Subcontractor_Performance_Score__c with PDF URL
+        # Note: Changed PDF_Link__c to Certification_URL__c to match your previous Salesforce schema
         sf.Subcontractor_Performance_Score__c.update(score_record_id, {
-            'PDF_Link__c': pdf_url
+            'Certification_URL__c': pdf_url
         })
-        logger.info(f"Successfully updated Subcontractor_Performance_Score__c record with PDF URL: {pdf_url}")
-
+        logger.info(f"Updated Subcontractor_Performance_Score__c with Certification_URL__c: {pdf_url}")
     except Exception as e:
         logger.error(f"Error storing scores in Salesforce: {str(e)}")
-        raise
+        raise HTTPException(status_code=500, detail=f"Error storing scores: {str(e)}")
 
 @app.post('/score')
-async def score_vendor(log: VendorLog, authorization: str = Header(...)):
+async def score_vendor(log: VendorLog, authorization: str = Header(None)):
     try:
         logger.info(f"Received Vendor Log: {log}")
-        if authorization != f'Bearer {API_KEY}':
-            raise HTTPException(status_code=401, detail='Invalid API key')
+        # Optional: Add API key check if needed
+        # 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)
@@ -269,6 +271,8 @@ async def score_vendor(log: VendorLog, authorization: str = Header(...)):
             'pdfContent': pdf_base64,
             'alert': alert_flag
         }
+    except HTTPException as e:
+        raise e
     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)}")
@@ -325,11 +329,15 @@ async def get_dashboard():
                 </style>
                 <script>
                     async function generateScores() {
-                        const response = await fetch('/generate', { method: 'POST' });
-                        if (response.ok) {
-                            window.location.reload();
-                        } else {
-                            alert('Error generating scores');
+                        try {
+                            const response = await fetch('/generate', { method: 'POST' });
+                            if (response.ok) {
+                                window.location.reload();
+                            } else {
+                                alert('Error generating scores');
+                            }
+                        } catch (error) {
+                            alert('Error generating scores: ' + error.message);
                         }
                     }
                 </script>
@@ -419,6 +427,8 @@ async def get_dashboard():
         </html>
         """
         return HTMLResponse(content=html_content)
+    except HTTPException as e:
+        raise e
     except Exception as e:
         logger.error(f"Error in / endpoint: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error generating dashboard: {str(e)}")
@@ -427,8 +437,8 @@ async def get_dashboard():
 async def generate_scores():
     try:
         global vendor_logs
-        fetched_logs = fetch_vendor_logs_from_salesforce()
         vendor_logs = []
+        fetched_logs = fetch_vendor_logs_from_salesforce()
         for log in fetched_logs:
             scores = calculate_scores(log)
             pdf_content = generate_pdf(log.vendorId, log.vendorLogName, scores)
@@ -449,7 +459,10 @@ async def generate_scores():
                 'scores': scores,
                 'extracted': True
             })
+        logger.info(f"Generated scores for {len(vendor_logs)} vendor logs")
         return {"status": "success"}
+    except HTTPException as e:
+        raise e
     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)}")