Update app.py

app.py

@@ -10,7 +10,6 @@ from retry import retry
 import time
 from datetime import datetime
 import base64
-import uuid
 
 # Print statement to confirm script initialization
 print("Starting Project Closure Readiness Evaluator app...")
@@ -65,10 +64,12 @@ else:
 def init_salesforce():
     if not SALESFORCE_AVAILABLE:
         logging.error("Salesforce library not available. Skipping connection.")
-        return None, None, "Salesforce library not available"
+        return None, "Salesforce library not available"
 
     try:
-        logging.info("Attempting to connect to Salesforce...")
+        logging.info("Attempting to connect to Salesforce with the following credentials:")
+        logging.info(f"Username: {SF_USERNAME}")
+        logging.info(f"Instance URL: {SF_INSTANCE_URL}")
         sf = Salesforce(
             username=SF_USERNAME,
             password=SF_PASSWORD,
@@ -76,55 +77,13 @@ def init_salesforce():
             instance_url=SF_INSTANCE_URL
         )
         logging.info("Salesforce connected successfully")
-
         # Test read access on Project_Closure_Handover__c
         test_query = sf.query("SELECT Id FROM Project_Closure_Handover__c LIMIT 1")
-        logging.info(f"Test query result (read access on Project_Closure_Handover__c): {test_query}")
-
-        # Describe Project_Closure_Handover__c to find the related object for Project_ID__c
+        logging.info(f"Test query result (read access): {test_query}")
+        # Test create access by attempting to describe the object and check permissions
         object_description = sf.Project_Closure_Handover__c.describe()
-        project_id_field = None
-        for field in object_description['fields']:
-            if field['name'] == 'Project_ID__c':
-                project_id_field = field
-                break
-
-        if not project_id_field:
-            logging.error("Project_ID__c field not found on Project_Closure_Handover__c")
-            return None, None, "Project_ID__c field not found on Project_Closure_Handover__c"
-
-        # Check if Project_ID__c is a reference (Lookup) field
-        if not project_id_field['referenceTo']:
-            logging.error("Project_ID__c is not a reference field. It must be a Lookup or Master-Detail field.")
-            return None, None, "Project_ID__c is not a reference field"
-
-        related_object = project_id_field['referenceTo'][0]  # e.g., 'Projects__c'
-        logging.info(f"Project_ID__c references object: {related_object}")
-
-        # Test read access on the related object
-        related_query = sf.query(f"SELECT Id FROM {related_object} LIMIT 1")
-        logging.info(f"{related_object} test query result (read access): {related_query}")
-
-        # Describe the related object to log its fields (for debugging)
-        related_object_description = getattr(sf, related_object).describe()
-        related_fields = [field['name'] for field in related_object_description['fields']]
-        logging.info(f"Fields on {related_object}: {related_fields}")
-
-        # Log some sample data from the related object to confirm records exist
-        sample_data_query = sf.query(f"SELECT Id, Name FROM {related_object} LIMIT 5")
-        logging.info(f"Sample data from {related_object}: {sample_data_query['records']}")
-
-        # Test object permissions for Project_Closure_Handover__c
-        permissions = {
-            "createable": object_description.get("createable", False),
-            "updateable": object_description.get("updateable", False)
-        }
-        logging.info(f"Object permissions for Project_Closure_Handover__c: {permissions}")
-        if not permissions["createable"]:
-            logging.error("User lacks create permission on Project_Closure_Handover__c")
-            return None, None, "User lacks create permission on Project_Closure_Handover__c"
-
-        return sf, related_object, "Salesforce connected successfully"
+        logging.info(f"Object description: {object_description}")
+        return sf, "Salesforce connected successfully"
     except SalesforceError as e:
         logging.error(f"Salesforce authentication failed: {str(e)}")
         logging.error("Possible issues: Incorrect credentials, IP restrictions, or insufficient permissions.")
@@ -134,37 +93,6 @@ def init_salesforce():
         logging.error("Check your Salesforce org settings, network restrictions, or API access.")
         raise
 
