Update app.py

app.py

@@ -1,65 +1,153 @@
-import gradio as gr
-from salesforce_utils import get_salesforce_objects, get_token, create_record, attach_pdf
+import streamlit as st
+from salesforce_utils import get_salesforce_objects, get_salesforce_object_fields, get_token, create_record, attach_pdf
 from ai_mapping import run_ai_mapping
 from ocr_utils import extract_text_from_pdf
-import tempfile
 import os
+import json
+import tempfile
+
+# Initialize session state for failed records
+if 'failed_records' not in st.session_state:
+    st.session_state.failed_records = []
 
-def process_contract(pdf_file, object_name):
-    if pdf_file is None:
-        return "❌ No file uploaded.", None
+def save_failed_record(pdf_name, object_name, error, mappings):
+    """Log failed records for reconciliation."""
+    st.session_state.failed_records.append({
+        "pdf_name": pdf_name,
+        "object_name": object_name,
+        "error": error,
+        "mappings": mappings
+    })
+
+def process_contract(uploaded_files, object_name, manual_mappings):
+    """Process uploaded PDFs and create Salesforce records."""
+    if not uploaded_files:
+        return "❌ No files uploaded.", None
 
-    # Get token and Salesforce objects
     try:
         token, instance_url = get_token()
     except Exception as e:
         return f"❌ Salesforce authentication failed: {str(e)}", None
 
-    # Step 1: OCR
+    # Get object fields for mapping
     try:
-        text_data = extract_text_from_pdf(pdf_file.name)  # Use .name to get file path
-        if not text_data:
-            return "⚠️ No text extracted from PDF. It may be empty or require OCR.", None
+        object_fields = get_salesforce_object_fields(token, instance_url, object_name)
+        object_field_names = [field['name'] for field in object_fields if field.get('createable')]
     except Exception as e:
-        return f"❌ Failed to extract text from PDF: {str(e)}", None
+        return f"❌ Failed to fetch object fields: {str(e)}", None
 
-    # Step 2: AI Mapping
-    try:
-        mappings = run_ai_mapping(text_data)
-    except Exception as e:
-        return f"❌ AI mapping failed: {str(e)}", None
+    results = []
+    for pdf_file in uploaded_files:
+        pdf_name = pdf_file.name
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+            tmp.write(pdf_file.read())
+            tmp_path = tmp.name
 
-    # Step 3: Create Salesforce record
-    try:
-        record_response = create_record(object_name, mappings, token, instance_url)
-        if 'id' in record_response:
-            attach_pdf(record_response['id'], pdf_file.name, token, instance_url)
-            return f"✅ Record created: {record_response['id']}", mappings
-        else:
-            return f"❌ Failed to create record: {record_response}", mappings
-    except Exception as e:
-        return f"❌ Failed to create Salesforce record: {str(e)}", mappings
+        try:
+            # Step 1: OCR
+            text_data = extract_text_from_pdf(tmp_path)
+            if not text_data:
+                save_failed_record(pdf_name, object_name, "No text extracted from PDF", {})
+                results.append(f"⚠️ {pdf_name}: No text extracted")
+                continue
 
-def get_salesforce_object_names():
-    try:
-        token, instance_url = get_token()
-        objects = get_salesforce_objects(token, instance_url)
-        return [obj['name'] for obj in objects if obj.get('createable')]
-    except Exception as e:
-        return [f"❌ Failed to fetch Salesforce objects: {str(e)}"]
+            # Step 2: AI Mapping
+            ai_result = run_ai_mapping(text_data, tmp_path, object_field_names)
+            if ai_result['status'] == 'failed':
+                save_failed_record(pdf_name, object_name, ai_result['error'], ai_result['mappings'])
+                results.append(f"❌ {pdf_name}: {ai_result['error']}")
+                continue
+
+            # Apply manual mappings (if provided)
+            mappings = {k: v['value'] for k, v in ai_result['mappings'].items()}
+            for field, value in manual_mappings.items():
+                if value and field in object_field_names:
+                    mappings[field] = value
+
+            # Step 3: Create Salesforce record
+            record_response = create_record(object_name, mappings, token, instance_url)
+            if 'id' in record_response:
+                attach_pdf(record_response['id'], tmp_path, token, instance_url)
+                results.append(f"✅ {pdf_name}: Record created (ID: {record_response['id']})")
+            else:
+                save_failed_record(pdf_name, object_name, f"Failed to create record: {record_response}", mappings)
+                results.append(f"❌ {pdf_name}: Failed to create record: {record_response}")
+        except Exception as e:
+            save_failed_record(pdf_name, object_name, str(e), {})
+            results.append(f"❌ {pdf_name}: {str(e)}")
+        finally:
+            os.unlink(tmp_path)
+
+    return "\n".join(results), ai_result
+
+def retry_failed_record(index, object_name, manual_mappings):
+    """Retry a failed record with manual corrections."""
+    failed_record = st.session_state.failed_records.pop(index)
+    pdf_name = failed_record['pdf_name']
+    with open(failed_record['pdf_path'], 'rb') as f:
+        result, ai_result = process_contract([f], object_name, manual_mappings)
+    return result
 
