Update app.py

app.py

@@ -1,170 +1,148 @@
-import pandas as pd
-import requests
-import gradio as gr
 import logging
-from uuid import uuid4
+import sys
+import gradio as gr
 from simple_salesforce import Salesforce
-import datetime
 
 # Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
 logger = logging.getLogger(__name__)
 
-# Salesforce credentials - replace with your actual credentials
+# Your Salesforce credentials
 SALESFORCE_USERNAME = "vaneshdevarapalli866@agentforce.com"
 SALESFORCE_PASSWORD = "vanesh@331"
 SALESFORCE_SECURITY_TOKEN = "VRUVbBOdG0s9Q4xy0W6DB1Y6b"
 
+# Connect to Salesforce
 def connect_to_salesforce():
     try:
-        sf_instance = Salesforce(
+        sf = Salesforce(
             username=SALESFORCE_USERNAME,
             password=SALESFORCE_PASSWORD,
             security_token=SALESFORCE_SECURITY_TOKEN,
-            domain="login"
+            domain="login",
         )
         logger.info("Connected to Salesforce successfully.")
-        return sf_instance
+        return sf
     except Exception as e:
-        logger.error(f"Salesforce connection failed: {e}")
+        logger.error(f"Failed to connect to Salesforce: {e}")
         raise
 
 sf = connect_to_salesforce()
 
-# Load and validate dataset
-def load_dataset(file_path="equipment_data.csv"):
+# Lookup Salesforce record ID by object API name and record Name (string)
+def lookup_record_id(object_api_name, record_name):
     try:
-        df = pd.read_csv(file_path)
-        required_columns = ["Equipment_ID__c", "Equipment_Type__c", "Usage_Hours__c", "Idle_Hours__c"]
-        optional_columns = ["Movement_Frequency__c", "Cost_Per_Hour__c"]
-        missing_required = [col for col in required_columns if col not in df.columns]
-        if missing_required:
-            logger.error(f"Missing required columns: {missing_required}")
+        query = f"SELECT Id FROM {object_api_name} WHERE Name = '{record_name}' LIMIT 1"
+        result = sf.query(query)
+        records = result.get("records", [])
+        if records:
+            record_id = records[0]["Id"]
+            logger.info(f"Found {object_api_name} ID for '{record_name}': {record_id}")
+            return record_id
+        else:
+            logger.warning(f"No {object_api_name} record found with Name '{record_name}'")
             return None
-        
-        # Ensure numeric columns are properly typed
-        numeric_cols = [col for col in required_columns + optional_columns if col in df.columns and col not in ["Equipment_ID__c", "Equipment_Type__c"]]
-        for col in numeric_cols:
-            df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
-        
-        # Add missing optional columns with default value 0
-        for col in optional_columns:
-            if col not in df.columns:
-                df[col] = 0.0
-                
-        return df
     except Exception as e:
-        logger.error(f"Failed to load dataset: {e}")
+        logger.error(f"Error looking up {object_api_name} ID: {e}")
         return None
 
-df = load_dataset()
-equipment_types = sorted(df["Equipment_Type__c"].dropna().unique().tolist()) if df is not None and not df.empty else ["No Equipment Types"]
-suggestion_types = ["Move", "Pause Rent", "Repair", "Replace"]
+# Dummy AI model (replace with your real AI logic or API call)
+def dummy_ai_model(usage_hours, idle_hours):
+    if usage_hours > 5:
+        suggestion = "Move"
+        confidence = 90.0
+        utilization_score = 85.0
+    else:
+        suggestion = "Pause Rent"
+        confidence = 75.0
+        utilization_score = 60.0
+    return suggestion, confidence, utilization_score
+
+def process_equipment_utilization(
+    equipment_name,
+    project_name,
+    usage_hours,
+    idle_hours,
+    report_link,
+    last_maintenance_date,
+):
+    equipment_id = lookup_record_id("Equipment__c", equipment_name)
+    project_id = lookup_record_id("Project__c", project_name)
+
+    if not equipment_id or not project_id:
+        return {
+            "status": "Error",
+            "message": "Could not find Salesforce record IDs for Equipment or Project. Please check names.",
+        }
 
-# Dummy AI model for suggestion and confidence
-def dummy_ai_suggestion(row):
-    return "Move", 0.85
+    ai_suggestion, suggestion_confidence, utilization_score = dummy_ai_model(
+        usage_hours, idle_hours
+    )
 
-# Filter equipment and generate display
-def filter_equipment(equipment_type, suggestion):
-    if not equipment_type or not suggestion or df is None or df.empty:
-        return "No data available or invalid filters selected.", ""
-    
-    try:
-        filtered = df[df["Equipment_Type__c"].str.lower() == equipment_type.lower()].copy()
-        if filtered.empty:
-            return f"No equipment found for type: {equipment_type}.", ""
-        
-        filtered["AI_Suggestion__c"] = None
-        filtered["Suggestion_Confidence__c"] = 0.0
-        
-        for idx, row in filtered.iterrows():
-            s, conf = dummy_ai_suggestion(row)
-            filtered.at[idx, "AI_Suggestion__c"] = s
-            filtered.at[idx, "Suggestion_Confidence__c"] = conf
-        
-        filtered = filtered[filtered["AI_Suggestion__c"].str.lower() == suggestion.lower()]
-        if filtered.empty:
-            return f"No equipment with suggestion '{suggestion}' for type '{equipment_type}'.", ""
-        
-        cards = [
-            f"ID: {row['Equipment_ID__c']} | Usage: {row['Usage_Hours__c']:.2f} hrs | "
-            f"Idle: {row['Idle_Hours__c']:.2f} hrs | Move Freq: {row.get('Movement_Frequency__c', 0):.2f} | "
-            f"Cost/hr: ${row.get('Cost_Per_Hour__c', 0):.2f} | AI: {row['AI_Suggestion__c']} "
-            f"({row['Suggestion_Confidence__c']:.2%})"
-            for _, row in filtered.iterrows()
-        ]
-        confidences = [f"{row['Equipment_ID__c']}: {row['Suggestion_Confidence__c']:.2%}" 
-                      for _, row in filtered.iterrows()]
-        return "\n\n".join(cards), "\n".join(confidences)
-    except Exception as e:
-        logger.error(f"Error in filter_equipment: {e}")
-        return "An error occurred while filtering equipment.", ""
+    record = {
+        "Equipment_ID__c": equipment_id,
+        "Project_ID__c": project_id,
+        "Usage_Hours__c": usage_hours,
+        "Idle_Hours__c": idle_hours,
+        "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_date,
+        "Dashboard_Flag__c": False,
+    }
 
-# Save selected equipment record to Salesforce
-def save_equipment_record(equipment_id, project_id, usage_hours, idle_hours,
-                          ai_suggestion, suggestion_confidence, utilization_score,
-                          report_link, last_maintenance):
     try:
-        last_maintenance_date = None
-        if last_maintenance:
-            last_maintenance_date = datetime.datetime.strptime(last_maintenance, "%Y-%m-%d").date()
-        record = {
-            "Equipment_ID__c": equipment_id,
-            "Project_ID__c": project_id,
-            "Usage_Hours__c": float(usage_hours),
-            "Idle_Hours__c": float(idle_hours),
-            "AI_Suggestion__c": ai_suggestion,
-            "Suggestion_Confidence__c": float(suggestion_confidence),
-            "Utilization_Score__c": float(utilization_score),
-            "Report_Link__c": report_link,
-            "Last_Maintenance__c": last_maintenance_date,
-            "Dashboard_Flag__c": False
+        response = sf.Equipment_Utilization_Record__c.create(record)
+        logger.info(f"Created Salesforce record: {response}")
+        return {
+            "status": "Success",
+            "Salesforce_Record_ID": response.get("id"),
+            "AI_Suggestion": ai_suggestion,
+            "Suggestion_Confidence": suggestion_confidence,
+            "Utilization_Score": utilization_score,
         }
-        resp = sf.Equipment_Utilization_Record__c.create(record)
-        return f"Salesforce record created with ID: {resp['id']}"
     except Exception as e:
-        logger.error(f"Error saving record to Salesforce: {e}")
-        return f"Error: {e}"
-
-# Gradio UI
-with gr.Blocks() as app:
-    gr.Markdown("# Equipment Utilization Dashboard")
-    gr.Markdown("Filter equipment by type and AI suggestion.")
-
-    with gr.Row():
-        etype = gr.Dropdown(equipment_types, label="Equipment Type", value=equipment_types[0])
-        suggestion = gr.Dropdown(suggestion_types, label="Suggestion Type", value=suggestion_types[0])
-
-    details = gr.Textbox(label="Equipment Details", lines=10)
-    confidences = gr.Textbox(label="Confidence Scores", lines=5)
-
-    save_btn = gr.Button("Save Equipment to Salesforce")
-
-    # Inputs for saving a record
-    equipment_id_in = gr.Textbox(label="Equipment ID")
-    project_id_in = gr.Textbox(label="Project ID")
-    usage_hours_in = gr.Number(label="Usage Hours")
-    idle_hours_in = gr.Number(label="Idle Hours")
-    ai_suggestion_in = gr.Textbox(label="AI Suggestion")
-    suggestion_confidence_in = gr.Number(label="Suggestion Confidence")
-    utilization_score_in = gr.Number(label="Utilization Score")
-    report_link_in = gr.Textbox(label="Report Link")
-    last_maintenance_in = gr.Textbox(label="Last Maintenance Date (YYYY-MM-DD)")
-
-    def update_display(equipment_type, suggestion_type):
-        return filter_equipment(equipment_type, suggestion_type)
+        logger.error(f"Failed to create Salesforce record: {e}")
+        return {"status": "Error", "message": str(e)}
+
+# Gradio UI function
+def gradio_submit(
+    equipment_name,
+    project_name,
+    usage_hours,
+    idle_hours,
+    report_link,
+    last_maintenance_date,
+):
+    return process_equipment_utilization(
+        equipment_name,
+        project_name,
+        usage_hours,
+        idle_hours,
+        report_link,
+        last_maintenance_date,
+    )
 
-    etype.change(update_display, inputs=[etype, suggestion], outputs=[details, confidences])
-    suggestion.change(update_display, inputs=[etype, suggestion], outputs=[details, confidences])
 
-    save_btn.click(
-        save_equipment_record,
-        inputs=[equipment_id_in, project_id_in, usage_hours_in, idle_hours_in,
-                ai_suggestion_in, suggestion_confidence_in, utilization_score_in,
-                report_link_in, last_maintenance_in],
-        outputs=details
-    )
+iface = gr.Interface(
+    fn=gradio_submit,
+    inputs=[
+        gr.Textbox(label="Equipment Name (Salesforce Name field)"),
+        gr.Textbox(label="Project Name (Salesforce Name field)"),
+        gr.Number(label="Usage Hours", value=0, minimum=0),
+        gr.Number(label="Idle Hours", value=0, minimum=0),
+        gr.Textbox(label="Report Link (URL)", value=""),
+        gr.Textbox(label="Last Maintenance Date (YYYY-MM-DD)", value=""),
+    ],
+    outputs=gr.JSON(label="Salesforce Insert Result"),
+    title="Equipment Utilization Record Creator with Name Lookup",
+    description="Input Equipment and Project names; the app looks up Salesforce IDs and creates the record.",
+)
 
 if __name__ == "__main__":
-    app.launch()
+    iface.launch(share=False)