-# Function to get the Salesforce record ID for a project based on its custom identifier
-def get_project_record_id(sf, related_object, project_code):
-    try:
-        # Sanitize the project_code to prevent SOQL injection
-        project_code = bleach.clean(project_code.strip())
-
-        # Try multiple fields to match the project_code
-        fields_to_try = ['Name', 'Project_Code__c', 'External_ID__c']
-        record_id = None
-        for field in fields_to_try:
-            query = f"SELECT Id FROM {related_object} WHERE {field} = '{project_code}' LIMIT 1"
-            logging.info(f"Trying query: {query}")
-            result = sf.query(query)
-            logging.debug(f"Query result for {field}: {result}")
-            if result['totalSize'] > 0:
-                record_id = result['records'][0]['Id']
-                logging.info(f"Found project record ID: {record_id} for {field}: {project_code} in {related_object}")
-                return record_id, "Success"
-            else:
-                logging.info(f"No project found with {field}: {project_code} in {related_object}")
-
-        # If no record is found after trying all fields
-        logging.error(f"No project found with {project_code} in {related_object} after trying fields: {fields_to_try}")
-        return None, f"No project found with {project_code} in {related_object} after trying fields: {fields_to_try}"
-    except SalesforceError as e:
-        logging.error(f"Failed to query project record: {str(e)}")
-        return None, f"Salesforce query error: {str(e)}"
-    except Exception as e:
-        logging.error(f"Error querying project record: {str(e)}")
-        return None, f"Error querying project: {str(e)}"
-
 # Summarize text using Hugging Face Inference API
 def summarize_text(text, max_length=100, min_length=30):
     if not HF_AVAILABLE:
@@ -186,68 +114,48 @@ def summarize_text(text, max_length=100, min_length=30):
         return text  # Fallback to original text
 
 # Create Salesforce record in custom object Project_Closure_Handover__c
-def create_salesforce_record(project_id, score, checklist_summary, missing_summary, status, escalated, logs, qa_report, punch_list_text, open_punch_items, pdf_path=None):
+def create_salesforce_record(score, checklist_summary, missing_summary, status, escalated, logs, qa_report, punch_list_text, open_punch_items, pdf_path=None):
     if not SALESFORCE_AVAILABLE:
         logging.error("Salesforce library not available. Skipping record creation.")
         return "Salesforce library not available"
 
     try:
-        sf, related_object, connection_message = init_salesforce()
-        if not sf or not related_object:
+        sf, connection_message = init_salesforce()
+        if not sf:
             logging.error(f"Skipping Salesforce record creation due to connection failure: {connection_message}")
             return connection_message
 
-        # Get the Salesforce record ID for the project
-        project_record_id, project_query_message = get_project_record_id(sf, related_object, project_id)
-        if not project_record_id:
-            logging.error(f"Failed to get project record ID: {project_query_message}")
-            return f"Error: {project_query_message}"
-
-        # Summarize checklist_summary and missing_summary
+        # Summarize checklist_summary and missing_summary using Hugging Face
         summarized_checklist = summarize_text(checklist_summary)
         summarized_missing = summarize_text(missing_summary)
 
         # Ensure inputs are properly formatted
-        project_id = str(project_id)[:80] if project_id else "Unknown"  # For display purposes
         score = float(score) if score is not None else 0.0
-        checklist_summary = str(checklist_summary)[:131072] if checklist_summary else ""
-        summarized_checklist = str(summarized_checklist)[:131072] if summarized_checklist else ""
-        missing_summary = str(missing_summary)[:131072] if missing_summary else ""
-        summarized_missing = str(summarized_missing)[:131072] if summarized_missing else ""
-        status = str(status)[:255] if status else ""
-        logs = str(logs)[:131072] if logs else ""
-        qa_report = str(qa_report)[:131072] if qa_report else ""
-        punch_list_text = str(punch_list_text)[:131072] if punch_list_text else ""
+        checklist_summary = str(checklist_summary) if checklist_summary else ""
+        summarized_checklist = str(summarized_checklist) if summarized_checklist else ""
+        missing_summary = str(missing_summary) if missing_summary else ""
+        summarized_missing = str(summarized_missing) if summarized_missing else ""
+        status = str(status) if status else ""
+        logs = str(logs) if logs else ""
+        qa_report = str(qa_report) if qa_report else ""
+        punch_list_text = str(punch_list_text) if punch_list_text else ""
         missing_documents = len(missing_summary.split(", ")) if missing_summary and missing_summary != "None" else 0
         open_punch_items = int(open_punch_items) if open_punch_items is not None else 0
-        evaluated_at = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
-        alert_sent = "true" if escalated else "false"
-        escalation_flag = "true" if escalated else "false"
+        evaluated_at = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")  # Salesforce Date/Time format
+        alert_sent = str(bool(escalated)).lower()  # Converts True/False to "true"/"false"
+        logging.info(f"Setting Alert_Sent__c to: {alert_sent}")
+        escalation_flag = str(bool(escalated)).lower()  # Ensure this is also a proper boolean string
 
