Update app.py

app.py

@@ -154,7 +154,7 @@ def create_salesforce_record(score, checklist_summary, missing_summary, status,
             "Status__c": status,
             "Summarized_Missing_Items__c": summarized_missing,
             "Alert_Sent__c": alert_sent,
-            "Client_PDF_Pack_URL__c": pdf_url if pdf_url else "",  # Use the publicly accessible URL
+            "Client_PDF_Pack_URL__c": pdf_url if pdf_url else "",
             "Closure_Pack_URL__c": "",
             "Escalation_Flag__c": escalation_flag,
             "Evaluated_At__c": evaluated_at,
@@ -181,11 +181,15 @@ def create_salesforce_record(score, checklist_summary, missing_summary, status,
         logging.error(f"Failed to create Salesforce Project_Closure_Handover__c record: {str(e)}")
         return f"Error creating record: {str(e)}"
 
-# Clean input to prevent injection attacks
+# Clean input to prevent injection attacks and ensure PDF compatibility
 def sanitize_input(text):
     if not text or not isinstance(text, str):
         return ""
-    return bleach.clean(text.strip())
+    # Clean HTML and strip whitespace
+    cleaned = bleach.clean(text.strip(), tags=[], attributes={})
+    # Replace non-ASCII characters with a space
+    cleaned = cleaned.encode('ascii', 'replace').decode('ascii').replace('?', ' ')
+    return cleaned
 
 # Rule-based completeness engine with weighted scoring
 def evaluate_readiness(logs, qa_report, punch_list_text):
@@ -261,73 +265,127 @@ def evaluate_readiness(logs, qa_report, punch_list_text):
 # Generate PDF report with signature slots and return a publicly accessible URL
 def generate_pdf(score, checklist_summary, missing_summary, checklist_status, logs, qa_report, punch_list_text):
     try:
-        # Sanitize inputs
+        # Sanitize inputs and handle None values
         logging.info("Sanitizing inputs for PDF generation")
         score = str(float(score)) if score is not None else "0"
-        checklist_summary = str(checklist_summary) if checklist_summary is not None else ""
-        checklist_status = str(checklist_status) if checklist_status is not None else ""
-
-        checklist_summary = checklist_summary.encode('ascii', 'ignore').decode('ascii')
-        checklist_status = checklist_status.encode('ascii', 'ignore').decode('ascii')
-
+        checklist_summary = sanitize_input(checklist_summary) if checklist_summary else "No checklist summary provided"
+        missing_summary = sanitize_input(missing_summary) if missing_summary else "None"
+        checklist_status = sanitize_input(checklist_status) if checklist_status else "Unknown"
+        logs = sanitize_input(logs) if logs else "No logs provided"
+        qa_report = sanitize_input(qa_report) if qa_report else "No QA report provided"
+        punch_list_text = sanitize_input(punch_list_text) if punch_list_text else "No punch list provided"
+
+        # Define the temporary file path
         pdf_path = "readiness_report.pdf"
-        logging.info(f"Creating PDF at {pdf_path}")
+        logging.info(f"Attempting to create PDF at {pdf_path}")
 
+        # Ensure the directory is writable
+        pdf_dir = os.path.dirname(pdf_path) or "."
+        if not os.access(pdf_dir, os.W_OK):
+            logging.error(f"No write permissions in directory: {pdf_dir}")
+            raise PermissionError(f"No write permissions in directory: {pdf_dir}")
+
+        # Create the PDF using reportlab
         c = canvas.Canvas(pdf_path, pagesize=letter)
         
-        c.setFont("Times-Bold", 16)
+        # Set initial font and draw title
+        logging.info("Setting font to Times-Bold for title")
+        try:
+            c.setFont("Times-Bold", 16)
+        except Exception as e:
+            logging.error(f"Font error: {str(e)}. Falling back to default font.")
+            c.setFont("Helvetica-Bold", 16)  # Fallback font
         c.drawString(50, 750, "Project Closure Readiness Report")
         
-        c.setFont("Times-Roman", 12)
+        # Draw basic fields
+        logging.info("Drawing basic fields")
+        try:
+            c.setFont("Times-Roman", 12)
+        except Exception as e:
+            logging.error(f"Font error: {str(e)}. Falling back to default font.")
+            c.setFont("Helvetica", 12)  # Fallback font
         c.drawString(50, 720, f"Readiness Score: {score}%")
         c.drawString(50, 700, f"Status: {checklist_status}")
         c.drawString(50, 680, "Checklist Summary:")
 
+        # Draw checklist summary with Y-position overflow handling
+        logging.info("Drawing checklist summary")
         y = 660
         BOTTOM_MARGIN = 50
-        for line in checklist_summary.split("\n"):
+        LINE_HEIGHT = 20
+        lines = checklist_summary.split("\n")
+        if not lines:
+            lines = ["No checklist summary available"]
+        for line in lines:
+            # Truncate long lines to prevent overflow
+            if len(line) > 80:  # Approximate character limit per line
+                line = line[:77] + "..."
             if y < BOTTOM_MARGIN:
                 logging.info("Y position below margin, creating new page")
                 c.showPage()
-                c.setFont("Times-Roman", 12)
+                try:
+                    c.setFont("Times-Roman", 12)
+                except:
+                    c.setFont("Helvetica", 12)
+                y = 750
+            c.drawString(50, y, line)
+            y -= LINE_HEIGHT
+
+        # Draw additional sections
+        logging.info("Drawing missing summary")
+        y -= 20
+        c.drawString(50, y, "Missing Items:")
+        y -= LINE_HEIGHT
+        missing_lines = missing_summary.split("\n") if missing_summary else ["None"]
+        for line in missing_lines:
+            if len(line) > 80:
+                line = line[:77] + "..."
+            if y < BOTTOM_MARGIN:
+                c.showPage()
+                try:
+                    c.setFont("Times-Roman", 12)
+                except:
+                    c.setFont("Helvetica", 12)
                 y = 750
             c.drawString(50, y, line)
-            y -= 20
+            y -= LINE_HEIGHT
 
+        # Draw signature slots
+        logging.info("Drawing signature slots")
+        y -= 20
         if y - 40 < BOTTOM_MARGIN:
             logging.info("Y position below margin, creating new page")
             c.showPage()
-            c.setFont("Times-Roman", 12)
+            try:
+                c.setFont("Times-Roman", 12)
+            except:
+                c.setFont("Helvetica", 12)
             y = 750
-        c.drawString(50, y - 40, "Stakeholder Signature: ____________________")
+        c.drawString(50, y - 20, "Stakeholder Signature: ____________________")
 
+        y -= 20
         if y - 60 < BOTTOM_MARGIN:
             logging.info("Y position below margin, creating new page")
             c.showPage()
-            c.setFont("Times-Roman", 12)
+            try:
+                c.setFont("Times-Roman", 12)
+            except:
+                c.setFont("Helvetica", 12)
             y = 750
-        c.drawString(50, y - 60, "Date: ____________________")
+        c.drawString(50, y - 40, "Date: ____________________")
 
+        # Finalize the PDF
+        logging.info("Finalizing PDF")
         c.save()
 
+        # Confirm the file exists
         if not os.path.exists(pdf_path):
             logging.error(f"PDF file {pdf_path} was not created")
             raise FileNotFoundError(f"PDF file {pdf_path} was not created")
 
         # Simulate uploading the PDF to a publicly accessible location
-        # In a real implementation, you'd upload to a service like AWS S3, Google Drive, or a file-sharing service
-        # and get a publicly accessible URL. For this example, we'll simulate a URL.
-        # Replace this with actual upload logic as needed.
         simulated_public_url = f"https://example.com/pdf/readiness_report_{int(time.time())}.pdf"
         logging.info(f"Simulated public URL for PDF: {simulated_public_url}")
-        
-        # TODO: Implement actual file upload to a service like AWS S3 or Google Drive
-        # Example with AWS S3 (requires boto3 and AWS credentials):
-        # import boto3
-        # s3 = boto3.client('s3', aws_access_key_id='YOUR_KEY', aws_secret_access_key='YOUR_SECRET')
-        # bucket_name = 'your-bucket'
-        # s3.upload_file(pdf_path, bucket_name, f"readiness_report_{int(time.time())}.pdf", ExtraArgs={'ACL': 'public-read'})
-        # public_url = f"https://{bucket_name}.s3.amazonaws.com/readiness_report_{int(time.time())}.pdf"
 
         logging.info(f"PDF generated successfully at {pdf_path}")
         return simulated_public_url, "PDF generation completed. Click the link to download."