-with gr.Blocks() as demo:
-    gr.Markdown("## 📄 Smart Contract Migrator (Gradio)")
+# Streamlit UI
+st.title("📄 Smart Contract Migrator (Streamlit)")
 
-    with gr.Row():
-        pdf_file = gr.File(label="Upload Contract PDF", file_types=[".pdf"])
-        object_list = gr.Dropdown(choices=get_salesforce_object_names(), label="Salesforce Object")
+# Epic 1: PDF Upload
+uploaded_files = st.file_uploader("Upload Contract PDFs", type="pdf", accept_multiple_files=True)
 
-    submit_btn = gr.Button("Extract, Map, and Upload")
+# Epic 2: Salesforce Object Selection
+try:
+    token, instance_url = get_token()
+    objects = get_salesforce_objects(token, instance_url)
+    object_names = [obj['name'] for obj in objects if obj.get('createable')]
+except Exception as e:
+    st.error(f"❌ Failed to fetch Salesforce objects: {str(e)}")
+    object_names = []
+
+object_name = st.selectbox("Select Salesforce Object", object_names)
+
+# Display object fields
+if object_name:
+    try:
+        object_fields = get_salesforce_object_fields(token, instance_url, object_name)
+        field_names = [field['name'] for field in object_fields if field.get('createable')]
+        st.write("Available Fields:")
+        st.write(field_names)
+    except Exception as e:
+        st.error(f"❌ Failed to fetch fields for {object_name}: {str(e)}")
+        field_names = []
 
-    output_text = gr.Textbox(label="Status")
-    output_json = gr.JSON(label="Field Mappings")
+# Manual mapping input
+manual_mappings = {}
+if field_names:
+    st.subheader("Manual Field Mappings (Optional)")
+    for field in field_names:
+        manual_mappings[field] = st.text_input(f"{field}", "")
 
-    submit_btn.click(fn=process_contract, inputs=[pdf_file, object_list], outputs=[output_text, output_json])
+# Process button
+if st.button("Extract, Map, and Upload"):
+    if uploaded_files and object_name:
+        status, ai_result = process_contract(uploaded_files, object_name, manual_mappings)
+        st.text_area("Status", status)
+        if ai_result:
+            st.json({
+                "mappings": ai_result['mappings'],
+                "unmapped_fields": ai_result['unmapped_fields'],
+                "status": ai_result['status']
+            })
 
-demo.launch()
+# Epic 6: Reconciliation Dashboard
+st.subheader("Reconciliation Dashboard")
+if st.session_state.failed_records:
+    for i, record in enumerate(st.session_state.failed_records):
+        with st.expander(f"Failed Record: {record['pdf_name']}"):
+            st.write(f"Object: {record['object_name']}")
+            st.write(f"Error: {record['error']}")
+            st.write("Mappings:", record['mappings'])
+            manual_mappings_retry = {}
+            for field in field_names:
+                manual_mappings_retry[field] = st.text_input(f"{field} (Retry)", key=f"retry_{i}_{field}")
+            if st.button("Retry", key=f"retry_btn_{i}"):
+                result = retry_failed_record(i, record['object_name'], manual_mappings_retry)
+                st.write(result)
+else:
+    st.write("No failed records.")