Update app.py

app.py

@@ -3,10 +3,10 @@ from paddleocr import PaddleOCR
 from PIL import Image
 import gradio as gr
 import re
-# from simple_salesforce import Salesforce  # Commented out to disable Salesforce integration
+from simple_salesforce import Salesforce
 import pandas as pd
 
-# Attribute mappings: readable names to Salesforce API names, in desired order
+# Attribute mappings: readable names to Salesforce API names
 ATTRIBUTE_MAPPING = {
     "Name": "Name__c",
     "Age": "Age__c",
@@ -21,18 +21,18 @@ ATTRIBUTE_ORDER = ["Name", "Age", "Gender", "Phone Number"]
 GENDER_MAPPING = {
     "Male": "Male",
     "Female": "Female",
-    "Other": "Others"  # Map 'Other' to 'Others' to match picklist
+    "Other": "Others"  # Map 'Other' to 'Others' to match Salesforce picklist
 }
 
-# Salesforce credentials (commented out since Salesforce integration is disabled)
-# SALESFORCE_USERNAME = "sathkruthatech@hms.com"
-# SALESFORCE_PASSWORD = "Hms@2025"
-# SALESFORCE_SECURITY_TOKEN = "5W0grf0aX0M9cD3yDZ2C5F"
+# Salesforce credentials
+SALESFORCE_USERNAME = "sathkruthatech@hms.com"
+SALESFORCE_PASSWORD = "Hms@2025"
+SALESFORCE_SECURITY_TOKEN = "5W0grf0aX0M9cD3yDZ2C5F"
 
 # Initialize PaddleOCR
 ocr = PaddleOCR(use_angle_cls=True, lang='en')
 
-# Function to extract text using PaddleOCR
+# Function to extract text from an image using PaddleOCR
 def extract_text(image):
     result = ocr.ocr(image)
     extracted_text = []
@@ -40,16 +40,16 @@ def extract_text(image):
         extracted_text.append(line[1][0])
     return "\n".join(extracted_text)
 
-# Function to extract attributes and their values
+# Function to extract attributes using regex
 def extract_attributes(extracted_text):
     attributes = {}
 
     # Patterns for extracting personal information
     patterns = {
-        "Name": r"Name[:\-]?\s*([A-Za-z]+)",  # Allow no space after Name:
-        "Age": r"Age[:\-]?\s*(\d{1,3})",
-        "Gender": r"Gender[:\-]?\s*(Male|Female|Other)",
-        "Phone Number": r"(?:(?:Phone Number)|Phone|Mobile|Phonenumber)[:\-]?\s*(?:\+91)?([6-9]\d{9})"
+        "Name": r"Name[:\-]?\s*([A-Za-z]+)",  # Extracts names without spaces
+        "Age": r"Age[:\-]?\s*(\d{1,3})",  # Extracts 1-3 digit age
+        "Gender": r"Gender[:\-]?\s*(Male|Female|Other)",  # Extracts Male, Female, or Other
+        "Phone Number": r"(?:(?:Phone Number)|Phone|Mobile|Phonenumber)[:\-]?\s*(?:\+91)?([6-9]\d{9})"  # Indian phone number: 10 digits, starts with 6-9
     }
 
     for readable_attr, pattern in patterns.items():
@@ -57,47 +57,59 @@ def extract_attributes(extracted_text):
         if match:
             attributes[readable_attr] = match.group(1).strip()
 
-    # Map Gender to picklist values
+    # Map Gender to Salesforce picklist values
     if "Gender" in attributes:
         attributes["Gender"] = GENDER_MAPPING.get(attributes["Gender"], attributes["Gender"])
 
     return attributes
 
-# Function to filter attributes for valid Salesforce fields (mocked for now)
-def filter_valid_attributes(attributes, valid_fields=None):
-    # Mock valid fields since Salesforce is disabled
-    if valid_fields is None:
-        valid_fields = {"Name", "Name__c", "Age__c", "Gender__c", "Phone_Number__c"}
-    
+# Function to filter attributes for valid Salesforce fields
+def filter_valid_attributes(attributes, valid_fields):
     filtered = {ATTRIBUTE_MAPPING[key]: value for key, value in attributes.items() if ATTRIBUTE_MAPPING[key] in valid_fields}
     
-    # Add the standard 'Name' field using the extracted Name value
+    # Add the standard 'Name' field (required by Salesforce for custom objects)
     if "Name" in attributes and "Name" in valid_fields:
         filtered["Name"] = attributes["Name"]
     
     return filtered
 
-# Function to interact with Salesforce (mocked for now)
+# Function to create a record in Salesforce
 def interact_with_salesforce(attributes):
     try:
-        # Mock Salesforce interaction since we cannot initialize Salesforce
-        valid_fields = {"Name", "Name__c", "Age__c", "Gender__c", "Phone_Number__c"}  # Mocked schema
+        # Initialize Salesforce connection
+        sf = Salesforce(
+            username=SALESFORCE_USERNAME,
+            password=SALESFORCE_PASSWORD,
+            security_token=SALESFORCE_SECURITY_TOKEN,
+            domain="test"  # Sandbox instance
+        )
+
+        # Reference the Patient_Registration__c object
+        object_name = "Patient_Registration__c"
+        sf_object = sf.__getattr__(object_name)
+
+        # Get the object's schema to validate fields
+        schema = sf_object.describe()
+        valid_fields = {field["name"] for field in schema["fields"]}
+
+        # Filter attributes to match valid Salesforce fields
         filtered_attributes = filter_valid_attributes(attributes, valid_fields)
 
-        # Log the attributes that would be sent to Salesforce
-        print(f"Attributes that would be sent to Salesforce: {filtered_attributes}")
+        # Log the attributes being sent for debugging
+        print(f"Attributes being sent to Salesforce: {filtered_attributes}")
 
-        # Ensure Age__c is a number (for compatibility with Salesforce)
+        # Ensure Age__c is a number (Salesforce expects an integer for this field)
         if "Age__c" in filtered_attributes:
             filtered_attributes["Age__c"] = int(filtered_attributes["Age__c"])
 
-        # Mock a successful Salesforce response
-        return f"✅ Mock Success: Attributes processed (Salesforce integration disabled). Data: {filtered_attributes}"
+        # Create the record in Salesforce
+        result = sf_object.create(filtered_attributes)
+        return f"✅ Successfully created Patient Registration record with ID: {result['id']}."
 
     except Exception as e:
-        return f"❌ Error processing attributes: {str(e)}"
+        return f"❌ Error interacting with Salesforce: {str(e)}"
 
-# Function to process image and extract attributes
+# Function to process the image and extract attributes
 def process_image(image):
     extracted_text = extract_text(image)
     if not extracted_text:
@@ -108,22 +120,22 @@ def process_image(image):
     # Ensure all attributes are present, even if empty, in the desired order
     ordered_attributes = {attr: attributes.get(attr, "") for attr in ATTRIBUTE_ORDER}
 
-    # Convert attributes to DataFrame with the desired order
+    # Convert attributes to DataFrame for display
     df = pd.DataFrame(list(ordered_attributes.items()), columns=["Attribute", "Value"])
     return f"Extracted Text:\n{extracted_text}", df, None
 
-# Function to handle edited attributes and export to Salesforce (mocked)
+# Function to handle edited attributes and export to Salesforce
 def export_to_salesforce(edited_df):
     try:
         # Convert edited DataFrame back to dictionary
         edited_attributes = dict(zip(edited_df["Attribute"], edited_df["Value"]))
 
-        # Export to Salesforce (mocked)
+        # Export to Salesforce
         message = interact_with_salesforce(edited_attributes)
         return message
 
     except Exception as e:
-        return f"❌ Error exporting attributes: {str(e)}"
+        return f"❌ Error exporting to Salesforce: {str(e)}"
 
 # Gradio Interface
 def app():