Update app.py

app.py

@@ -1,146 +1,151 @@
-import datetime
-import logging
-import sys
-import requests
 import gradio as gr
+import logging
 from simple_salesforce import Salesforce
 
-# Setup logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler(sys.stdout), logging.FileHandler("app_log.txt")]
-)
+# Configure logging
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Salesforce credentials — replace with your actual Salesforce credentials
+# Salesforce Credentials
 SALESFORCE_USERNAME = "vaneshdevarapalli866@agentforce.com"
 SALESFORCE_PASSWORD = "vanesh@331"
 SALESFORCE_SECURITY_TOKEN = "VRUVbBOdG0s9Q4xy0W6DB1Y6b"
 
-# Hugging Face model endpoint URL — replace with your real endpoint URL
-HUGGINGFACE_API_URL = "https://your-huggingface-model-endpoint"
+# Connect to Salesforce
+try:
+    sf = Salesforce(
+        username=SALESFORCE_USERNAME,
+        password=SALESFORCE_PASSWORD,
+        security_token=SALESFORCE_SECURITY_TOKEN,
+        domain="login"
+    )
+    logger.info("Connected to Salesforce successfully.")
+except Exception as e:
+    logger.error(f"Failed to connect to Salesforce: {e}")
+    raise
 
-def connect_to_salesforce():
+# Fetch Equipment records (Id, Name)
+def fetch_equipment_records():
     try:
-        sf_instance = Salesforce(
-            username=SALESFORCE_USERNAME,
-            password=SALESFORCE_PASSWORD,
-            security_token=SALESFORCE_SECURITY_TOKEN,
-            domain="login"
-        )
-        logger.info("Connected to Salesforce successfully.")
-        return sf_instance
+        query = "SELECT Id, Name FROM Equipment__c LIMIT 100"
+        result = sf.query(query)
+        choices = [(rec["Id"], rec["Name"]) for rec in result["records"]]
+        logger.info(f"Fetched {len(choices)} Equipment records")
+        return choices
     except Exception as e:
-        logger.error(f"Failed to connect to Salesforce: {e}")
-        raise
-
-sf = connect_to_salesforce()
+        logger.error(f"Error fetching equipment records: {e}")
+        return []
 
-def get_ai_suggestion(usage_hours, idle_hours, movement_frequency, cost_per_hour, last_maintenance_str):
+# Fetch Project records (Id, Name)
+def fetch_project_records():
     try:
-        payload = {
-            "usage_hours": usage_hours,
-            "idle_hours": idle_hours,
-            "movement_frequency": movement_frequency,
-            "cost_per_hour": cost_per_hour,
-            "last_maintenance": last_maintenance_str or ""
-        }
-        logger.info(f"Calling AI model with payload: {payload}")
-        response = requests.post(HUGGINGFACE_API_URL, json=payload, timeout=15)
-        response.raise_for_status()
-        data = response.json()
-        logger.info(f"Received AI response: {data}")
-
-        suggestion = data.get("suggestion", "No Action")
-        confidence = float(data.get("confidence", 0))
-        utilization_score = float(data.get("utilization_score", 0))
-        return suggestion, confidence, utilization_score
+        query = "SELECT Id, Name FROM Project__c LIMIT 100"
+        result = sf.query(query)
+        choices = [(rec["Id"], rec["Name"]) for rec in result["records"]]
+        logger.info(f"Fetched {len(choices)} Project records")
+        return choices
     except Exception as e:
-        logger.error(f"Error while calling AI model: {e}")
-        # Return fallback default values
-        return "No Action", 0, 0
-
-def process_equipment_utilization(equipment_id, project_id, usage_hours, idle_hours,
-                                  movement_frequency, cost_per_hour, report_link, last_maintenance):
-    last_maintenance_str = last_maintenance.strftime("%Y-%m-%d") if last_maintenance else None
-
-    # Get AI outputs
-    ai_suggestion, suggestion_confidence, utilization_score = get_ai_suggestion(
-        usage_hours, idle_hours, movement_frequency, cost_per_hour, last_maintenance_str
-    )
-
-    salesforce_record = {
+        logger.error(f"Error fetching project records: {e}")
+        return []
+
+equipment_choices = fetch_equipment_records()
+project_choices = fetch_project_records()
+
+# AI Suggestion options (must match Salesforce picklist exactly)
+ai_suggestion_options = ["Move", "Pause Rent", "Repair", "Replace"]
+
+def create_equipment_utilization_record(
+    equipment_name,
+    project_name,
+    usage_hours,
+    idle_hours,
+    last_maintenance,
+    utilization_score,
+    ai_suggestion,
+    suggestion_confidence,
+    dashboard_flag,
+    report_link
+):
+    # Find Salesforce IDs from the selected names
+    equipment_id = next((eid for eid, ename in equipment_choices if ename == equipment_name), None)
+    project_id = next((pid for pid, pname in project_choices if pname == project_name), None)
+
+    if not equipment_id or not project_id:
+        return {"error": "Invalid Equipment or Project selected. Please select valid options from dropdown."}
+
+    record = {
         "Equipment_ID__c": equipment_id,
         "Project_ID__c": project_id,
         "Usage_Hours__c": usage_hours,
         "Idle_Hours__c": idle_hours,
+        "Last_Maintenance__c": last_maintenance if last_maintenance else None,
+        "Utilization_Score__c": utilization_score if utilization_score else 0,
         "AI_Suggestion__c": ai_suggestion,
-        "Suggestion_Confidence__c": suggestion_confidence,
-        "Utilization_Score__c": utilization_score,
-        "Report_Link__c": report_link,
-        "Last_Maintenance__c": last_maintenance_str,
-        "Dashboard_Flag__c": False
+        "Suggestion_Confidence__c": suggestion_confidence if suggestion_confidence else 0,
+        "Dashboard_Flag__c": dashboard_flag if dashboard_flag is not None else False,
+        "Report_Link__c": report_link if report_link else ""
     }
 
     try:
-        response = sf.Equipment_Utilization_Record__c.create(salesforce_record)
-        logger.info(f"Record created in Salesforce: {response}")
-        return {
-            "Salesforce_Record_Id": response.get("id"),
-            "status": "Success",
-            "AI_Suggestion": ai_suggestion,
-            "Suggestion_Confidence": suggestion_confidence,
-            "Utilization_Score": utilization_score
-        }
+        response = sf.Equipment_Utilization_Record__c.create(record)
+        logger.info(f"Created Equipment Utilization Record with Id: {response['id']}")
+        return {"success": f"Record created successfully! Id: {response['id']}"}
     except Exception as e:
-        logger.error(f"Salesforce create record error: {e}")
-        return {"error": str(e)}
+        logger.error(f"Error creating Equipment Utilization Record: {e}")
+        return {"error": f"Failed to create record: {str(e)}"}
+
+# Build Gradio UI
+with gr.Blocks() as app:
+    gr.Markdown("# Equipment Utilization Record Uploader")
+    gr.Markdown("Select Equipment and Project, enter utilization details, and save to Salesforce.")
+
+    with gr.Row():
+        equipment_dropdown = gr.Dropdown(
+            label="Equipment",
+            choices=[ename for _, ename in equipment_choices],
+            interactive=True
+        )
+        project_dropdown = gr.Dropdown(
+            label="Project",
+            choices=[pname for _, pname in project_choices],
+            interactive=True
+        )
 
-def gradio_interface(equipment_id, project_id, usage_hours, idle_hours,
-                     movement_frequency, cost_per_hour, report_link, last_maintenance):
-    # Validate numeric inputs
-    try:
-        usage_hours = float(usage_hours)
-        idle_hours = float(idle_hours)
-        movement_frequency = float(movement_frequency)
-        cost_per_hour = float(cost_per_hour)
-    except Exception as e:
-        return {"error": f"Invalid numeric input: {e}"}
+    with gr.Row():
+        usage_hours = gr.Number(label="Usage Hours", value=0, precision=2)
+        idle_hours = gr.Number(label="Idle Hours", value=0, precision=2)
 
-    # Validate last maintenance date format
-    try:
-        last_maintenance_dt = datetime.datetime.strptime(last_maintenance, "%Y-%m-%d") if last_maintenance else None
-    except Exception as e:
-        return {"error": f"Invalid date format for Last Maintenance (expected YYYY-MM-DD): {e}"}
-
-    return process_equipment_utilization(
-        equipment_id,
-        project_id,
-        usage_hours,
-        idle_hours,
-        movement_frequency,
-        cost_per_hour,
-        report_link,
-        last_maintenance_dt
-    )
+    last_maintenance = gr.Textbox(label="Last Maintenance Date (YYYY-MM-DD)", placeholder="Optional")
+    utilization_score = gr.Number(label="Utilization Score (%)", value=0, precision=2)
+    suggestion_confidence = gr.Number(label="Suggestion Confidence (%)", value=0, precision=2)
 
-iface = gr.Interface(
-    fn=gradio_interface,
-    inputs=[
-        gr.Textbox(label="Equipment ID (Salesforce Record ID)"),
-        gr.Textbox(label="Project ID (Salesforce Record ID)"),
-        gr.Number(label="Usage Hours", value=0, minimum=0),
-        gr.Number(label="Idle Hours", value=0, minimum=0),
-        gr.Number(label="Movement Frequency", value=0, minimum=0),
-        gr.Number(label="Cost per Hour", value=0, minimum=0),
-        gr.Textbox(label="Report Link (URL)"),
-        gr.Textbox(label="Last Maintenance Date (YYYY-MM-DD)")
-    ],
-    outputs=gr.JSON(label="Salesforce Record Creation Result"),
-    title="Equipment Utilization AI Integration",
-    description="Input equipment data to get AI suggestions and save the record to Salesforce."
-)
+    ai_suggestion = gr.Dropdown(
+        label="AI Suggestion",
+        choices=ai_suggestion_options,
+        value=ai_suggestion_options[0]
+    )
+    dashboard_flag = gr.Checkbox(label="Dashboard Flag", value=False)
+    report_link = gr.Textbox(label="Report Link (URL)", placeholder="Optional")
+
+    output = gr.JSON(label="Salesforce Record Creation Result")
+
+    submit_btn = gr.Button("Submit Record")
+    submit_btn.click(
+        fn=create_equipment_utilization_record,
+        inputs=[
+            equipment_dropdown,
+            project_dropdown,
+            usage_hours,
+            idle_hours,
+            last_maintenance,
+            utilization_score,
+            ai_suggestion,
+            suggestion_confidence,
+            dashboard_flag,
+            report_link
+        ],
+        outputs=output
+    )
 
 if __name__ == "__main__":
-    iface.launch(share=False)
+    app.launch()