-        # Validate required fields
-        required_fields = {
-            "Project_ID__c": project_record_id,
-            "Readiness_Score__c": score,
-            "Checklist_Summary__c": checklist_summary,
-            "Status__c": status,
-            "Evaluated_At__c": evaluated_at
-        }
-        for field, value in required_fields.items():
-            if not value:
-                logging.error(f"Required field {field} is missing or empty")
-                return f"Error: Required field {field} is missing or empty"
-
-        # Create the record
+        # Create the record in Project_Closure_Handover__c without the PDF URL for now
         record = {
-            "Project_ID__c": project_record_id,  # Use the Salesforce record ID
             "Readiness_Score__c": score,
             "Checklist_Summary__c": checklist_summary,
             "Missing_Documents__c": missing_documents,
             "Status__c": status,
             "Summarized_Missing_Items__c": summarized_missing,
             "Alert_Sent__c": alert_sent,
-            "Client_PDF_Pack_URL__c": "",
-            "Closure_Pack_URL__c": "",
+            "Client_PDF_Pack_URL__c": "",  # Will be updated after attachment is created
+            "Closure_Pack_URL__c": "",  # Placeholder; update if you have a closure pack URL
             "Escalation_Flag__c": escalation_flag,
             "Evaluated_At__c": evaluated_at,
             "Logs__c": logs,
@@ -256,59 +164,57 @@ def create_salesforce_record(project_id, score, checklist_summary, missing_summa
             "QA_Report__c": qa_report
         }
 
-        logging.debug(f"Creating Salesforce record with data: {record}")
+        logging.debug(f"Attempting to create Salesforce record in Project_Closure_Handover__c with data: {record}")
         result = sf.Project_Closure_Handover__c.create(record)
+        logging.info(f"Successfully created Salesforce record: {result}")
         record_id = result.get('id')
-        if not record_id:
-            logging.error("Failed to retrieve record ID from Salesforce response")
-            return "Error: Failed to create Salesforce record"
-
-        logging.info(f"Successfully created Salesforce record: {record_id}")
+        logging.info(f"Record ID: {record_id}")
 
-        # Attach PDF if available
+        # Attach the PDF to the record if pdf_path exists and update the URL
         pdf_download_url = ""
         if pdf_path and os.path.exists(pdf_path):
-            try:
-                logging.info(f"Attaching PDF to Salesforce record ID: {record_id}")
-                with open(pdf_path, "rb") as pdf_file:
-                    pdf_content = pdf_file.read()
-                    pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
-
-                attachment = {
-                    "ParentId": record_id,
-                    "Name": f"Readiness_Report_{record_id}.pdf",
-                    "Body": pdf_base64,
-                    "ContentType": "application/pdf"
-                }
-
-                attachment_result = sf.Attachment.create(attachment)
-                attachment_id = attachment_result.get('id')
-                if not attachment_id:
-                    logging.error("Failed to retrieve attachment ID from Salesforce response")
-                    return f"Record created (ID: {record_id}), but failed to attach PDF"
-
-                logging.info(f"Successfully attached PDF: {attachment_id}")
-                pdf_download_url = f"{SF_INSTANCE_URL}/servlet/servlet.FileDownload?file={attachment_id}"
-
-                # Update record with PDF URL
-                update_data = {
-                    "Client_PDF_Pack_URL__c": pdf_download_url
-                }
-                sf.Project_Closure_Handover__c.update(record_id, update_data)
-                logging.info(f"Updated record {record_id} with PDF URL: {pdf_download_url}")
-            except Exception as e:
-                logging.error(f"Failed to attach PDF: {str(e)}")
-                return f"Record created (ID: {record_id}), but failed to attach PDF: {str(e)}"
+            logging.info(f"Attaching PDF to Salesforce record ID: {record_id}")
+            with open(pdf_path, "rb") as pdf_file:
+                pdf_content = pdf_file.read()
+                pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
+            
+            attachment = {
+                "ParentId": record_id,
+                "Name": "Readiness_Report.pdf",
+                "Body": pdf_base64,
+                "ContentType": "application/pdf"
+            }
+            
+            attachment_result = sf.Attachment.create(attachment)
+            logging.info(f"Successfully attached PDF to record: {attachment_result}")
+            attachment_id = attachment_result.get('id')
+            logging.info(f"Attachment ID: {attachment_id}")
+
+            # Construct the direct download URL for the attachment
+            pdf_download_url = f"{SF_INSTANCE_URL}/servlet/servlet.FileDownload?file={attachment_id}"
+            logging.info(f"Generated PDF download URL: {pdf_download_url}")
+
+            # Update the Project_Closure_Handover__c record with the PDF download URL
+            update_data = {
+                "Client_PDF_Pack_URL__c": pdf_download_url
+            }
+            sf.Project_Closure_Handover__c.update(record_id, update_data)
+            logging.info(f"Updated record {record_id} with Client_PDF_Pack_URL__c: {pdf_download_url}")
         else:
-            logging.warning(f"No PDF file found at {pdf_path}. Skipping attachment.")
+            logging.warning(f"No PDF file found at {pdf_path}. Skipping attachment and URL update.")
 
-        return f"Record created successfully. Record ID: {record_id}. PDF URL: {pdf_download_url}"
+        return f"Record created successfully. Record ID: {record_id}. PDF attached and URL set to: {pdf_download_url}"
     except SalesforceError as e:
-        logging.error(f"Salesforce error: {str(e)}")
+        logging.error(f"Salesforce error while creating Project_Closure_Handover__c record: {str(e)}")
         logging.error("Possible issues: Object permissions, field-level security, validation rules, or required fields.")
+        logging.error("Check the following in your Salesforce org:")
+        logging.error("- Ensure the user has Create and Edit permission on Project_Closure_Handover__c.")
+        logging.error("- Ensure the user has permission to create and read Attachments.")
+        logging.error("- Verify field-level security for all fields in the record.")
+        logging.error("- Check for validation rules or required fields that might be failing.")
         return f"Salesforce error: {str(e)}"
     except Exception as e:
-        logging.error(f"Failed to create Salesforce record: {str(e)}")
+        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
@@ -318,23 +224,27 @@ def sanitize_input(text):
     return bleach.clean(text.strip())
 
 # Rule-based completeness engine with weighted scoring
-def evaluate_readiness(project_id, logs, qa_report, punch_list_text):
+def evaluate_readiness(logs, qa_report, punch_list_text):
     try:
-        logging.info(f"Evaluating readiness for Project ID: {project_id} - Logs: {logs}, QA Report: {qa_report}, Punch List: {punch_list_text}")
+        # Log inputs for debugging
+        logging.info(f"Inputs - Logs: {logs}, QA Report: {qa_report}, Punch List: {punch_list_text}")
+
+        # Initialize score and lists for tracking
         score = 0
         missing_items = []
         checklist_details = []
 
-        LOGS_WEIGHT = 30
-        QA_WEIGHT = 40
-        PUNCH_WEIGHT = 30
+        # Define weights for scoring
+        LOGS_WEIGHT = 30  # 30% weight for logs
+        QA_WEIGHT = 40    # 40% weight for QA report
+        PUNCH_WEIGHT = 30 # 30% weight for punch list
 
-        project_id = sanitize_input(project_id)
+        # Sanitize inputs
         logs = sanitize_input(logs)
         qa_report = sanitize_input(qa_report)
         punch_list_text = sanitize_input(punch_list_text)
 
-        # Process Project Logs
+        # Process Project Logs (30% weight)
         log_keywords = r"complete|handover done|finished|closed|successful"
         negative_keywords = r"issue|pending|incomplete|problem|delay"
         logs_pass = logs and re.search(log_keywords, logs.lower())
@@ -343,15 +253,18 @@ def evaluate_readiness(project_id, logs, qa_report, punch_list_text):
         if logs_pass and not logs_negative:
             score += LOGS_WEIGHT
             checklist_details.append("Logs: Completed")
+            logging.info(f"Logs Check: Pass (positive keywords found, no negative keywords), Score: {score}%")
         elif logs_pass and logs_negative:
-            score += LOGS_WEIGHT // 2
+            score += LOGS_WEIGHT // 2  # Partial score for mixed signals
             missing_items.append("Issues detected in logs")
             checklist_details.append("Logs: Partially Completed (issues detected)")
+            logging.info(f"Logs Check: Partial Pass (positive and negative keywords found), Score: {score}%")
         else:
             missing_items.append("Project Logs Incomplete")
             checklist_details.append("Logs: Pending")
+            logging.info(f"Logs Check: Fail (no positive keywords or only negative keywords), Score: {score}%")
 
-        # Process QA Report
+        # Process QA Report (40% weight)
         qa_keywords = r"approved|passed|cleared"
         qa_pass = qa_report and re.search(qa_keywords, qa_report.lower())
         if qa_pass:
@@ -360,8 +273,9 @@ def evaluate_readiness(project_id, logs, qa_report, punch_list_text):
         else:
             missing_items.append("QA Approval Missing")
             checklist_details.append("QA Report: Pending")
+        logging.info(f"QA Check: {'Pass' if qa_pass else 'Fail'}, Score so far: {score}%")
 
-        # Process Punch List
+        # Process Punch List (30% weight)
         punch_keywords = r"none|resolved|closed|no issues"
         punch_pass = punch_list_text and re.search(punch_keywords, punch_list_text.lower())
         if punch_pass:
@@ -370,16 +284,26 @@ def evaluate_readiness(project_id, logs, qa_report, punch_list_text):
         else:
             missing_items.append("Open Punch Points Detected")
             checklist_details.append("Punch List: Pending")
+        logging.info(f"Punch List Check: {'Pass' if punch_pass else 'Fail'}, Final Score: {score}%")
+
+        # Calculate open punch items
+        open_punch_items = 0 if punch_pass else 1  # Simplified for dropdown input
 
-        open_punch_items = 0 if punch_pass else 1
+        # Enhanced escalation logic
         escalated = score < 70 or open_punch_items > 2
+        logging.info(f"Escalation Check: Score < 70 ({score < 70}), Open Punch Items > 2 ({open_punch_items > 2}), Escalated: {escalated}")
+
+        # Map "Pending" to "In Progress" for Salesforce Status__c picklist
         status = "Escalated" if escalated else ("Completed" if not missing_items else "In Progress")
-        checklist_status = "Escalated" if escalated else ("Completed" if not missing_items else "Pending")
+        checklist_status = "Escalated" if escalated else ("Completed" if not missing_items else "Pending")  # For UI display
 
+        # Build summaries
         checklist_summary = "\n".join(checklist_details)
         missing_summary = "None" if not missing_items else ", ".join(missing_items)
 
+        # Generate progress bar HTML
         color_class = "red" if score < 70 else "yellow" if score <= 90 else "green"
+        logging.info(f"Readiness Score: {score}%, Color Class: {color_class}")
         progress_bar = f"""
         <div class="progress-container">
             <div class="progress-bar {color_class}" style="width: {score}%;">
@@ -388,42 +312,44 @@ def evaluate_readiness(project_id, logs, qa_report, punch_list_text):
         </div>
         """
 
-        logging.info(f"Readiness Score: {score}%, Status: {status}, Escalated: {escalated}")
-        return (project_id, score, checklist_summary, missing_summary, status, progress_bar, escalated, logs, qa_report, punch_list_text, open_punch_items, checklist_status)
+        return (score, checklist_summary, missing_summary, status, progress_bar, escalated, logs, qa_report, punch_list_text, open_punch_items, checklist_status)
     except Exception as e:
         logging.error(f"Error in evaluate_readiness: {str(e)}")
         raise
 
 # Generate PDF report with signature slots
-def generate_pdf(project_id, score, checklist_summary, missing_summary, checklist_status, logs, qa_report, punch_list_text):
+def generate_pdf(score, checklist_summary, missing_summary, checklist_status, logs, qa_report, punch_list_text):
     try:
-        project_id = str(project_id)[:80] if project_id else "Unknown"
+        # Sanitize inputs
+        logging.info("Sanitizing inputs for PDF generation")
         score = str(float(score)) if score is not None else "0"
-        checklist_summary = str(checklist_summary)[:1000] if checklist_summary else ""
-        checklist_status = str(checklist_status)[:255] if checklist_status else ""
+        checklist_summary = str(checklist_summary) if checklist_summary is not None else ""
+        checklist_status = str(checklist_status) if checklist_status is not None else ""
 
+        # Remove non-ASCII characters
         checklist_summary = checklist_summary.encode('ascii', 'ignore').decode('ascii')
         checklist_status = checklist_status.encode('ascii', 'ignore').decode('ascii')
 
-        pdf_path = f"readiness_report_{uuid.uuid4()}.pdf"
-        logging.info(f"Generating PDF at {pdf_path}")
+        # Define the temporary file path
+        pdf_path = "readiness_report.pdf"
+        logging.info(f"Creating PDF at {pdf_path}")
 
+        # Create the PDF
         c = canvas.Canvas(pdf_path, pagesize=letter)
         c.setFont("Times-Bold", 16)
         c.drawString(50, 750, "Project Closure Readiness Report")
         c.setFont("Times-Roman", 12)
-        c.drawString(50, 730, f"Project ID: {project_id}")
-        c.drawString(50, 710, f"Readiness Score: {score}%")
-        c.drawString(50, 690, f"Status: {checklist_status}")
-        c.drawString(50, 670, "Checklist Summary:")
-        y = 650
+        c.drawString(50, 720, f"Readiness Score: {score}%")
+        c.drawString(50, 700, f"Status: {checklist_status}")
+        c.drawString(50, 680, "Checklist Summary:")
+        y = 660
         BOTTOM_MARGIN = 50
         for line in checklist_summary.split("\n"):
             if y < BOTTOM_MARGIN:
                 c.showPage()
                 c.setFont("Times-Roman", 12)
                 y = 750
-            c.drawString(50, y, line[:100])
+            c.drawString(50, y, line)
             y -= 20
         if y - 40 < BOTTOM_MARGIN:
             c.showPage()
@@ -437,6 +363,7 @@ def generate_pdf(project_id, score, checklist_summary, missing_summary, checklis
         c.drawString(50, y - 60, "Date: ____________________")
         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")
@@ -447,7 +374,7 @@ def generate_pdf(project_id, score, checklist_summary, missing_summary, checklis
         logging.error(f"Error in generate_pdf: {str(e)}")
         raise
 
-# Gradio interface
+# Gradio interface with updated UI
 with gr.Blocks(css="""
     .progress-container { background-color: #f0f0f0; width: 100%; height: 20px; border-radius: 5px; overflow: hidden; position: relative; }
     .progress-bar { height: 100%; text-align: center; line-height: 20px; color: #000; font-size: 12px; }
@@ -463,7 +390,6 @@ with gr.Blocks(css="""
     )
     with gr.Row():
         with gr.Column(scale=2):
-            project_id_input = gr.Textbox(label="Project ID", placeholder="Enter Project ID (e.g., PRJ-001)", value="PRJ-001")
             logs_input = gr.Textbox(label="Project Logs", lines=5, placeholder="Enter project logs (e.g., 'Project complete, handover done')")
             qa_input = gr.Dropdown(
                 label="QA Report",
@@ -479,7 +405,6 @@ with gr.Blocks(css="""
             )
             submit_btn = gr.Button("Evaluate and Generate PDF")
         with gr.Column(scale=3):
-            project_id_output = gr.Textbox(label="Project ID")
             score_output = gr.Number(label="Readiness Score (%)")
             progress_output = gr.HTML(label="Alert Indicator: Progress")
             gr.Markdown("Color-coded readiness: Red (<70%), Yellow (70-90%), Green (>90%)")
@@ -491,26 +416,25 @@ with gr.Blocks(css="""
             open_punch_items_output = gr.Number(label="Open Punch Items (Debug)")
             pdf_output = gr.File(label="Download PDF Report", type="filepath", interactive=False)
             pdf_debug = gr.Textbox(label="PDF Debug Output")
-            salesforce_output = gr.Textbox(label="Salesforce Status")
 
+    # Chain the evaluation, PDF generation, and Salesforce record creation
     submit_btn.click(
         fn=evaluate_readiness,
-        inputs=[project_id_input, logs_input, qa_input, punch_input],
+        inputs=[logs_input, qa_input, punch_input],
         outputs=[
-            project_id_output, score_output, checklist_output, missing_output, status_output, progress_output,
+            score_output, checklist_output, missing_output, status_output, progress_output,
             gr.State(), gr.State(), gr.State(), gr.State(), open_punch_items_output, status_output
         ]
     ).then(
         fn=generate_pdf,
-        inputs=[project_id_output, score_output, checklist_output, missing_output, status_output, gr.State(), gr.State(), gr.State()],
+        inputs=[score_output, checklist_output, missing_output, status_output, gr.State(), gr.State(), gr.State()],
         outputs=[pdf_output, pdf_debug]
     ).then(
         fn=create_salesforce_record,
         inputs=[
-            project_id_output, score_output, checklist_output, missing_output, status_output,
+            score_output, checklist_output, missing_output, status_output,
             gr.State(), gr.State(), gr.State(), gr.State(), open_punch_items_output, pdf_output
         ],
-        outputs=salesforce_output
+        outputs=None
     )
-
-demo.launch()
+    demo.launch()